From 35898a6cdf3d4afcff106342d31876eb305a3264 Mon Sep 17 00:00:00 2001 From: Nekotekina Date: Fri, 30 Jan 2015 02:58:53 +0300 Subject: [PATCH] Some functions added --- rpcs3/Emu/ARMv7/Modules/sceFiber.cpp | 24 +- rpcs3/Emu/ARMv7/Modules/sceGxm.h | 6 +- rpcs3/Emu/ARMv7/Modules/sceHttp.cpp | 455 +++++++++++++++++++++--- rpcs3/Emu/ARMv7/Modules/sceJpeg.cpp | 120 ++++++- rpcs3/Emu/ARMv7/Modules/sceJpegEnc.cpp | 89 ++++- rpcs3/Emu/ARMv7/Modules/sceLiveArea.cpp | 14 +- rpcs3/Emu/ARMv7/Modules/sceLocation.cpp | 202 ++++++++++- rpcs3/Emu/ARMv7/Modules/sceMd5.cpp | 39 +- rpcs3/Emu/ARMv7/Modules/sceMotion.cpp | 133 ++++++- rpcs3/Emu/ARMv7/Modules/sceMt19937.cpp | 21 +- rpcs3/Emu/ARMv7/PSVFuncList.h | 16 + 11 files changed, 997 insertions(+), 122 deletions(-) diff --git a/rpcs3/Emu/ARMv7/Modules/sceFiber.cpp b/rpcs3/Emu/ARMv7/Modules/sceFiber.cpp index 8d21dc8f66..ab35f7a9be 100644 --- a/rpcs3/Emu/ARMv7/Modules/sceFiber.cpp +++ b/rpcs3/Emu/ARMv7/Modules/sceFiber.cpp @@ -6,33 +6,37 @@ extern psv_log_base sceFiber; typedef vm::psv::ptr SceFiberEntry; -union SceFiber +struct SceFiber { static const uint size = 128; static const uint align = 8; u64 padding[size / sizeof(u64)]; }; -union SceFiberOptParam +struct SceFiberOptParam { static const uint size = 128; static const uint align = 8; u64 padding[size / sizeof(u64)]; }; -union SceFiberInfo +struct SceFiberInfo { static const uint size = 128; static const uint align = 8; - u64 padding[size / sizeof(u64)]; - struct + union { - SceFiberEntry entry; - u32 argOnInitialize; - vm::psv::ptr addrContext; - s32 sizeContext; - char name[32]; + u64 padding[size / sizeof(u64)]; + + struct + { + SceFiberEntry entry; + u32 argOnInitialize; + vm::psv::ptr addrContext; + s32 sizeContext; + char name[32]; + }; }; }; diff --git a/rpcs3/Emu/ARMv7/Modules/sceGxm.h b/rpcs3/Emu/ARMv7/Modules/sceGxm.h index 28cdac4daf..390c7ed1e7 100644 --- a/rpcs3/Emu/ARMv7/Modules/sceGxm.h +++ b/rpcs3/Emu/ARMv7/Modules/sceGxm.h @@ -1002,9 +1002,9 @@ enum SceGxmColorMask : u8 struct SceGxmBlendInfo { - SceGxmColorMask colorMask; - SceGxmBlendFunc colorFunc : 4; - SceGxmBlendFunc alphaFunc : 4; + SceGxmColorMask colorMask; + SceGxmBlendFunc colorFunc : 4; + SceGxmBlendFunc alphaFunc : 4; SceGxmBlendFactor colorSrc : 4; SceGxmBlendFactor colorDst : 4; SceGxmBlendFactor alphaSrc : 4; diff --git a/rpcs3/Emu/ARMv7/Modules/sceHttp.cpp b/rpcs3/Emu/ARMv7/Modules/sceHttp.cpp index 4f23c935cd..814159303e 100644 --- a/rpcs3/Emu/ARMv7/Modules/sceHttp.cpp +++ b/rpcs3/Emu/ARMv7/Modules/sceHttp.cpp @@ -4,6 +4,355 @@ extern psv_log_base sceHttp; +enum SceHttpHttpVersion : s32 +{ + SCE_HTTP_VERSION_1_0 = 1, + SCE_HTTP_VERSION_1_1 +}; + +enum SceHttpProxyMode : s32 +{ + SCE_HTTP_PROXY_AUTO, + SCE_HTTP_PROXY_MANUAL +}; + +enum SceHttpAddHeaderMode : s32 +{ + SCE_HTTP_HEADER_OVERWRITE, + SCE_HTTP_HEADER_ADD +}; + +enum SceHttpAuthType : s32 +{ + SCE_HTTP_AUTH_BASIC, + SCE_HTTP_AUTH_DIGEST, + SCE_HTTP_AUTH_RESERVED0, + SCE_HTTP_AUTH_RESERVED1, + SCE_HTTP_AUTH_RESERVED2 +}; + +typedef vm::psv::ptr realm, vm::psv::ptr username, vm::psv::ptr password, s32 needEntity, vm::psv::ptr> entityBody, vm::psv::ptr entitySize, vm::psv::ptr save, vm::psv::ptr userArg)> SceHttpAuthInfoCallback; + +typedef vm::psv::ptr method, vm::psv::ptr location, vm::psv::ptr userArg)> SceHttpRedirectCallback; + +struct SceHttpMemoryPoolStats +{ + u32 poolSize; + u32 maxInuseSize; + u32 currentInuseSize; + s32 reserved; +}; + +struct SceHttpUriElement +{ + s32 opaque; + vm::psv::ptr scheme; + vm::psv::ptr username; + vm::psv::ptr password; + vm::psv::ptr hostname; + vm::psv::ptr path; + vm::psv::ptr query; + vm::psv::ptr fragment; + u16 port; + u8 reserved[10]; +}; + +typedef vm::psv::ptr url, vm::psv::ptr cookieHeader, u32 headerLen, vm::psv::ptr userArg)> SceHttpCookieRecvCallback; + +typedef vm::psv::ptr url, vm::psv::ptr cookieHeader, vm::psv::ptr userArg)> SceHttpCookieSendCallback; + +struct SceSslCert; + +struct SceHttpsData +{ + vm::psv::ptr ptr; + u32 size; +}; + +struct SceHttpsCaList +{ + vm::psv::ptr> caCerts; + s32 caNum; +}; + +typedef vm::psv::ptr> sslCert, s32 certNum, vm::psv::ptr userArg)> SceHttpsCallback; + +s32 sceHttpInit(u32 poolSize) +{ + throw __FUNCTION__; +} + +s32 sceHttpTerm() +{ + throw __FUNCTION__; +} + +s32 sceHttpGetMemoryPoolStats(vm::psv::ptr currentStat) +{ + throw __FUNCTION__; +} + +s32 sceHttpCreateTemplate(vm::psv::ptr userAgent, s32 httpVer, s32 autoProxyConf) +{ + throw __FUNCTION__; +} + +s32 sceHttpDeleteTemplate(s32 tmplId) +{ + throw __FUNCTION__; +} + +s32 sceHttpCreateConnection(s32 tmplId, vm::psv::ptr serverName, vm::psv::ptr scheme, u16 port, s32 enableKeepalive) +{ + throw __FUNCTION__; +} + +s32 sceHttpCreateConnectionWithURL(s32 tmplId, vm::psv::ptr url, s32 enableKeepalive) +{ + throw __FUNCTION__; +} + +s32 sceHttpDeleteConnection(s32 connId) +{ + throw __FUNCTION__; +} + +s32 sceHttpCreateRequest(s32 connId, s32 method, vm::psv::ptr path, u64 contentLength) +{ + throw __FUNCTION__; +} + +s32 sceHttpCreateRequestWithURL(s32 connId, s32 method, vm::psv::ptr url, u64 contentLength) +{ + throw __FUNCTION__; +} + +s32 sceHttpDeleteRequest(s32 reqId) +{ + throw __FUNCTION__; +} + +s32 sceHttpSetResponseHeaderMaxSize(s32 id, u32 headerSize) +{ + throw __FUNCTION__; +} + +s32 sceHttpSetRecvBlockSize(s32 id, u32 blockSize) +{ + throw __FUNCTION__; +} + +s32 sceHttpSetRequestContentLength(s32 id, u64 contentLength) +{ + throw __FUNCTION__; +} + +s32 sceHttpSendRequest(s32 reqId, vm::psv::ptr postData, u32 size) +{ + throw __FUNCTION__; +} + +s32 sceHttpAbortRequest(s32 reqId) +{ + throw __FUNCTION__; +} + +s32 sceHttpGetResponseContentLength(s32 reqId, vm::psv::ptr contentLength) +{ + throw __FUNCTION__; +} + +s32 sceHttpGetStatusCode(s32 reqId, vm::psv::ptr statusCode) +{ + throw __FUNCTION__; +} + +s32 sceHttpGetAllResponseHeaders(s32 reqId, vm::psv::ptr> header, vm::psv::ptr headerSize) +{ + throw __FUNCTION__; +} + +s32 sceHttpReadData(s32 reqId, vm::psv::ptr data, u32 size) +{ + throw __FUNCTION__; +} + +s32 sceHttpAddRequestHeader(s32 id, vm::psv::ptr name, vm::psv::ptr value, u32 mode) +{ + throw __FUNCTION__; +} + +s32 sceHttpRemoveRequestHeader(s32 id, vm::psv::ptr name) +{ + throw __FUNCTION__; +} + +s32 sceHttpParseResponseHeader(vm::psv::ptr header, u32 headerLen, vm::psv::ptr fieldStr, vm::psv::ptr> fieldValue, vm::psv::ptr valueLen) +{ + throw __FUNCTION__; +} + +s32 sceHttpParseStatusLine(vm::psv::ptr statusLine, u32 lineLen, vm::psv::ptr httpMajorVer, vm::psv::ptr httpMinorVer, vm::psv::ptr responseCode, vm::psv::ptr> reasonPhrase, vm::psv::ptr phraseLen) +{ + throw __FUNCTION__; +} + +s32 sceHttpSetAuthInfoCallback(s32 id, SceHttpAuthInfoCallback cbfunc, vm::psv::ptr userArg) +{ + throw __FUNCTION__; +} + +s32 sceHttpSetAuthEnabled(s32 id, s32 enable) +{ + throw __FUNCTION__; +} + +s32 sceHttpGetAuthEnabled(s32 id, vm::psv::ptr enable) +{ + throw __FUNCTION__; +} + +s32 sceHttpSetRedirectCallback(s32 id, SceHttpRedirectCallback cbfunc, vm::psv::ptr userArg) +{ + throw __FUNCTION__; +} + +s32 sceHttpSetAutoRedirect(s32 id, s32 enable) +{ + throw __FUNCTION__; +} + +s32 sceHttpGetAutoRedirect(s32 id, vm::psv::ptr enable) +{ + throw __FUNCTION__; +} + +s32 sceHttpSetResolveTimeOut(s32 id, u32 usec) +{ + throw __FUNCTION__; +} + +s32 sceHttpSetResolveRetry(s32 id, s32 retry) +{ + throw __FUNCTION__; +} + +s32 sceHttpSetConnectTimeOut(s32 id, u32 usec) +{ + throw __FUNCTION__; +} + +s32 sceHttpSetSendTimeOut(s32 id, u32 usec) +{ + throw __FUNCTION__; +} + +s32 sceHttpSetRecvTimeOut(s32 id, u32 usec) +{ + throw __FUNCTION__; +} + +s32 sceHttpUriEscape(vm::psv::ptr out, vm::psv::ptr require, u32 prepare, vm::psv::ptr in) +{ + throw __FUNCTION__; +} + +s32 sceHttpUriUnescape(vm::psv::ptr out, vm::psv::ptr require, u32 prepare, vm::psv::ptr in) +{ + throw __FUNCTION__; +} + +s32 sceHttpUriParse(vm::psv::ptr out, vm::psv::ptr srcUrl, vm::psv::ptr pool, vm::psv::ptr require, u32 prepare) +{ + throw __FUNCTION__; +} + +s32 sceHttpUriBuild(vm::psv::ptr out, vm::psv::ptr require, u32 prepare, vm::psv::ptr srcElement, u32 option) +{ + throw __FUNCTION__; +} + +s32 sceHttpUriMerge(vm::psv::ptr mergedUrl, vm::psv::ptr url, vm::psv::ptr relativeUrl, vm::psv::ptr require, u32 prepare, u32 option) +{ + throw __FUNCTION__; +} + +s32 sceHttpUriSweepPath(vm::psv::ptr dst, vm::psv::ptr src, u32 srcSize) +{ + throw __FUNCTION__; +} + +s32 sceHttpSetCookieEnabled(s32 id, s32 enable) +{ + throw __FUNCTION__; +} + +s32 sceHttpGetCookieEnabled(s32 id, vm::psv::ptr enable) +{ + throw __FUNCTION__; +} + +s32 sceHttpGetCookie(vm::psv::ptr url, vm::psv::ptr cookie, vm::psv::ptr cookieLength, u32 prepare, s32 secure) +{ + throw __FUNCTION__; +} + +s32 sceHttpAddCookie(vm::psv::ptr url, vm::psv::ptr cookie, u32 cookieLength) +{ + throw __FUNCTION__; +} + +s32 sceHttpSetCookieRecvCallback(s32 id, SceHttpCookieRecvCallback cbfunc, vm::psv::ptr userArg) +{ + throw __FUNCTION__; +} + +s32 sceHttpSetCookieSendCallback(s32 id, SceHttpCookieSendCallback cbfunc, vm::psv::ptr userArg) +{ + throw __FUNCTION__; +} + +s32 sceHttpsLoadCert(s32 caCertNum, vm::psv::ptr> caList, vm::psv::ptr cert, vm::psv::ptr privKey) +{ + throw __FUNCTION__; +} + +s32 sceHttpsUnloadCert() +{ + throw __FUNCTION__; +} + +s32 sceHttpsEnableOption(u32 sslFlags) +{ + throw __FUNCTION__; +} + +s32 sceHttpsDisableOption(u32 sslFlags) +{ + throw __FUNCTION__; +} + +s32 sceHttpsGetSslError(s32 id, vm::psv::ptr errNum, vm::psv::ptr detail) +{ + throw __FUNCTION__; +} + +s32 sceHttpsSetSslCallback(s32 id, SceHttpsCallback cbfunc, vm::psv::ptr userArg) +{ + throw __FUNCTION__; +} + +s32 sceHttpsGetCaList(vm::psv::ptr caList) +{ + throw __FUNCTION__; +} + +s32 sceHttpsFreeCaList(vm::psv::ptr caList) +{ + throw __FUNCTION__; +} + + #define REG_FUNC(nid, name) reg_psv_func(nid, &sceHttp, #name, name) psv_log_base sceHttp("SceHttp", []() @@ -12,45 +361,45 @@ psv_log_base sceHttp("SceHttp", []() sceHttp.on_unload = nullptr; sceHttp.on_stop = nullptr; - //REG_FUNC(0x214926D9, sceHttpInit); - //REG_FUNC(0xC9076666, sceHttpTerm); - //REG_FUNC(0xF98CDFA9, sceHttpGetMemoryPoolStats); - //REG_FUNC(0x62241DAB, sceHttpCreateTemplate); - //REG_FUNC(0xEC85ECFB, sceHttpDeleteTemplate); - //REG_FUNC(0xC616C200, sceHttpCreateConnectionWithURL); - //REG_FUNC(0xAEB3307E, sceHttpCreateConnection); - //REG_FUNC(0xF0F65C15, sceHttpDeleteConnection); - //REG_FUNC(0xBD5DA1D0, sceHttpCreateRequestWithURL); - //REG_FUNC(0xB0284270, sceHttpCreateRequest); - //REG_FUNC(0x3D3D29AD, sceHttpDeleteRequest); - //REG_FUNC(0x9CA58B99, sceHttpSendRequest); - //REG_FUNC(0x7EDE3979, sceHttpReadData); - //REG_FUNC(0xF580D304, sceHttpGetResponseContentLength); - //REG_FUNC(0x27071691, sceHttpGetStatusCode); - //REG_FUNC(0xEA61662F, sceHttpAbortRequest); - //REG_FUNC(0x7B51B122, sceHttpAddRequestHeader); - //REG_FUNC(0x5EB5F548, sceHttpRemoveRequestHeader); - //REG_FUNC(0x11F6C27F, sceHttpGetAllResponseHeaders); - //REG_FUNC(0x03A6C89E, sceHttpParseResponseHeader); - //REG_FUNC(0x179C56DB, sceHttpParseStatusLine); - //REG_FUNC(0x1DA2A673, sceHttpUriEscape); - //REG_FUNC(0x1274D318, sceHttpUriUnescape); - //REG_FUNC(0x1D45F24E, sceHttpUriParse); - //REG_FUNC(0x47664424, sceHttpUriBuild); - //REG_FUNC(0x75027D1D, sceHttpUriMerge); - //REG_FUNC(0x50737A3F, sceHttpUriSweepPath); - //REG_FUNC(0x37C30C90, sceHttpSetRequestContentLength); - //REG_FUNC(0x11EC42D0, sceHttpSetAuthEnabled); - //REG_FUNC(0x6727874C, sceHttpGetAuthEnabled); - //REG_FUNC(0x34891C3F, sceHttpSetAutoRedirect); - //REG_FUNC(0x6EAD73EB, sceHttpGetAutoRedirect); - //REG_FUNC(0xE0A3A88D, sceHttpSetAuthInfoCallback); - //REG_FUNC(0x4E08167D, sceHttpSetRedirectCallback); - //REG_FUNC(0x8455B5B3, sceHttpSetResolveTimeOut); - //REG_FUNC(0x9AB56EA7, sceHttpSetResolveRetry); - //REG_FUNC(0x237CA86E, sceHttpSetConnectTimeOut); - //REG_FUNC(0x8AE3F008, sceHttpSetSendTimeOut); - //REG_FUNC(0x94BF196E, sceHttpSetRecvTimeOut); + REG_FUNC(0x214926D9, sceHttpInit); + REG_FUNC(0xC9076666, sceHttpTerm); + REG_FUNC(0xF98CDFA9, sceHttpGetMemoryPoolStats); + REG_FUNC(0x62241DAB, sceHttpCreateTemplate); + REG_FUNC(0xEC85ECFB, sceHttpDeleteTemplate); + REG_FUNC(0xC616C200, sceHttpCreateConnectionWithURL); + REG_FUNC(0xAEB3307E, sceHttpCreateConnection); + REG_FUNC(0xF0F65C15, sceHttpDeleteConnection); + REG_FUNC(0xBD5DA1D0, sceHttpCreateRequestWithURL); + REG_FUNC(0xB0284270, sceHttpCreateRequest); + REG_FUNC(0x3D3D29AD, sceHttpDeleteRequest); + REG_FUNC(0x9CA58B99, sceHttpSendRequest); + REG_FUNC(0x7EDE3979, sceHttpReadData); + REG_FUNC(0xF580D304, sceHttpGetResponseContentLength); + REG_FUNC(0x27071691, sceHttpGetStatusCode); + REG_FUNC(0xEA61662F, sceHttpAbortRequest); + REG_FUNC(0x7B51B122, sceHttpAddRequestHeader); + REG_FUNC(0x5EB5F548, sceHttpRemoveRequestHeader); + REG_FUNC(0x11F6C27F, sceHttpGetAllResponseHeaders); + REG_FUNC(0x03A6C89E, sceHttpParseResponseHeader); + REG_FUNC(0x179C56DB, sceHttpParseStatusLine); + REG_FUNC(0x1DA2A673, sceHttpUriEscape); + REG_FUNC(0x1274D318, sceHttpUriUnescape); + REG_FUNC(0x1D45F24E, sceHttpUriParse); + REG_FUNC(0x47664424, sceHttpUriBuild); + REG_FUNC(0x75027D1D, sceHttpUriMerge); + REG_FUNC(0x50737A3F, sceHttpUriSweepPath); + REG_FUNC(0x37C30C90, sceHttpSetRequestContentLength); + REG_FUNC(0x11EC42D0, sceHttpSetAuthEnabled); + REG_FUNC(0x6727874C, sceHttpGetAuthEnabled); + REG_FUNC(0x34891C3F, sceHttpSetAutoRedirect); + REG_FUNC(0x6EAD73EB, sceHttpGetAutoRedirect); + REG_FUNC(0xE0A3A88D, sceHttpSetAuthInfoCallback); + REG_FUNC(0x4E08167D, sceHttpSetRedirectCallback); + REG_FUNC(0x8455B5B3, sceHttpSetResolveTimeOut); + REG_FUNC(0x9AB56EA7, sceHttpSetResolveRetry); + REG_FUNC(0x237CA86E, sceHttpSetConnectTimeOut); + REG_FUNC(0x8AE3F008, sceHttpSetSendTimeOut); + REG_FUNC(0x94BF196E, sceHttpSetRecvTimeOut); //REG_FUNC(0x27A98BDA, sceHttpSetNonblock); //REG_FUNC(0xD65746BC, sceHttpGetNonblock); //REG_FUNC(0x5CEB6554, sceHttpSetEpollId); @@ -61,22 +410,22 @@ psv_log_base sceHttp("SceHttp", []() //REG_FUNC(0xCFB1DA4B, sceHttpUnsetEpoll); //REG_FUNC(0x65FE983F, sceHttpGetEpoll); //REG_FUNC(0x07D9F8BB, sceHttpDestroyEpoll); - //REG_FUNC(0xAEE573A3, sceHttpSetCookieEnabled); - //REG_FUNC(0x1B6EF66E, sceHttpGetCookieEnabled); - //REG_FUNC(0x70220BFA, sceHttpGetCookie); - //REG_FUNC(0xBEDB988D, sceHttpAddCookie); + REG_FUNC(0xAEE573A3, sceHttpSetCookieEnabled); + REG_FUNC(0x1B6EF66E, sceHttpGetCookieEnabled); + REG_FUNC(0x70220BFA, sceHttpGetCookie); + REG_FUNC(0xBEDB988D, sceHttpAddCookie); //REG_FUNC(0x4259FB9E, sceHttpCookieExport); //REG_FUNC(0x9DF48282, sceHttpCookieImport); - //REG_FUNC(0xD4F32A23, sceHttpSetCookieRecvCallback); - //REG_FUNC(0x11C03867, sceHttpSetCookieSendCallback); - //REG_FUNC(0xAE8D7C33, sceHttpsLoadCert); - //REG_FUNC(0x8577833F, sceHttpsUnloadCert); - //REG_FUNC(0x9FBE2869, sceHttpsEnableOption); - //REG_FUNC(0xC6D60403, sceHttpsDisableOption); + REG_FUNC(0xD4F32A23, sceHttpSetCookieRecvCallback); + REG_FUNC(0x11C03867, sceHttpSetCookieSendCallback); + REG_FUNC(0xAE8D7C33, sceHttpsLoadCert); + REG_FUNC(0x8577833F, sceHttpsUnloadCert); + REG_FUNC(0x9FBE2869, sceHttpsEnableOption); + REG_FUNC(0xC6D60403, sceHttpsDisableOption); //REG_FUNC(0x72CB0741, sceHttpsEnableOptionPrivate); //REG_FUNC(0x00659635, sceHttpsDisableOptionPrivate); - //REG_FUNC(0x2B79BDE0, sceHttpsGetSslError); - //REG_FUNC(0xA0926037, sceHttpsSetSslCallback); - //REG_FUNC(0xF71AA58D, sceHttpsGetCaList); - //REG_FUNC(0x56C95D94, sceHttpsFreeCaList); + REG_FUNC(0x2B79BDE0, sceHttpsGetSslError); + REG_FUNC(0xA0926037, sceHttpsSetSslCallback); + REG_FUNC(0xF71AA58D, sceHttpsGetCaList); + REG_FUNC(0x56C95D94, sceHttpsFreeCaList); }); diff --git a/rpcs3/Emu/ARMv7/Modules/sceJpeg.cpp b/rpcs3/Emu/ARMv7/Modules/sceJpeg.cpp index 5ec6f79614..06e8e0ec00 100644 --- a/rpcs3/Emu/ARMv7/Modules/sceJpeg.cpp +++ b/rpcs3/Emu/ARMv7/Modules/sceJpeg.cpp @@ -4,6 +4,108 @@ extern psv_log_base sceJpeg; +struct SceJpegOutputInfo +{ + s32 colorSpace; + u16 imageWidth; + u16 imageHeight; + u32 outputBufferSize; + u32 tempBufferSize; + u32 coefBufferSize; + + struct { u32 x, y; } pitch[4]; +}; + +struct SceJpegSplitDecodeCtrl +{ + vm::psv::ptr pStreamBuffer; + u32 streamBufferSize; + vm::psv::ptr pWriteBuffer; + u32 writeBufferSize; + s32 isEndOfStream; + s32 decodeMode; + + SceJpegOutputInfo outputInfo; + + vm::psv::ptr pOutputBuffer; + vm::psv::ptr pCoefBuffer; + + u32 internalData[3]; +}; + +s32 sceJpegInitMJpeg(s32 maxSplitDecoder) +{ + throw __FUNCTION__; +} + +s32 sceJpegFinishMJpeg() +{ + throw __FUNCTION__; +} + +s32 sceJpegDecodeMJpeg( + vm::psv::ptr pJpeg, + u32 isize, + vm::psv::ptr pRGBA, + u32 osize, + s32 decodeMode, + vm::psv::ptr pTempBuffer, + u32 tempBufferSize, + vm::psv::ptr pCoefBuffer, + u32 coefBufferSize) +{ + throw __FUNCTION__; +} + +s32 sceJpegDecodeMJpegYCbCr( + vm::psv::ptr pJpeg, + u32 isize, + vm::psv::ptr pYCbCr, + u32 osize, + s32 decodeMode, + vm::psv::ptr pCoefBuffer, + u32 coefBufferSize) +{ + throw __FUNCTION__; +} + +s32 sceJpegMJpegCsc( + vm::psv::ptr pRGBA, + vm::psv::ptr pYCbCr, + s32 xysize, + s32 iFrameWidth, + s32 colorOption, + s32 sampling) +{ + throw __FUNCTION__; +} + +s32 sceJpegGetOutputInfo( + vm::psv::ptr pJpeg, + u32 isize, + s32 outputFormat, + s32 decodeMode, + vm::psv::ptr pOutputInfo) +{ + throw __FUNCTION__; +} + +s32 sceJpegCreateSplitDecoder(vm::psv::ptr pCtrl) +{ + throw __FUNCTION__; +} + +s32 sceJpegDeleteSplitDecoder(vm::psv::ptr pCtrl) +{ + throw __FUNCTION__; +} + +s32 sceJpegSplitDecodeMJpeg(vm::psv::ptr pCtrl) +{ + throw __FUNCTION__; +} + + #define REG_FUNC(nid, name) reg_psv_func(nid, &sceJpeg, #name, name) psv_log_base sceJpeg("SceJpeg", []() @@ -12,13 +114,13 @@ psv_log_base sceJpeg("SceJpeg", []() sceJpeg.on_unload = nullptr; sceJpeg.on_stop = nullptr; - //REG_FUNC(0xB030773B, sceJpegInitMJpeg); - //REG_FUNC(0x62842598, sceJpegFinishMJpeg); - //REG_FUNC(0x6215B095, sceJpegDecodeMJpeg); - //REG_FUNC(0x2A769BD8, sceJpegDecodeMJpegYCbCr); - //REG_FUNC(0xC2380E3A, sceJpegMJpegCsc); - //REG_FUNC(0x353BA9B0, sceJpegGetOutputInfo); - //REG_FUNC(0x123B4734, sceJpegCreateSplitDecoder); - //REG_FUNC(0xDE8D5FA1, sceJpegDeleteSplitDecoder); - //REG_FUNC(0x4598EC9C, sceJpegSplitDecodeMJpeg); + REG_FUNC(0xB030773B, sceJpegInitMJpeg); + REG_FUNC(0x62842598, sceJpegFinishMJpeg); + REG_FUNC(0x6215B095, sceJpegDecodeMJpeg); + REG_FUNC(0x2A769BD8, sceJpegDecodeMJpegYCbCr); + REG_FUNC(0xC2380E3A, sceJpegMJpegCsc); + REG_FUNC(0x353BA9B0, sceJpegGetOutputInfo); + REG_FUNC(0x123B4734, sceJpegCreateSplitDecoder); + REG_FUNC(0xDE8D5FA1, sceJpegDeleteSplitDecoder); + REG_FUNC(0x4598EC9C, sceJpegSplitDecodeMJpeg); }); diff --git a/rpcs3/Emu/ARMv7/Modules/sceJpegEnc.cpp b/rpcs3/Emu/ARMv7/Modules/sceJpegEnc.cpp index 1567f5487d..690afd9e04 100644 --- a/rpcs3/Emu/ARMv7/Modules/sceJpegEnc.cpp +++ b/rpcs3/Emu/ARMv7/Modules/sceJpegEnc.cpp @@ -4,6 +4,77 @@ extern psv_log_base sceJpegEnc; +typedef vm::psv::ptr SceJpegEncoderContext; + +s32 sceJpegEncoderGetContextSize() +{ + throw __FUNCTION__; +} + +s32 sceJpegEncoderInit( + SceJpegEncoderContext context, + s32 iFrameWidth, + s32 iFrameHeight, + s32 pixelFormat, + vm::psv::ptr pJpeg, + u32 oJpegbufSize) +{ + throw __FUNCTION__; +} + +s32 sceJpegEncoderEncode( + SceJpegEncoderContext context, + vm::psv::ptr pYCbCr) +{ + throw __FUNCTION__; +} + +s32 sceJpegEncoderEnd(SceJpegEncoderContext context) +{ + throw __FUNCTION__; +} + +s32 sceJpegEncoderSetValidRegion( + SceJpegEncoderContext context, + s32 iFrameWidth, + s32 iFrameHeight) +{ + throw __FUNCTION__; +} + +s32 sceJpegEncoderSetCompressionRatio( + SceJpegEncoderContext context, + s32 compratio) +{ + throw __FUNCTION__; +} + +s32 sceJpegEncoderSetHeaderMode( + SceJpegEncoderContext context, + s32 headerMode) +{ + throw __FUNCTION__; +} + +s32 sceJpegEncoderSetOutputAddr( + SceJpegEncoderContext context, + vm::psv::ptr pJpeg, + u32 oJpegbufSize) +{ + throw __FUNCTION__; +} + +s32 sceJpegEncoderCsc( + SceJpegEncoderContext context, + vm::psv::ptr pYCbCr, + vm::psv::ptr pRGBA, + s32 iFrameWidth, + s32 inputPixelFormat) +{ + throw __FUNCTION__; +} + + #define REG_FUNC(nid, name) reg_psv_func(nid, &sceJpegEnc, #name, name) psv_log_base sceJpegEnc("SceJpegEnc", []() @@ -12,13 +83,13 @@ psv_log_base sceJpegEnc("SceJpegEnc", []() sceJpegEnc.on_unload = nullptr; sceJpegEnc.on_stop = nullptr; - //REG_FUNC(0x2B55844D, sceJpegEncoderGetContextSize); - //REG_FUNC(0x88DA92B4, sceJpegEncoderInit); - //REG_FUNC(0xC60DE94C, sceJpegEncoderEncode); - //REG_FUNC(0xC87AA849, sceJpegEncoderEnd); - //REG_FUNC(0x9511F3BC, sceJpegEncoderSetValidRegion); - //REG_FUNC(0xB2B828EC, sceJpegEncoderSetCompressionRatio); - //REG_FUNC(0x2F58B12C, sceJpegEncoderSetHeaderMode); - //REG_FUNC(0x25D52D97, sceJpegEncoderSetOutputAddr); - //REG_FUNC(0x824A7D4F, sceJpegEncoderCsc); + REG_FUNC(0x2B55844D, sceJpegEncoderGetContextSize); + REG_FUNC(0x88DA92B4, sceJpegEncoderInit); + REG_FUNC(0xC60DE94C, sceJpegEncoderEncode); + REG_FUNC(0xC87AA849, sceJpegEncoderEnd); + REG_FUNC(0x9511F3BC, sceJpegEncoderSetValidRegion); + REG_FUNC(0xB2B828EC, sceJpegEncoderSetCompressionRatio); + REG_FUNC(0x2F58B12C, sceJpegEncoderSetHeaderMode); + REG_FUNC(0x25D52D97, sceJpegEncoderSetOutputAddr); + REG_FUNC(0x824A7D4F, sceJpegEncoderCsc); }); diff --git a/rpcs3/Emu/ARMv7/Modules/sceLiveArea.cpp b/rpcs3/Emu/ARMv7/Modules/sceLiveArea.cpp index 4511ca2ae7..62eea18429 100644 --- a/rpcs3/Emu/ARMv7/Modules/sceLiveArea.cpp +++ b/rpcs3/Emu/ARMv7/Modules/sceLiveArea.cpp @@ -4,6 +4,16 @@ extern psv_log_base sceLiveArea; +s32 sceLiveAreaResourceReplaceAll(vm::psv::ptr dirpath) +{ + throw __FUNCTION__; +} + +s32 sceLiveAreaResourceGetStatus() +{ + throw __FUNCTION__; +} + #define REG_FUNC(nid, name) reg_psv_func(nid, &sceLiveArea, #name, name) psv_log_base sceLiveArea("SceLiveArea", []() @@ -12,6 +22,6 @@ psv_log_base sceLiveArea("SceLiveArea", []() sceLiveArea.on_unload = nullptr; sceLiveArea.on_stop = nullptr; - //REG_FUNC(0xA4B506F9, sceLiveAreaResourceReplaceAll); - //REG_FUNC(0x54A395FB, sceLiveAreaResourceGetStatus); + REG_FUNC(0xA4B506F9, sceLiveAreaResourceReplaceAll); + REG_FUNC(0x54A395FB, sceLiveAreaResourceGetStatus); }); diff --git a/rpcs3/Emu/ARMv7/Modules/sceLocation.cpp b/rpcs3/Emu/ARMv7/Modules/sceLocation.cpp index 734f7f62e1..8b61bca224 100644 --- a/rpcs3/Emu/ARMv7/Modules/sceLocation.cpp +++ b/rpcs3/Emu/ARMv7/Modules/sceLocation.cpp @@ -4,6 +4,174 @@ extern psv_log_base sceLocation; +typedef u8 SceLocationHandle; + +enum SceLocationLocationMethod : s32 +{ + SCE_LOCATION_LMETHOD_NONE = 0, + SCE_LOCATION_LMETHOD_AGPS_AND_3G_AND_WIFI = 1, + SCE_LOCATION_LMETHOD_GPS_AND_WIFI = 2, + SCE_LOCATION_LMETHOD_WIFI = 3, + SCE_LOCATION_LMETHOD_3G = 4, + SCE_LOCATION_LMETHOD_GPS = 5 +}; + +enum SceLocationHeadingMethod : s32 +{ + SCE_LOCATION_HMETHOD_NONE = 0, + SCE_LOCATION_HMETHOD_AUTO = 1, + SCE_LOCATION_HMETHOD_VERTICAL = 2, + SCE_LOCATION_HMETHOD_HORIZONTAL = 3, + SCE_LOCATION_HMETHOD_CAMERA = 4 +}; + +enum SceLocationDialogStatus : s32 +{ + SCE_LOCATION_DIALOG_STATUS_IDLE = 0, + SCE_LOCATION_DIALOG_STATUS_RUNNING = 1, + SCE_LOCATION_DIALOG_STATUS_FINISHED = 2 +}; + +enum SceLocationDialogResult : s32 +{ + SCE_LOCATION_DIALOG_RESULT_NONE = 0, + SCE_LOCATION_DIALOG_RESULT_DISABLE = 1, + SCE_LOCATION_DIALOG_RESULT_ENABLE = 2 +}; + +enum SceLocationPermissionApplicationStatus : s32 +{ + SCE_LOCATION_PERMISSION_APPLICATION_NONE = 0, + SCE_LOCATION_PERMISSION_APPLICATION_INIT = 1, + SCE_LOCATION_PERMISSION_APPLICATION_DENY = 2, + SCE_LOCATION_PERMISSION_APPLICATION_ALLOW = 3 +}; + +enum SceLocationPermissionStatus : s32 +{ + SCE_LOCATION_PERMISSION_DENY = 0, + SCE_LOCATION_PERMISSION_ALLOW = 1 +}; + +struct SceLocationLocationInfo +{ + double latitude; + double longitude; + double altitude; + float accuracy; + float reserve; + float direction; + float speed; + u64 timestamp; +}; + +struct SceLocationHeadingInfo +{ + float trueHeading; + float headingVectorX; + float headingVectorY; + float headingVectorZ; + float reserve; + float reserve2; + u64 timestamp; +}; + +typedef vm::psv::ptr location, vm::psv::ptr userdata)> SceLocationLocationInfoCallback; +typedef vm::psv::ptr heading, vm::psv::ptr userdata)> SceLocationHeadingInfoCallback; + +struct SceLocationPermissionInfo +{ + SceLocationPermissionStatus parentalstatus; + SceLocationPermissionStatus mainstatus; + SceLocationPermissionApplicationStatus applicationstatus; +}; + +s32 sceLocationOpen(vm::psv::ptr handle, SceLocationLocationMethod lmethod, SceLocationHeadingMethod hmethod) +{ + throw __FUNCTION__; +} + +s32 sceLocationClose(SceLocationHandle handle) +{ + throw __FUNCTION__; +} + +s32 sceLocationReopen(SceLocationHandle handle, SceLocationLocationMethod lmethod, SceLocationHeadingMethod hmethod) +{ + throw __FUNCTION__; +} + +s32 sceLocationGetMethod(SceLocationHandle handle, vm::psv::ptr lmethod, vm::psv::ptr hmethod) +{ + throw __FUNCTION__; +} + +s32 sceLocationGetLocation(SceLocationHandle handle, vm::psv::ptr linfo) +{ + throw __FUNCTION__; +} + +s32 sceLocationCancelGetLocation(SceLocationHandle handle) +{ + throw __FUNCTION__; +} + +s32 sceLocationStartLocationCallback(SceLocationHandle handle, u32 distance, SceLocationLocationInfoCallback callback, vm::psv::ptr userdata) +{ + throw __FUNCTION__; +} + +s32 sceLocationStopLocationCallback(SceLocationHandle handle) +{ + throw __FUNCTION__; +} + +s32 sceLocationGetHeading(SceLocationHandle handle, vm::psv::ptr hinfo) +{ + throw __FUNCTION__; +} + +s32 sceLocationStartHeadingCallback(SceLocationHandle handle, u32 difference, SceLocationHeadingInfoCallback callback, vm::psv::ptr userdata) +{ + throw __FUNCTION__; +} + +s32 sceLocationStopHeadingCallback(SceLocationHandle handle) +{ + throw __FUNCTION__; +} + +s32 sceLocationConfirm(SceLocationHandle handle) +{ + throw __FUNCTION__; +} + +s32 sceLocationConfirmGetStatus(SceLocationHandle handle, vm::psv::ptr status) +{ + throw __FUNCTION__; +} + +s32 sceLocationConfirmGetResult(SceLocationHandle handle, vm::psv::ptr result) +{ + throw __FUNCTION__; +} + +s32 sceLocationConfirmAbort(SceLocationHandle handle) +{ + throw __FUNCTION__; +} + +s32 sceLocationGetPermission(SceLocationHandle handle, vm::psv::ptr info) +{ + throw __FUNCTION__; +} + +s32 sceLocationSetGpsEmulationFile(vm::psv::ptr filename) +{ + throw __FUNCTION__; +} + + #define REG_FUNC(nid, name) reg_psv_func(nid, &sceLocation, #name, name) psv_log_base sceLocation("SceLibLocation", []() @@ -12,23 +180,23 @@ psv_log_base sceLocation("SceLibLocation", []() sceLocation.on_unload = nullptr; sceLocation.on_stop = nullptr; - //REG_FUNC(0xDD271661, sceLocationOpen); - //REG_FUNC(0x14FE76E8, sceLocationClose); - //REG_FUNC(0xB1F55065, sceLocationReopen); - //REG_FUNC(0x188CE004, sceLocationGetMethod); - //REG_FUNC(0x15BC27C8, sceLocationGetLocation); - //REG_FUNC(0x71503251, sceLocationCancelGetLocation); - //REG_FUNC(0x12D1F0EA, sceLocationStartLocationCallback); - //REG_FUNC(0xED378700, sceLocationStopLocationCallback); - //REG_FUNC(0x4E9E5ED9, sceLocationGetHeading); - //REG_FUNC(0x07D4DFE0, sceLocationStartHeadingCallback); - //REG_FUNC(0x92E53F94, sceLocationStopHeadingCallback); + REG_FUNC(0xDD271661, sceLocationOpen); + REG_FUNC(0x14FE76E8, sceLocationClose); + REG_FUNC(0xB1F55065, sceLocationReopen); + REG_FUNC(0x188CE004, sceLocationGetMethod); + REG_FUNC(0x15BC27C8, sceLocationGetLocation); + REG_FUNC(0x71503251, sceLocationCancelGetLocation); + REG_FUNC(0x12D1F0EA, sceLocationStartLocationCallback); + REG_FUNC(0xED378700, sceLocationStopLocationCallback); + REG_FUNC(0x4E9E5ED9, sceLocationGetHeading); + REG_FUNC(0x07D4DFE0, sceLocationStartHeadingCallback); + REG_FUNC(0x92E53F94, sceLocationStopHeadingCallback); //REG_FUNC(0xE055BCF5, sceLocationSetHeapAllocator); - //REG_FUNC(0xC895E567, sceLocationConfirm); - //REG_FUNC(0x730FF842, sceLocationConfirmGetStatus); - //REG_FUNC(0xFF016C13, sceLocationConfirmGetResult); - //REG_FUNC(0xE3CBF875, sceLocationConfirmAbort); - //REG_FUNC(0x482622C6, sceLocationGetPermission); - //REG_FUNC(0xDE0A9EA4, sceLocationSetGpsEmulationFile); + REG_FUNC(0xC895E567, sceLocationConfirm); + REG_FUNC(0x730FF842, sceLocationConfirmGetStatus); + REG_FUNC(0xFF016C13, sceLocationConfirmGetResult); + REG_FUNC(0xE3CBF875, sceLocationConfirmAbort); + REG_FUNC(0x482622C6, sceLocationGetPermission); + REG_FUNC(0xDE0A9EA4, sceLocationSetGpsEmulationFile); //REG_FUNC(0x760D08FF, sceLocationConfirmSetMessage); }); diff --git a/rpcs3/Emu/ARMv7/Modules/sceMd5.cpp b/rpcs3/Emu/ARMv7/Modules/sceMd5.cpp index aed0422ed4..d31e193e81 100644 --- a/rpcs3/Emu/ARMv7/Modules/sceMd5.cpp +++ b/rpcs3/Emu/ARMv7/Modules/sceMd5.cpp @@ -4,6 +4,37 @@ extern psv_log_base sceMd5; +struct SceMd5Context +{ + u32 h[4]; + u32 pad; + u16 usRemains; + u16 usComputed; + u64 ullTotalLen; + u8 buf[64]; + u8 result[64]; +}; + +s32 sceMd5Digest(vm::psv::ptr plain, u32 len, vm::psv::ptr digest) +{ + throw __FUNCTION__; +} + +s32 sceMd5BlockInit(vm::psv::ptr pContext) +{ + throw __FUNCTION__; +} + +s32 sceMd5BlockUpdate(vm::psv::ptr pContext, vm::psv::ptr plain, u32 len) +{ + throw __FUNCTION__; +} + +s32 sceMd5BlockResult(vm::psv::ptr pContext, vm::psv::ptr digest) +{ + throw __FUNCTION__; +} + #define REG_FUNC(nid, name) reg_psv_func(nid, &sceMd5, #name, name) psv_log_base sceMd5("SceMd5", []() @@ -12,8 +43,8 @@ psv_log_base sceMd5("SceMd5", []() sceMd5.on_unload = nullptr; sceMd5.on_stop = nullptr; - //REG_FUNC(0xB845BCCB, sceMd5Digest); - //REG_FUNC(0x4D6436F9, sceMd5BlockInit); - //REG_FUNC(0x094A4902, sceMd5BlockUpdate); - //REG_FUNC(0xB94ABF83, sceMd5BlockResult); + REG_FUNC(0xB845BCCB, sceMd5Digest); + REG_FUNC(0x4D6436F9, sceMd5BlockInit); + REG_FUNC(0x094A4902, sceMd5BlockUpdate); + REG_FUNC(0xB94ABF83, sceMd5BlockResult); }); diff --git a/rpcs3/Emu/ARMv7/Modules/sceMotion.cpp b/rpcs3/Emu/ARMv7/Modules/sceMotion.cpp index bc86726bb2..4128c78a65 100644 --- a/rpcs3/Emu/ARMv7/Modules/sceMotion.cpp +++ b/rpcs3/Emu/ARMv7/Modules/sceMotion.cpp @@ -4,6 +4,113 @@ extern psv_log_base sceMotion; +struct SceMotionState +{ + u32 timestamp; + SceFVector3 acceleration; + SceFVector3 angularVelocity; + u8 reserve1[12]; + SceFQuaternion deviceQuat; + SceUMatrix4 rotationMatrix; + SceUMatrix4 nedMatrix; + u8 reserve2[4]; + SceFVector3 basicOrientation; + u64 hostTimestamp; + u8 reserve3[40]; +}; + +struct SceMotionSensorState +{ + SceFVector3 accelerometer; + SceFVector3 gyro; + u8 reserve1[12]; + u32 timestamp; + u32 counter; + u8 reserve2[4]; + u64 hostTimestamp; + u8 reserve3[8]; +}; + +s32 sceMotionGetState(vm::psv::ptr motionState) +{ + throw __FUNCTION__; +} + +s32 sceMotionGetSensorState(vm::psv::ptr sensorState, s32 numRecords) +{ + throw __FUNCTION__; +} + +s32 sceMotionGetBasicOrientation(vm::psv::ptr basicOrientation) +{ + throw __FUNCTION__; +} + +//s32 sceMotionRotateYaw(const float radians) +//{ +// throw __FUNCTION__; +//} + +s32 sceMotionGetTiltCorrection() +{ + throw __FUNCTION__; +} + +s32 sceMotionSetTiltCorrection(s32 setValue) +{ + throw __FUNCTION__; +} + +s32 sceMotionGetDeadband() +{ + throw __FUNCTION__; +} + +s32 sceMotionSetDeadband(s32 setValue) +{ + throw __FUNCTION__; +} + +//s32 sceMotionSetAngleThreshold(const float angle) +//{ +// throw __FUNCTION__; +//} + +//float sceMotionGetAngleThreshold() +//{ +// throw __FUNCTION__; +//} + +s32 sceMotionReset() +{ + throw __FUNCTION__; +} + +s32 sceMotionMagnetometerOn() +{ + throw __FUNCTION__; +} + +s32 sceMotionMagnetometerOff() +{ + throw __FUNCTION__; +} + +s32 sceMotionGetMagnetometerState() +{ + throw __FUNCTION__; +} + +s32 sceMotionStartSampling() +{ + throw __FUNCTION__; +} + +s32 sceMotionStopSampling() +{ + throw __FUNCTION__; +} + #define REG_FUNC(nid, name) reg_psv_func(nid, &sceMotion, #name, name) psv_log_base sceMotion("SceMotion", []() @@ -12,20 +119,20 @@ psv_log_base sceMotion("SceMotion", []() sceMotion.on_unload = nullptr; sceMotion.on_stop = nullptr; - //REG_FUNC(0xBDB32767, sceMotionGetState); - //REG_FUNC(0x47D679EA, sceMotionGetSensorState); - //REG_FUNC(0xC1652201, sceMotionGetTiltCorrection); - //REG_FUNC(0xAF09FCDB, sceMotionSetTiltCorrection); - //REG_FUNC(0x112E0EAE, sceMotionGetDeadband); - //REG_FUNC(0x917EA390, sceMotionSetDeadband); + REG_FUNC(0xBDB32767, sceMotionGetState); + REG_FUNC(0x47D679EA, sceMotionGetSensorState); + REG_FUNC(0xC1652201, sceMotionGetTiltCorrection); + REG_FUNC(0xAF09FCDB, sceMotionSetTiltCorrection); + REG_FUNC(0x112E0EAE, sceMotionGetDeadband); + REG_FUNC(0x917EA390, sceMotionSetDeadband); //REG_FUNC(0x20F00078, sceMotionRotateYaw); - //REG_FUNC(0x0FD2CDA2, sceMotionReset); - //REG_FUNC(0x28034AC9, sceMotionStartSampling); - //REG_FUNC(0xAF32CB1D, sceMotionStopSampling); + REG_FUNC(0x0FD2CDA2, sceMotionReset); + REG_FUNC(0x28034AC9, sceMotionStartSampling); + REG_FUNC(0xAF32CB1D, sceMotionStopSampling); //REG_FUNC(0xDACB2A41, sceMotionSetAngleThreshold); //REG_FUNC(0x499B6C87, sceMotionGetAngleThreshold); - //REG_FUNC(0x4F28BFE0, sceMotionGetBasicOrientation); - //REG_FUNC(0x122A79F8, sceMotionMagnetometerOn); - //REG_FUNC(0xC1A7395A, sceMotionMagnetometerOff); - //REG_FUNC(0x3D4813AE, sceMotionGetMagnetometerState); + REG_FUNC(0x4F28BFE0, sceMotionGetBasicOrientation); + REG_FUNC(0x122A79F8, sceMotionMagnetometerOn); + REG_FUNC(0xC1A7395A, sceMotionMagnetometerOff); + REG_FUNC(0x3D4813AE, sceMotionGetMagnetometerState); }); diff --git a/rpcs3/Emu/ARMv7/Modules/sceMt19937.cpp b/rpcs3/Emu/ARMv7/Modules/sceMt19937.cpp index 3893d344bf..6a125206ec 100644 --- a/rpcs3/Emu/ARMv7/Modules/sceMt19937.cpp +++ b/rpcs3/Emu/ARMv7/Modules/sceMt19937.cpp @@ -4,6 +4,23 @@ extern psv_log_base sceMt19937; +struct SceMt19937Context +{ + u32 count; + u32 state[624]; +}; + +s32 sceMt19937Init(vm::psv::ptr pCtx, u32 seed) +{ + throw __FUNCTION__; +} + +u32 sceMt19937UInt(vm::psv::ptr pCtx) +{ + throw __FUNCTION__; +} + + #define REG_FUNC(nid, name) reg_psv_func(nid, &sceMt19937, #name, name) psv_log_base sceMt19937("SceMt19937", []() @@ -12,6 +29,6 @@ psv_log_base sceMt19937("SceMt19937", []() sceMt19937.on_unload = nullptr; sceMt19937.on_stop = nullptr; - //REG_FUNC(0xEE5BA27C, sceMt19937Init); - //REG_FUNC(0x29E43BB5, sceMt19937UInt); + REG_FUNC(0xEE5BA27C, sceMt19937Init); + REG_FUNC(0x29E43BB5, sceMt19937UInt); }); diff --git a/rpcs3/Emu/ARMv7/PSVFuncList.h b/rpcs3/Emu/ARMv7/PSVFuncList.h index 0326208f9f..a1948dcbec 100644 --- a/rpcs3/Emu/ARMv7/PSVFuncList.h +++ b/rpcs3/Emu/ARMv7/PSVFuncList.h @@ -647,3 +647,19 @@ struct SceDateTime u16 second; u32 microsecond; }; + +struct SceFVector3 +{ + float x, y, z; +}; + +struct SceFQuaternion +{ + float x, y, z, w; +}; + +union SceUMatrix4 +{ + float f[4][4]; + s32 i[4][4]; +};