From b3cb82752677678f0ddb46ab778d0fd1356ba614 Mon Sep 17 00:00:00 2001 From: Zangetsu38 Date: Mon, 13 Feb 2017 03:46:02 +0100 Subject: [PATCH] Registers more functions missing. Implement and stub cell_FreeType2. Reorder cellRtc. --- rpcs3/Emu/Cell/Modules/cellFont.cpp | 8 +- rpcs3/Emu/Cell/Modules/cellFontFT.cpp | 201 +++++++- rpcs3/Emu/Cell/Modules/cellFs.cpp | 140 +++++- rpcs3/Emu/Cell/Modules/cellHttp.cpp | 48 +- rpcs3/Emu/Cell/Modules/cellRtc.cpp | 103 +++-- rpcs3/Emu/Cell/Modules/cellSsl.cpp | 530 +++++++++++++++++++++- rpcs3/Emu/Cell/Modules/cell_FreeType2.cpp | 218 +++++++++ rpcs3/Emu/Cell/Modules/sys_io.cpp | 14 +- rpcs3/Emu/Cell/Modules/sys_net.cpp | 281 +++++++++++- rpcs3/Emu/Cell/PPUModule.cpp | 4 +- rpcs3/Emu/Cell/PPUModule.h | 3 +- rpcs3/emucore.vcxproj | 1 + rpcs3/emucore.vcxproj.filters | 3 + 13 files changed, 1494 insertions(+), 60 deletions(-) create mode 100644 rpcs3/Emu/Cell/Modules/cell_FreeType2.cpp diff --git a/rpcs3/Emu/Cell/Modules/cellFont.cpp b/rpcs3/Emu/Cell/Modules/cellFont.cpp index d4615e242c..6e26ff875e 100644 --- a/rpcs3/Emu/Cell/Modules/cellFont.cpp +++ b/rpcs3/Emu/Cell/Modules/cellFont.cpp @@ -1,4 +1,4 @@ -#include "stdafx.h" +#include "stdafx.h" #include "Emu/System.h" #include "Emu/Cell/PPUModule.h" @@ -740,10 +740,13 @@ s32 cellFontGraphicsGetLineRGBA() fmt::throw_exception("Unimplemented" HERE); } +s32 cellFontControl() +{ + fmt::throw_exception("Unimplemented" HERE); +} DECLARE(ppu_module_manager::cellFont)("cellFont", []() { - static ppu_static_module cell_FreeType2("cell_FreeType2"); REG_FUNC(cellFont, cellFontSetFontsetOpenMode); REG_FUNC(cellFont, cellFontSetFontOpenMode); @@ -827,4 +830,5 @@ DECLARE(ppu_module_manager::cellFont)("cellFont", []() REG_FUNC(cellFont, cellFontGetRenderEffectSlant); REG_FUNC(cellFont, cellFontGetScalePoint); REG_FUNC(cellFont, cellFontGraphicsGetLineRGBA); + REG_FUNC(cellFont, cellFontControl); }); diff --git a/rpcs3/Emu/Cell/Modules/cellFontFT.cpp b/rpcs3/Emu/Cell/Modules/cellFontFT.cpp index 20b3167a9f..345c3c7bb2 100644 --- a/rpcs3/Emu/Cell/Modules/cellFontFT.cpp +++ b/rpcs3/Emu/Cell/Modules/cellFontFT.cpp @@ -1,4 +1,4 @@ -#include "stdafx.h" +#include "stdafx.h" #include "Emu/Cell/PPUModule.h" #include "cellFontFT.h" @@ -26,9 +26,208 @@ s32 cellFontFTGetInitializedRevisionFlags() return CELL_OK; } +s32 FTCacheStream_CacheEnd() +{ + UNIMPLEMENTED_FUNC(cellFontFT); + return CELL_OK; +} + +s32 FTCacheStream_CacheInit() +{ + UNIMPLEMENTED_FUNC(cellFontFT); + return CELL_OK; +} + +s32 FTCacheStream_CalcCacheIndexSize() +{ + UNIMPLEMENTED_FUNC(cellFontFT); + return CELL_OK; +} + +s32 FTCacheStream_Init() +{ + UNIMPLEMENTED_FUNC(cellFontFT); + return CELL_OK; +} + +s32 FTFaceH_FontFamilyName() +{ + UNIMPLEMENTED_FUNC(cellFontFT); + return CELL_OK; +} + +s32 FTFaceH_FontStyleName() +{ + UNIMPLEMENTED_FUNC(cellFontFT); + return CELL_OK; +} + +s32 FTFaceH_GetAscender() +{ + UNIMPLEMENTED_FUNC(cellFontFT); + return CELL_OK; +} + +s32 FTFaceH_GetBoundingBoxHeight() +{ + UNIMPLEMENTED_FUNC(cellFontFT); + return CELL_OK; +} + +s32 FTFaceH_GetBoundingBoxMaxX() +{ + UNIMPLEMENTED_FUNC(cellFontFT); + return CELL_OK; +} + +s32 FTFaceH_GetBoundingBoxMaxY() +{ + UNIMPLEMENTED_FUNC(cellFontFT); + return CELL_OK; +} + +s32 FTFaceH_GetBoundingBoxMinX() +{ + UNIMPLEMENTED_FUNC(cellFontFT); + return CELL_OK; +} + +s32 FTFaceH_GetBoundingBoxMinY() +{ + UNIMPLEMENTED_FUNC(cellFontFT); + return CELL_OK; +} + +s32 FTFaceH_GetBoundingBoxWidth() +{ + UNIMPLEMENTED_FUNC(cellFontFT); + return CELL_OK; +} + +s32 FTFaceH_GetGlyphImage() +{ + UNIMPLEMENTED_FUNC(cellFontFT); + return CELL_OK; +} + +s32 FTFaceH_GetGlyphMetrics() +{ + UNIMPLEMENTED_FUNC(cellFontFT); + return CELL_OK; +} + +s32 FTFaceH_GetMaxHorizontalAdvance() +{ + UNIMPLEMENTED_FUNC(cellFontFT); + return CELL_OK; +} + +s32 FTFaceH_GetRenderBufferSize() +{ + UNIMPLEMENTED_FUNC(cellFontFT); + return CELL_OK; +} + +s32 FTFaceH_GetRenderScale() +{ + UNIMPLEMENTED_FUNC(cellFontFT); + return CELL_OK; +} + +s32 FTFaceH_GetRenderScalePoint() +{ + UNIMPLEMENTED_FUNC(cellFontFT); + return CELL_OK; +} + +s32 FTFaceH_SetCompositeCodes() +{ + UNIMPLEMENTED_FUNC(cellFontFT); + return CELL_OK; +} + +s32 FTFaceH_SetRenderScalePixel() +{ + UNIMPLEMENTED_FUNC(cellFontFT); + return CELL_OK; +} + +s32 FTFaceH_SetRenderScalePoint() +{ + UNIMPLEMENTED_FUNC(cellFontFT); + return CELL_OK; +} + +s32 FTManager_CloseFace() +{ + UNIMPLEMENTED_FUNC(cellFontFT); + return CELL_OK; +} + +s32 FTManager_Done_FreeType() +{ + UNIMPLEMENTED_FUNC(cellFontFT); + return CELL_OK; +} + +s32 FTManager_Init_FreeType() +{ + UNIMPLEMENTED_FUNC(cellFontFT); + return CELL_OK; +} + +s32 FTManager_OpenFileFace() +{ + UNIMPLEMENTED_FUNC(cellFontFT); + return CELL_OK; +} + +s32 FTManager_OpenMemFace() +{ + UNIMPLEMENTED_FUNC(cellFontFT); + return CELL_OK; +} + +s32 FTManager_OpenStreamFace() +{ + UNIMPLEMENTED_FUNC(cellFontFT); + return CELL_OK; +} + DECLARE(ppu_module_manager::cellFontFT)("cellFontFT", []() { REG_FUNC(cellFontFT, cellFontInitLibraryFreeTypeWithRevision); REG_FUNC(cellFontFT, cellFontFTGetRevisionFlags); REG_FUNC(cellFontFT, cellFontFTGetInitializedRevisionFlags); + + REG_FUNC(cellFontFT, FTCacheStream_CacheEnd); + REG_FUNC(cellFontFT, FTCacheStream_CacheInit); + REG_FUNC(cellFontFT, FTCacheStream_CalcCacheIndexSize); + REG_FUNC(cellFontFT, FTCacheStream_Init); + + REG_FUNC(cellFontFT, FTFaceH_FontFamilyName); + REG_FUNC(cellFontFT, FTFaceH_FontStyleName); + REG_FUNC(cellFontFT, FTFaceH_GetAscender); + REG_FUNC(cellFontFT, FTFaceH_GetBoundingBoxHeight); + REG_FUNC(cellFontFT, FTFaceH_GetBoundingBoxMaxX); + REG_FUNC(cellFontFT, FTFaceH_GetBoundingBoxMaxY); + REG_FUNC(cellFontFT, FTFaceH_GetBoundingBoxMinX); + REG_FUNC(cellFontFT, FTFaceH_GetBoundingBoxMinY); + REG_FUNC(cellFontFT, FTFaceH_GetBoundingBoxWidth); + REG_FUNC(cellFontFT, FTFaceH_GetGlyphImage); + REG_FUNC(cellFontFT, FTFaceH_GetGlyphMetrics); + REG_FUNC(cellFontFT, FTFaceH_GetMaxHorizontalAdvance); + REG_FUNC(cellFontFT, FTFaceH_GetRenderBufferSize); + REG_FUNC(cellFontFT, FTFaceH_GetRenderScale); + REG_FUNC(cellFontFT, FTFaceH_GetRenderScalePoint); + REG_FUNC(cellFontFT, FTFaceH_SetCompositeCodes); + REG_FUNC(cellFontFT, FTFaceH_SetRenderScalePixel); + REG_FUNC(cellFontFT, FTFaceH_SetRenderScalePoint); + + REG_FUNC(cellFontFT, FTManager_CloseFace); + REG_FUNC(cellFontFT, FTManager_Done_FreeType); + REG_FUNC(cellFontFT, FTManager_Init_FreeType); + REG_FUNC(cellFontFT, FTManager_OpenFileFace); + REG_FUNC(cellFontFT, FTManager_OpenMemFace); + REG_FUNC(cellFontFT, FTManager_OpenStreamFace); }); diff --git a/rpcs3/Emu/Cell/Modules/cellFs.cpp b/rpcs3/Emu/Cell/Modules/cellFs.cpp index ee56ab390b..46ac80ffd8 100644 --- a/rpcs3/Emu/Cell/Modules/cellFs.cpp +++ b/rpcs3/Emu/Cell/Modules/cellFs.cpp @@ -1,4 +1,4 @@ -#include "stdafx.h" +#include "stdafx.h" #include "Emu/System.h" #include "Emu/IdManager.h" #include "Emu/Cell/PPUModule.h" @@ -25,6 +25,12 @@ s32 cellFsOpen(vm::cptr path, s32 flags, vm::ptr fd, vm::cptr a return sys_fs_open(path, flags, fd, flags & CELL_FS_O_CREAT ? CELL_FS_S_IRUSR | CELL_FS_S_IWUSR : 0, arg, size); } +s32 cellFsOpen2() +{ + UNIMPLEMENTED_FUNC(cellFs); + return CELL_OK; +} + s32 cellFsRead(u32 fd, vm::ptr buf, u64 nbytes, vm::ptr nread) { cellFs.trace("cellFsRead(fd=0x%x, buf=0x%x, nbytes=0x%llx, nread=0x%x)", fd, buf, nbytes, nread); @@ -171,6 +177,12 @@ s32 cellFsFGetBlockSize(u32 fd, vm::ptr sector_size, vm::ptr block_siz return sys_fs_fget_block_size(fd, sector_size, block_size, vm::var{}, vm::var{}); } +s32 cellFsFGetBlockSize2() +{ + UNIMPLEMENTED_FUNC(cellFs); + return CELL_OK; +} + s32 cellFsGetBlockSize(vm::cptr path, vm::ptr sector_size, vm::ptr block_size) { cellFs.warning("cellFsGetBlockSize(path=%s, sector_size=*0x%x, block_size=*0x%x) -> sys_fs_get_block_size()", path, sector_size, block_size); @@ -181,6 +193,12 @@ s32 cellFsGetBlockSize(vm::cptr path, vm::ptr sector_size, vm::ptr{}); } +s32 cellFsGetBlockSize2() +{ + UNIMPLEMENTED_FUNC(cellFs); + return CELL_OK; +} + s32 cellFsTruncate(vm::cptr path, u64 size) { cellFs.warning("cellFsTruncate(path=%s, size=0x%llx) -> sys_fs_truncate()", path, size); @@ -209,6 +227,12 @@ s32 cellFsChmod(vm::cptr path, s32 mode) return sys_fs_chmod(path, mode); } +s32 cellFsChown() +{ + UNIMPLEMENTED_FUNC(cellFs); + return CELL_OK; +} + s32 cellFsUtime(vm::cptr path, vm::cptr timep) { cellFs.warning("cellFsUtime(path=%s, timep=*0x%x) -> sys_fs_utime()", path, timep); @@ -609,6 +633,12 @@ s32 cellFsSdataOpenByFd(u32 mself_fd, s32 flags, vm::ptr sdata_fd, u64 offs return CELL_OK; } +s32 cellFsSdataOpenWithVersion() +{ + UNIMPLEMENTED_FUNC(cellFs); + return CELL_OK; +} + using fs_aio_cb_t = vm::ptr xaio, s32 error, s32 xid, u64 size)>; // temporarily @@ -836,12 +866,97 @@ s32 cellFsUnregisterL10nCallbacks() fmt::throw_exception("Unimplemented" HERE); } +s32 cellFsAclRead() +{ + UNIMPLEMENTED_FUNC(cellFs); + return CELL_OK; +} + +s32 cellFsAclWrite() +{ + UNIMPLEMENTED_FUNC(cellFs); + return CELL_OK; +} + +s32 cellFsFcntl() +{ + UNIMPLEMENTED_FUNC(cellFs); + return CELL_OK; +} + +s32 cellFsFdatasync() +{ + UNIMPLEMENTED_FUNC(cellFs); + return CELL_OK; +} + +s32 cellFsLink() +{ + UNIMPLEMENTED_FUNC(cellFs); + return CELL_OK; +} + +s32 cellFsLsnGetCDA() +{ + UNIMPLEMENTED_FUNC(cellFs); + return CELL_OK; +} + +s32 cellFsLsnGetCDASize() +{ + UNIMPLEMENTED_FUNC(cellFs); + return CELL_OK; +} + +s32 cellFsLsnLock() +{ + UNIMPLEMENTED_FUNC(cellFs); + return CELL_OK; +} + +s32 cellFsLsnRead() +{ + UNIMPLEMENTED_FUNC(cellFs); + return CELL_OK; +} + +s32 cellFsLsnRead2() +{ + UNIMPLEMENTED_FUNC(cellFs); + return CELL_OK; +} + +s32 cellFsLsnUnlock() +{ + UNIMPLEMENTED_FUNC(cellFs); + return CELL_OK; +} + +s32 cellFsMappedAllocate() +{ + UNIMPLEMENTED_FUNC(cellFs); + return CELL_OK; +} + +s32 cellFsMappedFree() +{ + UNIMPLEMENTED_FUNC(cellFs); + return CELL_OK; +} + +s32 cellFsSymbolicLink() +{ + UNIMPLEMENTED_FUNC(cellFs); + return CELL_OK; +} DECLARE(ppu_module_manager::cellFs)("sys_fs", []() { REG_FUNC(sys_fs, cellFsOpen); + REG_FUNC(sys_fs, cellFsOpen2); REG_FUNC(sys_fs, cellFsSdataOpen); REG_FUNC(sys_fs, cellFsSdataOpenByFd); + REG_FUNC(sys_fs, cellFsSdataOpenWithVersion); REG_FUNC(sys_fs, cellFsRead).flags = MFF_PERFECT; REG_FUNC(sys_fs, cellFsWrite).flags = MFF_PERFECT; REG_FUNC(sys_fs, cellFsClose).flags = MFF_PERFECT; @@ -853,6 +968,7 @@ DECLARE(ppu_module_manager::cellFs)("sys_fs", []() REG_FUNC(sys_fs, cellFsMkdir); REG_FUNC(sys_fs, cellFsRename); REG_FUNC(sys_fs, cellFsChmod); + REG_FUNC(sys_fs, cellFsChown); REG_FUNC(sys_fs, cellFsFsync); REG_FUNC(sys_fs, cellFsRmdir); REG_FUNC(sys_fs, cellFsUnlink); @@ -860,12 +976,14 @@ DECLARE(ppu_module_manager::cellFs)("sys_fs", []() REG_FUNC(sys_fs, cellFsFtruncate).flags = MFF_PERFECT; REG_FUNC(sys_fs, cellFsTruncate); REG_FUNC(sys_fs, cellFsFGetBlockSize).flags = MFF_PERFECT; + REG_FUNC(sys_fs, cellFsFGetBlockSize2); REG_FUNC(sys_fs, cellFsAioInit); REG_FUNC(sys_fs, cellFsAioFinish); REG_FUNC(sys_fs, cellFsAioRead); REG_FUNC(sys_fs, cellFsAioWrite); REG_FUNC(sys_fs, cellFsAioCancel); REG_FUNC(sys_fs, cellFsGetBlockSize); + REG_FUNC(sys_fs, cellFsGetBlockSize2); REG_FUNC(sys_fs, cellFsGetFreeSize); REG_FUNC(sys_fs, cellFsReadWithOffset); REG_FUNC(sys_fs, cellFsWriteWithOffset); @@ -897,4 +1015,24 @@ DECLARE(ppu_module_manager::cellFs)("sys_fs", []() REG_FUNC(sys_fs, cellFsSetDiscReadRetrySetting); REG_FUNC(sys_fs, cellFsRegisterConversionCallback); REG_FUNC(sys_fs, cellFsUnregisterL10nCallbacks); + + REG_FUNC(sys_fs, cellFsAclRead); + REG_FUNC(sys_fs, cellFsAclWrite); + + REG_FUNC(sys_fs, cellFsFcntl); + REG_FUNC(sys_fs, cellFsFdatasync); + + REG_FUNC(sys_fs, cellFsLink); + + REG_FUNC(sys_fs, cellFsLsnGetCDA); + REG_FUNC(sys_fs, cellFsLsnGetCDASize); + REG_FUNC(sys_fs, cellFsLsnLock); + REG_FUNC(sys_fs, cellFsLsnRead); + REG_FUNC(sys_fs, cellFsLsnRead2); + REG_FUNC(sys_fs, cellFsLsnUnlock); + + REG_FUNC(sys_fs, cellFsMappedAllocate); + REG_FUNC(sys_fs, cellFsMappedFree); + + REG_FUNC(sys_fs, cellFsSymbolicLink); }); diff --git a/rpcs3/Emu/Cell/Modules/cellHttp.cpp b/rpcs3/Emu/Cell/Modules/cellHttp.cpp index 088241c209..7909f67294 100644 --- a/rpcs3/Emu/Cell/Modules/cellHttp.cpp +++ b/rpcs3/Emu/Cell/Modules/cellHttp.cpp @@ -1,10 +1,17 @@ -#include "stdafx.h" +#include "stdafx.h" #include "Emu/Cell/PPUModule.h" #include "cellHttp.h" logs::channel cellHttp("cellHttp", logs::level::notice); + +s32 cellHttpAuthCacheFlush() +{ + UNIMPLEMENTED_FUNC(cellHttp); + return CELL_OK; +} + s32 cellHttpInit() { UNIMPLEMENTED_FUNC(cellHttp); @@ -65,12 +72,30 @@ s32 cellHttpSessionCookieFlush() return CELL_OK; } +s32 cellHttpCookieExport() +{ + UNIMPLEMENTED_FUNC(cellHttp); + return CELL_OK; +} + s32 cellHttpCookieExportWithClientId() { UNIMPLEMENTED_FUNC(cellHttp); return CELL_OK; } +s32 cellHttpCookieFlush() +{ + UNIMPLEMENTED_FUNC(cellHttp); + return CELL_OK; +} + +s32 cellHttpCookieImport() +{ + UNIMPLEMENTED_FUNC(cellHttp); + return CELL_OK; +} + s32 cellHttpCookieImportWithClientId() { UNIMPLEMENTED_FUNC(cellHttp); @@ -257,6 +282,18 @@ s32 cellHttpClientPollConnections() return CELL_OK; } +s32 cellHttpClientSetConnectionStateCallback() +{ + UNIMPLEMENTED_FUNC(cellHttp); + return CELL_OK; +} + +s32 cellHttpClientSetConnectionWaitStatus() +{ + UNIMPLEMENTED_FUNC(cellHttp); + return CELL_OK; +} + s32 cellHttpClientSetRecvTimeout() { UNIMPLEMENTED_FUNC(cellHttp); @@ -601,6 +638,7 @@ s32 cellHttpClientSetSslIdDestroyCallback() DECLARE(ppu_module_manager::cellHttp)("cellHttp", []() { + REG_FUNC(cellHttp, cellHttpAuthCacheFlush); REG_FUNC(cellHttp, cellHttpInit); REG_FUNC(cellHttp, cellHttpEnd); REG_FUNC(cellHttp, cellHttpsInit); @@ -612,8 +650,13 @@ DECLARE(ppu_module_manager::cellHttp)("cellHttp", []() REG_FUNC(cellHttp, cellHttpEndCookie); REG_FUNC(cellHttp, cellHttpAddCookieWithClientId); REG_FUNC(cellHttp, cellHttpSessionCookieFlush); + + REG_FUNC(cellHttp, cellHttpCookieExport); REG_FUNC(cellHttp, cellHttpCookieExportWithClientId); + REG_FUNC(cellHttp, cellHttpCookieFlush); + REG_FUNC(cellHttp, cellHttpCookieImport); REG_FUNC(cellHttp, cellHttpCookieImportWithClientId); + REG_FUNC(cellHttp, cellHttpClientSetCookieSendCallback); REG_FUNC(cellHttp, cellHttpClientSetCookieRecvCallback); @@ -647,6 +690,9 @@ DECLARE(ppu_module_manager::cellHttp)("cellHttp", []() REG_FUNC(cellHttp, cellHttpClientCloseAllConnections); REG_FUNC(cellHttp, cellHttpClientCloseConnections); REG_FUNC(cellHttp, cellHttpClientPollConnections); + + REG_FUNC(cellHttp, cellHttpClientSetConnectionStateCallback); + REG_FUNC(cellHttp, cellHttpClientSetConnectionWaitStatus); REG_FUNC(cellHttp, cellHttpClientSetRecvTimeout); REG_FUNC(cellHttp, cellHttpClientGetRecvTimeout); REG_FUNC(cellHttp, cellHttpClientSetSendTimeout); diff --git a/rpcs3/Emu/Cell/Modules/cellRtc.cpp b/rpcs3/Emu/Cell/Modules/cellRtc.cpp index 5edc1d7972..2440a0ccb1 100644 --- a/rpcs3/Emu/Cell/Modules/cellRtc.cpp +++ b/rpcs3/Emu/Cell/Modules/cellRtc.cpp @@ -1,4 +1,4 @@ -#include "stdafx.h" +#include "stdafx.h" #include "Emu/Cell/PPUModule.h" #include "cellRtc.h" @@ -175,6 +175,12 @@ s32 cellRtcConvertLocalTimeToUtc(vm::ptr pLocalTime, vm::ptr pDateTime, vm::ptr puiDosTime) { cellRtc.todo("cellRtcGetDosTime(pDateTime=*0x%x, puiDosTime=*0x%x)", pDateTime, puiDosTime); @@ -182,6 +188,12 @@ s32 cellRtcGetDosTime(vm::ptr pDateTime, vm::ptr puiDosTim return CELL_OK; } +s32 cellRtcGetSystemTime() +{ + UNIMPLEMENTED_FUNC(cellRtc); + return CELL_OK; +} + s32 cellRtcGetTime_t(vm::ptr pDateTime, vm::ptr piTime) { cellRtc.todo("cellRtcGetTime_t(pDateTime=*0x%x, piTime=*0x%x)", pDateTime, piTime); @@ -196,6 +208,24 @@ s32 cellRtcGetWin32FileTime(vm::ptr pDateTime, vm::ptr pul return CELL_OK; } +s32 cellRtcSetCurrentSecureTick() +{ + UNIMPLEMENTED_FUNC(cellRtc); + return CELL_OK; +} + +s32 cellRtcSetCurrentTick() +{ + UNIMPLEMENTED_FUNC(cellRtc); + return CELL_OK; +} + +s32 cellRtcSetConf() +{ + UNIMPLEMENTED_FUNC(cellRtc); + return CELL_OK; +} + s32 cellRtcSetDosTime(vm::ptr pDateTime, u32 uiDosTime) { cellRtc.todo("cellRtcSetDosTime(pDateTime=*0x%x, uiDosTime=0x%x)", pDateTime, uiDosTime); @@ -203,6 +233,12 @@ s32 cellRtcSetDosTime(vm::ptr pDateTime, u32 uiDosTime) return CELL_OK; } +s32 cellRtcGetTickResolution() +{ + UNIMPLEMENTED_FUNC(cellRtc); + return CELL_OK; +} + s32 cellRtcSetTime_t(vm::ptr pDateTime, u64 iTime) { cellRtc.todo("cellRtcSetTime_t(pDateTime=*0x%x, iTime=0x%llx)", pDateTime, iTime); @@ -210,6 +246,12 @@ s32 cellRtcSetTime_t(vm::ptr pDateTime, u64 iTime) return CELL_OK; } +s32 cellRtcSetSystemTime() +{ + UNIMPLEMENTED_FUNC(cellRtc); + return CELL_OK; +} + s32 cellRtcSetWin32FileTime(vm::ptr pDateTime, u64 ulWin32FileTime) { cellRtc.todo("cellRtcSetWin32FileTime(pDateTime=*0x%x, ulWin32FileTime=0x%llx)", pDateTime, ulWin32FileTime); @@ -252,48 +294,6 @@ s32 cellRtcCompareTick(vm::ptr pTick0, vm::ptr pTick1) return CELL_OK; } -s32 cellRtcGetCurrentSecureTick() -{ - UNIMPLEMENTED_FUNC(cellRtc); - return CELL_OK; -} - -s32 cellRtcGetTickResolution() -{ - UNIMPLEMENTED_FUNC(cellRtc); - return CELL_OK; -} - -s32 cellRtcGetSystemTime() -{ - UNIMPLEMENTED_FUNC(cellRtc); - return CELL_OK; -} - -s32 cellRtcSetConf() -{ - UNIMPLEMENTED_FUNC(cellRtc); - return CELL_OK; -} - -s32 cellRtcSetCurrentSecureTick() -{ - UNIMPLEMENTED_FUNC(cellRtc); - return CELL_OK; -} - -s32 cellRtcSetCurrentTick() -{ - UNIMPLEMENTED_FUNC(cellRtc); - return CELL_OK; -} - -s32 cellRtcSetSystemTime() -{ - UNIMPLEMENTED_FUNC(cellRtc); - return CELL_OK; -} - DECLARE(ppu_module_manager::cellRtc)("cellRtc", []() { REG_FUNC(cellRtc, cellRtcGetCurrentTick); @@ -309,6 +309,7 @@ DECLARE(ppu_module_manager::cellRtc)("cellRtc", []() REG_FUNC(cellRtc, cellRtcGetTick); REG_FUNC(cellRtc, cellRtcSetTick); + REG_FUNC(cellRtc, cellRtcTickAddTicks); REG_FUNC(cellRtc, cellRtcTickAddMicroseconds); REG_FUNC(cellRtc, cellRtcTickAddSeconds); @@ -318,14 +319,23 @@ DECLARE(ppu_module_manager::cellRtc)("cellRtc", []() REG_FUNC(cellRtc, cellRtcTickAddWeeks); REG_FUNC(cellRtc, cellRtcTickAddMonths); REG_FUNC(cellRtc, cellRtcTickAddYears); + REG_FUNC(cellRtc, cellRtcConvertUtcToLocalTime); REG_FUNC(cellRtc, cellRtcConvertLocalTimeToUtc); + REG_FUNC(cellRtc, cellRtcGetCurrentSecureTick); REG_FUNC(cellRtc, cellRtcGetDosTime); + REG_FUNC(cellRtc, cellRtcGetTickResolution); + REG_FUNC(cellRtc, cellRtcGetSystemTime); REG_FUNC(cellRtc, cellRtcGetTime_t); REG_FUNC(cellRtc, cellRtcGetWin32FileTime); + + REG_FUNC(cellRtc, cellRtcSetConf); + REG_FUNC(cellRtc, cellRtcSetCurrentSecureTick); + REG_FUNC(cellRtc, cellRtcSetCurrentTick); REG_FUNC(cellRtc, cellRtcSetDosTime); REG_FUNC(cellRtc, cellRtcSetTime_t); + REG_FUNC(cellRtc, cellRtcSetSystemTime); REG_FUNC(cellRtc, cellRtcSetWin32FileTime); REG_FUNC(cellRtc, cellRtcIsLeapYear); @@ -334,11 +344,4 @@ DECLARE(ppu_module_manager::cellRtc)("cellRtc", []() REG_FUNC(cellRtc, cellRtcCheckValid); REG_FUNC(cellRtc, cellRtcCompareTick); - REG_FUNC(cellRtc, cellRtcGetCurrentSecureTick); - REG_FUNC(cellRtc, cellRtcGetTickResolution); - REG_FUNC(cellRtc, cellRtcGetSystemTime); - REG_FUNC(cellRtc, cellRtcSetConf); - REG_FUNC(cellRtc, cellRtcSetCurrentSecureTick); - REG_FUNC(cellRtc, cellRtcSetCurrentTick); - REG_FUNC(cellRtc, cellRtcSetSystemTime); }); diff --git a/rpcs3/Emu/Cell/Modules/cellSsl.cpp b/rpcs3/Emu/Cell/Modules/cellSsl.cpp index daa0707378..5bfd7232a2 100644 --- a/rpcs3/Emu/Cell/Modules/cellSsl.cpp +++ b/rpcs3/Emu/Cell/Modules/cellSsl.cpp @@ -1,4 +1,4 @@ -#include "stdafx.h" +#include "stdafx.h" #include "Emu/Cell/PPUModule.h" logs::channel cellSsl("cellSsl", logs::level::notice); @@ -87,6 +87,444 @@ s32 cellSslCertGetMd5Fingerprint() return CELL_OK; } +s32 _cellSslConvertCipherId() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 _cellSslConvertSslVersion() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 _cellSslIsInitd() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 _cellSslPemReadPrivateKey() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 _cellSslPemReadX509() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 BER_read_item() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 BIO_ctrl() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 BIO_dump() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 BIO_get_cb_arg() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 BIO_get_retry_reason() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 BIO_new_mem() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 BIO_new_socket() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 BIO_printf() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 BIO_ptr_ctrl() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 BIO_set_cb_arg() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 ERR_clear_error() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 ERR_get_error() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 ERR_error_string() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 ERR_func_error_string() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 ERR_peek_error() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 EVP_PKEY_free() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 R_time_cmp() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 R_time_export() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 R_time_free() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 R_time_import() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 R_time_new() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSL_CIPHER_description() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSL_CIPHER_get_bits() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSL_CIPHER_get_name() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSL_CIPHER_get_version() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSL_CTX_ctrl() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSL_CTX_free() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSL_CTX_new() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSL_CTX_set_app_verify_cb() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSL_CTX_set_info_cb() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSL_CTX_set_options() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSL_CTX_set_verify_mode() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSL_CTX_use_certificate() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSL_SESSION_free() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSL_alert_type_string_long() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSL_do_handshake() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSL_free() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSL_get_current_cipher() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSL_get_error() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSL_get_version() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSL_new() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSL_peek() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSL_read() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSL_set_bio() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSL_set_ssl_method() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSL_shutdown() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSL_state() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSL_state_string_long() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSL_version() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSL_want() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSL_write() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSLCERT_free() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSLCERT_from_binary() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSLCERT_get_basic_constraints_int() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSLCERT_get_extension() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSLCERT_get_issuer_name() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSLCERT_get_notAfter() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSLCERT_get_notBefore() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSLCERT_get_pubkey() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSLCERT_NAME_cmp() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSLCERT_NAME_ENTRY_get_info() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSLCERT_NAME_get_entry() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSLCERT_NAME_get_entry_count() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSLCERT_NAME_oneline() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSLCERT_OID_to_string() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSLCERT_verify() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 SSLv3_client_method() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +s32 TLSv1_client_method() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + DECLARE(ppu_module_manager::cellSsl)("cellSsl", []() { REG_FUNC(cellSsl, cellSslInit); @@ -105,4 +543,94 @@ DECLARE(ppu_module_manager::cellSsl)("cellSsl", []() REG_FUNC(cellSsl, cellSslCertGetNameEntryCount); REG_FUNC(cellSsl, cellSslCertGetNameEntryInfo); REG_FUNC(cellSsl, cellSslCertGetMd5Fingerprint); + + REG_FUNC(cellSsl, _cellSslConvertCipherId); + REG_FUNC(cellSsl, _cellSslConvertSslVersion); + REG_FUNC(cellSsl, _cellSslIsInitd); + REG_FUNC(cellSsl, _cellSslPemReadPrivateKey); + REG_FUNC(cellSsl, _cellSslPemReadX509); + + REG_FUNC(cellSsl, BER_read_item); + + REG_FUNC(cellSsl, BIO_ctrl); + REG_FUNC(cellSsl, BIO_dump); + REG_FUNC(cellSsl, BIO_get_cb_arg); + REG_FUNC(cellSsl, BIO_get_retry_reason); + REG_FUNC(cellSsl, BIO_new_mem); + REG_FUNC(cellSsl, BIO_new_socket); + REG_FUNC(cellSsl, BIO_printf); + REG_FUNC(cellSsl, BIO_ptr_ctrl); + REG_FUNC(cellSsl, BIO_set_cb_arg); + + REG_FUNC(cellSsl, ERR_clear_error); + REG_FUNC(cellSsl, ERR_get_error); + REG_FUNC(cellSsl, ERR_error_string); + REG_FUNC(cellSsl, ERR_func_error_string); + REG_FUNC(cellSsl, ERR_peek_error); + + REG_FUNC(cellSsl, EVP_PKEY_free); + + REG_FUNC(cellSsl, R_time_cmp); + REG_FUNC(cellSsl, R_time_export); + REG_FUNC(cellSsl, R_time_free); + REG_FUNC(cellSsl, R_time_import); + REG_FUNC(cellSsl, R_time_new); + + REG_FUNC(cellSsl, SSL_CIPHER_description); + REG_FUNC(cellSsl, SSL_CIPHER_get_bits); + REG_FUNC(cellSsl, SSL_CIPHER_get_name); + REG_FUNC(cellSsl, SSL_CIPHER_get_version); + + REG_FUNC(cellSsl, SSL_CTX_ctrl); + REG_FUNC(cellSsl, SSL_CTX_free); + REG_FUNC(cellSsl, SSL_CTX_new); + REG_FUNC(cellSsl, SSL_CTX_set_app_verify_cb); + REG_FUNC(cellSsl, SSL_CTX_set_info_cb); + REG_FUNC(cellSsl, SSL_CTX_set_options); + REG_FUNC(cellSsl, SSL_CTX_set_verify_mode); + REG_FUNC(cellSsl, SSL_CTX_use_certificate); + + REG_FUNC(cellSsl, SSL_SESSION_free); + + REG_FUNC(cellSsl, SSL_alert_type_string_long); + REG_FUNC(cellSsl, SSL_do_handshake); + REG_FUNC(cellSsl, SSL_free); + REG_FUNC(cellSsl, SSL_get_current_cipher); + REG_FUNC(cellSsl, SSL_get_error); + REG_FUNC(cellSsl, SSL_get_version); + REG_FUNC(cellSsl, SSL_new); + REG_FUNC(cellSsl, SSL_peek); + REG_FUNC(cellSsl, SSL_read); + REG_FUNC(cellSsl, SSL_set_bio); + REG_FUNC(cellSsl, SSL_set_ssl_method); + REG_FUNC(cellSsl, SSL_shutdown); + REG_FUNC(cellSsl, SSL_state); + REG_FUNC(cellSsl, SSL_state_string_long); + REG_FUNC(cellSsl, SSL_version); + REG_FUNC(cellSsl, SSL_want); + REG_FUNC(cellSsl, SSL_write); + + REG_FUNC(cellSsl, SSLCERT_free); + REG_FUNC(cellSsl, SSLCERT_from_binary); + + REG_FUNC(cellSsl, SSLCERT_get_basic_constraints_int); + REG_FUNC(cellSsl, SSLCERT_get_extension); + REG_FUNC(cellSsl, SSLCERT_get_issuer_name); + REG_FUNC(cellSsl, SSLCERT_get_notAfter); + REG_FUNC(cellSsl, SSLCERT_get_notBefore); + REG_FUNC(cellSsl, SSLCERT_get_pubkey); + + REG_FUNC(cellSsl, SSLCERT_NAME_cmp); + REG_FUNC(cellSsl, SSLCERT_NAME_ENTRY_get_info); + REG_FUNC(cellSsl, SSLCERT_NAME_get_entry); + REG_FUNC(cellSsl, SSLCERT_NAME_get_entry_count); + REG_FUNC(cellSsl, SSLCERT_NAME_oneline); + + REG_FUNC(cellSsl, SSLCERT_OID_to_string); + + REG_FUNC(cellSsl, SSLCERT_verify); + + REG_FUNC(cellSsl, SSLv3_client_method); + + REG_FUNC(cellSsl, TLSv1_client_method); }); diff --git a/rpcs3/Emu/Cell/Modules/cell_FreeType2.cpp b/rpcs3/Emu/Cell/Modules/cell_FreeType2.cpp new file mode 100644 index 0000000000..c249c908b4 --- /dev/null +++ b/rpcs3/Emu/Cell/Modules/cell_FreeType2.cpp @@ -0,0 +1,218 @@ +#include "stdafx.h" +#include "Emu/System.h" +#include "Emu/Cell/PPUModule.h" + +logs::channel cell_FreeType2("cell_FreeType2", logs::level::notice); + +// Functions +s32 cellFreeType2Ex() +{ + UNIMPLEMENTED_FUNC(cell_FreeType2); + return CELL_OK; +} + +s32 FT_Add_Default_Modules() +{ + UNIMPLEMENTED_FUNC(cell_FreeType2); + return CELL_OK; +} + +s32 FT_Bitmap_Copy() +{ + UNIMPLEMENTED_FUNC(cell_FreeType2); + return CELL_OK; +} + +s32 FT_Bitmap_Embolden() +{ + UNIMPLEMENTED_FUNC(cell_FreeType2); + return CELL_OK; +} + +s32 FT_Bitmap_New() +{ + UNIMPLEMENTED_FUNC(cell_FreeType2); + return CELL_OK; +} + +s32 FT_Done_Face() +{ + UNIMPLEMENTED_FUNC(cell_FreeType2); + return CELL_OK; +} + +s32 FT_Done_Glyph() +{ + UNIMPLEMENTED_FUNC(cell_FreeType2); + return CELL_OK; +} + +s32 FT_Get_Char_Index() +{ + UNIMPLEMENTED_FUNC(cell_FreeType2); + return CELL_OK; +} + +s32 FT_Get_Glyph() +{ + UNIMPLEMENTED_FUNC(cell_FreeType2); + return CELL_OK; +} + +s32 FT_Get_Sfnt_Table() +{ + UNIMPLEMENTED_FUNC(cell_FreeType2); + return CELL_OK; +} + +s32 FT_Glyph_Copy() +{ + UNIMPLEMENTED_FUNC(cell_FreeType2); + return CELL_OK; +} + +s32 FT_Glyph_Get_CBox() +{ + UNIMPLEMENTED_FUNC(cell_FreeType2); + return CELL_OK; +} + +s32 FT_Glyph_To_Bitmap() +{ + UNIMPLEMENTED_FUNC(cell_FreeType2); + return CELL_OK; +} + +s32 FT_Glyph_Transform() +{ + UNIMPLEMENTED_FUNC(cell_FreeType2); + return CELL_OK; +} + +s32 FT_Init_FreeType() +{ + UNIMPLEMENTED_FUNC(cell_FreeType2); + return CELL_OK; +} + +s32 FT_Load_Glyph() +{ + UNIMPLEMENTED_FUNC(cell_FreeType2); + return CELL_OK; +} + +s32 FT_MulFix() +{ + UNIMPLEMENTED_FUNC(cell_FreeType2); + return CELL_OK; +} + +s32 FT_New_Face() +{ + UNIMPLEMENTED_FUNC(cell_FreeType2); + return CELL_OK; +} + +s32 FT_New_Library() +{ + UNIMPLEMENTED_FUNC(cell_FreeType2); + return CELL_OK; +} + +s32 FT_New_Memory_Face() +{ + UNIMPLEMENTED_FUNC(cell_FreeType2); + return CELL_OK; +} + +s32 FT_Open_Face() +{ + UNIMPLEMENTED_FUNC(cell_FreeType2); + return CELL_OK; +} + +s32 FT_Outline_Embolden() +{ + UNIMPLEMENTED_FUNC(cell_FreeType2); + return CELL_OK; +} + +s32 FT_Render_Glyph() +{ + UNIMPLEMENTED_FUNC(cell_FreeType2); + return CELL_OK; +} + + +s32 FT_RoundFix() +{ + UNIMPLEMENTED_FUNC(cell_FreeType2); + return CELL_OK; +} + +s32 FT_Select_Charmap() +{ + UNIMPLEMENTED_FUNC(cell_FreeType2); + return CELL_OK; +} + +s32 FT_Set_Char_Size() +{ + UNIMPLEMENTED_FUNC(cell_FreeType2); + return CELL_OK; +} + +s32 FT_Set_Transform() +{ + UNIMPLEMENTED_FUNC(cell_FreeType2); + return CELL_OK; +} + +s32 FT_Vector_Transform() +{ + UNIMPLEMENTED_FUNC(cell_FreeType2); + return CELL_OK; +} + +DECLARE(ppu_module_manager::cell_FreeType2)("cell_FreeType2", []() +{ + REG_FUNC(cell_FreeType2, cellFreeType2Ex); + + REG_FUNC(cell_FreeType2, FT_Add_Default_Modules); + + REG_FUNC(cell_FreeType2, FT_Bitmap_Copy); + REG_FUNC(cell_FreeType2, FT_Bitmap_Embolden); + REG_FUNC(cell_FreeType2, FT_Bitmap_New); + + REG_FUNC(cell_FreeType2, FT_Done_Face); + REG_FUNC(cell_FreeType2, FT_Done_Glyph); + + REG_FUNC(cell_FreeType2, FT_Get_Char_Index); + REG_FUNC(cell_FreeType2, FT_Get_Glyph); + REG_FUNC(cell_FreeType2, FT_Get_Sfnt_Table); + + REG_FUNC(cell_FreeType2, FT_Glyph_Copy); + REG_FUNC(cell_FreeType2, FT_Glyph_Get_CBox); + REG_FUNC(cell_FreeType2, FT_Glyph_To_Bitmap); + REG_FUNC(cell_FreeType2, FT_Glyph_Transform); + + REG_FUNC(cell_FreeType2, FT_Init_FreeType); + REG_FUNC(cell_FreeType2, FT_Load_Glyph); + REG_FUNC(cell_FreeType2, FT_MulFix); + + REG_FUNC(cell_FreeType2, FT_New_Face); + REG_FUNC(cell_FreeType2, FT_New_Library); + REG_FUNC(cell_FreeType2, FT_New_Memory_Face); + + REG_FUNC(cell_FreeType2, FT_Open_Face); + REG_FUNC(cell_FreeType2, FT_Outline_Embolden); + REG_FUNC(cell_FreeType2, FT_Render_Glyph); + REG_FUNC(cell_FreeType2, FT_RoundFix); + REG_FUNC(cell_FreeType2, FT_Select_Charmap); + + REG_FUNC(cell_FreeType2, FT_Set_Char_Size); + REG_FUNC(cell_FreeType2, FT_Set_Transform); + + REG_FUNC(cell_FreeType2, FT_Vector_Transform); +}); + diff --git a/rpcs3/Emu/Cell/Modules/sys_io.cpp b/rpcs3/Emu/Cell/Modules/sys_io.cpp index 3b212433d4..802eedae08 100644 --- a/rpcs3/Emu/Cell/Modules/sys_io.cpp +++ b/rpcs3/Emu/Cell/Modules/sys_io.cpp @@ -1,4 +1,4 @@ -#include "stdafx.h" +#include "stdafx.h" #include "Emu/Cell/PPUModule.h" logs::channel sys_io("sys_io", logs::level::notice); @@ -28,11 +28,21 @@ s32 sys_config_remove_service_listener() fmt::throw_exception("Unimplemented" HERE); } +s32 sys_config_register_io_error_handler() +{ + fmt::throw_exception("Unimplemented" HERE); +} + s32 sys_config_register_service() { fmt::throw_exception("Unimplemented" HERE); } +s32 sys_config_unregister_io_error_handler() +{ + fmt::throw_exception("Unimplemented" HERE); +} + s32 sys_config_unregister_service() { fmt::throw_exception("Unimplemented" HERE); @@ -49,6 +59,8 @@ DECLARE(ppu_module_manager::sys_io)("sys_io", []() REG_FUNC(sys_io, sys_config_stop); REG_FUNC(sys_io, sys_config_add_service_listener); REG_FUNC(sys_io, sys_config_remove_service_listener); + REG_FUNC(sys_io, sys_config_register_io_error_handler); REG_FUNC(sys_io, sys_config_register_service); + REG_FUNC(sys_io, sys_config_unregister_io_error_handler); REG_FUNC(sys_io, sys_config_unregister_service); }); diff --git a/rpcs3/Emu/Cell/Modules/sys_net.cpp b/rpcs3/Emu/Cell/Modules/sys_net.cpp index ccbcfbc627..ba7d57926a 100644 --- a/rpcs3/Emu/Cell/Modules/sys_net.cpp +++ b/rpcs3/Emu/Cell/Modules/sys_net.cpp @@ -1,4 +1,4 @@ -#include "stdafx.h" +#include "stdafx.h" #include "Emu/Cell/PPUModule.h" #include "Emu/IdManager.h" @@ -899,12 +899,30 @@ namespace sys_net return CELL_OK; } + s32 sys_net_get_if_list() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 sys_net_get_name_server() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + s32 sys_net_get_netemu_test_param() { UNIMPLEMENTED_FUNC(libnet); return CELL_OK; } + s32 sys_net_get_routing_table_af() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + s32 sys_net_get_sockinfo(s32 s, vm::ptr p, s32 n) { libnet.todo("sys_net_get_sockinfo()"); @@ -1022,6 +1040,221 @@ namespace sys_net libnet.todo("sys_net_free_thread_context(tid=%d, flags=%d)", tid, flags); return CELL_OK; } + + s32 _sys_net_lib_abort() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 _sys_net_lib_bnet_control() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 __sys_net_lib_calloc() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 _sys_net_lib_free() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 _sys_net_lib_get_system_time() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 _sys_net_lib_if_nametoindex() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 _sys_net_lib_ioctl() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 __sys_net_lib_malloc() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 _sys_net_lib_rand() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 __sys_net_lib_realloc() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 _sys_net_lib_reset_libnetctl_queue() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 _sys_net_lib_set_libnetctl_queue() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 _sys_net_lib_thread_create() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 _sys_net_lib_thread_exit() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 _sys_net_lib_thread_join() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 _sys_net_lib_sync_clear() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 _sys_net_lib_sync_create() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 _sys_net_lib_sync_destroy() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 _sys_net_lib_sync_signal() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 _sys_net_lib_sync_wait() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 _sys_net_lib_sysctl() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 _sys_net_lib_usleep() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 sys_netset_abort() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 sys_netset_close() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 sys_netset_get_if_id() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 sys_netset_get_status() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 sys_netset_if_down() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 sys_netset_get_key_value() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + s32 sys_netset_if_up() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 sys_netset_open() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 _sce_net_get_name_server() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 _sce_net_add_name_server_with_char() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 _sce_net_flush_route() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 _sce_net_set_default_gateway() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 _sce_net_set_ip_and_mask() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } + + s32 _sce_net_set_name_server() + { + UNIMPLEMENTED_FUNC(libnet); + return CELL_OK; + } } // Define macro for namespace @@ -1065,7 +1298,10 @@ DECLARE(ppu_module_manager::libnet)("sys_net", []() REG_FUNC_(sys_net_set_udpp2p_test_param); REG_FUNC_(sys_net_get_lib_name_server); REG_FUNC_(sys_net_if_ctl); + REG_FUNC_(sys_net_get_if_list); + REG_FUNC_(sys_net_get_name_server); REG_FUNC_(sys_net_get_netemu_test_param); + REG_FUNC_(sys_net_get_routing_table_af); REG_FUNC_(sys_net_get_sockinfo); REG_FUNC_(sys_net_close_dump); REG_FUNC_(sys_net_set_test_param); @@ -1085,4 +1321,47 @@ DECLARE(ppu_module_manager::libnet)("sys_net", []() REG_FUNC_(_sys_net_h_errno_loc); REG_FUNC_(sys_net_set_netemu_test_param); REG_FUNC_(sys_net_free_thread_context); + + REG_FUNC_(_sys_net_lib_abort); + REG_FUNC_(_sys_net_lib_bnet_control); + REG_FUNC_(__sys_net_lib_calloc); + REG_FUNC_(_sys_net_lib_free); + REG_FUNC_(_sys_net_lib_get_system_time); + REG_FUNC_(_sys_net_lib_if_nametoindex); + REG_FUNC_(_sys_net_lib_ioctl); + REG_FUNC_(__sys_net_lib_malloc); + REG_FUNC_(_sys_net_lib_rand); + REG_FUNC_(__sys_net_lib_realloc); + REG_FUNC_(_sys_net_lib_reset_libnetctl_queue); + REG_FUNC_(_sys_net_lib_set_libnetctl_queue); + + REG_FUNC_(_sys_net_lib_thread_create); + REG_FUNC_(_sys_net_lib_thread_exit); + REG_FUNC_(_sys_net_lib_thread_join); + + REG_FUNC_(_sys_net_lib_sync_clear); + REG_FUNC_(_sys_net_lib_sync_create); + REG_FUNC_(_sys_net_lib_sync_destroy); + REG_FUNC_(_sys_net_lib_sync_signal); + REG_FUNC_(_sys_net_lib_sync_wait); + + REG_FUNC_(_sys_net_lib_sysctl); + REG_FUNC_(_sys_net_lib_usleep); + + REG_FUNC_(sys_netset_abort); + REG_FUNC_(sys_netset_close); + REG_FUNC_(sys_netset_get_if_id); + REG_FUNC_(sys_netset_get_key_value); + REG_FUNC_(sys_netset_get_status); + REG_FUNC_(sys_netset_if_down); + REG_FUNC_(sys_netset_if_up); + REG_FUNC_(sys_netset_open); + + REG_FUNC_(_sce_net_add_name_server_with_char); + REG_FUNC_(_sce_net_flush_route); + + REG_FUNC_(_sce_net_get_name_server); + REG_FUNC_(_sce_net_set_default_gateway); + REG_FUNC_(_sce_net_set_ip_and_mask); + REG_FUNC_(_sce_net_set_name_server); }); diff --git a/rpcs3/Emu/Cell/PPUModule.cpp b/rpcs3/Emu/Cell/PPUModule.cpp index 2fb9de6a90..7dd65a4e0e 100644 --- a/rpcs3/Emu/Cell/PPUModule.cpp +++ b/rpcs3/Emu/Cell/PPUModule.cpp @@ -1,4 +1,4 @@ -#include "stdafx.h" +#include "stdafx.h" #include "Utilities/Config.h" #include "Utilities/AutoPause.h" #include "Crypto/sha1.h" @@ -34,6 +34,7 @@ LOG_CHANNEL(cellDmux); LOG_CHANNEL(cellFiber); LOG_CHANNEL(cellFont); LOG_CHANNEL(cellFontFT); +LOG_CHANNEL(cell_FreeType2); LOG_CHANNEL(cellFs); LOG_CHANNEL(cellGame); LOG_CHANNEL(cellGameExec); @@ -226,6 +227,7 @@ static void ppu_initialize_modules() &ppu_module_manager::cellFiber, &ppu_module_manager::cellFont, &ppu_module_manager::cellFontFT, + &ppu_module_manager::cell_FreeType2, &ppu_module_manager::cellFs, &ppu_module_manager::cellGame, &ppu_module_manager::cellGameExec, diff --git a/rpcs3/Emu/Cell/PPUModule.h b/rpcs3/Emu/Cell/PPUModule.h index f1d5024019..ddbad4a821 100644 --- a/rpcs3/Emu/Cell/PPUModule.h +++ b/rpcs3/Emu/Cell/PPUModule.h @@ -1,4 +1,4 @@ -#pragma once +#pragma once #include "PPUFunction.h" #include "PPUCallback.h" @@ -120,6 +120,7 @@ public: static const ppu_static_module cellFiber; static const ppu_static_module cellFont; static const ppu_static_module cellFontFT; + static const ppu_static_module cell_FreeType2; static const ppu_static_module cellFs; static const ppu_static_module cellGame; static const ppu_static_module cellGameExec; diff --git a/rpcs3/emucore.vcxproj b/rpcs3/emucore.vcxproj index 4de590baf1..7f8c520aad 100644 --- a/rpcs3/emucore.vcxproj +++ b/rpcs3/emucore.vcxproj @@ -156,6 +156,7 @@ + diff --git a/rpcs3/emucore.vcxproj.filters b/rpcs3/emucore.vcxproj.filters index a9c2f5ae6c..b48947d452 100644 --- a/rpcs3/emucore.vcxproj.filters +++ b/rpcs3/emucore.vcxproj.filters @@ -347,6 +347,9 @@ Emu\Cell\Modules + + Emu\Cell\Modules + Emu\Cell\Modules