ShuriZma
/
rpcs3
mirror of https://github.com/RPCS3/rpcs3.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

PSV modules refactoring

This commit is contained in:
Nekotekina 2015-06-21 02:04:01 +03:00
parent 8229c0ed3d
commit bc9481db1b
129 changed files with 5000 additions and 4588 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
Utilities/StrFmt.h
View File

@ -257,12 +257,8 @@ namespace fmt
be_t<> forced to .value() (fmt::unveil reverts byte order automatically)
External specializations for fmt::unveil (can be found in another headers):
vm::ps3::ptr (fmt::unveil) (vm_ptr.h) (with appropriate address type, using .addr() can be avoided)
vm::ps3::bptr (fmt::unveil) (vm_ptr.h)
vm::psv::ptr (fmt::unveil) (vm_ptr.h)
vm::ps3::ref (fmt::unveil) (vm_ref.h)
vm::ps3::bref (fmt::unveil) (vm_ref.h)
vm::psv::ref (fmt::unveil) (vm_ref.h)
vm::ptr, vm::bptr, ... (fmt::unveil) (vm_ptr.h) (with appropriate address type, using .addr() can be avoided)
vm::ref, vm::bref, ... (fmt::unveil) (vm_ref.h)
*/
template<typename... Args> force_inline safe_buffers std::string format(const char* fmt, Args... args)

2
Utilities/Thread.cpp
View File

@ -1373,7 +1373,7 @@ void thread_t::set_name(const std::string& name)
thread_t::~thread_t()
{
if (m_state.exchange(TS_NON_EXISTENT) == TS_JOINABLE)
if (m_state == TS_JOINABLE)
{
if (m_autojoin)
{

31
rpcs3/Emu/ARMv7/ARMv7Interpreter.cpp
View File

@ -1,5 +1,4 @@
#include "stdafx.h"
#include <map>
#include "Utilities/Log.h"
#include "Emu/System.h"
#include "Emu/Memory/Memory.h"
@ -1969,7 +1968,7 @@ void ARMv7_instrs::LDM(ARMv7Context& context, const ARMv7Code code, const ARMv7_
if (ConditionPassed(context, cond))
{
auto memory = vm::psv::ptr<u32>::make(context.read_gpr(n));
auto memory = vm::ptr<u32>::make(context.read_gpr(n));
for (u32 i = 0; i < 16; i++)
{
@ -2088,7 +2087,7 @@ void ARMv7_instrs::LDR_IMM(ARMv7Context& context, const ARMv7Code code, const AR
{
const u32 offset_addr = add ? context.read_gpr(n) + imm32 : context.read_gpr(n) - imm32;
const u32 addr = index ? offset_addr : context.read_gpr(n);
context.write_gpr(t, vm::psv::read32(addr));
context.write_gpr(t, vm::read32(addr));
if (wback)
{
@ -2137,7 +2136,7 @@ void ARMv7_instrs::LDR_LIT(ARMv7Context& context, const ARMv7Code code, const AR
if (ConditionPassed(context, cond))
{
const u32 data = vm::psv::read32(addr);
const u32 data = vm::read32(addr);
context.write_gpr(t, data);
}
}
@ -2194,7 +2193,7 @@ void ARMv7_instrs::LDR_REG(ARMv7Context& context, const ARMv7Code code, const AR
const u32 offset = Shift(context.read_gpr(m), shift_t, shift_n, context.APSR.C);
const u32 offset_addr = add ? context.read_gpr(n) + offset : context.read_gpr(n) - offset;
const u32 addr = index ? offset_addr : context.read_gpr(n);
context.write_gpr(t, vm::psv::read32(addr));
context.write_gpr(t, vm::read32(addr));
if (wback)
{
@ -2386,7 +2385,7 @@ void ARMv7_instrs::LDRD_IMM(ARMv7Context& context, const ARMv7Code code, const A
{
const u32 offset_addr = add ? context.read_gpr(n) + imm32 : context.read_gpr(n) - imm32;
const u32 addr = index ? offset_addr : context.read_gpr(n);
const u64 value = vm::psv::read64(addr);
const u64 value = vm::read64(addr);
context.write_gpr(t, (u32)(value));
context.write_gpr(t2, (u32)(value >> 32));
@ -2431,7 +2430,7 @@ void ARMv7_instrs::LDRD_LIT(ARMv7Context& context, const ARMv7Code code, const A
if (ConditionPassed(context, cond))
{
const u64 value = vm::psv::read64(addr);
const u64 value = vm::read64(addr);
context.write_gpr(t, (u32)(value));
context.write_gpr(t2, (u32)(value >> 32));
}
@ -2511,7 +2510,7 @@ void ARMv7_instrs::LDRH_IMM(ARMv7Context& context, const ARMv7Code code, const A
{
const u32 offset_addr = add ? context.read_gpr(n) + imm32 : context.read_gpr(n) - imm32;
const u32 addr = index ? offset_addr : context.read_gpr(n);
context.write_gpr(t, vm::psv::read16(addr));
context.write_gpr(t, vm::read16(addr));
if (wback)
{
@ -3475,7 +3474,7 @@ void ARMv7_instrs::POP(ARMv7Context& context, const ARMv7Code code, const ARMv7_
if (ConditionPassed(context, cond))
{
auto stack = vm::psv::ptr<u32>::make(context.SP);
auto stack = vm::ptr<u32>::make(context.SP);
for (u32 i = 0; i < 16; i++)
{
@ -3546,7 +3545,7 @@ void ARMv7_instrs::PUSH(ARMv7Context& context, const ARMv7Code code, const ARMv7
if (ConditionPassed(context, cond))
{
auto memory = vm::psv::ptr<u32>::make(context.SP);
auto memory = vm::ptr<u32>::make(context.SP);
for (u32 i = 15; ~i; i--)
{
@ -4296,7 +4295,7 @@ void ARMv7_instrs::STM(ARMv7Context& context, const ARMv7Code code, const ARMv7_
if (ConditionPassed(context, cond))
{
auto memory = vm::psv::ptr<u32>::make(context.read_gpr(n));
auto memory = vm::ptr<u32>::make(context.read_gpr(n));
for (u32 i = 0; i < 16; i++)
{
@ -4414,7 +4413,7 @@ void ARMv7_instrs::STR_IMM(ARMv7Context& context, const ARMv7Code code, const AR
{
const u32 offset_addr = add ? context.read_gpr(n) + imm32 : context.read_gpr(n) - imm32;
const u32 addr = index ? offset_addr : context.read_gpr(n);
vm::psv::write32(addr, context.read_gpr(t));
vm::write32(addr, context.read_gpr(t));
if (wback)
{
@ -4474,7 +4473,7 @@ void ARMv7_instrs::STR_REG(ARMv7Context& context, const ARMv7Code code, const AR
const u32 offset = Shift(context.read_gpr(m), shift_t, shift_n, context.APSR.C);
const u32 offset_addr = add ? context.read_gpr(n) + offset : context.read_gpr(n) - offset;
const u32 addr = index ? offset_addr : context.read_gpr(n);
vm::psv::write32(addr, context.read_gpr(t));
vm::write32(addr, context.read_gpr(t));
if (wback)
{
@ -4653,7 +4652,7 @@ void ARMv7_instrs::STRD_IMM(ARMv7Context& context, const ARMv7Code code, const A
const u32 n_value = context.read_gpr(n);
const u32 offset = add ? n_value + imm32 : n_value - imm32;
const u32 addr = index ? offset : n_value;
vm::psv::write64(addr, (u64)context.read_gpr(t2) << 32 | (u64)context.read_gpr(t));
vm::write64(addr, (u64)context.read_gpr(t2) << 32 | (u64)context.read_gpr(t));
if (wback)
{
@ -4733,7 +4732,7 @@ void ARMv7_instrs::STRH_IMM(ARMv7Context& context, const ARMv7Code code, const A
{
const u32 offset_addr = add ? context.read_gpr(n) + imm32 : context.read_gpr(n) - imm32;
const u32 addr = index ? offset_addr : context.read_gpr(n);
vm::psv::write16(addr, (u16)context.read_gpr(t));
vm::write16(addr, (u16)context.read_gpr(t));
if (wback)
{
@ -4793,7 +4792,7 @@ void ARMv7_instrs::STRH_REG(ARMv7Context& context, const ARMv7Code code, const A
const u32 offset = Shift(context.read_gpr(m), shift_t, shift_n, context.APSR.C);
const u32 offset_addr = add ? context.read_gpr(n) + offset : context.read_gpr(n) - offset;
const u32 addr = index ? offset_addr : context.read_gpr(n);
vm::psv::write16(addr, (u16)context.read_gpr(t));
vm::write16(addr, (u16)context.read_gpr(t));
if (wback)
{

14
rpcs3/Emu/ARMv7/Modules/sceAppMgr.cpp
View File

@ -2,21 +2,14 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceAppMgr;
#include "sceAppMgr.h"
struct SceAppMgrEvent
{
s32 event;
s32 appId;
char param[56];
};
s32 sceAppMgrReceiveEventNum(vm::psv::ptr<s32> eventNum)
s32 sceAppMgrReceiveEventNum(vm::ptr<s32> eventNum)
{
throw __FUNCTION__;
}
s32 sceAppMgrReceiveEvent(vm::psv::ptr<SceAppMgrEvent> appEvent)
s32 sceAppMgrReceiveEvent(vm::ptr<SceAppMgrEvent> appEvent)
{
throw __FUNCTION__;
}
@ -39,6 +32,7 @@ psv_log_base sceAppMgr("SceAppMgr", []()
sceAppMgr.on_load = nullptr;
sceAppMgr.on_unload = nullptr;
sceAppMgr.on_stop = nullptr;
sceAppMgr.on_error = nullptr;
REG_FUNC(0x47E5DD7D, sceAppMgrReceiveEventNum);
REG_FUNC(0xCFAD5A3A, sceAppMgrReceiveEvent);

10
rpcs3/Emu/ARMv7/Modules/sceAppMgr.h Normal file
View File

@ -0,0 +1,10 @@
#pragma once
struct SceAppMgrEvent
{
le_t<s32> event;
le_t<s32> appId;
char param[56];
};
extern psv_log_base sceAppMgr;

21
rpcs3/Emu/ARMv7/Modules/sceAppUtil.cpp
View File

@ -4,7 +4,7 @@
#include "sceAppUtil.h"
s32 sceAppUtilInit(vm::psv::ptr<const SceAppUtilInitParam> initParam, vm::psv::ptr<SceAppUtilBootParam> bootParam)
s32 sceAppUtilInit(vm::ptr<const SceAppUtilInitParam> initParam, vm::ptr<SceAppUtilBootParam> bootParam)
{
throw __FUNCTION__;
}
@ -14,27 +14,27 @@ s32 sceAppUtilShutdown()
throw __FUNCTION__;
}
s32 sceAppUtilSaveDataSlotCreate(u32 slotId, vm::psv::ptr<const SceAppUtilSaveDataSlotParam> param, vm::psv::ptr<const SceAppUtilSaveDataMountPoint> mountPoint)
s32 sceAppUtilSaveDataSlotCreate(u32 slotId, vm::ptr<const SceAppUtilSaveDataSlotParam> param, vm::ptr<const SceAppUtilSaveDataMountPoint> mountPoint)
{
throw __FUNCTION__;
}
s32 sceAppUtilSaveDataSlotDelete(u32 slotId, vm::psv::ptr<const SceAppUtilSaveDataMountPoint> mountPoint)
s32 sceAppUtilSaveDataSlotDelete(u32 slotId, vm::ptr<const SceAppUtilSaveDataMountPoint> mountPoint)
{
throw __FUNCTION__;
}
s32 sceAppUtilSaveDataSlotSetParam(u32 slotId, vm::psv::ptr<const SceAppUtilSaveDataSlotParam> param, vm::psv::ptr<const SceAppUtilSaveDataMountPoint> mountPoint)
s32 sceAppUtilSaveDataSlotSetParam(u32 slotId, vm::ptr<const SceAppUtilSaveDataSlotParam> param, vm::ptr<const SceAppUtilSaveDataMountPoint> mountPoint)
{
throw __FUNCTION__;
}
s32 sceAppUtilSaveDataSlotGetParam(u32 slotId, vm::psv::ptr<SceAppUtilSaveDataSlotParam> param, vm::psv::ptr<const SceAppUtilSaveDataMountPoint> mountPoint)
s32 sceAppUtilSaveDataSlotGetParam(u32 slotId, vm::ptr<SceAppUtilSaveDataSlotParam> param, vm::ptr<const SceAppUtilSaveDataMountPoint> mountPoint)
{
throw __FUNCTION__;
}
s32 sceAppUtilSaveDataFileSave(vm::psv::ptr<const SceAppUtilSaveDataFileSlot> slot, vm::psv::ptr<const SceAppUtilSaveDataFile> files, u32 fileNum, vm::psv::ptr<const SceAppUtilSaveDataMountPoint> mountPoint, vm::psv::ptr<u32> requiredSizeKB)
s32 sceAppUtilSaveDataFileSave(vm::ptr<const SceAppUtilSaveDataFileSlot> slot, vm::ptr<const SceAppUtilSaveDataFile> files, u32 fileNum, vm::ptr<const SceAppUtilSaveDataMountPoint> mountPoint, vm::ptr<u32> requiredSizeKB)
{
throw __FUNCTION__;
}
@ -49,22 +49,22 @@ s32 sceAppUtilPhotoUmount()
throw __FUNCTION__;
}
s32 sceAppUtilSystemParamGetInt(u32 paramId, vm::psv::ptr<s32> value)
s32 sceAppUtilSystemParamGetInt(u32 paramId, vm::ptr<s32> value)
{
throw __FUNCTION__;
}
s32 sceAppUtilSystemParamGetString(u32 paramId, vm::psv::ptr<char> buf, u32 bufSize)
s32 sceAppUtilSystemParamGetString(u32 paramId, vm::ptr<char> buf, u32 bufSize)
{
throw __FUNCTION__;
}
s32 sceAppUtilSaveSafeMemory(vm::psv::ptr<const void> buf, u32 bufSize, s64 offset)
s32 sceAppUtilSaveSafeMemory(vm::ptr<const void> buf, u32 bufSize, s64 offset)
{
throw __FUNCTION__;
}
s32 sceAppUtilLoadSafeMemory(vm::psv::ptr<void> buf, u32 bufSize, s64 offset)
s32 sceAppUtilLoadSafeMemory(vm::ptr<void> buf, u32 bufSize, s64 offset)
{
throw __FUNCTION__;
}
@ -77,6 +77,7 @@ psv_log_base sceAppUtil("SceAppUtil", []()
sceAppUtil.on_load = nullptr;
sceAppUtil.on_unload = nullptr;
sceAppUtil.on_stop = nullptr;
sceAppUtil.on_error = nullptr;
REG_FUNC(0xDAFFE671, sceAppUtilInit);
REG_FUNC(0xB220B00B, sceAppUtilShutdown);

44
rpcs3/Emu/ARMv7/Modules/sceAppUtil.h
View File

@ -2,14 +2,14 @@
struct SceAppUtilInitParam
{
u32 workBufSize;
le_t<u32> workBufSize;
char reserved[60];
};
struct SceAppUtilBootParam
{
u32 attr;
u32 appVersion;
le_t<u32> attr;
le_t<u32> appVersion;
char reserved[32];
};
@ -20,49 +20,49 @@ struct SceAppUtilSaveDataMountPoint
struct SceAppUtilSaveDataSlotParam
{
u32 status;
le_t<u32> status;
char title[64];
char subTitle[128];
char detail[512];
char iconPath[64];
s32 userParam;
u32 sizeKB;
le_t<s32> userParam;
le_t<u32> sizeKB;
SceDateTime modifiedTime;
char reserved[48];
};
struct SceAppUtilSaveDataSlotEmptyParam
{
vm::psv::ptr<char> title;
vm::psv::ptr<char> iconPath;
vm::psv::ptr<void> iconBuf;
u32 iconBufSize;
vm::lptr<char> title;
vm::lptr<char> iconPath;
vm::lptr<void> iconBuf;
le_t<u32> iconBufSize;
char reserved[32];
};
struct SceAppUtilSaveDataSlot
{
u32 id;
u32 status;
s32 userParam;
vm::psv::ptr<SceAppUtilSaveDataSlotEmptyParam> emptyParam;
le_t<u32> id;
le_t<u32> status;
le_t<s32> userParam;
vm::lptr<SceAppUtilSaveDataSlotEmptyParam> emptyParam;
};
struct SceAppUtilSaveDataFile
{
vm::psv::ptr<const char> filePath;
vm::psv::ptr<void> buf;
u32 bufSize;
s64 offset;
u32 mode;
u32 progDelta;
vm::lptr<const char> filePath;
vm::lptr<void> buf;
le_t<u32> bufSize;
le_t<s64> offset;
le_t<u32> mode;
le_t<u32> progDelta;
char reserved[32];
};
struct SceAppUtilSaveDataFileSlot
{
u32 id;
vm::psv::ptr<SceAppUtilSaveDataSlotParam> slotParam;
le_t<u32> id;
vm::lptr<SceAppUtilSaveDataSlotParam> slotParam;
char reserved[32];
};

7
rpcs3/Emu/ARMv7/Modules/sceAudio.cpp
View File

@ -2,7 +2,7 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceAudio;
#include "sceAudio.h"
s32 sceAudioOutOpenPort(s32 portType, s32 len, s32 freq, s32 param)
{
@ -14,12 +14,12 @@ s32 sceAudioOutReleasePort(s32 port)
throw __FUNCTION__;
}
s32 sceAudioOutOutput(s32 port, vm::psv::ptr<void> ptr)
s32 sceAudioOutOutput(s32 port, vm::ptr<void> ptr)
{
throw __FUNCTION__;
}
s32 sceAudioOutSetVolume(s32 port, s32 flag, vm::psv::ptr<s32> vol)
s32 sceAudioOutSetVolume(s32 port, s32 flag, vm::ptr<s32> vol)
{
throw __FUNCTION__;
}
@ -52,6 +52,7 @@ psv_log_base sceAudio("SceAudio", []()
sceAudio.on_load = nullptr;
sceAudio.on_unload = nullptr;
sceAudio.on_stop = nullptr;
sceAudio.on_error = nullptr;
REG_FUNC(0x5BC341E4, sceAudioOutOpenPort);
REG_FUNC(0x69E2E6B5, sceAudioOutReleasePort);

3
rpcs3/Emu/ARMv7/Modules/sceAudio.h Normal file
View File

@ -0,0 +1,3 @@
#pragma once
extern psv_log_base sceAudio;

5
rpcs3/Emu/ARMv7/Modules/sceAudioIn.cpp
View File

@ -2,7 +2,7 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceAudioIn;
#include "sceAudioIn.h"
s32 sceAudioInOpenPort(s32 portType, s32 grain, s32 freq, s32 param)
{
@ -14,7 +14,7 @@ s32 sceAudioInReleasePort(s32 port)
throw __FUNCTION__;
}
s32 sceAudioInInput(s32 port, vm::psv::ptr<void> destPtr)
s32 sceAudioInInput(s32 port, vm::ptr<void> destPtr)
{
throw __FUNCTION__;
}
@ -27,6 +27,7 @@ psv_log_base sceAudioIn("SceAudioIn", []()
sceAudioIn.on_load = nullptr;
sceAudioIn.on_unload = nullptr;
sceAudioIn.on_stop = nullptr;
sceAudioIn.on_error = nullptr;
REG_FUNC(0x638ADD2D, sceAudioInInput);
REG_FUNC(0x39B50DC1, sceAudioInOpenPort);

3
rpcs3/Emu/ARMv7/Modules/sceAudioIn.h Normal file
View File

@ -0,0 +1,3 @@
#pragma once
extern psv_log_base sceAudioIn;

95
rpcs3/Emu/ARMv7/Modules/sceAudiodec.cpp
View File

@ -2,89 +2,9 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceAudiodec;
#include "sceAudiodec.h"
struct SceAudiodecInitStreamParam
{
u32 size;
u32 totalStreams;
};
struct SceAudiodecInitChParam
{
u32 size;
u32 totalCh;
};
union SceAudiodecInitParam
{
u32 size;
SceAudiodecInitChParam at9;
SceAudiodecInitStreamParam mp3;
SceAudiodecInitStreamParam aac;
SceAudiodecInitStreamParam celp;
};
struct SceAudiodecInfoAt9
{
u32 size;
u8 configData[4];
u32 ch;
u32 bitRate;
u32 samplingRate;
u32 superFrameSize;
u32 framesInSuperFrame;
};
struct SceAudiodecInfoMp3
{
u32 size;
u32 ch;
u32 version;
};
struct SceAudiodecInfoAac
{
u32 size;
u32 isAdts;
u32 ch;
u32 samplingRate;
u32 isSbr;
};
struct SceAudiodecInfoCelp
{
u32 size;
u32 excitationMode;
u32 samplingRate;
u32 bitRate;
u32 lostCount;
};
union SceAudiodecInfo
{
u32 size;
SceAudiodecInfoAt9 at9;
SceAudiodecInfoMp3 mp3;
SceAudiodecInfoAac aac;
SceAudiodecInfoCelp celp;
};
struct SceAudiodecCtrl
{
u32 size;
s32 handle;
vm::psv::ptr<u8> pEs;
u32 inputEsSize;
u32 maxEsSize;
vm::psv::ptr<void> pPcm;
u32 outputPcmSize;
u32 maxPcmSize;
u32 wordLength;
vm::psv::ptr<SceAudiodecInfo> pInfo;
};
s32 sceAudiodecInitLibrary(u32 codecType, vm::psv::ptr<SceAudiodecInitParam> pInitParam)
s32 sceAudiodecInitLibrary(u32 codecType, vm::ptr<SceAudiodecInitParam> pInitParam)
{
throw __FUNCTION__;
}
@ -94,27 +14,27 @@ s32 sceAudiodecTermLibrary(u32 codecType)
throw __FUNCTION__;
}
s32 sceAudiodecCreateDecoder(vm::psv::ptr<SceAudiodecCtrl> pCtrl, u32 codecType)
s32 sceAudiodecCreateDecoder(vm::ptr<SceAudiodecCtrl> pCtrl, u32 codecType)
{
throw __FUNCTION__;
}
s32 sceAudiodecDeleteDecoder(vm::psv::ptr<SceAudiodecCtrl> pCtrl)
s32 sceAudiodecDeleteDecoder(vm::ptr<SceAudiodecCtrl> pCtrl)
{
throw __FUNCTION__;
}
s32 sceAudiodecDecode(vm::psv::ptr<SceAudiodecCtrl> pCtrl)
s32 sceAudiodecDecode(vm::ptr<SceAudiodecCtrl> pCtrl)
{
throw __FUNCTION__;
}
s32 sceAudiodecClearContext(vm::psv::ptr<SceAudiodecCtrl> pCtrl)
s32 sceAudiodecClearContext(vm::ptr<SceAudiodecCtrl> pCtrl)
{
throw __FUNCTION__;
}
s32 sceAudiodecGetInternalError(vm::psv::ptr<SceAudiodecCtrl> pCtrl, vm::psv::ptr<s32> pInternalError)
s32 sceAudiodecGetInternalError(vm::ptr<SceAudiodecCtrl> pCtrl, vm::ptr<s32> pInternalError)
{
throw __FUNCTION__;
}
@ -127,6 +47,7 @@ psv_log_base sceAudiodec("SceAudiodec", []()
sceAudiodec.on_load = nullptr;
sceAudiodec.on_unload = nullptr;
sceAudiodec.on_stop = nullptr;
sceAudiodec.on_error = nullptr;
REG_FUNC(0x445C2CEF, sceAudiodecInitLibrary);
REG_FUNC(0x45719B9D, sceAudiodecTermLibrary);

83
rpcs3/Emu/ARMv7/Modules/sceAudiodec.h Normal file
View File

@ -0,0 +1,83 @@
#pragma once
struct SceAudiodecInitStreamParam
{
le_t<u32> size;
le_t<u32> totalStreams;
};
struct SceAudiodecInitChParam
{
le_t<u32> size;
le_t<u32> totalCh;
};
union SceAudiodecInitParam
{
le_t<u32> size;
SceAudiodecInitChParam at9;
SceAudiodecInitStreamParam mp3;
SceAudiodecInitStreamParam aac;
SceAudiodecInitStreamParam celp;
};
struct SceAudiodecInfoAt9
{
le_t<u32> size;
u8 configData[4];
le_t<u32> ch;
le_t<u32> bitRate;
le_t<u32> samplingRate;
le_t<u32> superFrameSize;
le_t<u32> framesInSuperFrame;
};
struct SceAudiodecInfoMp3
{
le_t<u32> size;
le_t<u32> ch;
le_t<u32> version;
};
struct SceAudiodecInfoAac
{
le_t<u32> size;
le_t<u32> isAdts;
le_t<u32> ch;
le_t<u32> samplingRate;
le_t<u32> isSbr;
};
struct SceAudiodecInfoCelp
{
le_t<u32> size;
le_t<u32> excitationMode;
le_t<u32> samplingRate;
le_t<u32> bitRate;
le_t<u32> lostCount;
};
union SceAudiodecInfo
{
le_t<u32> size;
SceAudiodecInfoAt9 at9;
SceAudiodecInfoMp3 mp3;
SceAudiodecInfoAac aac;
SceAudiodecInfoCelp celp;
};
struct SceAudiodecCtrl
{
le_t<u32> size;
le_t<s32> handle;
vm::lptr<u8> pEs;
le_t<u32> inputEsSize;
le_t<u32> maxEsSize;
vm::lptr<void> pPcm;
le_t<u32> outputPcmSize;
le_t<u32> maxPcmSize;
le_t<u32> wordLength;
vm::lptr<SceAudiodecInfo> pInfo;
};
extern psv_log_base sceAudiodec;

74
rpcs3/Emu/ARMv7/Modules/sceAudioenc.cpp
View File

@ -2,66 +2,9 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceAudioenc;
#include "sceAudioenc.h"
struct SceAudioencInitStreamParam
{
u32 size;
u32 totalStreams;
};
struct SceAudioencInfoCelp
{
u32 size;
u32 excitationMode;
u32 samplingRate;
u32 bitRate;
};
struct SceAudioencOptInfoCelp
{
u32 size;
u8 header[32];
u32 headerSize;
u32 encoderVersion;
};
union SceAudioencInitParam
{
u32 size;
SceAudioencInitStreamParam celp;
};
union SceAudioencInfo
{
u32 size;
SceAudioencInfoCelp celp;
};
union SceAudioencOptInfo
{
u32 size;
SceAudioencOptInfoCelp celp;
};
struct SceAudioencCtrl
{
u32 size;
s32 handle;
vm::psv::ptr<u8> pInputPcm;
u32 inputPcmSize;
u32 maxPcmSize;
vm::psv::ptr<void> pOutputEs;
u32 outputEsSize;
u32 maxEsSize;
u32 wordLength;
vm::psv::ptr<SceAudioencInfo> pInfo;
vm::psv::ptr<SceAudioencOptInfo> pOptInfo;
};
s32 sceAudioencInitLibrary(u32 codecType, vm::psv::ptr<SceAudioencInitParam> pInitParam)
s32 sceAudioencInitLibrary(u32 codecType, vm::ptr<SceAudioencInitParam> pInitParam)
{
throw __FUNCTION__;
}
@ -71,32 +14,32 @@ s32 sceAudioencTermLibrary(u32 codecType)
throw __FUNCTION__;
}
s32 sceAudioencCreateEncoder(vm::psv::ptr<SceAudioencCtrl> pCtrl, u32 codecType)
s32 sceAudioencCreateEncoder(vm::ptr<SceAudioencCtrl> pCtrl, u32 codecType)
{
throw __FUNCTION__;
}
s32 sceAudioencDeleteEncoder(vm::psv::ptr<SceAudioencCtrl> pCtrl)
s32 sceAudioencDeleteEncoder(vm::ptr<SceAudioencCtrl> pCtrl)
{
throw __FUNCTION__;
}
s32 sceAudioencEncode(vm::psv::ptr<SceAudioencCtrl> pCtrl)
s32 sceAudioencEncode(vm::ptr<SceAudioencCtrl> pCtrl)
{
throw __FUNCTION__;
}
s32 sceAudioencClearContext(vm::psv::ptr<SceAudioencCtrl> pCtrl)
s32 sceAudioencClearContext(vm::ptr<SceAudioencCtrl> pCtrl)
{
throw __FUNCTION__;
}
s32 sceAudioencGetOptInfo(vm::psv::ptr<SceAudioencCtrl> pCtrl)
s32 sceAudioencGetOptInfo(vm::ptr<SceAudioencCtrl> pCtrl)
{
throw __FUNCTION__;
}
s32 sceAudioencGetInternalError(vm::psv::ptr<SceAudioencCtrl> pCtrl, vm::psv::ptr<s32> pInternalError)
s32 sceAudioencGetInternalError(vm::ptr<SceAudioencCtrl> pCtrl, vm::ptr<s32> pInternalError)
{
throw __FUNCTION__;
}
@ -109,6 +52,7 @@ psv_log_base sceAudioenc("SceAudioenc", []()
sceAudioenc.on_load = nullptr;
sceAudioenc.on_unload = nullptr;
sceAudioenc.on_stop = nullptr;
sceAudioenc.on_error = nullptr;
REG_FUNC(0x76EE4DC6, sceAudioencInitLibrary);
REG_FUNC(0xAB32D022, sceAudioencTermLibrary);

59
rpcs3/Emu/ARMv7/Modules/sceAudioenc.h Normal file
View File

@ -0,0 +1,59 @@
#pragma once
struct SceAudioencInitStreamParam
{
le_t<u32> size;
le_t<u32> totalStreams;
};
struct SceAudioencInfoCelp
{
le_t<u32> size;
le_t<u32> excitationMode;
le_t<u32> samplingRate;
le_t<u32> bitRate;
};
struct SceAudioencOptInfoCelp
{
le_t<u32> size;
u8 header[32];
le_t<u32> headerSize;
le_t<u32> encoderVersion;
};
union SceAudioencInitParam
{
le_t<u32> size;
SceAudioencInitStreamParam celp;
};
union SceAudioencInfo
{
le_t<u32> size;
SceAudioencInfoCelp celp;
};
union SceAudioencOptInfo
{
le_t<u32> size;
SceAudioencOptInfoCelp celp;
};
struct SceAudioencCtrl
{
le_t<u32> size;
le_t<s32> handle;
vm::lptr<u8> pInputPcm;
le_t<u32> inputPcmSize;
le_t<u32> maxPcmSize;
vm::lptr<void> pOutputEs;
le_t<u32> outputEsSize;
le_t<u32> maxEsSize;
le_t<u32> wordLength;
vm::lptr<SceAudioencInfo> pInfo;
vm::lptr<SceAudioencOptInfo> pOptInfo;
};
extern psv_log_base sceAudioenc;

76
rpcs3/Emu/ARMv7/Modules/sceCamera.cpp
View File

@ -2,46 +2,9 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceCamera;
#include "sceCamera.h"
struct SceCameraInfo
{
u32 sizeThis;
u32 wPriority;
u32 wFormat;
u32 wResolution;
u32 wFramerate;
u32 wWidth;
u32 wHeight;
u32 wRange;
u32 _padding_0;
u32 sizeIBase;
u32 sizeUBase;
u32 sizeVBase;
vm::psv::ptr<void> pvIBase;
vm::psv::ptr<void> pvUBase;
vm::psv::ptr<void> pvVBase;
u32 wPitch;
u32 wBuffer;
};
struct SceCameraRead
{
u32 sizeThis;
s32 dwMode;
s32 _padding_0;
s32 dwStatus;
u32 qwFrame;
u32 qwTimestamp;
u32 sizeIBase;
u32 sizeUBase;
u32 sizeVBase;
vm::psv::ptr<void> pvIBase;
vm::psv::ptr<void> pvUBase;
vm::psv::ptr<void> pvVBase;
};
s32 sceCameraOpen(s32 devnum, vm::psv::ptr<SceCameraInfo> pInfo)
s32 sceCameraOpen(s32 devnum, vm::ptr<SceCameraInfo> pInfo)
{
throw __FUNCTION__;
}
@ -61,7 +24,7 @@ s32 sceCameraStop(s32 devnum)
throw __FUNCTION__;
}
s32 sceCameraRead(s32 devnum, vm::psv::ptr<SceCameraRead> pRead)
s32 sceCameraRead(s32 devnum, vm::ptr<SceCameraRead> pRead)
{
throw __FUNCTION__;
}
@ -71,7 +34,7 @@ s32 sceCameraIsActive(s32 devnum)
throw __FUNCTION__;
}
s32 sceCameraGetSaturation(s32 devnum, vm::psv::ptr<s32> pLevel)
s32 sceCameraGetSaturation(s32 devnum, vm::ptr<s32> pLevel)
{
throw __FUNCTION__;
}
@ -81,7 +44,7 @@ s32 sceCameraSetSaturation(s32 devnum, s32 level)
throw __FUNCTION__;
}
s32 sceCameraGetBrightness(s32 devnum, vm::psv::ptr<s32> pLevel)
s32 sceCameraGetBrightness(s32 devnum, vm::ptr<s32> pLevel)
{
throw __FUNCTION__;
}
@ -91,7 +54,7 @@ s32 sceCameraSetBrightness(s32 devnum, s32 level)
throw __FUNCTION__;
}
s32 sceCameraGetContrast(s32 devnum, vm::psv::ptr<s32> pLevel)
s32 sceCameraGetContrast(s32 devnum, vm::ptr<s32> pLevel)
{
throw __FUNCTION__;
}
@ -101,7 +64,7 @@ s32 sceCameraSetContrast(s32 devnum, s32 level)
throw __FUNCTION__;
}
s32 sceCameraGetSharpness(s32 devnum, vm::psv::ptr<s32> pLevel)
s32 sceCameraGetSharpness(s32 devnum, vm::ptr<s32> pLevel)
{
throw __FUNCTION__;
}
@ -111,7 +74,7 @@ s32 sceCameraSetSharpness(s32 devnum, s32 level)
throw __FUNCTION__;
}
s32 sceCameraGetReverse(s32 devnum, vm::psv::ptr<s32> pMode)
s32 sceCameraGetReverse(s32 devnum, vm::ptr<s32> pMode)
{
throw __FUNCTION__;
}
@ -121,7 +84,7 @@ s32 sceCameraSetReverse(s32 devnum, s32 mode)
throw __FUNCTION__;
}
s32 sceCameraGetEffect(s32 devnum, vm::psv::ptr<s32> pMode)
s32 sceCameraGetEffect(s32 devnum, vm::ptr<s32> pMode)
{
throw __FUNCTION__;
}
@ -131,7 +94,7 @@ s32 sceCameraSetEffect(s32 devnum, s32 mode)
throw __FUNCTION__;
}
s32 sceCameraGetEV(s32 devnum, vm::psv::ptr<s32> pLevel)
s32 sceCameraGetEV(s32 devnum, vm::ptr<s32> pLevel)
{
throw __FUNCTION__;
}
@ -141,7 +104,7 @@ s32 sceCameraSetEV(s32 devnum, s32 level)
throw __FUNCTION__;
}
s32 sceCameraGetZoom(s32 devnum, vm::psv::ptr<s32> pLevel)
s32 sceCameraGetZoom(s32 devnum, vm::ptr<s32> pLevel)
{
throw __FUNCTION__;
}
@ -151,7 +114,7 @@ s32 sceCameraSetZoom(s32 devnum, s32 level)
throw __FUNCTION__;
}
s32 sceCameraGetAntiFlicker(s32 devnum, vm::psv::ptr<s32> pMode)
s32 sceCameraGetAntiFlicker(s32 devnum, vm::ptr<s32> pMode)
{
throw __FUNCTION__;
}
@ -161,7 +124,7 @@ s32 sceCameraSetAntiFlicker(s32 devnum, s32 mode)
throw __FUNCTION__;
}
s32 sceCameraGetISO(s32 devnum, vm::psv::ptr<s32> pMode)
s32 sceCameraGetISO(s32 devnum, vm::ptr<s32> pMode)
{
throw __FUNCTION__;
}
@ -171,7 +134,7 @@ s32 sceCameraSetISO(s32 devnum, s32 mode)
throw __FUNCTION__;
}
s32 sceCameraGetGain(s32 devnum, vm::psv::ptr<s32> pMode)
s32 sceCameraGetGain(s32 devnum, vm::ptr<s32> pMode)
{
throw __FUNCTION__;
}
@ -181,7 +144,7 @@ s32 sceCameraSetGain(s32 devnum, s32 mode)
throw __FUNCTION__;
}
s32 sceCameraGetWhiteBalance(s32 devnum, vm::psv::ptr<s32> pMode)
s32 sceCameraGetWhiteBalance(s32 devnum, vm::ptr<s32> pMode)
{
throw __FUNCTION__;
}
@ -191,7 +154,7 @@ s32 sceCameraSetWhiteBalance(s32 devnum, s32 mode)
throw __FUNCTION__;
}
s32 sceCameraGetBacklight(s32 devnum, vm::psv::ptr<s32> pMode)
s32 sceCameraGetBacklight(s32 devnum, vm::ptr<s32> pMode)
{
throw __FUNCTION__;
}
@ -201,7 +164,7 @@ s32 sceCameraSetBacklight(s32 devnum, s32 mode)
throw __FUNCTION__;
}
s32 sceCameraGetNightmode(s32 devnum, vm::psv::ptr<s32> pMode)
s32 sceCameraGetNightmode(s32 devnum, vm::ptr<s32> pMode)
{
throw __FUNCTION__;
}
@ -221,7 +184,7 @@ s32 sceCameraLedBlink(s32 devnum, s32 iOnCount, s32 iOffCount, s32 iBlinkCount)
throw __FUNCTION__;
}
s32 sceCameraGetNoiseReductionForDebug(s32 devnum, vm::psv::ptr<s32> pLevel)
s32 sceCameraGetNoiseReductionForDebug(s32 devnum, vm::ptr<s32> pLevel)
{
throw __FUNCTION__;
}
@ -231,7 +194,7 @@ s32 sceCameraSetNoiseReductionForDebug(s32 devnum, s32 level)
throw __FUNCTION__;
}
s32 sceCameraGetSharpnessOffForDebug(s32 devnum, vm::psv::ptr<s32> pLevel)
s32 sceCameraGetSharpnessOffForDebug(s32 devnum, vm::ptr<s32> pLevel)
{
throw __FUNCTION__;
}
@ -254,6 +217,7 @@ psv_log_base sceCamera("SceCamera", []()
sceCamera.on_load = nullptr;
sceCamera.on_unload = nullptr;
sceCamera.on_stop = nullptr;
sceCamera.on_error = nullptr;
REG_FUNC(0xA462F801, sceCameraOpen);
REG_FUNC(0xCD6E1CFC, sceCameraClose);

40
rpcs3/Emu/ARMv7/Modules/sceCamera.h Normal file
View File

@ -0,0 +1,40 @@
#pragma once
struct SceCameraInfo
{
le_t<u32> sizeThis;
le_t<u32> wPriority;
le_t<u32> wFormat;
le_t<u32> wResolution;
le_t<u32> wFramerate;
le_t<u32> wWidth;
le_t<u32> wHeight;
le_t<u32> wRange;
le_t<u32> _padding_0;
le_t<u32> sizeIBase;
le_t<u32> sizeUBase;
le_t<u32> sizeVBase;
vm::lptr<void> pvIBase;
vm::lptr<void> pvUBase;
vm::lptr<void> pvVBase;
le_t<u32> wPitch;
le_t<u32> wBuffer;
};
struct SceCameraRead
{
le_t<u32> sizeThis;
le_t<s32> dwMode;
le_t<s32> _padding_0;
le_t<s32> dwStatus;
le_t<u32> qwFrame;
le_t<u32> qwTimestamp;
le_t<u32> sizeIBase;
le_t<u32> sizeUBase;
le_t<u32> sizeVBase;
vm::lptr<void> pvIBase;
vm::lptr<void> pvUBase;
vm::lptr<void> pvVBase;
};
extern psv_log_base sceCamera;

11
rpcs3/Emu/ARMv7/Modules/sceCodecEngine.cpp
View File

@ -2,13 +2,7 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceCodecEngine;
struct SceCodecEnginePmonProcessorLoad
{
u32 size;
u32 average;
};
#include "sceCodecEngine.h"
s32 sceCodecEnginePmonStart()
{
@ -20,7 +14,7 @@ s32 sceCodecEnginePmonStop()
throw __FUNCTION__;
}
s32 sceCodecEnginePmonGetProcessorLoad(vm::psv::ptr<SceCodecEnginePmonProcessorLoad> pProcessorLoad)
s32 sceCodecEnginePmonGetProcessorLoad(vm::ptr<SceCodecEnginePmonProcessorLoad> pProcessorLoad)
{
throw __FUNCTION__;
}
@ -38,6 +32,7 @@ psv_log_base sceCodecEngine("SceCodecEngine", []()
sceCodecEngine.on_load = nullptr;
sceCodecEngine.on_unload = nullptr;
sceCodecEngine.on_stop = nullptr;
sceCodecEngine.on_error = nullptr;
REG_FUNC(0x3E718890, sceCodecEnginePmonStart);
REG_FUNC(0x268B1EF5, sceCodecEnginePmonStop);

9
rpcs3/Emu/ARMv7/Modules/sceCodecEngine.h Normal file
View File

@ -0,0 +1,9 @@
#pragma once
struct SceCodecEnginePmonProcessorLoad
{
le_t<u32> size;
le_t<u32> average;
};
extern psv_log_base sceCodecEngine;

333
rpcs3/Emu/ARMv7/Modules/sceCommonDialog.cpp
View File

@ -2,314 +2,14 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
#include "sceGxm.h"
#include "sceAppUtil.h"
#include "sceIme.h"
#include "sceCommonDialog.h"
extern psv_log_base sceCommonDialog;
enum SceCommonDialogStatus : s32
{
SCE_COMMON_DIALOG_STATUS_NONE = 0,
SCE_COMMON_DIALOG_STATUS_RUNNING = 1,
SCE_COMMON_DIALOG_STATUS_FINISHED = 2
};
enum SceCommonDialogResult : s32
{
SCE_COMMON_DIALOG_RESULT_OK,
SCE_COMMON_DIALOG_RESULT_USER_CANCELED,
SCE_COMMON_DIALOG_RESULT_ABORTED
};
struct SceCommonDialogRenderTargetInfo
{
vm::psv::ptr<void> depthSurfaceData;
vm::psv::ptr<void> colorSurfaceData;
SceGxmColorSurfaceType surfaceType;
SceGxmColorFormat colorFormat;
u32 width;
u32 height;
u32 strideInPixels;
u8 reserved[32];
};
struct SceCommonDialogUpdateParam
{
SceCommonDialogRenderTargetInfo renderTarget;
vm::psv::ptr<SceGxmSyncObject> displaySyncObject;
u8 reserved[32];
};
struct SceMsgDialogUserMessageParam
{
s32 buttonType;
vm::psv::ptr<const char> msg;
char reserved[32];
};
struct SceMsgDialogSystemMessageParam
{
s32 sysMsgType;
s32 value;
char reserved[32];
};
struct SceMsgDialogErrorCodeParam
{
s32 errorCode;
char reserved[32];
};
struct SceMsgDialogProgressBarParam
{
s32 barType;
SceMsgDialogSystemMessageParam sysMsgParam;
vm::psv::ptr<const char> msg;
char reserved[32];
};
struct SceMsgDialogParam
{
u32 sdkVersion;
s32 mode;
vm::psv::ptr<SceMsgDialogUserMessageParam> userMsgParam;
vm::psv::ptr<SceMsgDialogSystemMessageParam> sysMsgParam;
vm::psv::ptr<SceMsgDialogErrorCodeParam> errorCodeParam;
vm::psv::ptr<SceMsgDialogProgressBarParam> progBarParam;
u32 flag;
char reserved[32];
};
struct SceMsgDialogResult
{
s32 mode;
s32 result;
s32 buttonId;
u8 reserved[32];
};
struct SceNetCheckDialogParam
{
u32 sdkVersion;
s32 mode;
u8 reserved[128];
};
struct SceNetCheckDialogResult
{
s32 result;
u8 reserved[128];
};
struct SceSaveDataDialogFixedParam
{
u32 targetSlot;
char reserved[32];
};
struct SceSaveDataDialogListParam
{
vm::psv::ptr<const u32> slotList;
u32 slotListSize;
s32 focusPos;
u32 focusId;
vm::psv::ptr<const char> listTitle;
char reserved[32];
};
struct SceSaveDataDialogUserMessageParam
{
s32 buttonType;
vm::psv::ptr<const char> msg;
u32 targetSlot;
char reserved[32];
};
struct SceSaveDataDialogSystemMessageParam
{
s32 sysMsgType;
s32 value;
u32 targetSlot;
char reserved[32];
};
struct SceSaveDataDialogErrorCodeParam
{
s32 errorCode;
u32 targetSlot;
char reserved[32];
};
struct SceSaveDataDialogProgressBarParam
{
s32 barType;
SceSaveDataDialogSystemMessageParam sysMsgParam;
vm::psv::ptr<const char> msg;
u32 targetSlot;
char reserved[32];
};
struct SceSaveDataDialogSlotConfigParam
{
vm::psv::ptr<const SceAppUtilSaveDataMountPoint> mountPoint;
vm::psv::ptr<const char> appSubDir;
char reserved[32];
};
struct SceSaveDataDialogParam
{
u32 sdkVersion;
s32 mode;
s32 dispType;
vm::psv::ptr<SceSaveDataDialogFixedParam> fixedParam;
vm::psv::ptr<SceSaveDataDialogListParam> listParam;
vm::psv::ptr<SceSaveDataDialogUserMessageParam> userMsgParam;
vm::psv::ptr<SceSaveDataDialogSystemMessageParam> sysMsgParam;
vm::psv::ptr<SceSaveDataDialogErrorCodeParam> errorCodeParam;
vm::psv::ptr<SceSaveDataDialogProgressBarParam> progBarParam;
vm::psv::ptr<SceSaveDataDialogSlotConfigParam> slotConfParam;
u32 flag;
vm::psv::ptr<void> userdata;
char reserved[32];
};
struct SceSaveDataDialogFinishParam
{
u32 flag;
char reserved[32];
};
struct SceSaveDataDialogSlotInfo
{
u32 isExist;
vm::psv::ptr<SceAppUtilSaveDataSlotParam> slotParam;
u8 reserved[32];
};
struct SceSaveDataDialogResult
{
s32 mode;
s32 result;
s32 buttonId;
u32 slotId;
vm::psv::ptr<SceSaveDataDialogSlotInfo> slotInfo;
vm::psv::ptr<void> userdata;
char reserved[32];
};
struct SceImeDialogParam
{
u32 sdkVersion;
u32 inputMethod;
u64 supportedLanguages;
s32 languagesForced;
u32 type;
u32 option;
vm::psv::ptr<SceImeCharFilter> filter;
u32 dialogMode;
u32 textBoxMode;
vm::psv::ptr<const u16> title;
u32 maxTextLength;
vm::psv::ptr<u16> initialText;
vm::psv::ptr<u16> inputTextBuffer;
char reserved[32];
};
struct SceImeDialogResult
{
s32 result;
char reserved[32];
};
enum ScePhotoImportDialogFormatType : s32
{
SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_UNKNOWN = 0,
SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_JPEG,
SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_PNG,
SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_GIF,
SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_BMP,
SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_TIFF
};
enum ScePhotoImportDialogOrientation : s32
{
SCE_PHOTOIMPORT_DIALOG_ORIENTATION_UNKNOWN = 0,
SCE_PHOTOIMPORT_DIALOG_ORIENTATION_TOP_LEFT,
SCE_PHOTOIMPORT_DIALOG_ORIENTATION_TOP_RIGHT,
SCE_PHOTOIMPORT_DIALOG_ORIENTATION_BOTTOM_RIGHT,
SCE_PHOTOIMPORT_DIALOG_ORIENTATION_BOTTOM_LEFT,
SCE_PHOTOIMPORT_DIALOG_ORIENTATION_LEFT_TOP,
SCE_PHOTOIMPORT_DIALOG_ORIENTATION_RIGHT_TOP,
SCE_PHOTOIMPORT_DIALOG_ORIENTATION_RIGHT_BOTTOM,
SCE_PHOTOIMPORT_DIALOG_ORIENTATION_LEFT_BOTTOM
};
struct ScePhotoImportDialogFileDataSub
{
u32 width;
u32 height;
ScePhotoImportDialogFormatType format;
ScePhotoImportDialogOrientation orientation;
char reserved[32];
};
struct ScePhotoImportDialogFileData
{
char fileName[1024];
char photoTitle[256];
char reserved[32];
};
struct ScePhotoImportDialogItemData
{
ScePhotoImportDialogFileData fileData;
ScePhotoImportDialogFileDataSub dataSub;
char reserved[32];
};
struct ScePhotoImportDialogResult
{
s32 result;
u32 importedItemNum;
char reserved[32];
};
struct ScePhotoImportDialogParam
{
u32 sdkVersion;
s32 mode;
u32 visibleCategory;
u32 itemCount;
vm::psv::ptr<ScePhotoImportDialogItemData> itemData;
char reserved[32];
};
struct ScePhotoReviewDialogParam
{
u32 sdkVersion;
s32 mode;
char fileName[1024];
vm::psv::ptr<void> workMemory;
u32 workMemorySize;
char reserved[32];
};
struct ScePhotoReviewDialogResult
{
s32 result;
char reserved[32];
};
s32 sceCommonDialogUpdate(vm::psv::ptr<const SceCommonDialogUpdateParam> updateParam)
s32 sceCommonDialogUpdate(vm::ptr<const SceCommonDialogUpdateParam> updateParam)
{
throw __FUNCTION__;
}
s32 sceMsgDialogInit(vm::psv::ptr<const SceMsgDialogParam> param)
s32 sceMsgDialogInit(vm::ptr<const SceMsgDialogParam> param)
{
throw __FUNCTION__;
}
@ -324,7 +24,7 @@ s32 sceMsgDialogAbort()
throw __FUNCTION__;
}
s32 sceMsgDialogGetResult(vm::psv::ptr<SceMsgDialogResult> result)
s32 sceMsgDialogGetResult(vm::ptr<SceMsgDialogResult> result)
{
throw __FUNCTION__;
}
@ -349,7 +49,7 @@ s32 sceMsgDialogProgressBarSetValue(s32 target, u32 rate)
throw __FUNCTION__;
}
s32 sceNetCheckDialogInit(vm::psv::ptr<SceNetCheckDialogParam> param)
s32 sceNetCheckDialogInit(vm::ptr<SceNetCheckDialogParam> param)
{
throw __FUNCTION__;
}
@ -364,7 +64,7 @@ s32 sceNetCheckDialogAbort()
throw __FUNCTION__;
}
s32 sceNetCheckDialogGetResult(vm::psv::ptr<SceNetCheckDialogResult> result)
s32 sceNetCheckDialogGetResult(vm::ptr<SceNetCheckDialogResult> result)
{
throw __FUNCTION__;
}
@ -374,7 +74,7 @@ s32 sceNetCheckDialogTerm()
throw __FUNCTION__;
}
s32 sceSaveDataDialogInit(vm::psv::ptr<const SceSaveDataDialogParam> param)
s32 sceSaveDataDialogInit(vm::ptr<const SceSaveDataDialogParam> param)
{
throw __FUNCTION__;
}
@ -389,7 +89,7 @@ s32 sceSaveDataDialogAbort()
throw __FUNCTION__;
}
s32 sceSaveDataDialogGetResult(vm::psv::ptr<SceSaveDataDialogResult> result)
s32 sceSaveDataDialogGetResult(vm::ptr<SceSaveDataDialogResult> result)
{
throw __FUNCTION__;
}
@ -409,12 +109,12 @@ s32 sceSaveDataDialogSubClose()
throw __FUNCTION__;
}
s32 sceSaveDataDialogContinue(vm::psv::ptr<const SceSaveDataDialogParam> param)
s32 sceSaveDataDialogContinue(vm::ptr<const SceSaveDataDialogParam> param)
{
throw __FUNCTION__;
}
s32 sceSaveDataDialogFinish(vm::psv::ptr<const SceSaveDataDialogFinishParam> param)
s32 sceSaveDataDialogFinish(vm::ptr<const SceSaveDataDialogFinishParam> param)
{
throw __FUNCTION__;
}
@ -429,7 +129,7 @@ s32 sceSaveDataDialogProgressBarSetValue(s32 target, u32 rate)
throw __FUNCTION__;
}
s32 sceImeDialogInit(vm::psv::ptr<const SceImeDialogParam> param)
s32 sceImeDialogInit(vm::ptr<const SceImeDialogParam> param)
{
throw __FUNCTION__;
}
@ -444,7 +144,7 @@ s32 sceImeDialogAbort()
throw __FUNCTION__;
}
s32 sceImeDialogGetResult(vm::psv::ptr<SceImeDialogResult> result)
s32 sceImeDialogGetResult(vm::ptr<SceImeDialogResult> result)
{
throw __FUNCTION__;
}
@ -454,7 +154,7 @@ s32 sceImeDialogTerm()
throw __FUNCTION__;
}
s32 scePhotoImportDialogInit(vm::psv::ptr<const ScePhotoImportDialogParam> param)
s32 scePhotoImportDialogInit(vm::ptr<const ScePhotoImportDialogParam> param)
{
throw __FUNCTION__;
}
@ -464,7 +164,7 @@ SceCommonDialogStatus scePhotoImportDialogGetStatus()
throw __FUNCTION__;
}
s32 scePhotoImportDialogGetResult(vm::psv::ptr<ScePhotoImportDialogResult> result)
s32 scePhotoImportDialogGetResult(vm::ptr<ScePhotoImportDialogResult> result)
{
throw __FUNCTION__;
}
@ -479,7 +179,7 @@ s32 scePhotoImportDialogAbort()
throw __FUNCTION__;
}
s32 scePhotoReviewDialogInit(vm::psv::ptr<const ScePhotoReviewDialogParam> param)
s32 scePhotoReviewDialogInit(vm::ptr<const ScePhotoReviewDialogParam> param)
{
throw __FUNCTION__;
}
@ -489,7 +189,7 @@ SceCommonDialogStatus scePhotoReviewDialogGetStatus()
throw __FUNCTION__;
}
s32 scePhotoReviewDialogGetResult(vm::psv::ptr<ScePhotoReviewDialogResult> result)
s32 scePhotoReviewDialogGetResult(vm::ptr<ScePhotoReviewDialogResult> result)
{
throw __FUNCTION__;
}
@ -512,6 +212,7 @@ psv_log_base sceCommonDialog("SceCommonDialog", []()
sceCommonDialog.on_load = nullptr;
sceCommonDialog.on_unload = nullptr;
sceCommonDialog.on_stop = nullptr;
sceCommonDialog.on_error = nullptr;
REG_FUNC(0x90530F2F, sceCommonDialogUpdate);
REG_FUNC(0x755FF270, sceMsgDialogInit);

302
rpcs3/Emu/ARMv7/Modules/sceCommonDialog.h Normal file
View File

@ -0,0 +1,302 @@
#pragma once
#include "sceGxm.h"
#include "sceAppUtil.h"
#include "sceIme.h"
enum SceCommonDialogStatus : s32
{
SCE_COMMON_DIALOG_STATUS_NONE = 0,
SCE_COMMON_DIALOG_STATUS_RUNNING = 1,
SCE_COMMON_DIALOG_STATUS_FINISHED = 2,
};
enum SceCommonDialogResult : s32
{
SCE_COMMON_DIALOG_RESULT_OK,
SCE_COMMON_DIALOG_RESULT_USER_CANCELED,
SCE_COMMON_DIALOG_RESULT_ABORTED,
};
struct SceCommonDialogRenderTargetInfo
{
vm::lptr<void> depthSurfaceData;
vm::lptr<void> colorSurfaceData;
le_t<u32> surfaceType; // SceGxmColorSurfaceType
le_t<u32> colorFormat; // SceGxmColorFormat
le_t<u32> width;
le_t<u32> height;
le_t<u32> strideInPixels;
u8 reserved[32];
};
struct SceCommonDialogUpdateParam
{
SceCommonDialogRenderTargetInfo renderTarget;
vm::lptr<SceGxmSyncObject> displaySyncObject;
u8 reserved[32];
};
struct SceMsgDialogUserMessageParam
{
le_t<s32> buttonType;
vm::lptr<const char> msg;
char reserved[32];
};
struct SceMsgDialogSystemMessageParam
{
le_t<s32> sysMsgType;
le_t<s32> value;
char reserved[32];
};
struct SceMsgDialogErrorCodeParam
{
le_t<s32> errorCode;
char reserved[32];
};
struct SceMsgDialogProgressBarParam
{
le_t<s32> barType;
SceMsgDialogSystemMessageParam sysMsgParam;
vm::lptr<const char> msg;
char reserved[32];
};
struct SceMsgDialogParam
{
le_t<u32> sdkVersion;
le_t<s32> mode;
vm::lptr<SceMsgDialogUserMessageParam> userMsgParam;
vm::lptr<SceMsgDialogSystemMessageParam> sysMsgParam;
vm::lptr<SceMsgDialogErrorCodeParam> errorCodeParam;
vm::lptr<SceMsgDialogProgressBarParam> progBarParam;
le_t<u32> flag;
char reserved[32];
};
struct SceMsgDialogResult
{
le_t<s32> mode;
le_t<s32> result;
le_t<s32> buttonId;
u8 reserved[32];
};
struct SceNetCheckDialogParam
{
le_t<u32> sdkVersion;
le_t<s32> mode;
u8 reserved[128];
};
struct SceNetCheckDialogResult
{
le_t<s32> result;
u8 reserved[128];
};
struct SceSaveDataDialogFixedParam
{
le_t<u32> targetSlot;
char reserved[32];
};
struct SceSaveDataDialogListParam
{
vm::lptr<const u32> slotList;
le_t<u32> slotListSize;
le_t<s32> focusPos;
le_t<u32> focusId;
vm::lptr<const char> listTitle;
char reserved[32];
};
struct SceSaveDataDialogUserMessageParam
{
le_t<s32> buttonType;
vm::lptr<const char> msg;
le_t<u32> targetSlot;
char reserved[32];
};
struct SceSaveDataDialogSystemMessageParam
{
le_t<s32> sysMsgType;
le_t<s32> value;
le_t<u32> targetSlot;
char reserved[32];
};
struct SceSaveDataDialogErrorCodeParam
{
le_t<s32> errorCode;
le_t<u32> targetSlot;
char reserved[32];
};
struct SceSaveDataDialogProgressBarParam
{
le_t<s32> barType;
SceSaveDataDialogSystemMessageParam sysMsgParam;
vm::lptr<const char> msg;
le_t<u32> targetSlot;
char reserved[32];
};
struct SceSaveDataDialogSlotConfigParam
{
vm::lptr<const SceAppUtilSaveDataMountPoint> mountPoint;
vm::lptr<const char> appSubDir;
char reserved[32];
};
struct SceSaveDataDialogParam
{
le_t<u32> sdkVersion;
le_t<s32> mode;
le_t<s32> dispType;
vm::lptr<SceSaveDataDialogFixedParam> fixedParam;
vm::lptr<SceSaveDataDialogListParam> listParam;
vm::lptr<SceSaveDataDialogUserMessageParam> userMsgParam;
vm::lptr<SceSaveDataDialogSystemMessageParam> sysMsgParam;
vm::lptr<SceSaveDataDialogErrorCodeParam> errorCodeParam;
vm::lptr<SceSaveDataDialogProgressBarParam> progBarParam;
vm::lptr<SceSaveDataDialogSlotConfigParam> slotConfParam;
le_t<u32> flag;
vm::lptr<void> userdata;
char reserved[32];
};
struct SceSaveDataDialogFinishParam
{
le_t<u32> flag;
char reserved[32];
};
struct SceSaveDataDialogSlotInfo
{
le_t<u32> isExist;
vm::lptr<SceAppUtilSaveDataSlotParam> slotParam;
u8 reserved[32];
};
struct SceSaveDataDialogResult
{
le_t<s32> mode;
le_t<s32> result;
le_t<s32> buttonId;
le_t<u32> slotId;
vm::lptr<SceSaveDataDialogSlotInfo> slotInfo;
vm::lptr<void> userdata;
char reserved[32];
};
struct SceImeDialogParam
{
le_t<u32> sdkVersion;
le_t<u32> inputMethod;
le_t<u64> supportedLanguages;
le_t<s32> languagesForced;
le_t<u32> type;
le_t<u32> option;
vm::lptr<SceImeCharFilter> filter;
le_t<u32> dialogMode;
le_t<u32> textBoxMode;
vm::lptr<const u16> title;
le_t<u32> maxTextLength;
vm::lptr<u16> initialText;
vm::lptr<u16> inputTextBuffer;
char reserved[32];
};
struct SceImeDialogResult
{
le_t<s32> result;
char reserved[32];
};
enum ScePhotoImportDialogFormatType : s32
{
SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_UNKNOWN = 0,
SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_JPEG,
SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_PNG,
SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_GIF,
SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_BMP,
SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_TIFF
};
enum ScePhotoImportDialogOrientation : s32
{
SCE_PHOTOIMPORT_DIALOG_ORIENTATION_UNKNOWN = 0,
SCE_PHOTOIMPORT_DIALOG_ORIENTATION_TOP_LEFT,
SCE_PHOTOIMPORT_DIALOG_ORIENTATION_TOP_RIGHT,
SCE_PHOTOIMPORT_DIALOG_ORIENTATION_BOTTOM_RIGHT,
SCE_PHOTOIMPORT_DIALOG_ORIENTATION_BOTTOM_LEFT,
SCE_PHOTOIMPORT_DIALOG_ORIENTATION_LEFT_TOP,
SCE_PHOTOIMPORT_DIALOG_ORIENTATION_RIGHT_TOP,
SCE_PHOTOIMPORT_DIALOG_ORIENTATION_RIGHT_BOTTOM,
SCE_PHOTOIMPORT_DIALOG_ORIENTATION_LEFT_BOTTOM,
};
struct ScePhotoImportDialogFileDataSub
{
le_t<u32> width;
le_t<u32> height;
ScePhotoImportDialogFormatType format;
ScePhotoImportDialogOrientation orientation;
char reserved[32];
};
struct ScePhotoImportDialogFileData
{
char fileName[1024];
char photoTitle[256];
char reserved[32];
};
struct ScePhotoImportDialogItemData
{
ScePhotoImportDialogFileData fileData;
ScePhotoImportDialogFileDataSub dataSub;
char reserved[32];
};
struct ScePhotoImportDialogResult
{
le_t<s32> result;
le_t<u32> importedItemNum;
char reserved[32];
};
struct ScePhotoImportDialogParam
{
le_t<u32> sdkVersion;
le_t<s32> mode;
le_t<u32> visibleCategory;
le_t<u32> itemCount;
vm::lptr<ScePhotoImportDialogItemData> itemData;
char reserved[32];
};
struct ScePhotoReviewDialogParam
{
le_t<u32> sdkVersion;
le_t<s32> mode;
char fileName[1024];
vm::lptr<void> workMemory;
le_t<u32> workMemorySize;
char reserved[32];
};
struct ScePhotoReviewDialogResult
{
le_t<s32> result;
char reserved[32];
};
extern psv_log_base sceCommonDialog;

36
rpcs3/Emu/ARMv7/Modules/sceCtrl.cpp
View File

@ -2,60 +2,39 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceCtrl;
struct SceCtrlData
{
u64 timeStamp;
u32 buttons;
u8 lx;
u8 ly;
u8 rx;
u8 ry;
u8 rsrv[16];
};
struct SceCtrlRapidFireRule
{
u32 uiMask;
u32 uiTrigger;
u32 uiTarget;
u32 uiDelay;
u32 uiMake;
u32 uiBreak;
};
#include "sceCtrl.h"
s32 sceCtrlSetSamplingMode(u32 uiMode)
{
throw __FUNCTION__;
}
s32 sceCtrlGetSamplingMode(vm::psv::ptr<u32> puiMode)
s32 sceCtrlGetSamplingMode(vm::ptr<u32> puiMode)
{
throw __FUNCTION__;
}
s32 sceCtrlPeekBufferPositive(s32 port, vm::psv::ptr<SceCtrlData> pData, s32 nBufs)
s32 sceCtrlPeekBufferPositive(s32 port, vm::ptr<SceCtrlData> pData, s32 nBufs)
{
throw __FUNCTION__;
}
s32 sceCtrlPeekBufferNegative(s32 port, vm::psv::ptr<SceCtrlData> pData, s32 nBufs)
s32 sceCtrlPeekBufferNegative(s32 port, vm::ptr<SceCtrlData> pData, s32 nBufs)
{
throw __FUNCTION__;
}
s32 sceCtrlReadBufferPositive(s32 port, vm::psv::ptr<SceCtrlData> pData, s32 nBufs)
s32 sceCtrlReadBufferPositive(s32 port, vm::ptr<SceCtrlData> pData, s32 nBufs)
{
throw __FUNCTION__;
}
s32 sceCtrlReadBufferNegative(s32 port, vm::psv::ptr<SceCtrlData> pData, s32 nBufs)
s32 sceCtrlReadBufferNegative(s32 port, vm::ptr<SceCtrlData> pData, s32 nBufs)
{
throw __FUNCTION__;
}
s32 sceCtrlSetRapidFire(s32 port, s32 idx, vm::psv::ptr<const SceCtrlRapidFireRule> pRule)
s32 sceCtrlSetRapidFire(s32 port, s32 idx, vm::ptr<const SceCtrlRapidFireRule> pRule)
{
throw __FUNCTION__;
}
@ -73,6 +52,7 @@ psv_log_base sceCtrl("SceCtrl", []()
sceCtrl.on_load = nullptr;
sceCtrl.on_unload = nullptr;
sceCtrl.on_stop = nullptr;
sceCtrl.on_error = nullptr;
REG_FUNC(0xA497B150, sceCtrlSetSamplingMode);
REG_FUNC(0xEC752AAF, sceCtrlGetSamplingMode);

24
rpcs3/Emu/ARMv7/Modules/sceCtrl.h Normal file
View File

@ -0,0 +1,24 @@
#pragma once
struct SceCtrlData
{
le_t<u64> timeStamp;
le_t<u32> buttons;
u8 lx;
u8 ly;
u8 rx;
u8 ry;
u8 reserved[16];
};
struct SceCtrlRapidFireRule
{
le_t<u32> uiMask;
le_t<u32> uiTrigger;
le_t<u32> uiTarget;
le_t<u32> uiDelay;
le_t<u32> uiMake;
le_t<u32> uiBreak;
};
extern psv_log_base sceCtrl;

13
rpcs3/Emu/ARMv7/Modules/sceDbg.cpp
View File

@ -2,13 +2,7 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceDbg;
enum SceDbgBreakOnErrorState : s32
{
SCE_DBG_DISABLE_BREAK_ON_ERROR = 0,
SCE_DBG_ENABLE_BREAK_ON_ERROR
};
#include "sceDbg.h"
s32 sceDbgSetMinimumLogLevel(s32 minimumLogLevel)
{
@ -20,12 +14,12 @@ s32 sceDbgSetBreakOnErrorState(SceDbgBreakOnErrorState state)
throw __FUNCTION__;
}
s32 sceDbgAssertionHandler(vm::psv::ptr<const char> pFile, s32 line, bool stop, vm::psv::ptr<const char> pComponent, vm::psv::ptr<const char> pMessage) // va_args...
s32 sceDbgAssertionHandler(vm::ptr<const char> pFile, s32 line, bool stop, vm::ptr<const char> pComponent, vm::ptr<const char> pMessage) // va_args...
{
throw __FUNCTION__;
}
s32 sceDbgLoggingHandler(vm::psv::ptr<const char> pFile, s32 line, s32 severity, vm::psv::ptr<const char> pComponent, vm::psv::ptr<const char> pMessage) // va_args...
s32 sceDbgLoggingHandler(vm::ptr<const char> pFile, s32 line, s32 severity, vm::ptr<const char> pComponent, vm::ptr<const char> pMessage) // va_args...
{
throw __FUNCTION__;
}
@ -38,6 +32,7 @@ psv_log_base sceDbg("SceDbg", []()
sceDbg.on_load = nullptr;
sceDbg.on_unload = nullptr;
sceDbg.on_stop = nullptr;
sceDbg.on_error = nullptr;
REG_FUNC(0x941622FA, sceDbgSetMinimumLogLevel);
REG_FUNC(0x1AF3678B, sceDbgAssertionHandler);

9
rpcs3/Emu/ARMv7/Modules/sceDbg.h Normal file
View File

@ -0,0 +1,9 @@
#pragma once
enum SceDbgBreakOnErrorState : s32
{
SCE_DBG_DISABLE_BREAK_ON_ERROR = 0,
SCE_DBG_ENABLE_BREAK_ON_ERROR
};
extern psv_log_base sceDbg;

11
rpcs3/Emu/ARMv7/Modules/sceDeci4p.cpp
View File

@ -2,11 +2,9 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceDeci4p;
#include "sceDeci4p.h"
typedef vm::psv::ptr<s32(s32 notifyId, s32 notifyCount, s32 notifyArg, vm::psv::ptr<void> pCommon)> SceKernelDeci4pCallback;
s32 sceKernelDeci4pOpen(vm::psv::ptr<const char> protoname, u32 protonum, u32 bufsize)
s32 sceKernelDeci4pOpen(vm::ptr<const char> protoname, u32 protonum, u32 bufsize)
{
throw __FUNCTION__;
}
@ -16,12 +14,12 @@ s32 sceKernelDeci4pClose(s32 socketid)
throw __FUNCTION__;
}
s32 sceKernelDeci4pRead(s32 socketid, vm::psv::ptr<void> buffer, u32 size, u32 reserved)
s32 sceKernelDeci4pRead(s32 socketid, vm::ptr<void> buffer, u32 size, u32 reserved)
{
throw __FUNCTION__;
}
s32 sceKernelDeci4pWrite(s32 socketid, vm::psv::ptr<const void> buffer, u32 size, u32 reserved)
s32 sceKernelDeci4pWrite(s32 socketid, vm::ptr<const void> buffer, u32 size, u32 reserved)
{
throw __FUNCTION__;
}
@ -39,6 +37,7 @@ psv_log_base sceDeci4p("SceDeci4pUserp", []()
sceDeci4p.on_load = nullptr;
sceDeci4p.on_unload = nullptr;
sceDeci4p.on_stop = nullptr;
sceDeci4p.on_error = nullptr;
REG_FUNC(0x28578FE8, sceKernelDeci4pOpen);
REG_FUNC(0x63B0C50F, sceKernelDeci4pClose);

5
rpcs3/Emu/ARMv7/Modules/sceDeci4p.h Normal file
View File

@ -0,0 +1,5 @@
#pragma once
using SceKernelDeci4pCallback = func_def<s32(s32 notifyId, s32 notifyCount, s32 notifyArg, vm::ptr<void> pCommon)>;
extern psv_log_base sceDeci4p;

29
rpcs3/Emu/ARMv7/Modules/sceDeflt.cpp
View File

@ -2,69 +2,69 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceDeflt;
#include "sceDeflt.h"
s32 sceGzipIsValid(vm::psv::ptr<const void> pSrcGzip)
s32 sceGzipIsValid(vm::ptr<const void> pSrcGzip)
{
throw __FUNCTION__;
}
s32 sceGzipGetInfo(vm::psv::ptr<const void> pSrcGzip, vm::psv::pptr<const void> ppvExtra, vm::psv::pptr<const char> ppszName, vm::psv::pptr<const char> ppszComment, vm::psv::ptr<u16> pusCrc, vm::psv::pptr<const void> ppvData)
s32 sceGzipGetInfo(vm::ptr<const void> pSrcGzip, vm::pptr<const void> ppvExtra, vm::pptr<const char> ppszName, vm::pptr<const char> ppszComment, vm::ptr<u16> pusCrc, vm::pptr<const void> ppvData)
{
throw __FUNCTION__;
}
vm::psv::ptr<const char> sceGzipGetName(vm::psv::ptr<const void> pSrcGzip)
vm::ptr<const char> sceGzipGetName(vm::ptr<const void> pSrcGzip)
{
throw __FUNCTION__;
}
vm::psv::ptr<const char> sceGzipGetComment(vm::psv::ptr<const void> pSrcGzip)
vm::ptr<const char> sceGzipGetComment(vm::ptr<const void> pSrcGzip)
{
throw __FUNCTION__;
}
vm::psv::ptr<const void> sceGzipGetCompressedData(vm::psv::ptr<const void> pSrcGzip)
vm::ptr<const void> sceGzipGetCompressedData(vm::ptr<const void> pSrcGzip)
{
throw __FUNCTION__;
}
s32 sceGzipDecompress(vm::psv::ptr<void> pDst, u32 uiBufSize, vm::psv::ptr<const void> pSrcGzip, vm::psv::ptr<u32> puiCrc32)
s32 sceGzipDecompress(vm::ptr<void> pDst, u32 uiBufSize, vm::ptr<const void> pSrcGzip, vm::ptr<u32> puiCrc32)
{
throw __FUNCTION__;
}
s32 sceZlibIsValid(vm::psv::ptr<const void> pSrcZlib)
s32 sceZlibIsValid(vm::ptr<const void> pSrcZlib)
{
throw __FUNCTION__;
}
s32 sceZlibGetInfo(vm::psv::ptr<const void> pSrcZlib, vm::psv::ptr<u8> pbCmf, vm::psv::ptr<u8> pbFlg, vm::psv::ptr<u32> puiDictId, vm::psv::pptr<const void> ppvData)
s32 sceZlibGetInfo(vm::ptr<const void> pSrcZlib, vm::ptr<u8> pbCmf, vm::ptr<u8> pbFlg, vm::ptr<u32> puiDictId, vm::pptr<const void> ppvData)
{
throw __FUNCTION__;
}
vm::psv::ptr<const void> sceZlibGetCompressedData(vm::psv::ptr<const void> pSrcZlib)
vm::ptr<const void> sceZlibGetCompressedData(vm::ptr<const void> pSrcZlib)
{
throw __FUNCTION__;
}
s32 sceZlibDecompress(vm::psv::ptr<void> pDst, u32 uiBufSize, vm::psv::ptr<const void> pSrcZlib, vm::psv::ptr<u32> puiAdler32)
s32 sceZlibDecompress(vm::ptr<void> pDst, u32 uiBufSize, vm::ptr<const void> pSrcZlib, vm::ptr<u32> puiAdler32)
{
throw __FUNCTION__;
}
u32 sceZlibAdler32(u32 uiAdler, vm::psv::ptr<const u8> pSrc, u32 uiSize)
u32 sceZlibAdler32(u32 uiAdler, vm::ptr<const u8> pSrc, u32 uiSize)
{
throw __FUNCTION__;
}
s32 sceDeflateDecompress(vm::psv::ptr<void> pDst, u32 uiBufSize, vm::psv::ptr<const void> pSrcDeflate, vm::psv::pptr<const void> ppNext)
s32 sceDeflateDecompress(vm::ptr<void> pDst, u32 uiBufSize, vm::ptr<const void> pSrcDeflate, vm::pptr<const void> ppNext)
{
throw __FUNCTION__;
}
s32 sceZipGetInfo(vm::psv::ptr<const void> pSrc, vm::psv::pptr<const void> ppvExtra, vm::psv::ptr<u32> puiCrc, vm::psv::pptr<const void> ppvData)
s32 sceZipGetInfo(vm::ptr<const void> pSrc, vm::pptr<const void> ppvExtra, vm::ptr<u32> puiCrc, vm::pptr<const void> ppvData)
{
throw __FUNCTION__;
}
@ -77,6 +77,7 @@ psv_log_base sceDeflt("SceDeflt", []()
sceDeflt.on_load = nullptr;
sceDeflt.on_unload = nullptr;
sceDeflt.on_stop = nullptr;
sceDeflt.on_error = nullptr;
REG_FUNC(0xCD83A464, sceZlibAdler32);
REG_FUNC(0x110D5050, sceDeflateDecompress);

3
rpcs3/Emu/ARMv7/Modules/sceDeflt.h Normal file
View File

@ -0,0 +1,3 @@
#pragma once
extern psv_log_base sceDeflt;

19
rpcs3/Emu/ARMv7/Modules/sceDisplay.cpp
View File

@ -2,29 +2,19 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceDisplay;
#include "sceDisplay.h"
struct SceDisplayFrameBuf
{
u32 size;
vm::psv::ptr<void> base;
u32 pitch;
u32 pixelformat;
u32 width;
u32 height;
};
s32 sceDisplayGetRefreshRate(vm::psv::ptr<float> pFps)
s32 sceDisplayGetRefreshRate(vm::ptr<float> pFps)
{
throw __FUNCTION__;
}
s32 sceDisplaySetFrameBuf(vm::psv::ptr<const SceDisplayFrameBuf> pFrameBuf, s32 iUpdateTimingMode)
s32 sceDisplaySetFrameBuf(vm::ptr<const SceDisplayFrameBuf> pFrameBuf, s32 iUpdateTimingMode)
{
throw __FUNCTION__;
}
s32 sceDisplayGetFrameBuf(vm::psv::ptr<SceDisplayFrameBuf> pFrameBuf, s32 iUpdateTimingMode)
s32 sceDisplayGetFrameBuf(vm::ptr<SceDisplayFrameBuf> pFrameBuf, s32 iUpdateTimingMode)
{
throw __FUNCTION__;
}
@ -92,6 +82,7 @@ psv_log_base sceDisplay("SceDisplay", []()
sceDisplay.on_load = nullptr;
sceDisplay.on_unload = nullptr;
sceDisplay.on_stop = nullptr;
sceDisplay.on_error = nullptr;
// SceDisplayUser
REG_FUNC(0x7A410B64, sceDisplaySetFrameBuf);

13
rpcs3/Emu/ARMv7/Modules/sceDisplay.h Normal file
View File

@ -0,0 +1,13 @@
#pragma once
struct SceDisplayFrameBuf
{
le_t<u32> size;
vm::lptr<void> base;
le_t<u32> pitch;
le_t<u32> pixelformat;
le_t<u32> width;
le_t<u32> height;
};
extern psv_log_base sceDisplay;

55
rpcs3/Emu/ARMv7/Modules/sceFiber.cpp
View File

@ -2,80 +2,44 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceFiber;
#include "sceFiber.h"
typedef vm::psv::ptr<void(u32 argOnInitialize, u32 argOnRun)> SceFiberEntry;
struct SceFiber
{
static const uint size = 128;
static const uint align = 8;
u64 padding[size / sizeof(u64)];
};
struct SceFiberOptParam
{
static const uint size = 128;
static const uint align = 8;
u64 padding[size / sizeof(u64)];
};
struct SceFiberInfo
{
static const uint size = 128;
static const uint align = 8;
union
{
u64 padding[size / sizeof(u64)];
struct
{
SceFiberEntry entry;
u32 argOnInitialize;
vm::psv::ptr<void> addrContext;
s32 sizeContext;
char name[32];
};
};
};
s32 _sceFiberInitializeImpl(vm::psv::ptr<SceFiber> fiber, vm::psv::ptr<const char> name, SceFiberEntry entry, u32 argOnInitialize, vm::psv::ptr<void> addrContext, u32 sizeContext, vm::psv::ptr<const SceFiberOptParam> optParam, u32 buildVersion)
s32 _sceFiberInitializeImpl(vm::ptr<SceFiber> fiber, vm::ptr<const char> name, vm::ptr<SceFiberEntry> entry, u32 argOnInitialize, vm::ptr<void> addrContext, u32 sizeContext, vm::ptr<const SceFiberOptParam> optParam, u32 buildVersion)
{
throw __FUNCTION__;
}
s32 sceFiberOptParamInitialize(vm::psv::ptr<SceFiberOptParam> optParam)
s32 sceFiberOptParamInitialize(vm::ptr<SceFiberOptParam> optParam)
{
throw __FUNCTION__;
}
s32 sceFiberFinalize(vm::psv::ptr<SceFiber> fiber)
s32 sceFiberFinalize(vm::ptr<SceFiber> fiber)
{
throw __FUNCTION__;
}
s32 sceFiberRun(vm::psv::ptr<SceFiber> fiber, u32 argOnRunTo, vm::psv::ptr<u32> argOnReturn)
s32 sceFiberRun(vm::ptr<SceFiber> fiber, u32 argOnRunTo, vm::ptr<u32> argOnReturn)
{
throw __FUNCTION__;
}
s32 sceFiberSwitch(vm::psv::ptr<SceFiber> fiber, u32 argOnRunTo, vm::psv::ptr<u32> argOnRun)
s32 sceFiberSwitch(vm::ptr<SceFiber> fiber, u32 argOnRunTo, vm::ptr<u32> argOnRun)
{
throw __FUNCTION__;
}
s32 sceFiberGetSelf(vm::psv::pptr<SceFiber> fiber)
s32 sceFiberGetSelf(vm::pptr<SceFiber> fiber)
{
throw __FUNCTION__;
}
s32 sceFiberReturnToThread(u32 argOnReturn, vm::psv::ptr<u32> argOnRun)
s32 sceFiberReturnToThread(u32 argOnReturn, vm::ptr<u32> argOnRun)
{
throw __FUNCTION__;
}
s32 sceFiberGetInfo(vm::psv::ptr<SceFiber> fiber, vm::psv::ptr<SceFiberInfo> fiberInfo)
s32 sceFiberGetInfo(vm::ptr<SceFiber> fiber, vm::ptr<SceFiberInfo> fiberInfo)
{
throw __FUNCTION__;
}
@ -88,6 +52,7 @@ psv_log_base sceFiber("SceFiber", []()
sceFiber.on_load = nullptr;
sceFiber.on_unload = nullptr;
sceFiber.on_stop = nullptr;
sceFiber.on_error = nullptr;
REG_FUNC(0xF24A298C, _sceFiberInitializeImpl);
//REG_FUNC(0xC6A3F9BB, _sceFiberInitializeWithInternalOptionImpl);

38
rpcs3/Emu/ARMv7/Modules/sceFiber.h Normal file
View File

@ -0,0 +1,38 @@
#pragma once
using SceFiberEntry = func_def<void(u32 argOnInitialize, u32 argOnRun)>;
struct SceFiber
{
le_t<u64> padding[16];
};
CHECK_SIZE_ALIGN(SceFiber, 128, 8);
struct SceFiberOptParam
{
le_t<u64> padding[16];
};
CHECK_SIZE_ALIGN(SceFiberOptParam, 128, 8);
struct SceFiberInfo
{
union
{
le_t<u64> padding[16];
struct
{
vm::lptr<SceFiberEntry> entry;
le_t<u32> argOnInitialize;
vm::lptr<void> addrContext;
le_t<s32> sizeContext;
char name[32];
};
};
};
CHECK_SIZE_ALIGN(SceFiberInfo, 128, 8);
extern psv_log_base sceFiber;

399
rpcs3/Emu/ARMv7/Modules/sceFios.cpp
View File

@ -2,127 +2,9 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceFios;
#include "sceFios.h"
typedef s64 SceFiosOffset;
typedef s64 SceFiosSize;
typedef u8 SceFiosOpEvent;
typedef s32 SceFiosHandle;
typedef SceFiosHandle SceFiosOp;
typedef SceFiosHandle SceFiosFH;
typedef SceFiosHandle SceFiosDH;
typedef s64 SceFiosTime;
typedef s8 SceFiosPriority;
typedef SceFiosTime SceFiosTimeInterval;
typedef u64 SceFiosDate;
typedef s32 SceFiosOverlayID;
typedef vm::psv::ptr<s32(vm::psv::ptr<void> pContext, SceFiosOp op, SceFiosOpEvent event, s32 err)> SceFiosOpCallback;
typedef vm::psv::ptr<s32(vm::psv::ptr<const char> fmt, va_list ap)> SceFiosVprintfCallback;
typedef vm::psv::ptr<vm::psv::ptr<void>(vm::psv::ptr<void> dst, vm::psv::ptr<const void> src, u32 len)> SceFiosMemcpyCallback;
enum SceFiosWhence : s32
{
SCE_FIOS_SEEK_SET = 0,
SCE_FIOS_SEEK_CUR = 1,
SCE_FIOS_SEEK_END = 2
};
struct SceFiosBuffer
{
vm::psv::ptr<void> pPtr;
u32 length;
};
struct SceFiosOpAttr
{
SceFiosTime deadline;
SceFiosOpCallback pCallback;
vm::psv::ptr<void> pCallbackContext;
s32 priority : 8;
u32 opflags : 24;
u32 userTag;
vm::psv::ptr<void> userPtr;
vm::psv::ptr<void> pReserved;
};
struct SceFiosDirEntry
{
SceFiosOffset fileSize;
u32 statFlags;
u16 nameLength;
u16 fullPathLength;
u16 offsetToName;
u16 reserved[3];
char fullPath[1024];
};
struct SceFiosStat
{
SceFiosOffset fileSize;
SceFiosDate accessDate;
SceFiosDate modificationDate;
SceFiosDate creationDate;
u32 statFlags;
u32 reserved;
s64 uid;
s64 gid;
s64 dev;
s64 ino;
s64 mode;
};
struct SceFiosOpenParams
{
u32 openFlags;
u32 reserved;
SceFiosBuffer buffer;
};
struct SceFiosTuple
{
SceFiosOffset offset;
SceFiosSize size;
char path[1024];
};
struct SceFiosParams
{
u32 initialized : 1;
u32 paramsSize : 14;
u32 pathMax : 16;
u32 profiling;
SceFiosBuffer opStorage;
SceFiosBuffer fhStorage;
SceFiosBuffer dhStorage;
SceFiosBuffer chunkStorage;
SceFiosVprintfCallback pVprintf;
SceFiosMemcpyCallback pMemcpy;
s32 threadPriority[2];
s32 threadAffinity[2];
};
struct SceFiosOverlay
{
u8 type;
u8 order;
u8 reserved[10];
SceFiosOverlayID id;
char dst[292];
char src[292];
};
typedef vm::psv::ptr<void()> SceFiosIOFilterCallback;
struct SceFiosPsarcDearchiverContext
{
u32 sizeOfContext;
u32 workBufferSize;
vm::psv::ptr<void> pWorkBuffer;
s32 reserved[4];
};
s32 sceFiosInitialize(vm::psv::ptr<const SceFiosParams> pParameters)
s32 sceFiosInitialize(vm::ptr<const SceFiosParams> pParameters)
{
throw __FUNCTION__;
}
@ -132,37 +14,37 @@ void sceFiosTerminate()
throw __FUNCTION__;
}
bool sceFiosIsInitialized(vm::psv::ptr<SceFiosParams> pOutParameters)
bool sceFiosIsInitialized(vm::ptr<SceFiosParams> pOutParameters)
{
throw __FUNCTION__;
}
void sceFiosUpdateParameters(vm::psv::ptr<const SceFiosParams> pParameters)
void sceFiosUpdateParameters(vm::ptr<const SceFiosParams> pParameters)
{
throw __FUNCTION__;
}
void sceFiosSetGlobalDefaultOpAttr(vm::psv::ptr<const SceFiosOpAttr> pAttr)
void sceFiosSetGlobalDefaultOpAttr(vm::ptr<const SceFiosOpAttr> pAttr)
{
throw __FUNCTION__;
}
bool sceFiosGetGlobalDefaultOpAttr(vm::psv::ptr<SceFiosOpAttr> pOutAttr)
bool sceFiosGetGlobalDefaultOpAttr(vm::ptr<SceFiosOpAttr> pOutAttr)
{
throw __FUNCTION__;
}
void sceFiosSetThreadDefaultOpAttr(vm::psv::ptr<const SceFiosOpAttr> pAttr)
void sceFiosSetThreadDefaultOpAttr(vm::ptr<const SceFiosOpAttr> pAttr)
{
throw __FUNCTION__;
}
bool sceFiosGetThreadDefaultOpAttr(vm::psv::ptr<SceFiosOpAttr> pOutAttr)
bool sceFiosGetThreadDefaultOpAttr(vm::ptr<SceFiosOpAttr> pOutAttr)
{
throw __FUNCTION__;
}
void sceFiosGetDefaultOpAttr(vm::psv::ptr<SceFiosOpAttr> pOutAttr)
void sceFiosGetDefaultOpAttr(vm::ptr<SceFiosOpAttr> pOutAttr)
{
throw __FUNCTION__;
}
@ -207,587 +89,587 @@ bool sceFiosIsIdle()
throw __FUNCTION__;
}
u32 sceFiosGetAllFHs(vm::psv::ptr<SceFiosFH> pOutArray, u32 arraySize)
u32 sceFiosGetAllFHs(vm::ptr<s32> pOutArray, u32 arraySize)
{
throw __FUNCTION__;
}
u32 sceFiosGetAllDHs(vm::psv::ptr<SceFiosDH> pOutArray, u32 arraySize)
u32 sceFiosGetAllDHs(vm::ptr<s32> pOutArray, u32 arraySize)
{
throw __FUNCTION__;
}
u32 sceFiosGetAllOps(vm::psv::ptr<SceFiosOp> pOutArray, u32 arraySize)
u32 sceFiosGetAllOps(vm::ptr<s32> pOutArray, u32 arraySize)
{
throw __FUNCTION__;
}
bool sceFiosIsValidHandle(SceFiosHandle h)
bool sceFiosIsValidHandle(s32 h)
{
throw __FUNCTION__;
}
s32 sceFiosPathcmp(vm::psv::ptr<const char> pA, vm::psv::ptr<const char> pB)
s32 sceFiosPathcmp(vm::ptr<const char> pA, vm::ptr<const char> pB)
{
throw __FUNCTION__;
}
s32 sceFiosPathncmp(vm::psv::ptr<const char> pA, vm::psv::ptr<const char> pB, u32 n)
s32 sceFiosPathncmp(vm::ptr<const char> pA, vm::ptr<const char> pB, u32 n)
{
throw __FUNCTION__;
}
s32 sceFiosPrintf(vm::psv::ptr<const char> pFormat) // va_args...
s32 sceFiosPrintf(vm::ptr<const char> pFormat) // va_args...
{
throw __FUNCTION__;
}
s32 sceFiosVprintf(vm::psv::ptr<const char> pFormat) // va_list
s32 sceFiosVprintf(vm::ptr<const char> pFormat) // va_list
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFileExists(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<bool> pOutExists)
s32 sceFiosFileExists(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, vm::ptr<bool> pOutExists)
{
throw __FUNCTION__;
}
bool sceFiosFileExistsSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
bool sceFiosFileExistsSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFileGetSize(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<SceFiosSize> pOutSize)
s32 sceFiosFileGetSize(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, vm::ptr<s64> pOutSize)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosFileGetSizeSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
s64 sceFiosFileGetSizeSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFileDelete(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
s32 sceFiosFileDelete(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
{
throw __FUNCTION__;
}
s32 sceFiosFileDeleteSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
s32 sceFiosFileDeleteSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosDirectoryExists(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<bool> pOutExists)
s32 sceFiosDirectoryExists(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, vm::ptr<bool> pOutExists)
{
throw __FUNCTION__;
}
bool sceFiosDirectoryExistsSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
bool sceFiosDirectoryExistsSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosDirectoryCreate(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
s32 sceFiosDirectoryCreate(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
{
throw __FUNCTION__;
}
s32 sceFiosDirectoryCreateSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
s32 sceFiosDirectoryCreateSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosDirectoryDelete(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
s32 sceFiosDirectoryDelete(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
{
throw __FUNCTION__;
}
s32 sceFiosDirectoryDeleteSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
s32 sceFiosDirectoryDeleteSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosExists(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<bool> pOutExists)
s32 sceFiosExists(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, vm::ptr<bool> pOutExists)
{
throw __FUNCTION__;
}
bool sceFiosExistsSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
bool sceFiosExistsSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosStat(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<SceFiosStat> pOutStatus)
s32 sceFiosStat(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, vm::ptr<SceFiosStat> pOutStatus)
{
throw __FUNCTION__;
}
s32 sceFiosStatSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<SceFiosStat> pOutStatus)
s32 sceFiosStatSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, vm::ptr<SceFiosStat> pOutStatus)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosDelete(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
s32 sceFiosDelete(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
{
throw __FUNCTION__;
}
s32 sceFiosDeleteSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
s32 sceFiosDeleteSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosResolve(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const SceFiosTuple> pInTuple, vm::psv::ptr<SceFiosTuple> pOutTuple)
s32 sceFiosResolve(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const SceFiosTuple> pInTuple, vm::ptr<SceFiosTuple> pOutTuple)
{
throw __FUNCTION__;
}
s32 sceFiosResolveSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const SceFiosTuple> pInTuple, vm::psv::ptr<SceFiosTuple> pOutTuple)
s32 sceFiosResolveSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const SceFiosTuple> pInTuple, vm::ptr<SceFiosTuple> pOutTuple)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosRename(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pOldPath, vm::psv::ptr<const char> pNewPath)
s32 sceFiosRename(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pOldPath, vm::ptr<const char> pNewPath)
{
throw __FUNCTION__;
}
s32 sceFiosRenameSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pOldPath, vm::psv::ptr<const char> pNewPath)
s32 sceFiosRenameSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pOldPath, vm::ptr<const char> pNewPath)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFileRead(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<void> pBuf, SceFiosSize length, SceFiosOffset offset)
s32 sceFiosFileRead(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, vm::ptr<void> pBuf, s64 length, s64 offset)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosFileReadSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<void> pBuf, SceFiosSize length, SceFiosOffset offset)
s64 sceFiosFileReadSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, vm::ptr<void> pBuf, s64 length, s64 offset)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFileWrite(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<const void> pBuf, SceFiosSize length, SceFiosOffset offset)
s32 sceFiosFileWrite(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, vm::ptr<const void> pBuf, s64 length, s64 offset)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosFileWriteSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<const void> pBuf, SceFiosSize length, SceFiosOffset offset)
s64 sceFiosFileWriteSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, vm::ptr<const void> pBuf, s64 length, s64 offset)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFileTruncate(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, SceFiosSize length)
s32 sceFiosFileTruncate(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, s64 length)
{
throw __FUNCTION__;
}
s32 sceFiosFileTruncateSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, SceFiosSize length)
s32 sceFiosFileTruncateSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, s64 length)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFHOpen(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<SceFiosFH> pOutFH, vm::psv::ptr<const char> pPath, vm::psv::ptr<const SceFiosOpenParams> pOpenParams)
s32 sceFiosFHOpen(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<s32> pOutFH, vm::ptr<const char> pPath, vm::ptr<const SceFiosOpenParams> pOpenParams)
{
throw __FUNCTION__;
}
s32 sceFiosFHOpenSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<SceFiosFH> pOutFH, vm::psv::ptr<const char> pPath, vm::psv::ptr<const SceFiosOpenParams> pOpenParams)
s32 sceFiosFHOpenSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<s32> pOutFH, vm::ptr<const char> pPath, vm::ptr<const SceFiosOpenParams> pOpenParams)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFHStat(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<SceFiosStat> pOutStatus)
s32 sceFiosFHStat(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<SceFiosStat> pOutStatus)
{
throw __FUNCTION__;
}
s32 sceFiosFHStatSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<SceFiosStat> pOutStatus)
s32 sceFiosFHStatSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<SceFiosStat> pOutStatus)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFHTruncate(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, SceFiosSize length)
s32 sceFiosFHTruncate(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, s64 length)
{
throw __FUNCTION__;
}
s32 sceFiosFHTruncateSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, SceFiosSize length)
s32 sceFiosFHTruncateSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, s64 length)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFHSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh)
s32 sceFiosFHSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh)
{
throw __FUNCTION__;
}
s32 sceFiosFHSyncSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh)
s32 sceFiosFHSyncSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFHRead(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<void> pBuf, SceFiosSize length)
s32 sceFiosFHRead(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<void> pBuf, s64 length)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosFHReadSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<void> pBuf, SceFiosSize length)
s64 sceFiosFHReadSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<void> pBuf, s64 length)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFHWrite(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const void> pBuf, SceFiosSize length)
s32 sceFiosFHWrite(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const void> pBuf, s64 length)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosFHWriteSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const void> pBuf, SceFiosSize length)
s64 sceFiosFHWriteSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const void> pBuf, s64 length)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFHReadv(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt)
s32 sceFiosFHReadv(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const SceFiosBuffer> iov, s32 iovcnt)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosFHReadvSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt)
s64 sceFiosFHReadvSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const SceFiosBuffer> iov, s32 iovcnt)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFHWritev(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt)
s32 sceFiosFHWritev(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const SceFiosBuffer> iov, s32 iovcnt)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosFHWritevSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt)
s64 sceFiosFHWritevSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const SceFiosBuffer> iov, s32 iovcnt)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFHPread(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<void> pBuf, SceFiosSize length, SceFiosOffset offset)
s32 sceFiosFHPread(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<void> pBuf, s64 length, s64 offset)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosFHPreadSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<void> pBuf, SceFiosSize length, SceFiosOffset offset)
s64 sceFiosFHPreadSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<void> pBuf, s64 length, s64 offset)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFHPwrite(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const void> pBuf, SceFiosSize length, SceFiosOffset offset)
s32 sceFiosFHPwrite(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const void> pBuf, s64 length, s64 offset)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosFHPwriteSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const void> pBuf, SceFiosSize length, SceFiosOffset offset)
s64 sceFiosFHPwriteSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const void> pBuf, s64 length, s64 offset)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFHPreadv(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt, SceFiosOffset offset)
s32 sceFiosFHPreadv(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const SceFiosBuffer> iov, s32 iovcnt, s64 offset)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosFHPreadvSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt, SceFiosOffset offset)
s64 sceFiosFHPreadvSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const SceFiosBuffer> iov, s32 iovcnt, s64 offset)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFHPwritev(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt, SceFiosOffset offset)
s32 sceFiosFHPwritev(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const SceFiosBuffer> iov, s32 iovcnt, s64 offset)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosFHPwritevSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt, SceFiosOffset offset)
s64 sceFiosFHPwritevSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const SceFiosBuffer> iov, s32 iovcnt, s64 offset)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFHClose(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh)
s32 sceFiosFHClose(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh)
{
throw __FUNCTION__;
}
s32 sceFiosFHCloseSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh)
s32 sceFiosFHCloseSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh)
{
throw __FUNCTION__;
}
SceFiosOffset sceFiosFHSeek(SceFiosFH fh, SceFiosOffset offset, SceFiosWhence whence)
s64 sceFiosFHSeek(s32 fh, s64 offset, SceFiosWhence whence)
{
throw __FUNCTION__;
}
SceFiosOffset sceFiosFHTell(SceFiosFH fh)
s64 sceFiosFHTell(s32 fh)
{
throw __FUNCTION__;
}
vm::psv::ptr<const char> sceFiosFHGetPath(SceFiosFH fh)
vm::ptr<const char> sceFiosFHGetPath(s32 fh)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosFHGetSize(SceFiosFH fh)
s64 sceFiosFHGetSize(s32 fh)
{
throw __FUNCTION__;
}
vm::psv::ptr<SceFiosOpenParams> sceFiosFHGetOpenParams(SceFiosFH fh)
vm::ptr<SceFiosOpenParams> sceFiosFHGetOpenParams(s32 fh)
{
throw __FUNCTION__;
}
//SceFiosOp sceFiosDHOpen(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<SceFiosDH> pOutDH, vm::psv::ptr<const char> pPath, SceFiosBuffer buf)
//{
// throw __FUNCTION__;
//}
//
//s32 sceFiosDHOpenSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<SceFiosDH> pOutDH, vm::psv::ptr<const char> pPath, SceFiosBuffer buf)
//{
// throw __FUNCTION__;
//}
s32 sceFiosDHOpen(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<s32> pOutDH, vm::ptr<const char> pPath, SceFiosBuffer buf)
{
throw __FUNCTION__;
}
s32 sceFiosDHOpenSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<s32> pOutDH, vm::ptr<const char> pPath, SceFiosBuffer buf)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosDHRead(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosDH dh, vm::psv::ptr<SceFiosDirEntry> pOutEntry)
s32 sceFiosDHRead(vm::ptr<const SceFiosOpAttr> pAttr, s32 dh, vm::ptr<SceFiosDirEntry> pOutEntry)
{
throw __FUNCTION__;
}
s32 sceFiosDHReadSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosDH dh, vm::psv::ptr<SceFiosDirEntry> pOutEntry)
s32 sceFiosDHReadSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 dh, vm::ptr<SceFiosDirEntry> pOutEntry)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosDHClose(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosDH dh)
s32 sceFiosDHClose(vm::ptr<const SceFiosOpAttr> pAttr, s32 dh)
{
throw __FUNCTION__;
}
s32 sceFiosDHCloseSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosDH dh)
s32 sceFiosDHCloseSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 dh)
{
throw __FUNCTION__;
}
vm::psv::ptr<const char> sceFiosDHGetPath(SceFiosDH dh)
vm::ptr<const char> sceFiosDHGetPath(s32 dh)
{
throw __FUNCTION__;
}
bool sceFiosOpIsDone(SceFiosOp op)
bool sceFiosOpIsDone(s32 op)
{
throw __FUNCTION__;
}
s32 sceFiosOpWait(SceFiosOp op)
s32 sceFiosOpWait(s32 op)
{
throw __FUNCTION__;
}
s32 sceFiosOpWaitUntil(SceFiosOp op, SceFiosTime deadline)
s32 sceFiosOpWaitUntil(s32 op, s64 deadline)
{
throw __FUNCTION__;
}
void sceFiosOpDelete(SceFiosOp op)
void sceFiosOpDelete(s32 op)
{
throw __FUNCTION__;
}
s32 sceFiosOpSyncWait(SceFiosOp op)
s32 sceFiosOpSyncWait(s32 op)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosOpSyncWaitForIO(SceFiosOp op)
s64 sceFiosOpSyncWaitForIO(s32 op)
{
throw __FUNCTION__;
}
s32 sceFiosOpGetError(SceFiosOp op)
s32 sceFiosOpGetError(s32 op)
{
throw __FUNCTION__;
}
void sceFiosOpCancel(SceFiosOp op)
void sceFiosOpCancel(s32 op)
{
throw __FUNCTION__;
}
bool sceFiosOpIsCancelled(SceFiosOp op)
bool sceFiosOpIsCancelled(s32 op)
{
throw __FUNCTION__;
}
vm::psv::ptr<const SceFiosOpAttr> sceFiosOpGetAttr(SceFiosOp op)
vm::ptr<const SceFiosOpAttr> sceFiosOpGetAttr(s32 op)
{
throw __FUNCTION__;
}
vm::psv::ptr<const char> sceFiosOpGetPath(SceFiosOp op)
vm::ptr<const char> sceFiosOpGetPath(s32 op)
{
throw __FUNCTION__;
}
vm::psv::ptr<void> sceFiosOpGetBuffer(SceFiosOp op)
vm::ptr<void> sceFiosOpGetBuffer(s32 op)
{
throw __FUNCTION__;
}
SceFiosOffset sceFiosOpGetOffset(SceFiosOp op)
s64 sceFiosOpGetOffset(s32 op)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosOpGetRequestCount(SceFiosOp op)
s64 sceFiosOpGetRequestCount(s32 op)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosOpGetActualCount(SceFiosOp op)
s64 sceFiosOpGetActualCount(s32 op)
{
throw __FUNCTION__;
}
void sceFiosOpReschedule(SceFiosOp op, SceFiosTime newDeadline)
void sceFiosOpReschedule(s32 op, s64 newDeadline)
{
throw __FUNCTION__;
}
SceFiosTime sceFiosTimeGetCurrent()
s64 sceFiosTimeGetCurrent()
{
throw __FUNCTION__;
}
s64 sceFiosTimeIntervalToNanoseconds(SceFiosTimeInterval interval)
s64 sceFiosTimeIntervalToNanoseconds(s64 interval)
{
throw __FUNCTION__;
}
SceFiosTimeInterval sceFiosTimeIntervalFromNanoseconds(s64 ns)
s64 sceFiosTimeIntervalFromNanoseconds(s64 ns)
{
throw __FUNCTION__;
}
SceFiosDate sceFiosDateGetCurrent()
u64 sceFiosDateGetCurrent()
{
throw __FUNCTION__;
}
SceFiosDate sceFiosDateFromComponents(vm::psv::ptr<const tm> pComponents)
u64 sceFiosDateFromComponents(vm::ptr<const tm> pComponents)
{
throw __FUNCTION__;
}
vm::psv::ptr<tm> sceFiosDateToComponents(SceFiosDate date, vm::psv::ptr<tm> pOutComponents)
vm::ptr<tm> sceFiosDateToComponents(u64 date, vm::ptr<tm> pOutComponents)
{
throw __FUNCTION__;
}
SceFiosDate sceFiosDateFromSceDateTime(vm::psv::ptr<const SceDateTime> pSceDateTime)
u64 sceFiosDateFromSceDateTime(vm::ptr<const SceDateTime> pSceDateTime)
{
throw __FUNCTION__;
}
vm::psv::ptr<SceDateTime> sceFiosDateToSceDateTime(SceFiosDate date, vm::psv::ptr<SceDateTime> pSceDateTime)
vm::ptr<SceDateTime> sceFiosDateToSceDateTime(u64 date, vm::ptr<SceDateTime> pSceDateTime)
{
throw __FUNCTION__;
}
s32 sceFiosOverlayAdd(vm::psv::ptr<const SceFiosOverlay> pOverlay, vm::psv::ptr<SceFiosOverlayID> pOutID)
s32 sceFiosOverlayAdd(vm::ptr<const SceFiosOverlay> pOverlay, vm::ptr<s32> pOutID)
{
throw __FUNCTION__;
}
s32 sceFiosOverlayRemove(SceFiosOverlayID id)
s32 sceFiosOverlayRemove(s32 id)
{
throw __FUNCTION__;
}
s32 sceFiosOverlayGetInfo(SceFiosOverlayID id, vm::psv::ptr<SceFiosOverlay> pOutOverlay)
s32 sceFiosOverlayGetInfo(s32 id, vm::ptr<SceFiosOverlay> pOutOverlay)
{
throw __FUNCTION__;
}
s32 sceFiosOverlayModify(SceFiosOverlayID id, vm::psv::ptr<const SceFiosOverlay> pNewValue)
s32 sceFiosOverlayModify(s32 id, vm::ptr<const SceFiosOverlay> pNewValue)
{
throw __FUNCTION__;
}
s32 sceFiosOverlayGetList(vm::psv::ptr<SceFiosOverlayID> pOutIDs, u32 maxIDs, vm::psv::ptr<u32> pActualIDs)
s32 sceFiosOverlayGetList(vm::ptr<s32> pOutIDs, u32 maxIDs, vm::ptr<u32> pActualIDs)
{
throw __FUNCTION__;
}
s32 sceFiosOverlayResolveSync(s32 resolveFlag, vm::psv::ptr<const char> pInPath, vm::psv::ptr<char> pOutPath, u32 maxPath)
s32 sceFiosOverlayResolveSync(s32 resolveFlag, vm::ptr<const char> pInPath, vm::ptr<char> pOutPath, u32 maxPath)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosArchiveGetMountBufferSize(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pArchivePath, vm::psv::ptr<const SceFiosOpenParams> pOpenParams)
s32 sceFiosArchiveGetMountBufferSize(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pArchivePath, vm::ptr<const SceFiosOpenParams> pOpenParams)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosArchiveGetMountBufferSizeSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pArchivePath, vm::psv::ptr<const SceFiosOpenParams> pOpenParams)
s64 sceFiosArchiveGetMountBufferSizeSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pArchivePath, vm::ptr<const SceFiosOpenParams> pOpenParams)
{
throw __FUNCTION__;
}
//SceFiosOp sceFiosArchiveMount(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<SceFiosFH> pOutFH, vm::psv::ptr<const char> pArchivePath, vm::psv::ptr<const char> pMountPoint, SceFiosBuffer mountBuffer, vm::psv::ptr<const SceFiosOpenParams> pOpenParams)
//{
// throw __FUNCTION__;
//}
//
//s32 sceFiosArchiveMountSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<SceFiosFH> pOutFH, vm::psv::ptr<const char> pArchivePath, vm::psv::ptr<const char> pMountPoint, SceFiosBuffer mountBuffer, vm::psv::ptr<const SceFiosOpenParams> pOpenParams)
//{
// throw __FUNCTION__;
//}
s32 sceFiosArchiveMount(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<s32> pOutFH, vm::ptr<const char> pArchivePath, vm::ptr<const char> pMountPoint, SceFiosBuffer mountBuffer, vm::ptr<const SceFiosOpenParams> pOpenParams)
{
throw __FUNCTION__;
}
s32 sceFiosArchiveMountSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<s32> pOutFH, vm::ptr<const char> pArchivePath, vm::ptr<const char> pMountPoint, SceFiosBuffer mountBuffer, vm::ptr<const SceFiosOpenParams> pOpenParams)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosArchiveUnmount(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh)
s32 sceFiosArchiveUnmount(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh)
{
throw __FUNCTION__;
}
s32 sceFiosArchiveUnmountSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh)
s32 sceFiosArchiveUnmountSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh)
{
throw __FUNCTION__;
}
vm::psv::ptr<char> sceFiosDebugDumpError(s32 err, vm::psv::ptr<char> pBuffer, u32 bufferSize)
vm::ptr<char> sceFiosDebugDumpError(s32 err, vm::ptr<char> pBuffer, u32 bufferSize)
{
throw __FUNCTION__;
}
vm::psv::ptr<char> sceFiosDebugDumpOp(SceFiosOp op, vm::psv::ptr<char> pBuffer, u32 bufferSize)
vm::ptr<char> sceFiosDebugDumpOp(s32 op, vm::ptr<char> pBuffer, u32 bufferSize)
{
throw __FUNCTION__;
}
vm::psv::ptr<char> sceFiosDebugDumpFH(SceFiosFH fh, vm::psv::ptr<char> pBuffer, u32 bufferSize)
vm::ptr<char> sceFiosDebugDumpFH(s32 fh, vm::ptr<char> pBuffer, u32 bufferSize)
{
throw __FUNCTION__;
}
vm::psv::ptr<char> sceFiosDebugDumpDH(SceFiosDH dh, vm::psv::ptr<char> pBuffer, u32 bufferSize)
vm::ptr<char> sceFiosDebugDumpDH(s32 dh, vm::ptr<char> pBuffer, u32 bufferSize)
{
throw __FUNCTION__;
}
vm::psv::ptr<char> sceFiosDebugDumpDate(SceFiosDate date, vm::psv::ptr<char> pBuffer, u32 bufferSize)
vm::ptr<char> sceFiosDebugDumpDate(u64 date, vm::ptr<char> pBuffer, u32 bufferSize)
{
throw __FUNCTION__;
}
s32 sceFiosIOFilterAdd(s32 index, SceFiosIOFilterCallback pFilterCallback, vm::psv::ptr<void> pFilterContext)
s32 sceFiosIOFilterAdd(s32 index, vm::ptr<SceFiosIOFilterCallback> pFilterCallback, vm::ptr<void> pFilterContext)
{
throw __FUNCTION__;
}
s32 sceFiosIOFilterGetInfo(s32 index, vm::psv::ptr<SceFiosIOFilterCallback> pOutFilterCallback, vm::psv::pptr<void> pOutFilterContext)
s32 sceFiosIOFilterGetInfo(s32 index, vm::pptr<SceFiosIOFilterCallback> pOutFilterCallback, vm::pptr<void> pOutFilterContext)
{
throw __FUNCTION__;
}
@ -809,6 +691,7 @@ psv_log_base sceFios("SceFios2", []()
sceFios.on_load = nullptr;
sceFios.on_unload = nullptr;
sceFios.on_stop = nullptr;
sceFios.on_error = nullptr;
REG_FUNC(0x15857180, sceFiosArchiveGetMountBufferSize);
REG_FUNC(0xDF3352FC, sceFiosArchiveGetMountBufferSizeSync);

113
rpcs3/Emu/ARMv7/Modules/sceFios.h Normal file
View File

@ -0,0 +1,113 @@
#pragma once
using SceFiosOpCallback = func_def<s32(vm::ptr<void> pContext, s32 op, u8 event, s32 err)>;
using SceFiosVprintfCallback = func_def<s32(vm::cptr<char> fmt, va_list ap)>;
using SceFiosMemcpyCallback = func_def<vm::ptr<void>(vm::ptr<void> dst, vm::cptr<void> src, u32 len)>;
enum SceFiosWhence : s32
{
SCE_FIOS_SEEK_SET = 0,
SCE_FIOS_SEEK_CUR = 1,
SCE_FIOS_SEEK_END = 2,
};
struct SceFiosBuffer
{
vm::lptr<void> pPtr;
le_t<u32> length;
};
struct SceFiosOpAttr
{
le_t<s64> deadline;
vm::lptr<SceFiosOpCallback> pCallback;
vm::lptr<void> pCallbackContext;
//le_t<s32> priority : 8;
//le_t<u32> opflags : 24;
le_t<u32> params; // priority, opflags
le_t<u32> userTag;
vm::lptr<void> userPtr;
vm::lptr<void> pReserved;
};
struct SceFiosDirEntry
{
le_t<s64> fileSize;
le_t<u32> statFlags;
le_t<u16> nameLength;
le_t<u16> fullPathLength;
le_t<u16> offsetToName;
le_t<u16> reserved[3];
char fullPath[1024];
};
struct SceFiosStat
{
le_t<s64> fileSize;
le_t<u64> accessDate;
le_t<u64> modificationDate;
le_t<u64> creationDate;
le_t<u32> statFlags;
le_t<u32> reserved;
le_t<s64> uid;
le_t<s64> gid;
le_t<s64> dev;
le_t<s64> ino;
le_t<s64> mode;
};
struct SceFiosOpenParams
{
le_t<u32> openFlags;
le_t<u32> reserved;
SceFiosBuffer buffer;
};
struct SceFiosTuple
{
le_t<s64> offset;
le_t<s64> size;
char path[1024];
};
struct SceFiosParams
{
//le_t<u32> initialized : 1;
//le_t<u32> paramsSize : 14;
//le_t<u32> pathMax : 16;
le_t<u32> params; // initialized, paramsSize, pathMax
le_t<u32> profiling;
SceFiosBuffer opStorage;
SceFiosBuffer fhStorage;
SceFiosBuffer dhStorage;
SceFiosBuffer chunkStorage;
vm::lptr<SceFiosVprintfCallback> pVprintf;
vm::lptr<SceFiosMemcpyCallback> pMemcpy;
le_t<s32> threadPriority[2];
le_t<s32> threadAffinity[2];
};
struct SceFiosOverlay
{
u8 type;
u8 order;
u8 reserved[10];
le_t<s32> id;
char dst[292];
char src[292];
};
using SceFiosIOFilterCallback = func_def<void()>;
struct SceFiosPsarcDearchiverContext
{
le_t<u32> sizeOfContext;
le_t<u32> workBufferSize;
vm::lptr<void> pWorkBuffer;
le_t<s32> reserved[4];
};
extern psv_log_base sceFios;

75
rpcs3/Emu/ARMv7/Modules/sceFpu.cpp
View File

@ -2,7 +2,79 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceFpu;
#include "sceFpu.h"
float sceFpuSinf(float x)
{
throw __FUNCTION__;
}
float sceFpuCosf(float x)
{
throw __FUNCTION__;
}
float sceFpuTanf(float x)
{
throw __FUNCTION__;
}
float sceFpuAtanf(float x)
{
throw __FUNCTION__;
}
float sceFpuAtan2f(float y, float x)
{
throw __FUNCTION__;
}
float sceFpuAsinf(float x)
{
throw __FUNCTION__;
}
float sceFpuAcosf(float x)
{
throw __FUNCTION__;
}
float sceFpuLogf(float x)
{
throw __FUNCTION__;
}
float sceFpuLog2f(float fs)
{
throw __FUNCTION__;
}
float sceFpuLog10f(float fs)
{
throw __FUNCTION__;
}
float sceFpuExpf(float x)
{
throw __FUNCTION__;
}
float sceFpuExp2f(float x)
{
throw __FUNCTION__;
}
float sceFpuExp10f(float x)
{
throw __FUNCTION__;
}
float sceFpuPowf(float x, float y)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceFpu, #name, name)
@ -11,6 +83,7 @@ psv_log_base sceFpu("SceFpu", []()
sceFpu.on_load = nullptr;
sceFpu.on_unload = nullptr;
sceFpu.on_stop = nullptr;
sceFpu.on_error = nullptr;
//REG_FUNC(0x33E1AC14, sceFpuSinf);
//REG_FUNC(0xDB66BA89, sceFpuCosf);

3
rpcs3/Emu/ARMv7/Modules/sceFpu.h Normal file
View File

@ -0,0 +1,3 @@
#pragma once
extern psv_log_base sceFpu;

433
rpcs3/Emu/ARMv7/Modules/sceGxm.cpp
View File

File diff suppressed because it is too large Load Diff

174
rpcs3/Emu/ARMv7/Modules/sceGxm.h
View File

@ -29,15 +29,15 @@ enum
SCE_GXM_ERROR_DRIVER = 0x805B0017,
};
typedef void(SceGxmDisplayQueueCallback)(vm::psv::ptr<const void> callbackData);
using SceGxmDisplayQueueCallback = func_def<void(vm::cptr<void> callbackData)>;
struct SceGxmInitializeParams
{
u32 flags;
u32 displayQueueMaxPendingCount;
vm::psv::ptr<SceGxmDisplayQueueCallback> displayQueueCallback;
u32 displayQueueCallbackDataSize;
s32 parameterBufferSize;
le_t<u32> flags;
le_t<u32> displayQueueMaxPendingCount;
vm::lptr<SceGxmDisplayQueueCallback> displayQueueCallback;
le_t<u32> displayQueueCallbackDataSize;
le_t<s32> parameterBufferSize;
};
enum SceGxmMemoryAttribFlags : u32
@ -1002,13 +1002,13 @@ enum SceGxmColorMask : u8
struct SceGxmBlendInfo
{
SceGxmColorMask colorMask;
SceGxmBlendFunc colorFunc : 4;
SceGxmBlendFunc alphaFunc : 4;
SceGxmBlendFactor colorSrc : 4;
SceGxmBlendFactor colorDst : 4;
SceGxmBlendFactor alphaSrc : 4;
SceGxmBlendFactor alphaDst : 4;
u8 colorMask; // SceGxmColorMask
u8 colorFunc : 4; // SceGxmBlendFunc
u8 alphaFunc : 4; // SceGxmBlendFunc
u8 colorSrc : 4; // SceGxmBlendFactor
u8 colorDst : 4; // SceGxmBlendFactor
u8 alphaSrc : 4; // SceGxmBlendFactor
u8 alphaDst : 4; // SceGxmBlendFactor
};
struct SceGxmRenderTarget;
@ -1017,63 +1017,63 @@ struct SceGxmSyncObject;
struct SceGxmVertexAttribute
{
u16 streamIndex;
u16 offset;
SceGxmAttributeFormat format;
le_t<u16> streamIndex;
le_t<u16> offset;
u8 format; // SceGxmAttributeFormat
u8 componentCount;
u16 regIndex;
le_t<u16> regIndex;
};
struct SceGxmVertexStream
{
u16 stride;
u16 indexSource;
le_t<u16> stride;
le_t<u16> indexSource;
};
struct SceGxmTexture
{
u32 controlWords[4];
le_t<u32> controlWords[4];
};
struct SceGxmColorSurface
{
u32 pbeSidebandWord;
u32 pbeEmitWords[6];
u32 outputRegisterSize;
le_t<u32> pbeSidebandWord;
le_t<u32> pbeEmitWords[6];
le_t<u32> outputRegisterSize;
SceGxmTexture backgroundTex;
};
struct SceGxmDepthStencilSurface
{
u32 zlsControl;
vm::psv::ptr<void> depthData;
vm::psv::ptr<void> stencilData;
float backgroundDepth;
u32 backgroundControl;
le_t<u32> zlsControl;
vm::lptr<void> depthData;
vm::lptr<void> stencilData;
le_t<float> backgroundDepth;
le_t<u32> backgroundControl;
};
struct SceGxmAuxiliarySurface
{
SceGxmColorFormat colorFormat;
SceGxmColorSurfaceType type;
u32 width;
u32 height;
u32 stride;
vm::psv::ptr<void> data;
le_t<u32> colorFormat; // SceGxmColorFormat
le_t<u32> type; // SceGxmColorSurfaceType
le_t<u32> width;
le_t<u32> height;
le_t<u32> stride;
vm::lptr<void> data;
};
struct SceGxmNotification
{
vm::psv::ptr<volatile u32> address;
u32 value;
vm::lptr<volatile u32> address;
le_t<u32> value;
};
struct SceGxmValidRegion
{
u32 xMin;
u32 yMin;
u32 xMax;
u32 yMax;
le_t<u32> xMin;
le_t<u32> yMin;
le_t<u32> xMax;
le_t<u32> yMax;
};
struct SceGxmContext;
@ -1089,17 +1089,17 @@ enum
struct SceGxmContextParams
{
vm::psv::ptr<void> hostMem;
u32 hostMemSize;
vm::psv::ptr<void> vdmRingBufferMem;
u32 vdmRingBufferMemSize;
vm::psv::ptr<void> vertexRingBufferMem;
u32 vertexRingBufferMemSize;
vm::psv::ptr<void> fragmentRingBufferMem;
u32 fragmentRingBufferMemSize;
vm::psv::ptr<void> fragmentUsseRingBufferMem;
u32 fragmentUsseRingBufferMemSize;
u32 fragmentUsseRingBufferOffset;
vm::lptr<void> hostMem;
le_t<u32> hostMemSize;
vm::lptr<void> vdmRingBufferMem;
le_t<u32> vdmRingBufferMemSize;
vm::lptr<void> vertexRingBufferMem;
le_t<u32> vertexRingBufferMemSize;
vm::lptr<void> fragmentRingBufferMem;
le_t<u32> fragmentRingBufferMemSize;
vm::lptr<void> fragmentUsseRingBufferMem;
le_t<u32> fragmentUsseRingBufferMemSize;
le_t<u32> fragmentUsseRingBufferOffset;
};
struct SceGxmVertexProgram;
@ -1115,17 +1115,17 @@ enum
struct SceGxmPrecomputedVertexState
{
u32 data[SCE_GXM_PRECOMPUTED_VERTEX_STATE_WORD_COUNT];
le_t<u32> data[SCE_GXM_PRECOMPUTED_VERTEX_STATE_WORD_COUNT];
};
struct SceGxmPrecomputedFragmentState
{
u32 data[SCE_GXM_PRECOMPUTED_FRAGMENT_STATE_WORD_COUNT];
le_t<u32> data[SCE_GXM_PRECOMPUTED_FRAGMENT_STATE_WORD_COUNT];
};
struct SceGxmPrecomputedDraw
{
u32 data[SCE_GXM_PRECOMPUTED_DRAW_WORD_COUNT];
le_t<u32> data[SCE_GXM_PRECOMPUTED_DRAW_WORD_COUNT];
};
enum : u32
@ -1193,34 +1193,32 @@ struct SceGxmShaderPatcher;
struct SceGxmRegisteredProgram;
typedef vm::psv::ptr<SceGxmRegisteredProgram> SceGxmShaderPatcherId;
typedef vm::psv::ptr<void>(SceGxmShaderPatcherHostAllocCallback)(vm::psv::ptr<void> userData, u32 size);
typedef void(SceGxmShaderPatcherHostFreeCallback)(vm::psv::ptr<void> userData, vm::psv::ptr<void> mem);
typedef vm::psv::ptr<void>(SceGxmShaderPatcherBufferAllocCallback)(vm::psv::ptr<void> userData, u32 size);
typedef void(SceGxmShaderPatcherBufferFreeCallback)(vm::psv::ptr<void> userData, vm::psv::ptr<void> mem);
typedef vm::psv::ptr<void>(SceGxmShaderPatcherUsseAllocCallback)(vm::psv::ptr<void> userData, u32 size, vm::psv::ptr<u32> usseOffset);
typedef void(SceGxmShaderPatcherUsseFreeCallback)(vm::psv::ptr<void> userData, vm::psv::ptr<void> mem);
using SceGxmShaderPatcherHostAllocCallback = func_def<vm::ptr<void>(vm::ptr<void> userData, u32 size)>;
using SceGxmShaderPatcherHostFreeCallback = func_def<void(vm::ptr<void> userData, vm::ptr<void> mem)>;
using SceGxmShaderPatcherBufferAllocCallback = func_def<vm::ptr<void>(vm::ptr<void> userData, u32 size)>;
using SceGxmShaderPatcherBufferFreeCallback = func_def<void(vm::ptr<void> userData, vm::ptr<void> mem)>;
using SceGxmShaderPatcherUsseAllocCallback = func_def<vm::ptr<void>(vm::ptr<void> userData, u32 size, vm::ptr<u32> usseOffset)>;
using SceGxmShaderPatcherUsseFreeCallback = func_def<void(vm::ptr<void> userData, vm::ptr<void> mem)>;
struct SceGxmShaderPatcherParams
{
vm::psv::ptr<void> userData;
vm::psv::ptr<SceGxmShaderPatcherHostAllocCallback> hostAllocCallback;
vm::psv::ptr<SceGxmShaderPatcherHostFreeCallback> hostFreeCallback;
vm::psv::ptr<SceGxmShaderPatcherBufferAllocCallback> bufferAllocCallback;
vm::psv::ptr<SceGxmShaderPatcherBufferFreeCallback> bufferFreeCallback;
vm::psv::ptr<void> bufferMem;
u32 bufferMemSize;
vm::psv::ptr<SceGxmShaderPatcherUsseAllocCallback> vertexUsseAllocCallback;
vm::psv::ptr<SceGxmShaderPatcherUsseFreeCallback> vertexUsseFreeCallback;
vm::psv::ptr<void> vertexUsseMem;
u32 vertexUsseMemSize;
u32 vertexUsseOffset;
vm::psv::ptr<SceGxmShaderPatcherUsseAllocCallback> fragmentUsseAllocCallback;
vm::psv::ptr<SceGxmShaderPatcherUsseFreeCallback> fragmentUsseFreeCallback;
vm::psv::ptr<void> fragmentUsseMem;
u32 fragmentUsseMemSize;
u32 fragmentUsseOffset;
vm::lptr<void> userData;
vm::lptr<SceGxmShaderPatcherHostAllocCallback> hostAllocCallback;
vm::lptr<SceGxmShaderPatcherHostFreeCallback> hostFreeCallback;
vm::lptr<SceGxmShaderPatcherBufferAllocCallback> bufferAllocCallback;
vm::lptr<SceGxmShaderPatcherBufferFreeCallback> bufferFreeCallback;
vm::lptr<void> bufferMem;
le_t<u32> bufferMemSize;
vm::lptr<SceGxmShaderPatcherUsseAllocCallback> vertexUsseAllocCallback;
vm::lptr<SceGxmShaderPatcherUsseFreeCallback> vertexUsseFreeCallback;
vm::lptr<void> vertexUsseMem;
le_t<u32> vertexUsseMemSize;
le_t<u32> vertexUsseOffset;
vm::lptr<SceGxmShaderPatcherUsseAllocCallback> fragmentUsseAllocCallback;
vm::lptr<SceGxmShaderPatcherUsseFreeCallback> fragmentUsseFreeCallback;
vm::lptr<void> fragmentUsseMem;
le_t<u32> fragmentUsseMemSize;
le_t<u32> fragmentUsseOffset;
};
enum SceGxmRenderTargetFlags : u32
@ -1230,15 +1228,15 @@ enum SceGxmRenderTargetFlags : u32
struct SceGxmRenderTargetParams
{
SceGxmRenderTargetFlags flags;
u16 width;
u16 height;
u16 scenesPerFrame;
SceGxmMultisampleMode multisampleMode;
u32 multisampleLocations;
vm::psv::ptr<void> hostMem;
u32 hostMemSize;
s32 driverMemBlock;
le_t<u32> flags; // SceGxmRenderTargetFlags
le_t<u16> width;
le_t<u16> height;
le_t<u16> scenesPerFrame;
le_t<u16> multisampleMode; // SceGxmMultisampleMode
le_t<u32> multisampleLocations;
vm::lptr<void> hostMem;
le_t<u32> hostMemSize;
le_t<s32> driverMemBlock;
};
extern psv_log_base sceGxm;

146
rpcs3/Emu/ARMv7/Modules/sceHttp.cpp
View File

@ -2,80 +2,7 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
#include "sceSsl.h"
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<s32(s32 request, SceHttpAuthType authType, vm::psv::ptr<const char> realm, vm::psv::ptr<char> username, vm::psv::ptr<char> password, s32 needEntity, vm::psv::pptr<u8> entityBody, vm::psv::ptr<u32> entitySize, vm::psv::ptr<s32> save, vm::psv::ptr<void> userArg)> SceHttpAuthInfoCallback;
typedef vm::psv::ptr<s32(s32 request, s32 statusCode, vm::psv::ptr<s32> method, vm::psv::ptr<const char> location, vm::psv::ptr<void> userArg)> SceHttpRedirectCallback;
struct SceHttpMemoryPoolStats
{
u32 poolSize;
u32 maxInuseSize;
u32 currentInuseSize;
s32 reserved;
};
struct SceHttpUriElement
{
s32 opaque;
vm::psv::ptr<char> scheme;
vm::psv::ptr<char> username;
vm::psv::ptr<char> password;
vm::psv::ptr<char> hostname;
vm::psv::ptr<char> path;
vm::psv::ptr<char> query;
vm::psv::ptr<char> fragment;
u16 port;
u8 reserved[10];
};
typedef vm::psv::ptr<s32(s32 request, vm::psv::ptr<const char> url, vm::psv::ptr<const char> cookieHeader, u32 headerLen, vm::psv::ptr<void> userArg)> SceHttpCookieRecvCallback;
typedef vm::psv::ptr<s32(s32 request, vm::psv::ptr<const char> url, vm::psv::ptr<const char> cookieHeader, vm::psv::ptr<void> userArg)> SceHttpCookieSendCallback;
struct SceHttpsData
{
vm::psv::ptr<char> ptr;
u32 size;
};
struct SceHttpsCaList
{
vm::psv::lpptr<SceSslCert> caCerts;
s32 caNum;
};
typedef vm::psv::ptr<s32(u32 verifyEsrr, vm::psv::ptr<const vm::psv::ptr<SceSslCert>> sslCert, s32 certNum, vm::psv::ptr<void> userArg)> SceHttpsCallback;
#include "sceHttp.h"
s32 sceHttpInit(u32 poolSize)
{
@ -87,12 +14,12 @@ s32 sceHttpTerm()
throw __FUNCTION__;
}
s32 sceHttpGetMemoryPoolStats(vm::psv::ptr<SceHttpMemoryPoolStats> currentStat)
s32 sceHttpGetMemoryPoolStats(vm::ptr<SceHttpMemoryPoolStats> currentStat)
{
throw __FUNCTION__;
}
s32 sceHttpCreateTemplate(vm::psv::ptr<const char> userAgent, s32 httpVer, s32 autoProxyConf)
s32 sceHttpCreateTemplate(vm::ptr<const char> userAgent, s32 httpVer, s32 autoProxyConf)
{
throw __FUNCTION__;
}
@ -102,12 +29,12 @@ s32 sceHttpDeleteTemplate(s32 tmplId)
throw __FUNCTION__;
}
s32 sceHttpCreateConnection(s32 tmplId, vm::psv::ptr<const char> serverName, vm::psv::ptr<const char> scheme, u16 port, s32 enableKeepalive)
s32 sceHttpCreateConnection(s32 tmplId, vm::ptr<const char> serverName, vm::ptr<const char> scheme, u16 port, s32 enableKeepalive)
{
throw __FUNCTION__;
}
s32 sceHttpCreateConnectionWithURL(s32 tmplId, vm::psv::ptr<const char> url, s32 enableKeepalive)
s32 sceHttpCreateConnectionWithURL(s32 tmplId, vm::ptr<const char> url, s32 enableKeepalive)
{
throw __FUNCTION__;
}
@ -117,12 +44,12 @@ s32 sceHttpDeleteConnection(s32 connId)
throw __FUNCTION__;
}
s32 sceHttpCreateRequest(s32 connId, s32 method, vm::psv::ptr<const char> path, u64 contentLength)
s32 sceHttpCreateRequest(s32 connId, s32 method, vm::ptr<const char> path, u64 contentLength)
{
throw __FUNCTION__;
}
s32 sceHttpCreateRequestWithURL(s32 connId, s32 method, vm::psv::ptr<const char> url, u64 contentLength)
s32 sceHttpCreateRequestWithURL(s32 connId, s32 method, vm::ptr<const char> url, u64 contentLength)
{
throw __FUNCTION__;
}
@ -147,7 +74,7 @@ s32 sceHttpSetRequestContentLength(s32 id, u64 contentLength)
throw __FUNCTION__;
}
s32 sceHttpSendRequest(s32 reqId, vm::psv::ptr<const void> postData, u32 size)
s32 sceHttpSendRequest(s32 reqId, vm::ptr<const void> postData, u32 size)
{
throw __FUNCTION__;
}
@ -157,47 +84,47 @@ s32 sceHttpAbortRequest(s32 reqId)
throw __FUNCTION__;
}
s32 sceHttpGetResponseContentLength(s32 reqId, vm::psv::ptr<u64> contentLength)
s32 sceHttpGetResponseContentLength(s32 reqId, vm::ptr<u64> contentLength)
{
throw __FUNCTION__;
}
s32 sceHttpGetStatusCode(s32 reqId, vm::psv::ptr<s32> statusCode)
s32 sceHttpGetStatusCode(s32 reqId, vm::ptr<s32> statusCode)
{
throw __FUNCTION__;
}
s32 sceHttpGetAllResponseHeaders(s32 reqId, vm::psv::pptr<char> header, vm::psv::ptr<u32> headerSize)
s32 sceHttpGetAllResponseHeaders(s32 reqId, vm::pptr<char> header, vm::ptr<u32> headerSize)
{
throw __FUNCTION__;
}
s32 sceHttpReadData(s32 reqId, vm::psv::ptr<void> data, u32 size)
s32 sceHttpReadData(s32 reqId, vm::ptr<void> data, u32 size)
{
throw __FUNCTION__;
}
s32 sceHttpAddRequestHeader(s32 id, vm::psv::ptr<const char> name, vm::psv::ptr<const char> value, u32 mode)
s32 sceHttpAddRequestHeader(s32 id, vm::ptr<const char> name, vm::ptr<const char> value, u32 mode)
{
throw __FUNCTION__;
}
s32 sceHttpRemoveRequestHeader(s32 id, vm::psv::ptr<const char> name)
s32 sceHttpRemoveRequestHeader(s32 id, vm::ptr<const char> name)
{
throw __FUNCTION__;
}
s32 sceHttpParseResponseHeader(vm::psv::ptr<const char> header, u32 headerLen, vm::psv::ptr<const char> fieldStr, vm::psv::pptr<const char> fieldValue, vm::psv::ptr<u32> valueLen)
s32 sceHttpParseResponseHeader(vm::ptr<const char> header, u32 headerLen, vm::ptr<const char> fieldStr, vm::pptr<const char> fieldValue, vm::ptr<u32> valueLen)
{
throw __FUNCTION__;
}
s32 sceHttpParseStatusLine(vm::psv::ptr<const char> statusLine, u32 lineLen, vm::psv::ptr<s32> httpMajorVer, vm::psv::ptr<s32> httpMinorVer, vm::psv::ptr<s32> responseCode, vm::psv::pptr<const char> reasonPhrase, vm::psv::ptr<u32> phraseLen)
s32 sceHttpParseStatusLine(vm::ptr<const char> statusLine, u32 lineLen, vm::ptr<s32> httpMajorVer, vm::ptr<s32> httpMinorVer, vm::ptr<s32> responseCode, vm::pptr<const char> reasonPhrase, vm::ptr<u32> phraseLen)
{
throw __FUNCTION__;
}
s32 sceHttpSetAuthInfoCallback(s32 id, SceHttpAuthInfoCallback cbfunc, vm::psv::ptr<void> userArg)
s32 sceHttpSetAuthInfoCallback(s32 id, vm::ptr<SceHttpAuthInfoCallback> cbfunc, vm::ptr<void> userArg)
{
throw __FUNCTION__;
}
@ -207,12 +134,12 @@ s32 sceHttpSetAuthEnabled(s32 id, s32 enable)
throw __FUNCTION__;
}
s32 sceHttpGetAuthEnabled(s32 id, vm::psv::ptr<s32> enable)
s32 sceHttpGetAuthEnabled(s32 id, vm::ptr<s32> enable)
{
throw __FUNCTION__;
}
s32 sceHttpSetRedirectCallback(s32 id, SceHttpRedirectCallback cbfunc, vm::psv::ptr<void> userArg)
s32 sceHttpSetRedirectCallback(s32 id, vm::ptr<SceHttpRedirectCallback> cbfunc, vm::ptr<void> userArg)
{
throw __FUNCTION__;
}
@ -222,7 +149,7 @@ s32 sceHttpSetAutoRedirect(s32 id, s32 enable)
throw __FUNCTION__;
}
s32 sceHttpGetAutoRedirect(s32 id, vm::psv::ptr<s32> enable)
s32 sceHttpGetAutoRedirect(s32 id, vm::ptr<s32> enable)
{
throw __FUNCTION__;
}
@ -252,32 +179,32 @@ s32 sceHttpSetRecvTimeOut(s32 id, u32 usec)
throw __FUNCTION__;
}
s32 sceHttpUriEscape(vm::psv::ptr<char> out, vm::psv::ptr<u32> require, u32 prepare, vm::psv::ptr<const char> in)
s32 sceHttpUriEscape(vm::ptr<char> out, vm::ptr<u32> require, u32 prepare, vm::ptr<const char> in)
{
throw __FUNCTION__;
}
s32 sceHttpUriUnescape(vm::psv::ptr<char> out, vm::psv::ptr<u32> require, u32 prepare, vm::psv::ptr<const char> in)
s32 sceHttpUriUnescape(vm::ptr<char> out, vm::ptr<u32> require, u32 prepare, vm::ptr<const char> in)
{
throw __FUNCTION__;
}
s32 sceHttpUriParse(vm::psv::ptr<SceHttpUriElement> out, vm::psv::ptr<const char> srcUrl, vm::psv::ptr<void> pool, vm::psv::ptr<u32> require, u32 prepare)
s32 sceHttpUriParse(vm::ptr<SceHttpUriElement> out, vm::ptr<const char> srcUrl, vm::ptr<void> pool, vm::ptr<u32> require, u32 prepare)
{
throw __FUNCTION__;
}
s32 sceHttpUriBuild(vm::psv::ptr<char> out, vm::psv::ptr<u32> require, u32 prepare, vm::psv::ptr<const SceHttpUriElement> srcElement, u32 option)
s32 sceHttpUriBuild(vm::ptr<char> out, vm::ptr<u32> require, u32 prepare, vm::ptr<const SceHttpUriElement> srcElement, u32 option)
{
throw __FUNCTION__;
}
s32 sceHttpUriMerge(vm::psv::ptr<char> mergedUrl, vm::psv::ptr<const char> url, vm::psv::ptr<const char> relativeUrl, vm::psv::ptr<u32> require, u32 prepare, u32 option)
s32 sceHttpUriMerge(vm::ptr<char> mergedUrl, vm::ptr<const char> url, vm::ptr<const char> relativeUrl, vm::ptr<u32> require, u32 prepare, u32 option)
{
throw __FUNCTION__;
}
s32 sceHttpUriSweepPath(vm::psv::ptr<char> dst, vm::psv::ptr<const char> src, u32 srcSize)
s32 sceHttpUriSweepPath(vm::ptr<char> dst, vm::ptr<const char> src, u32 srcSize)
{
throw __FUNCTION__;
}
@ -287,32 +214,32 @@ s32 sceHttpSetCookieEnabled(s32 id, s32 enable)
throw __FUNCTION__;
}
s32 sceHttpGetCookieEnabled(s32 id, vm::psv::ptr<s32> enable)
s32 sceHttpGetCookieEnabled(s32 id, vm::ptr<s32> enable)
{
throw __FUNCTION__;
}
s32 sceHttpGetCookie(vm::psv::ptr<const char> url, vm::psv::ptr<char> cookie, vm::psv::ptr<u32> cookieLength, u32 prepare, s32 secure)
s32 sceHttpGetCookie(vm::ptr<const char> url, vm::ptr<char> cookie, vm::ptr<u32> cookieLength, u32 prepare, s32 secure)
{
throw __FUNCTION__;
}
s32 sceHttpAddCookie(vm::psv::ptr<const char> url, vm::psv::ptr<const char> cookie, u32 cookieLength)
s32 sceHttpAddCookie(vm::ptr<const char> url, vm::ptr<const char> cookie, u32 cookieLength)
{
throw __FUNCTION__;
}
s32 sceHttpSetCookieRecvCallback(s32 id, SceHttpCookieRecvCallback cbfunc, vm::psv::ptr<void> userArg)
s32 sceHttpSetCookieRecvCallback(s32 id, vm::ptr<SceHttpCookieRecvCallback> cbfunc, vm::ptr<void> userArg)
{
throw __FUNCTION__;
}
s32 sceHttpSetCookieSendCallback(s32 id, SceHttpCookieSendCallback cbfunc, vm::psv::ptr<void> userArg)
s32 sceHttpSetCookieSendCallback(s32 id, vm::ptr<SceHttpCookieSendCallback> cbfunc, vm::ptr<void> userArg)
{
throw __FUNCTION__;
}
s32 sceHttpsLoadCert(s32 caCertNum, vm::psv::pptr<const SceHttpsData> caList, vm::psv::ptr<const SceHttpsData> cert, vm::psv::ptr<const SceHttpsData> privKey)
s32 sceHttpsLoadCert(s32 caCertNum, vm::pptr<const SceHttpsData> caList, vm::ptr<const SceHttpsData> cert, vm::ptr<const SceHttpsData> privKey)
{
throw __FUNCTION__;
}
@ -332,22 +259,22 @@ s32 sceHttpsDisableOption(u32 sslFlags)
throw __FUNCTION__;
}
s32 sceHttpsGetSslError(s32 id, vm::psv::ptr<s32> errNum, vm::psv::ptr<u32> detail)
s32 sceHttpsGetSslError(s32 id, vm::ptr<s32> errNum, vm::ptr<u32> detail)
{
throw __FUNCTION__;
}
s32 sceHttpsSetSslCallback(s32 id, SceHttpsCallback cbfunc, vm::psv::ptr<void> userArg)
s32 sceHttpsSetSslCallback(s32 id, vm::ptr<SceHttpsCallback> cbfunc, vm::ptr<void> userArg)
{
throw __FUNCTION__;
}
s32 sceHttpsGetCaList(vm::psv::ptr<SceHttpsCaList> caList)
s32 sceHttpsGetCaList(vm::ptr<SceHttpsCaList> caList)
{
throw __FUNCTION__;
}
s32 sceHttpsFreeCaList(vm::psv::ptr<SceHttpsCaList> caList)
s32 sceHttpsFreeCaList(vm::ptr<SceHttpsCaList> caList)
{
throw __FUNCTION__;
}
@ -360,6 +287,7 @@ psv_log_base sceHttp("SceHttp", []()
sceHttp.on_load = nullptr;
sceHttp.on_unload = nullptr;
sceHttp.on_stop = nullptr;
sceHttp.on_error = nullptr;
REG_FUNC(0x214926D9, sceHttpInit);
REG_FUNC(0xC9076666, sceHttpTerm);

74
rpcs3/Emu/ARMv7/Modules/sceHttp.h Normal file
View File

@ -0,0 +1,74 @@
#pragma once
#include "sceSsl.h"
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
};
using SceHttpAuthInfoCallback = func_def<s32(s32 request, SceHttpAuthType authType, vm::cptr<char> realm, vm::ptr<char> username, vm::ptr<char> password, s32 needEntity, vm::pptr<u8> entityBody, vm::ptr<u32> entitySize, vm::ptr<s32> save, vm::ptr<void> userArg)>;
using SceHttpRedirectCallback = func_def<s32(s32 request, s32 statusCode, vm::ptr<s32> method, vm::cptr<char> location, vm::ptr<void> userArg)>;
struct SceHttpMemoryPoolStats
{
le_t<u32> poolSize;
le_t<u32> maxInuseSize;
le_t<u32> currentInuseSize;
le_t<s32> reserved;
};
struct SceHttpUriElement
{
le_t<s32> opaque;
vm::lptr<char> scheme;
vm::lptr<char> username;
vm::lptr<char> password;
vm::lptr<char> hostname;
vm::lptr<char> path;
vm::lptr<char> query;
vm::lptr<char> fragment;
le_t<u16> port;
u8 reserved[10];
};
using SceHttpCookieRecvCallback = func_def<s32(s32 request, vm::cptr<char> url, vm::cptr<char> cookieHeader, u32 headerLen, vm::ptr<void> userArg)>;
using SceHttpCookieSendCallback = func_def<s32(s32 request, vm::cptr<char> url, vm::cptr<char> cookieHeader, vm::ptr<void> userArg)>;
struct SceHttpsData
{
vm::lptr<char> ptr;
le_t<u32> size;
};
struct SceHttpsCaList
{
vm::lpptr<SceSslCert> caCerts;
le_t<s32> caNum;
};
using SceHttpsCallback = func_def<s32(u32 verifyEsrr, vm::cptr<vm::ptr<SceSslCert>> sslCert, s32 certNum, vm::ptr<void> userArg)>;
extern psv_log_base sceHttp;

7
rpcs3/Emu/ARMv7/Modules/sceIme.cpp
View File

@ -4,7 +4,7 @@
#include "sceIme.h"
s32 sceImeOpen(vm::psv::ptr<SceImeParam> param)
s32 sceImeOpen(vm::ptr<SceImeParam> param)
{
throw __FUNCTION__;
}
@ -14,12 +14,12 @@ s32 sceImeUpdate()
throw __FUNCTION__;
}
s32 sceImeSetCaret(vm::psv::ptr<const SceImeCaret> caret)
s32 sceImeSetCaret(vm::ptr<const SceImeCaret> caret)
{
throw __FUNCTION__;
}
s32 sceImeSetPreeditGeometry(vm::psv::ptr<const SceImePreeditGeometry> preedit)
s32 sceImeSetPreeditGeometry(vm::ptr<const SceImePreeditGeometry> preedit)
{
throw __FUNCTION__;
}
@ -37,6 +37,7 @@ psv_log_base sceIme("SceIme", []()
sceIme.on_load = nullptr;
sceIme.on_unload = nullptr;
sceIme.on_stop = nullptr;
sceIme.on_error = nullptr;
REG_FUNC(0x0E050613, sceImeOpen);
REG_FUNC(0x71D6898A, sceImeUpdate);

68
rpcs3/Emu/ARMv7/Modules/sceIme.h
View File

@ -1,70 +1,70 @@
#pragma once
typedef s32(SceImeCharFilter)(u16 ch);
using SceImeCharFilter = func_def<s32(u16 ch)>;
struct SceImeRect
{
u32 x;
u32 y;
u32 width;
u32 height;
le_t<u32> x;
le_t<u32> y;
le_t<u32> width;
le_t<u32> height;
};
struct SceImeEditText
{
u32 preeditIndex;
u32 preeditLength;
u32 caretIndex;
vm::psv::ptr<u16> str;
le_t<u32> preeditIndex;
le_t<u32> preeditLength;
le_t<u32> caretIndex;
vm::lptr<u16> str;
};
union SceImeEventParam
{
SceImeRect rect;
SceImeEditText text;
u32 caretIndex;
le_t<u32> caretIndex;
};
struct SceImeEvent
{
u32 id;
le_t<u32> id;
SceImeEventParam param;
};
struct SceImeCaret
{
u32 x;
u32 y;
u32 height;
u32 index;
le_t<u32> x;
le_t<u32> y;
le_t<u32> height;
le_t<u32> index;
};
struct SceImePreeditGeometry
{
u32 x;
u32 y;
u32 height;
le_t<u32> x;
le_t<u32> y;
le_t<u32> height;
};
typedef void(SceImeEventHandler)(vm::psv::ptr<void> arg, vm::psv::ptr<const SceImeEvent> e);
using SceImeEventHandler = func_def<void(vm::ptr<void> arg, vm::cptr<SceImeEvent> e)>;
struct SceImeParam
{
u32 size;
u32 inputMethod;
u64 supportedLanguages;
s32 languagesForced;
u32 type;
u32 option;
vm::psv::ptr<void> work;
vm::psv::ptr<void> arg;
vm::psv::ptr<SceImeEventHandler> handler;
vm::psv::ptr<SceImeCharFilter> filter;
vm::psv::ptr<u32> initialText;
u32 maxTextLength;
vm::psv::ptr<u32> inputTextBuffer;
u32 reserved0;
u32 reserved1;
le_t<u32> size;
le_t<u32> inputMethod;
le_t<u64> supportedLanguages;
le_t<s32> languagesForced;
le_t<u32> type;
le_t<u32> option;
vm::lptr<void> work;
vm::lptr<void> arg;
vm::lptr<SceImeEventHandler> handler;
vm::lptr<SceImeCharFilter> filter;
vm::lptr<u32> initialText;
le_t<u32> maxTextLength;
vm::lptr<u32> inputTextBuffer;
le_t<u32> reserved0;
le_t<u32> reserved1;
};
extern psv_log_base sceIme;

60
rpcs3/Emu/ARMv7/Modules/sceJpeg.cpp
View File

@ -2,36 +2,7 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
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<u8> pStreamBuffer;
u32 streamBufferSize;
vm::psv::ptr<u8> pWriteBuffer;
u32 writeBufferSize;
s32 isEndOfStream;
s32 decodeMode;
SceJpegOutputInfo outputInfo;
vm::psv::ptr<void> pOutputBuffer;
vm::psv::ptr<void> pCoefBuffer;
u32 internalData[3];
};
#include "sceJpeg.h"
s32 sceJpegInitMJpeg(s32 maxSplitDecoder)
{
@ -44,34 +15,34 @@ s32 sceJpegFinishMJpeg()
}
s32 sceJpegDecodeMJpeg(
vm::psv::ptr<const u8> pJpeg,
vm::ptr<const u8> pJpeg,
u32 isize,
vm::psv::ptr<void> pRGBA,
vm::ptr<void> pRGBA,
u32 osize,
s32 decodeMode,
vm::psv::ptr<void> pTempBuffer,
vm::ptr<void> pTempBuffer,
u32 tempBufferSize,
vm::psv::ptr<void> pCoefBuffer,
vm::ptr<void> pCoefBuffer,
u32 coefBufferSize)
{
throw __FUNCTION__;
}
s32 sceJpegDecodeMJpegYCbCr(
vm::psv::ptr<const u8> pJpeg,
vm::ptr<const u8> pJpeg,
u32 isize,
vm::psv::ptr<u8> pYCbCr,
vm::ptr<u8> pYCbCr,
u32 osize,
s32 decodeMode,
vm::psv::ptr<void> pCoefBuffer,
vm::ptr<void> pCoefBuffer,
u32 coefBufferSize)
{
throw __FUNCTION__;
}
s32 sceJpegMJpegCsc(
vm::psv::ptr<void> pRGBA,
vm::psv::ptr<const u8> pYCbCr,
vm::ptr<void> pRGBA,
vm::ptr<const u8> pYCbCr,
s32 xysize,
s32 iFrameWidth,
s32 colorOption,
@ -81,26 +52,26 @@ s32 sceJpegMJpegCsc(
}
s32 sceJpegGetOutputInfo(
vm::psv::ptr<const u8> pJpeg,
vm::ptr<const u8> pJpeg,
u32 isize,
s32 outputFormat,
s32 decodeMode,
vm::psv::ptr<SceJpegOutputInfo> pOutputInfo)
vm::ptr<SceJpegOutputInfo> pOutputInfo)
{
throw __FUNCTION__;
}
s32 sceJpegCreateSplitDecoder(vm::psv::ptr<SceJpegSplitDecodeCtrl> pCtrl)
s32 sceJpegCreateSplitDecoder(vm::ptr<SceJpegSplitDecodeCtrl> pCtrl)
{
throw __FUNCTION__;
}
s32 sceJpegDeleteSplitDecoder(vm::psv::ptr<SceJpegSplitDecodeCtrl> pCtrl)
s32 sceJpegDeleteSplitDecoder(vm::ptr<SceJpegSplitDecodeCtrl> pCtrl)
{
throw __FUNCTION__;
}
s32 sceJpegSplitDecodeMJpeg(vm::psv::ptr<SceJpegSplitDecodeCtrl> pCtrl)
s32 sceJpegSplitDecodeMJpeg(vm::ptr<SceJpegSplitDecodeCtrl> pCtrl)
{
throw __FUNCTION__;
}
@ -113,6 +84,7 @@ psv_log_base sceJpeg("SceJpeg", []()
sceJpeg.on_load = nullptr;
sceJpeg.on_unload = nullptr;
sceJpeg.on_stop = nullptr;
sceJpeg.on_error = nullptr;
REG_FUNC(0xB030773B, sceJpegInitMJpeg);
REG_FUNC(0x62842598, sceJpegFinishMJpeg);

38
rpcs3/Emu/ARMv7/Modules/sceJpeg.h Normal file
View File

@ -0,0 +1,38 @@
#pragma once
struct SceJpegOutputInfo
{
le_t<s32> colorSpace;
le_t<u16> imageWidth;
le_t<u16> imageHeight;
le_t<u32> outputBufferSize;
le_t<u32> tempBufferSize;
le_t<u32> coefBufferSize;
struct _pitch_t
{
le_t<u32> x;
le_t<u32> y;
};
_pitch_t pitch[4];
};
struct SceJpegSplitDecodeCtrl
{
vm::lptr<u8> pStreamBuffer;
le_t<u32> streamBufferSize;
vm::lptr<u8> pWriteBuffer;
le_t<u32> writeBufferSize;
le_t<s32> isEndOfStream;
le_t<s32> decodeMode;
SceJpegOutputInfo outputInfo;
vm::lptr<void> pOutputBuffer;
vm::lptr<void> pCoefBuffer;
le_t<u32> internalData[3];
};
extern psv_log_base sceJpeg;

15
rpcs3/Emu/ARMv7/Modules/sceJpegEnc.cpp
View File

@ -2,9 +2,7 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceJpegEnc;
typedef vm::psv::ptr<void> SceJpegEncoderContext;
#include "sceJpegEnc.h"
s32 sceJpegEncoderGetContextSize()
{
@ -16,7 +14,7 @@ s32 sceJpegEncoderInit(
s32 iFrameWidth,
s32 iFrameHeight,
s32 pixelFormat,
vm::psv::ptr<void> pJpeg,
vm::ptr<void> pJpeg,
u32 oJpegbufSize)
{
throw __FUNCTION__;
@ -24,7 +22,7 @@ s32 sceJpegEncoderInit(
s32 sceJpegEncoderEncode(
SceJpegEncoderContext context,
vm::psv::ptr<const void> pYCbCr)
vm::ptr<const void> pYCbCr)
{
throw __FUNCTION__;
}
@ -58,7 +56,7 @@ s32 sceJpegEncoderSetHeaderMode(
s32 sceJpegEncoderSetOutputAddr(
SceJpegEncoderContext context,
vm::psv::ptr<void> pJpeg,
vm::ptr<void> pJpeg,
u32 oJpegbufSize)
{
throw __FUNCTION__;
@ -66,8 +64,8 @@ s32 sceJpegEncoderSetOutputAddr(
s32 sceJpegEncoderCsc(
SceJpegEncoderContext context,
vm::psv::ptr<void> pYCbCr,
vm::psv::ptr<const void> pRGBA,
vm::ptr<void> pYCbCr,
vm::ptr<const void> pRGBA,
s32 iFrameWidth,
s32 inputPixelFormat)
{
@ -82,6 +80,7 @@ psv_log_base sceJpegEnc("SceJpegEnc", []()
sceJpegEnc.on_load = nullptr;
sceJpegEnc.on_unload = nullptr;
sceJpegEnc.on_stop = nullptr;
sceJpegEnc.on_error = nullptr;
REG_FUNC(0x2B55844D, sceJpegEncoderGetContextSize);
REG_FUNC(0x88DA92B4, sceJpegEncoderInit);

5
rpcs3/Emu/ARMv7/Modules/sceJpegEnc.h Normal file
View File

@ -0,0 +1,5 @@
#pragma once
using SceJpegEncoderContext = vm::ptr<void>;
extern psv_log_base sceJpegEnc;

27
rpcs3/Emu/ARMv7/Modules/sceLibKernel.cpp
View File

@ -13,8 +13,6 @@
#include "psv_mutex.h"
#include "psv_cond.h"
#define RETURN_ERROR(code) { Emu.Pause(); sceLibKernel.Error("%s() failed: %s", __FUNCTION__, #code); return code; }
s32 sceKernelAllocMemBlock(vm::ptr<const char> name, s32 type, u32 vsize, vm::ptr<SceKernelAllocMemBlockOpt> pOpt)
{
throw __FUNCTION__;
@ -68,14 +66,14 @@ s32 sceKernelStartThread(s32 threadId, u32 argSize, vm::ptr<const void> pArgBloc
if (!t)
{
RETURN_ERROR(SCE_KERNEL_ERROR_INVALID_UID);
return SCE_KERNEL_ERROR_INVALID_UID;
}
// thread should be in DORMANT state, but it's not possible to check it correctly atm
if (t->IsAlive())
{
RETURN_ERROR(SCE_KERNEL_ERROR_NOT_DORMANT);
return SCE_KERNEL_ERROR_NOT_DORMANT;
}
ARMv7Thread& thread = static_cast<ARMv7Thread&>(*t);
@ -110,14 +108,14 @@ s32 sceKernelDeleteThread(s32 threadId)
if (!t)
{
RETURN_ERROR(SCE_KERNEL_ERROR_INVALID_UID);
return SCE_KERNEL_ERROR_INVALID_UID;
}
// thread should be in DORMANT state, but it's not possible to check it correctly atm
if (t->IsAlive())
{
RETURN_ERROR(SCE_KERNEL_ERROR_NOT_DORMANT);
return SCE_KERNEL_ERROR_NOT_DORMANT;
}
Emu.GetCPU().RemoveThread(threadId);
@ -268,7 +266,7 @@ s32 sceKernelWaitThreadEnd(s32 threadId, vm::ptr<s32> pExitStatus, vm::ptr<u32>
if (!t)
{
RETURN_ERROR(SCE_KERNEL_ERROR_INVALID_UID);
return SCE_KERNEL_ERROR_INVALID_UID;
}
ARMv7Thread& thread = static_cast<ARMv7Thread&>(*t);
@ -402,7 +400,7 @@ s32 sceKernelCreateEventFlag(vm::ptr<const char> pName, u32 attr, u32 initPatter
return id;
}
RETURN_ERROR(SCE_KERNEL_ERROR_ERROR);
return SCE_KERNEL_ERROR_ERROR;
}
s32 sceKernelDeleteEventFlag(s32 evfId)
@ -466,7 +464,7 @@ s32 sceKernelCreateSema(vm::ptr<const char> pName, u32 attr, s32 initCount, s32
return id;
}
RETURN_ERROR(SCE_KERNEL_ERROR_ERROR);
return SCE_KERNEL_ERROR_ERROR;
}
s32 sceKernelDeleteSema(s32 semaId)
@ -477,12 +475,12 @@ s32 sceKernelDeleteSema(s32 semaId)
if (!sema)
{
RETURN_ERROR(SCE_KERNEL_ERROR_INVALID_UID);
return SCE_KERNEL_ERROR_INVALID_UID;
}
if (!g_psv_sema_list.remove(semaId))
{
RETURN_ERROR(SCE_KERNEL_ERROR_INVALID_UID);
return SCE_KERNEL_ERROR_INVALID_UID;
}
return SCE_OK;
@ -506,7 +504,7 @@ s32 sceKernelWaitSema(s32 semaId, s32 needCount, vm::ptr<u32> pTimeout)
if (!sema)
{
RETURN_ERROR(SCE_KERNEL_ERROR_INVALID_UID);
return SCE_KERNEL_ERROR_INVALID_UID;
}
sceLibKernel.Error("*** name = %s", sema->name);
@ -550,7 +548,7 @@ s32 sceKernelCreateMutex(vm::ptr<const char> pName, u32 attr, s32 initCount, vm:
return id;
}
RETURN_ERROR(SCE_KERNEL_ERROR_ERROR);
return SCE_KERNEL_ERROR_ERROR;
}
s32 sceKernelDeleteMutex(s32 mutexId)
@ -651,7 +649,7 @@ s32 sceKernelCreateCond(vm::ptr<const char> pName, u32 attr, s32 mutexId, vm::pt
return id;
}
RETURN_ERROR(SCE_KERNEL_ERROR_ERROR);
return SCE_KERNEL_ERROR_ERROR;
}
s32 sceKernelDeleteCond(s32 condId)
@ -1022,6 +1020,7 @@ psv_log_base sceLibKernel("sceLibKernel", []()
sceLibKernel.on_load = nullptr;
sceLibKernel.on_unload = nullptr;
sceLibKernel.on_stop = nullptr;
//sceLibKernel.on_error = nullptr; // keep default error handler
// REG_FUNC(???, sceKernelGetEventInfo);

2
rpcs3/Emu/ARMv7/Modules/sceLibKernel.h
View File

@ -387,7 +387,7 @@ struct SceKernelCallbackInfo
// Thread Manager definitions (events)
using SceKernelThreadEventHandler = func_def<s32(s32 type, s32 threadId, s32 arg, vm::psv::ptr<void> pCommon)>;
using SceKernelThreadEventHandler = func_def<s32(s32 type, s32 threadId, s32 arg, vm::ptr<void> pCommon)>;
struct SceKernelEventInfo
{

27
rpcs3/Emu/ARMv7/Modules/sceLibc.cpp
View File

@ -5,17 +5,15 @@
#include "Emu/ARMv7/ARMv7Thread.h"
#include "Emu/ARMv7/ARMv7Callback.h"
extern psv_log_base sceLibc;
#include "sceLibc.h"
vm::psv::ptr<void> g_dso;
typedef void(atexit_func_t)(vm::psv::ptr<void>);
vm::ptr<void> g_dso;
std::vector<std::function<void(ARMv7Context&)>> g_atexit;
std::mutex g_atexit_mutex;
std::string armv7_fmt(ARMv7Context& context, vm::psv::ptr<const char> fmt, u32 g_count, u32 f_count, u32 v_count)
std::string armv7_fmt(ARMv7Context& context, vm::cptr<char> fmt, u32 g_count, u32 f_count, u32 v_count)
{
std::string result;
@ -130,7 +128,7 @@ std::string armv7_fmt(ARMv7Context& context, vm::psv::ptr<const char> fmt, u32 g
case 's':
{
// string
auto string = vm::psv::ptr<const char>::make(context.get_next_gpr_arg(g_count, f_count, v_count));
auto string = vm::cptr<char>::make(context.get_next_gpr_arg(g_count, f_count, v_count));
if (plus_sign || minus_sign || space_sign || number_sign || zero_padding || width || prec) break;
@ -151,7 +149,7 @@ std::string armv7_fmt(ARMv7Context& context, vm::psv::ptr<const char> fmt, u32 g
namespace sce_libc_func
{
void __cxa_atexit(vm::psv::ptr<atexit_func_t> func, vm::psv::ptr<void> arg, vm::psv::ptr<void> dso)
void __cxa_atexit(vm::ptr<atexit_func_t> func, vm::ptr<void> arg, vm::ptr<void> dso)
{
sceLibc.Warning("__cxa_atexit(func=*0x%x, arg=*0x%x, dso=*0x%x)", func, arg, dso);
@ -163,7 +161,7 @@ namespace sce_libc_func
});
}
void __aeabi_atexit(vm::psv::ptr<void> arg, vm::psv::ptr<atexit_func_t> func, vm::psv::ptr<void> dso)
void __aeabi_atexit(vm::ptr<void> arg, vm::ptr<atexit_func_t> func, vm::ptr<void> dso)
{
sceLibc.Warning("__aeabi_atexit(arg=*0x%x, func=*0x%x, dso=*0x%x)", arg, func, dso);
@ -202,7 +200,7 @@ namespace sce_libc_func
}
}
void printf(ARMv7Context& context, vm::psv::ptr<const char> fmt) // va_args...
void printf(ARMv7Context& context, vm::cptr<char> fmt) // va_args...
{
sceLibc.Warning("printf(fmt=*0x%x)", fmt);
sceLibc.Log("*** *fmt = '%s'", fmt.get_ptr());
@ -213,7 +211,7 @@ namespace sce_libc_func
LOG_NOTICE(TTY, result);
}
void sprintf(ARMv7Context& context, vm::psv::ptr<char> str, vm::psv::ptr<const char> fmt) // va_args...
void sprintf(ARMv7Context& context, vm::ptr<char> str, vm::cptr<char> fmt) // va_args...
{
sceLibc.Warning("sprintf(str=*0x%x, fmt=*0x%x)", str, fmt);
sceLibc.Log("*** *fmt = '%s'", fmt.get_ptr());
@ -224,28 +222,28 @@ namespace sce_libc_func
::memcpy(str.get_ptr(), result.c_str(), result.size() + 1);
}
void __cxa_set_dso_handle_main(vm::psv::ptr<void> dso)
void __cxa_set_dso_handle_main(vm::ptr<void> dso)
{
sceLibc.Warning("__cxa_set_dso_handle_main(dso=*0x%x)", dso);
g_dso = dso;
}
void memcpy(vm::psv::ptr<void> dst, vm::psv::ptr<const void> src, u32 size)
void memcpy(vm::ptr<void> dst, vm::cptr<void> src, u32 size)
{
sceLibc.Warning("memcpy(dst=*0x%x, src=*0x%x, size=0x%x)", dst, src, size);
::memcpy(dst.get_ptr(), src.get_ptr(), size);
}
void memset(vm::psv::ptr<void> dst, s32 value, u32 size)
void memset(vm::ptr<void> dst, s32 value, u32 size)
{
sceLibc.Warning("memset(dst=*0x%x, value=%d, size=0x%x)", dst, value, size);
::memset(dst.get_ptr(), value, size);
}
void _Assert(ARMv7Context& context, vm::psv::ptr<const char> text, vm::psv::ptr<const char> func)
void _Assert(ARMv7Context& context, vm::cptr<char> text, vm::cptr<char> func)
{
sceLibc.Error("_Assert(text=*0x%x, func=*0x%x)", text, func);
@ -265,6 +263,7 @@ psv_log_base sceLibc("SceLibc", []()
sceLibc.on_load = nullptr;
sceLibc.on_unload = nullptr;
sceLibc.on_stop = nullptr;
sceLibc.on_error = nullptr;
REG_FUNC(0xE4531F85, _Assert);
//REG_FUNC(0xE71C5CDE, _Stoul);

5
rpcs3/Emu/ARMv7/Modules/sceLibc.h Normal file
View File

@ -0,0 +1,5 @@
#pragma once
using atexit_func_t = func_def<void(vm::ptr<void>)>;
extern psv_log_base sceLibc;

3
rpcs3/Emu/ARMv7/Modules/sceLibm.cpp
View File

@ -2,7 +2,7 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceLibm;
#include "sceLibm.h"
namespace sce_libm_func
{
@ -16,6 +16,7 @@ psv_log_base sceLibm("SceLibm", []()
sceLibm.on_load = nullptr;
sceLibm.on_unload = nullptr;
sceLibm.on_stop = nullptr;
sceLibm.on_error = nullptr;
//REG_FUNC(0xC73FE76D, _Exp);
//REG_FUNC(0xFF4EAE04, _FExp);

3
rpcs3/Emu/ARMv7/Modules/sceLibm.h Normal file
View File

@ -0,0 +1,3 @@
#pragma once
extern psv_log_base sceLibm;

3
rpcs3/Emu/ARMv7/Modules/sceLibstdcxx.cpp
View File

@ -2,7 +2,7 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceLibstdcxx;
#include "sceLibstdcxx.h"
namespace sce_libstdcxx_func
{
@ -30,6 +30,7 @@ psv_log_base sceLibstdcxx("SceLibstdcxx", []()
sceLibstdcxx.on_load = nullptr;
sceLibstdcxx.on_unload = nullptr;
sceLibstdcxx.on_stop = nullptr;
sceLibstdcxx.on_error = nullptr;
//REG_FUNC(0x52B0C625, std::bad_typeid::what() const);
//REG_FUNC(0x64D7D074, std::bad_typeid::_Doraise() const);

3
rpcs3/Emu/ARMv7/Modules/sceLibstdcxx.h Normal file
View File

@ -0,0 +1,3 @@
#pragma once
extern psv_log_base sceLibstdcxx;

5
rpcs3/Emu/ARMv7/Modules/sceLiveArea.cpp
View File

@ -2,9 +2,9 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceLiveArea;
#include "sceLiveArea.h"
s32 sceLiveAreaResourceReplaceAll(vm::psv::ptr<const char> dirpath)
s32 sceLiveAreaResourceReplaceAll(vm::cptr<char> dirpath)
{
throw __FUNCTION__;
}
@ -21,6 +21,7 @@ psv_log_base sceLiveArea("SceLiveArea", []()
sceLiveArea.on_load = nullptr;
sceLiveArea.on_unload = nullptr;
sceLiveArea.on_stop = nullptr;
sceLiveArea.on_error = nullptr;
REG_FUNC(0xA4B506F9, sceLiveAreaResourceReplaceAll);
REG_FUNC(0x54A395FB, sceLiveAreaResourceGetStatus);

3
rpcs3/Emu/ARMv7/Modules/sceLiveArea.h Normal file
View File

@ -0,0 +1,3 @@
#pragma once
extern psv_log_base sceLiveArea;

119
rpcs3/Emu/ARMv7/Modules/sceLocation.cpp
View File

@ -2,171 +2,89 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceLocation;
#include "sceLocation.h"
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<void(s32 result, SceLocationHandle handle, vm::psv::ptr<const SceLocationLocationInfo> location, vm::psv::ptr<void> userdata)> SceLocationLocationInfoCallback;
typedef vm::psv::ptr<void(s32 result, SceLocationHandle handle, vm::psv::ptr<const SceLocationHeadingInfo> heading, vm::psv::ptr<void> userdata)> SceLocationHeadingInfoCallback;
struct SceLocationPermissionInfo
{
SceLocationPermissionStatus parentalstatus;
SceLocationPermissionStatus mainstatus;
SceLocationPermissionApplicationStatus applicationstatus;
};
s32 sceLocationOpen(vm::psv::ptr<SceLocationHandle> handle, SceLocationLocationMethod lmethod, SceLocationHeadingMethod hmethod)
s32 sceLocationOpen(vm::ptr<u8> handle, SceLocationLocationMethod lmethod, SceLocationHeadingMethod hmethod)
{
throw __FUNCTION__;
}
s32 sceLocationClose(SceLocationHandle handle)
s32 sceLocationClose(u8 handle)
{
throw __FUNCTION__;
}
s32 sceLocationReopen(SceLocationHandle handle, SceLocationLocationMethod lmethod, SceLocationHeadingMethod hmethod)
s32 sceLocationReopen(u8 handle, SceLocationLocationMethod lmethod, SceLocationHeadingMethod hmethod)
{
throw __FUNCTION__;
}
s32 sceLocationGetMethod(SceLocationHandle handle, vm::psv::ptr<SceLocationLocationMethod> lmethod, vm::psv::ptr<SceLocationHeadingMethod> hmethod)
s32 sceLocationGetMethod(u8 handle, vm::ptr<SceLocationLocationMethod> lmethod, vm::ptr<SceLocationHeadingMethod> hmethod)
{
throw __FUNCTION__;
}
s32 sceLocationGetLocation(SceLocationHandle handle, vm::psv::ptr<SceLocationLocationInfo> linfo)
s32 sceLocationGetLocation(u8 handle, vm::ptr<SceLocationLocationInfo> linfo)
{
throw __FUNCTION__;
}
s32 sceLocationCancelGetLocation(SceLocationHandle handle)
s32 sceLocationCancelGetLocation(u8 handle)
{
throw __FUNCTION__;
}
s32 sceLocationStartLocationCallback(SceLocationHandle handle, u32 distance, SceLocationLocationInfoCallback callback, vm::psv::ptr<void> userdata)
s32 sceLocationStartLocationCallback(u8 handle, u32 distance, vm::ptr<SceLocationLocationInfoCallback> callback, vm::ptr<void> userdata)
{
throw __FUNCTION__;
}
s32 sceLocationStopLocationCallback(SceLocationHandle handle)
s32 sceLocationStopLocationCallback(u8 handle)
{
throw __FUNCTION__;
}
s32 sceLocationGetHeading(SceLocationHandle handle, vm::psv::ptr<SceLocationHeadingInfo> hinfo)
s32 sceLocationGetHeading(u8 handle, vm::ptr<SceLocationHeadingInfo> hinfo)
{
throw __FUNCTION__;
}
s32 sceLocationStartHeadingCallback(SceLocationHandle handle, u32 difference, SceLocationHeadingInfoCallback callback, vm::psv::ptr<void> userdata)
s32 sceLocationStartHeadingCallback(u8 handle, u32 difference, vm::ptr<SceLocationHeadingInfoCallback> callback, vm::ptr<void> userdata)
{
throw __FUNCTION__;
}
s32 sceLocationStopHeadingCallback(SceLocationHandle handle)
s32 sceLocationStopHeadingCallback(u8 handle)
{
throw __FUNCTION__;
}
s32 sceLocationConfirm(SceLocationHandle handle)
s32 sceLocationConfirm(u8 handle)
{
throw __FUNCTION__;
}
s32 sceLocationConfirmGetStatus(SceLocationHandle handle, vm::psv::ptr<SceLocationDialogStatus> status)
s32 sceLocationConfirmGetStatus(u8 handle, vm::ptr<SceLocationDialogStatus> status)
{
throw __FUNCTION__;
}
s32 sceLocationConfirmGetResult(SceLocationHandle handle, vm::psv::ptr<SceLocationDialogResult> result)
s32 sceLocationConfirmGetResult(u8 handle, vm::ptr<SceLocationDialogResult> result)
{
throw __FUNCTION__;
}
s32 sceLocationConfirmAbort(SceLocationHandle handle)
s32 sceLocationConfirmAbort(u8 handle)
{
throw __FUNCTION__;
}
s32 sceLocationGetPermission(SceLocationHandle handle, vm::psv::ptr<SceLocationPermissionInfo> info)
s32 sceLocationGetPermission(u8 handle, vm::ptr<SceLocationPermissionInfo> info)
{
throw __FUNCTION__;
}
s32 sceLocationSetGpsEmulationFile(vm::psv::ptr<char> filename)
s32 sceLocationSetGpsEmulationFile(vm::ptr<char> filename)
{
throw __FUNCTION__;
}
@ -179,6 +97,7 @@ psv_log_base sceLocation("SceLibLocation", []()
sceLocation.on_load = nullptr;
sceLocation.on_unload = nullptr;
sceLocation.on_stop = nullptr;
sceLocation.on_error = nullptr;
REG_FUNC(0xDD271661, sceLocationOpen);
REG_FUNC(0x14FE76E8, sceLocationClose);

83
rpcs3/Emu/ARMv7/Modules/sceLocation.h Normal file
View File

@ -0,0 +1,83 @@
#pragma once
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
{
le_t<double> latitude;
le_t<double> longitude;
le_t<double> altitude;
le_t<float> accuracy;
le_t<float> reserve;
le_t<float> direction;
le_t<float> speed;
le_t<u64> timestamp;
};
struct SceLocationHeadingInfo
{
le_t<float> trueHeading;
le_t<float> headingVectorX;
le_t<float> headingVectorY;
le_t<float> headingVectorZ;
le_t<float> reserve;
le_t<float> reserve2;
le_t<u64> timestamp;
};
using SceLocationLocationInfoCallback = func_def<void(s32 result, u8 handle, vm::cptr<SceLocationLocationInfo> location, vm::ptr<void> userdata)>;
using SceLocationHeadingInfoCallback = func_def<void(s32 result, u8 handle, vm::cptr<SceLocationHeadingInfo> heading, vm::ptr<void> userdata)>;
struct SceLocationPermissionInfo
{
SceLocationPermissionStatus parentalstatus;
SceLocationPermissionStatus mainstatus;
SceLocationPermissionApplicationStatus applicationstatus;
};
extern psv_log_base sceLocation;

22
rpcs3/Emu/ARMv7/Modules/sceMd5.cpp
View File

@ -2,35 +2,24 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceMd5;
#include "sceMd5.h"
struct SceMd5Context
{
u32 h[4];
u32 pad;
u16 usRemains;
u16 usComputed;
u64 ullTotalLen;
u8 buf[64];
u8 result[64];
};
s32 sceMd5Digest(vm::psv::ptr<const void> plain, u32 len, vm::psv::ptr<u8> digest)
s32 sceMd5Digest(vm::ptr<const void> plain, u32 len, vm::ptr<u8> digest)
{
throw __FUNCTION__;
}
s32 sceMd5BlockInit(vm::psv::ptr<SceMd5Context> pContext)
s32 sceMd5BlockInit(vm::ptr<SceMd5Context> pContext)
{
throw __FUNCTION__;
}
s32 sceMd5BlockUpdate(vm::psv::ptr<SceMd5Context> pContext, vm::psv::ptr<const void> plain, u32 len)
s32 sceMd5BlockUpdate(vm::ptr<SceMd5Context> pContext, vm::ptr<const void> plain, u32 len)
{
throw __FUNCTION__;
}
s32 sceMd5BlockResult(vm::psv::ptr<SceMd5Context> pContext, vm::psv::ptr<u8> digest)
s32 sceMd5BlockResult(vm::ptr<SceMd5Context> pContext, vm::ptr<u8> digest)
{
throw __FUNCTION__;
}
@ -42,6 +31,7 @@ psv_log_base sceMd5("SceMd5", []()
sceMd5.on_load = nullptr;
sceMd5.on_unload = nullptr;
sceMd5.on_stop = nullptr;
sceMd5.on_error = nullptr;
REG_FUNC(0xB845BCCB, sceMd5Digest);
REG_FUNC(0x4D6436F9, sceMd5BlockInit);

14
rpcs3/Emu/ARMv7/Modules/sceMd5.h Normal file
View File

@ -0,0 +1,14 @@
#pragma once
struct SceMd5Context
{
le_t<u32> h[4];
le_t<u32> pad;
le_t<u16> usRemains;
le_t<u16> usComputed;
le_t<u64> ullTotalLen;
u8 buf[64];
u8 result[64];
};
extern psv_log_base sceMd5;

60
rpcs3/Emu/ARMv7/Modules/sceMotion.cpp
View File

@ -2,54 +2,27 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceMotion;
#include "sceMotion.h"
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<SceMotionState> motionState)
s32 sceMotionGetState(vm::ptr<SceMotionState> motionState)
{
throw __FUNCTION__;
}
s32 sceMotionGetSensorState(vm::psv::ptr<SceMotionSensorState> sensorState, s32 numRecords)
s32 sceMotionGetSensorState(vm::ptr<SceMotionSensorState> sensorState, s32 numRecords)
{
throw __FUNCTION__;
}
s32 sceMotionGetBasicOrientation(vm::psv::ptr<SceFVector3> basicOrientation)
s32 sceMotionGetBasicOrientation(vm::ptr<SceFVector3> basicOrientation)
{
throw __FUNCTION__;
}
//s32 sceMotionRotateYaw(const float radians)
//{
// throw __FUNCTION__;
//}
s32 sceMotionRotateYaw(const float radians)
{
throw __FUNCTION__;
}
s32 sceMotionGetTiltCorrection()
{
@ -71,15 +44,15 @@ s32 sceMotionSetDeadband(s32 setValue)
throw __FUNCTION__;
}
//s32 sceMotionSetAngleThreshold(const float angle)
//{
// throw __FUNCTION__;
//}
s32 sceMotionSetAngleThreshold(const float angle)
{
throw __FUNCTION__;
}
//float sceMotionGetAngleThreshold()
//{
// throw __FUNCTION__;
//}
float sceMotionGetAngleThreshold()
{
throw __FUNCTION__;
}
s32 sceMotionReset()
{
@ -118,6 +91,7 @@ psv_log_base sceMotion("SceMotion", []()
sceMotion.on_load = nullptr;
sceMotion.on_unload = nullptr;
sceMotion.on_stop = nullptr;
sceMotion.on_error = nullptr;
REG_FUNC(0xBDB32767, sceMotionGetState);
REG_FUNC(0x47D679EA, sceMotionGetSensorState);

30
rpcs3/Emu/ARMv7/Modules/sceMotion.h Normal file
View File

@ -0,0 +1,30 @@
#pragma once
struct SceMotionState
{
le_t<u32> timestamp;
SceFVector3 acceleration;
SceFVector3 angularVelocity;
u8 reserve1[12];
SceFQuaternion deviceQuat;
SceUMatrix4 rotationMatrix;
SceUMatrix4 nedMatrix;
u8 reserve2[4];
SceFVector3 basicOrientation;
le_t<u64> hostTimestamp;
u8 reserve3[40];
};
struct SceMotionSensorState
{
SceFVector3 accelerometer;
SceFVector3 gyro;
u8 reserve1[12];
le_t<u32> timestamp;
le_t<u32> counter;
u8 reserve2[4];
le_t<u64> hostTimestamp;
u8 reserve3[8];
};
extern psv_log_base sceMotion;

13
rpcs3/Emu/ARMv7/Modules/sceMt19937.cpp
View File

@ -2,20 +2,14 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceMt19937;
#include "sceMt19937.h"
struct SceMt19937Context
{
u32 count;
u32 state[624];
};
s32 sceMt19937Init(vm::psv::ptr<SceMt19937Context> pCtx, u32 seed)
s32 sceMt19937Init(vm::ptr<SceMt19937Context> pCtx, u32 seed)
{
throw __FUNCTION__;
}
u32 sceMt19937UInt(vm::psv::ptr<SceMt19937Context> pCtx)
u32 sceMt19937UInt(vm::ptr<SceMt19937Context> pCtx)
{
throw __FUNCTION__;
}
@ -28,6 +22,7 @@ psv_log_base sceMt19937("SceMt19937", []()
sceMt19937.on_load = nullptr;
sceMt19937.on_unload = nullptr;
sceMt19937.on_stop = nullptr;
sceMt19937.on_error = nullptr;
REG_FUNC(0xEE5BA27C, sceMt19937Init);
REG_FUNC(0x29E43BB5, sceMt19937UInt);

9
rpcs3/Emu/ARMv7/Modules/sceMt19937.h Normal file
View File

@ -0,0 +1,9 @@
#pragma once
struct SceMt19937Context
{
le_t<u32> count;
le_t<u32> state[624];
};
extern psv_log_base sceMt19937;

75
rpcs3/Emu/ARMv7/Modules/sceNet.cpp
View File

@ -4,7 +4,7 @@
#include "sceNet.h"
s32 sceNetSetDnsInfo(vm::psv::ptr<SceNetDnsInfo> info, s32 flags)
s32 sceNetSetDnsInfo(vm::ptr<SceNetDnsInfo> info, s32 flags)
{
throw __FUNCTION__;
}
@ -14,12 +14,12 @@ s32 sceNetClearDnsCache(s32 flags)
throw __FUNCTION__;
}
s32 sceNetDumpCreate(vm::psv::ptr<const char> name, s32 len, s32 flags)
s32 sceNetDumpCreate(vm::ptr<const char> name, s32 len, s32 flags)
{
throw __FUNCTION__;
}
s32 sceNetDumpRead(s32 id, vm::psv::ptr<void> buf, s32 len, vm::psv::ptr<s32> pflags)
s32 sceNetDumpRead(s32 id, vm::ptr<void> buf, s32 len, vm::ptr<s32> pflags)
{
throw __FUNCTION__;
}
@ -34,22 +34,22 @@ s32 sceNetDumpAbort(s32 id, s32 flags)
throw __FUNCTION__;
}
s32 sceNetEpollCreate(vm::psv::ptr<const char> name, s32 flags)
s32 sceNetEpollCreate(vm::ptr<const char> name, s32 flags)
{
throw __FUNCTION__;
}
s32 sceNetEpollControl(s32 eid, s32 op, s32 id, vm::psv::ptr<SceNetEpollEvent> event)
s32 sceNetEpollControl(s32 eid, s32 op, s32 id, vm::ptr<SceNetEpollEvent> event)
{
throw __FUNCTION__;
}
s32 sceNetEpollWait(s32 eid, vm::psv::ptr<SceNetEpollEvent> events, s32 maxevents, s32 timeout)
s32 sceNetEpollWait(s32 eid, vm::ptr<SceNetEpollEvent> events, s32 maxevents, s32 timeout)
{
throw __FUNCTION__;
}
s32 sceNetEpollWaitCB(s32 eid, vm::psv::ptr<SceNetEpollEvent> events, s32 maxevents, s32 timeout)
s32 sceNetEpollWaitCB(s32 eid, vm::ptr<SceNetEpollEvent> events, s32 maxevents, s32 timeout)
{
throw __FUNCTION__;
}
@ -64,32 +64,32 @@ s32 sceNetEpollAbort(s32 eid, s32 flags)
throw __FUNCTION__;
}
vm::psv::ptr<s32> sceNetErrnoLoc()
vm::ptr<s32> sceNetErrnoLoc()
{
throw __FUNCTION__;
}
s32 sceNetEtherStrton(vm::psv::ptr<const char> str, vm::psv::ptr<SceNetEtherAddr> n)
s32 sceNetEtherStrton(vm::ptr<const char> str, vm::ptr<SceNetEtherAddr> n)
{
throw __FUNCTION__;
}
s32 sceNetEtherNtostr(vm::psv::ptr<const SceNetEtherAddr> n, vm::psv::ptr<char> str, u32 len)
s32 sceNetEtherNtostr(vm::ptr<const SceNetEtherAddr> n, vm::ptr<char> str, u32 len)
{
throw __FUNCTION__;
}
s32 sceNetGetMacAddress(vm::psv::ptr<SceNetEtherAddr> addr, s32 flags)
s32 sceNetGetMacAddress(vm::ptr<SceNetEtherAddr> addr, s32 flags)
{
throw __FUNCTION__;
}
vm::psv::ptr<const char> sceNetInetNtop(s32 af, vm::psv::ptr<const void> src, vm::psv::ptr<char> dst, SceNetSocklen_t size)
vm::ptr<const char> sceNetInetNtop(s32 af, vm::ptr<const void> src, vm::ptr<char> dst, SceNetSocklen_t size)
{
throw __FUNCTION__;
}
s32 sceNetInetPton(s32 af, vm::psv::ptr<const char> src, vm::psv::ptr<void> dst)
s32 sceNetInetPton(s32 af, vm::ptr<const char> src, vm::ptr<void> dst)
{
throw __FUNCTION__;
}
@ -124,7 +124,7 @@ u16 sceNetNtohs(u16 net16)
throw __FUNCTION__;
}
s32 sceNetInit(vm::psv::ptr<SceNetInitParam> param)
s32 sceNetInit(vm::ptr<SceNetInitParam> param)
{
throw __FUNCTION__;
}
@ -149,32 +149,32 @@ s32 sceNetShowNetstat()
throw __FUNCTION__;
}
s32 sceNetEmulationSet(vm::psv::ptr<SceNetEmulationParam> param, s32 flags)
s32 sceNetEmulationSet(vm::ptr<SceNetEmulationParam> param, s32 flags)
{
throw __FUNCTION__;
}
s32 sceNetEmulationGet(vm::psv::ptr<SceNetEmulationParam> param, s32 flags)
s32 sceNetEmulationGet(vm::ptr<SceNetEmulationParam> param, s32 flags)
{
throw __FUNCTION__;
}
s32 sceNetResolverCreate(vm::psv::ptr<const char> name, vm::psv::ptr<SceNetResolverParam> param, s32 flags)
s32 sceNetResolverCreate(vm::ptr<const char> name, vm::ptr<SceNetResolverParam> param, s32 flags)
{
throw __FUNCTION__;
}
s32 sceNetResolverStartNtoa(s32 rid, vm::psv::ptr<const char> hostname, vm::psv::ptr<SceNetInAddr> addr, s32 timeout, s32 retry, s32 flags)
s32 sceNetResolverStartNtoa(s32 rid, vm::ptr<const char> hostname, vm::ptr<SceNetInAddr> addr, s32 timeout, s32 retry, s32 flags)
{
throw __FUNCTION__;
}
s32 sceNetResolverStartAton(s32 rid, vm::psv::ptr<const SceNetInAddr> addr, vm::psv::ptr<char> hostname, s32 len, s32 timeout, s32 retry, s32 flags)
s32 sceNetResolverStartAton(s32 rid, vm::ptr<const SceNetInAddr> addr, vm::ptr<char> hostname, s32 len, s32 timeout, s32 retry, s32 flags)
{
throw __FUNCTION__;
}
s32 sceNetResolverGetError(s32 rid, vm::psv::ptr<s32> result)
s32 sceNetResolverGetError(s32 rid, vm::ptr<s32> result)
{
throw __FUNCTION__;
}
@ -189,37 +189,37 @@ s32 sceNetResolverAbort(s32 rid, s32 flags)
throw __FUNCTION__;
}
s32 sceNetSocket(vm::psv::ptr<const char> name, s32 domain, s32 type, s32 protocol)
s32 sceNetSocket(vm::ptr<const char> name, s32 domain, s32 type, s32 protocol)
{
throw __FUNCTION__;
}
s32 sceNetAccept(s32 s, vm::psv::ptr<SceNetSockaddr> addr, vm::psv::ptr<SceNetSocklen_t> addrlen)
s32 sceNetAccept(s32 s, vm::ptr<SceNetSockaddr> addr, vm::ptr<SceNetSocklen_t> addrlen)
{
throw __FUNCTION__;
}
s32 sceNetBind(s32 s, vm::psv::ptr<const SceNetSockaddr> addr, SceNetSocklen_t addrlen)
s32 sceNetBind(s32 s, vm::ptr<const SceNetSockaddr> addr, SceNetSocklen_t addrlen)
{
throw __FUNCTION__;
}
s32 sceNetConnect(s32 s, vm::psv::ptr<const SceNetSockaddr> name, SceNetSocklen_t namelen)
s32 sceNetConnect(s32 s, vm::ptr<const SceNetSockaddr> name, SceNetSocklen_t namelen)
{
throw __FUNCTION__;
}
s32 sceNetGetpeername(s32 s, vm::psv::ptr<SceNetSockaddr> name, vm::psv::ptr<SceNetSocklen_t> namelen)
s32 sceNetGetpeername(s32 s, vm::ptr<SceNetSockaddr> name, vm::ptr<SceNetSocklen_t> namelen)
{
throw __FUNCTION__;
}
s32 sceNetGetsockname(s32 s, vm::psv::ptr<SceNetSockaddr> name, vm::psv::ptr<SceNetSocklen_t> namelen)
s32 sceNetGetsockname(s32 s, vm::ptr<SceNetSockaddr> name, vm::ptr<SceNetSocklen_t> namelen)
{
throw __FUNCTION__;
}
s32 sceNetGetsockopt(s32 s, s32 level, s32 optname, vm::psv::ptr<void> optval, vm::psv::ptr<SceNetSocklen_t> optlen)
s32 sceNetGetsockopt(s32 s, s32 level, s32 optname, vm::ptr<void> optval, vm::ptr<SceNetSocklen_t> optlen)
{
throw __FUNCTION__;
}
@ -229,37 +229,37 @@ s32 sceNetListen(s32 s, s32 backlog)
throw __FUNCTION__;
}
s32 sceNetRecv(s32 s, vm::psv::ptr<void> buf, u32 len, s32 flags)
s32 sceNetRecv(s32 s, vm::ptr<void> buf, u32 len, s32 flags)
{
throw __FUNCTION__;
}
s32 sceNetRecvfrom(s32 s, vm::psv::ptr<void> buf, u32 len, s32 flags, vm::psv::ptr<SceNetSockaddr> from, vm::psv::ptr<SceNetSocklen_t> fromlen)
s32 sceNetRecvfrom(s32 s, vm::ptr<void> buf, u32 len, s32 flags, vm::ptr<SceNetSockaddr> from, vm::ptr<SceNetSocklen_t> fromlen)
{
throw __FUNCTION__;
}
s32 sceNetRecvmsg(s32 s, vm::psv::ptr<SceNetMsghdr> msg, s32 flags)
s32 sceNetRecvmsg(s32 s, vm::ptr<SceNetMsghdr> msg, s32 flags)
{
throw __FUNCTION__;
}
s32 sceNetSend(s32 s, vm::psv::ptr<const void> msg, u32 len, s32 flags)
s32 sceNetSend(s32 s, vm::ptr<const void> msg, u32 len, s32 flags)
{
throw __FUNCTION__;
}
s32 sceNetSendto(s32 s, vm::psv::ptr<const void> msg, u32 len, s32 flags, vm::psv::ptr<const SceNetSockaddr> to, SceNetSocklen_t tolen)
s32 sceNetSendto(s32 s, vm::ptr<const void> msg, u32 len, s32 flags, vm::ptr<const SceNetSockaddr> to, SceNetSocklen_t tolen)
{
throw __FUNCTION__;
}
s32 sceNetSendmsg(s32 s, vm::psv::ptr<const SceNetMsghdr> msg, s32 flags)
s32 sceNetSendmsg(s32 s, vm::ptr<const SceNetMsghdr> msg, s32 flags)
{
throw __FUNCTION__;
}
s32 sceNetSetsockopt(s32 s, s32 level, s32 optname, vm::psv::ptr<const void> optval, SceNetSocklen_t optlen)
s32 sceNetSetsockopt(s32 s, s32 level, s32 optname, vm::ptr<const void> optval, SceNetSocklen_t optlen)
{
throw __FUNCTION__;
}
@ -279,17 +279,17 @@ s32 sceNetSocketAbort(s32 s, s32 flags)
throw __FUNCTION__;
}
s32 sceNetGetSockInfo(s32 s, vm::psv::ptr<SceNetSockInfo> info, s32 n, s32 flags)
s32 sceNetGetSockInfo(s32 s, vm::ptr<SceNetSockInfo> info, s32 n, s32 flags)
{
throw __FUNCTION__;
}
s32 sceNetGetSockIdInfo(vm::psv::ptr<SceNetFdSet> fds, s32 sockinfoflags, s32 flags)
s32 sceNetGetSockIdInfo(vm::ptr<SceNetFdSet> fds, s32 sockinfoflags, s32 flags)
{
throw __FUNCTION__;
}
s32 sceNetGetStatisticsInfo(vm::psv::ptr<SceNetStatisticsInfo> info, s32 flags)
s32 sceNetGetStatisticsInfo(vm::ptr<SceNetStatisticsInfo> info, s32 flags)
{
throw __FUNCTION__;
}
@ -302,6 +302,7 @@ psv_log_base sceNet("SceNet", []()
sceNet.on_load = nullptr;
sceNet.on_unload = nullptr;
sceNet.on_stop = nullptr;
sceNet.on_error = nullptr;
REG_FUNC(0xD62EF218, sceNetSetDnsInfo);
REG_FUNC(0xFEC1166D, sceNetClearDnsCache);

149
rpcs3/Emu/ARMv7/Modules/sceNet.h
View File

@ -1,22 +1,19 @@
#pragma once
typedef u32 SceNetInAddr_t;
typedef u16 SceNetInPort_t;
typedef u8 SceNetSaFamily_t;
typedef u32 SceNetSocklen_t;
struct SceNetInAddr
{
SceNetInAddr_t s_addr;
le_t<u32> s_addr;
};
struct SceNetSockaddrIn
{
u8 sin_len;
SceNetSaFamily_t sin_family;
SceNetInPort_t sin_port;
u8 sin_family;
le_t<u16> sin_port;
SceNetInAddr sin_addr;
SceNetInPort_t sin_vport;
le_t<u16> sin_vport;
char sin_zero[6];
};
@ -28,34 +25,34 @@ struct SceNetDnsInfo
struct SceNetSockaddr
{
u8 sa_len;
SceNetSaFamily_t sa_family;
u8 sa_family;
char sa_data[14];
};
struct SceNetEpollDataExt
{
s32 id;
u32 data;
le_t<s32> id;
le_t<u32> data;
};
union SceNetEpollData
{
vm::psv::ptr<void> ptr;
s32 fd;
u32 _u32;
u64 _u64;
vm::lptr<void> ptr;
le_t<s32> fd;
le_t<u32> _u32;
le_t<u64> _u64;
SceNetEpollDataExt ext;
};
struct SceNetEpollSystemData
{
u32 system[4];
le_t<u32> system[4];
};
struct SceNetEpollEvent
{
u32 events;
u32 reserved;
le_t<u32> events;
le_t<u32> reserved;
SceNetEpollSystemData system;
SceNetEpollData data;
};
@ -80,108 +77,106 @@ struct SceNetIpMreq
struct SceNetInitParam
{
vm::psv::ptr<void> memory;
s32 size;
s32 flags;
vm::lptr<void> memory;
le_t<s32> size;
le_t<s32> flags;
};
struct SceNetEmulationData
{
u16 drop_rate;
u16 drop_duration;
u16 pass_duration;
u16 delay_time;
u16 delay_jitter;
u16 order_rate;
u16 order_delay_time;
u16 duplication_rate;
u32 bps_limit;
u16 lower_size_limit;
u16 upper_size_limit;
u32 system_policy_pattern;
u32 game_policy_pattern;
u16 policy_flags[64];
le_t<u16> drop_rate;
le_t<u16> drop_duration;
le_t<u16> pass_duration;
le_t<u16> delay_time;
le_t<u16> delay_jitter;
le_t<u16> order_rate;
le_t<u16> order_delay_time;
le_t<u16> duplication_rate;
le_t<u32> bps_limit;
le_t<u16> lower_size_limit;
le_t<u16> upper_size_limit;
le_t<u32> system_policy_pattern;
le_t<u32> game_policy_pattern;
le_t<u16> policy_flags[64];
u8 reserved[64];
};
struct SceNetEmulationParam
{
u16 version;
u16 option_number;
u16 current_version;
u16 result;
u32 flags;
u32 reserved1;
le_t<u16> version;
le_t<u16> option_number;
le_t<u16> current_version;
le_t<u16> result;
le_t<u32> flags;
le_t<u32> reserved1;
SceNetEmulationData send;
SceNetEmulationData recv;
u32 seed;
le_t<u32> seed;
u8 reserved[44];
};
typedef vm::psv::ptr<vm::psv::ptr<void>(u32 size, s32 rid, vm::psv::ptr<const char> name, vm::psv::ptr<void> user)> SceNetResolverFunctionAllocate;
typedef vm::psv::ptr<void(vm::psv::ptr<void> ptr, s32 rid, vm::psv::ptr<const char> name, vm::psv::ptr<void> user)> SceNetResolverFunctionFree;
using SceNetResolverFunctionAllocate = func_def<vm::ptr<void>(u32 size, s32 rid, vm::cptr<char> name, vm::ptr<void> user)>;
using SceNetResolverFunctionFree = func_def<void(vm::ptr<void> ptr, s32 rid, vm::cptr<char> name, vm::ptr<void> user)>;
struct SceNetResolverParam
{
SceNetResolverFunctionAllocate allocate;
SceNetResolverFunctionFree free;
vm::psv::ptr<void> user;
vm::lptr<SceNetResolverFunctionAllocate> allocate;
vm::lptr<SceNetResolverFunctionFree> free;
vm::lptr<void> user;
};
struct SceNetLinger
{
s32 l_onoff;
s32 l_linger;
le_t<s32> l_onoff;
le_t<s32> l_linger;
};
struct SceNetIovec
{
vm::psv::ptr<void> iov_base;
u32 iov_len;
vm::lptr<void> iov_base;
le_t<u32> iov_len;
};
struct SceNetMsghdr
{
vm::psv::ptr<void> msg_name;
SceNetSocklen_t msg_namelen;
vm::psv::ptr<SceNetIovec> msg_iov;
s32 msg_iovlen;
vm::psv::ptr<void> msg_control;
SceNetSocklen_t msg_controllen;
s32 msg_flags;
vm::lptr<void> msg_name;
le_t<u32> msg_namelen;
vm::lptr<SceNetIovec> msg_iov;
le_t<s32> msg_iovlen;
vm::lptr<void> msg_control;
le_t<u32> msg_controllen;
le_t<s32> msg_flags;
};
struct SceNetSockInfo
{
char name[32];
s32 pid;
s32 s;
le_t<s32> pid;
le_t<s32> s;
s8 socket_type;
s8 policy;
s16 reserved16;
s32 recv_queue_length;
s32 send_queue_length;
le_t<s16> reserved16;
le_t<s32> recv_queue_length;
le_t<s32> send_queue_length;
SceNetInAddr local_adr;
SceNetInAddr remote_adr;
SceNetInPort_t local_port;
SceNetInPort_t remote_port;
SceNetInPort_t local_vport;
SceNetInPort_t remote_vport;
s32 state;
s32 flags;
s32 reserved[8];
le_t<u16> local_port;
le_t<u16> remote_port;
le_t<u16> local_vport;
le_t<u16> remote_vport;
le_t<s32> state;
le_t<s32> flags;
le_t<s32> reserved[8];
};
struct SceNetStatisticsInfo
{
s32 kernel_mem_free_size;
s32 kernel_mem_free_min;
s32 packet_count;
s32 packet_qos_count;
s32 libnet_mem_free_size;
s32 libnet_mem_free_min;
le_t<s32> kernel_mem_free_size;
le_t<s32> kernel_mem_free_min;
le_t<s32> packet_count;
le_t<s32> packet_qos_count;
le_t<s32> libnet_mem_free_size;
le_t<s32> libnet_mem_free_min;
};
extern psv_log_base sceNet;

67
rpcs3/Emu/ARMv7/Modules/sceNetCtl.cpp
View File

@ -2,51 +2,7 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
#include "sceNet.h"
extern psv_log_base sceNetCtl;
union SceNetCtlInfo
{
char cnf_name[65];
u32 device;
SceNetEtherAddr ether_addr;
u32 mtu;
u32 link;
SceNetEtherAddr bssid;
char ssid[33];
u32 wifi_security;
u32 rssi_dbm;
u32 rssi_percentage;
u32 channel;
u32 ip_config;
char dhcp_hostname[256];
char pppoe_auth_name[128];
char ip_address[16];
char netmask[16];
char default_route[16];
char primary_dns[16];
char secondary_dns[16];
u32 http_proxy_config;
char http_proxy_server[256];
u32 http_proxy_port;
};
struct SceNetCtlNatInfo
{
u32 size;
s32 stun_status;
s32 nat_type;
SceNetInAddr mapped_addr;
};
struct SceNetCtlAdhocPeerInfo
{
vm::psv::ptr<SceNetCtlAdhocPeerInfo> next;
SceNetInAddr inet_addr;
};
typedef vm::psv::ptr<void(s32 event_type, vm::psv::ptr<void> arg)> SceNetCtlCallback;
#include "sceNetCtl.h"
s32 sceNetCtlInit()
{
@ -63,32 +19,32 @@ s32 sceNetCtlCheckCallback()
throw __FUNCTION__;
}
s32 sceNetCtlInetGetResult(s32 eventType, vm::psv::ptr<s32> errorCode)
s32 sceNetCtlInetGetResult(s32 eventType, vm::ptr<s32> errorCode)
{
throw __FUNCTION__;
}
s32 sceNetCtlAdhocGetResult(s32 eventType, vm::psv::ptr<s32> errorCode)
s32 sceNetCtlAdhocGetResult(s32 eventType, vm::ptr<s32> errorCode)
{
throw __FUNCTION__;
}
s32 sceNetCtlInetGetInfo(s32 code, vm::psv::ptr<SceNetCtlInfo> info)
s32 sceNetCtlInetGetInfo(s32 code, vm::ptr<SceNetCtlInfo> info)
{
throw __FUNCTION__;
}
s32 sceNetCtlInetGetState(vm::psv::ptr<s32> state)
s32 sceNetCtlInetGetState(vm::ptr<s32> state)
{
throw __FUNCTION__;
}
s32 sceNetCtlGetNatInfo(vm::psv::ptr<SceNetCtlNatInfo> natinfo)
s32 sceNetCtlGetNatInfo(vm::ptr<SceNetCtlNatInfo> natinfo)
{
throw __FUNCTION__;
}
s32 sceNetCtlInetRegisterCallback(SceNetCtlCallback func, vm::psv::ptr<void> arg, vm::psv::ptr<s32> cid)
s32 sceNetCtlInetRegisterCallback(vm::ptr<SceNetCtlCallback> func, vm::ptr<void> arg, vm::ptr<s32> cid)
{
throw __FUNCTION__;
}
@ -98,7 +54,7 @@ s32 sceNetCtlInetUnregisterCallback(s32 cid)
throw __FUNCTION__;
}
s32 sceNetCtlAdhocRegisterCallback(SceNetCtlCallback func, vm::psv::ptr<void> arg, vm::psv::ptr<s32> cid)
s32 sceNetCtlAdhocRegisterCallback(vm::ptr<SceNetCtlCallback> func, vm::ptr<void> arg, vm::ptr<s32> cid)
{
throw __FUNCTION__;
}
@ -108,7 +64,7 @@ s32 sceNetCtlAdhocUnregisterCallback(s32 cid)
throw __FUNCTION__;
}
s32 sceNetCtlAdhocGetState(vm::psv::ptr<s32> state)
s32 sceNetCtlAdhocGetState(vm::ptr<s32> state)
{
throw __FUNCTION__;
}
@ -118,12 +74,12 @@ s32 sceNetCtlAdhocDisconnect()
throw __FUNCTION__;
}
s32 sceNetCtlAdhocGetPeerList(vm::psv::ptr<u32> buflen, vm::psv::ptr<void> buf)
s32 sceNetCtlAdhocGetPeerList(vm::ptr<u32> buflen, vm::ptr<void> buf)
{
throw __FUNCTION__;
}
s32 sceNetCtlAdhocGetInAddr(vm::psv::ptr<SceNetInAddr> inaddr)
s32 sceNetCtlAdhocGetInAddr(vm::ptr<SceNetInAddr> inaddr)
{
throw __FUNCTION__;
}
@ -135,6 +91,7 @@ psv_log_base sceNetCtl("SceNetCtl", []()
sceNetCtl.on_load = nullptr;
sceNetCtl.on_unload = nullptr;
sceNetCtl.on_stop = nullptr;
sceNetCtl.on_error = nullptr;
REG_FUNC(0x495CA1DB, sceNetCtlInit);
REG_FUNC(0xCD188648, sceNetCtlTerm);

47
rpcs3/Emu/ARMv7/Modules/sceNetCtl.h Normal file
View File

@ -0,0 +1,47 @@
#pragma once
#include "sceNet.h"
union SceNetCtlInfo
{
char cnf_name[65];
le_t<u32> device;
SceNetEtherAddr ether_addr;
le_t<u32> mtu;
le_t<u32> link;
SceNetEtherAddr bssid;
char ssid[33];
le_t<u32> wifi_security;
le_t<u32> rssi_dbm;
le_t<u32> rssi_percentage;
le_t<u32> channel;
le_t<u32> ip_config;
char dhcp_hostname[256];
char pppoe_auth_name[128];
char ip_address[16];
char netmask[16];
char default_route[16];
char primary_dns[16];
char secondary_dns[16];
le_t<u32> http_proxy_config;
char http_proxy_server[256];
le_t<u32> http_proxy_port;
};
struct SceNetCtlNatInfo
{
le_t<u32> size;
le_t<s32> stun_status;
le_t<s32> nat_type;
SceNetInAddr mapped_addr;
};
struct SceNetCtlAdhocPeerInfo
{
vm::lptr<SceNetCtlAdhocPeerInfo> next;
SceNetInAddr inet_addr;
};
using SceNetCtlCallback = func_def<void(s32 event_type, vm::ptr<void> arg)>;
extern psv_log_base sceNetCtl;

218
rpcs3/Emu/ARMv7/Modules/sceNgs.cpp
View File

@ -2,123 +2,14 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceNgs;
#include "sceNgs.h"
struct SceNgsVoiceDefinition;
typedef u32 SceNgsModuleID;
typedef u32 SceNgsParamsID;
typedef vm::psv::ptr<void> SceNgsHVoice;
typedef vm::psv::ptr<void> SceNgsHPatch;
typedef vm::psv::ptr<void> SceNgsHSynSystem;
typedef vm::psv::ptr<void> SceNgsHRack;
struct SceNgsModuleParamHeader
{
s32 moduleId;
s32 chan;
};
struct SceNgsParamsDescriptor
{
SceNgsParamsID id;
u32 size;
};
struct SceNgsBufferInfo
{
vm::psv::ptr<void> data;
u32 size;
};
struct SceNgsVoicePreset
{
s32 nNameOffset;
u32 uNameLength;
s32 nPresetDataOffset;
u32 uSizePresetData;
s32 nBypassFlagsOffset;
u32 uNumBypassFlags;
};
struct SceNgsSystemInitParams
{
s32 nMaxRacks;
s32 nMaxVoices;
s32 nGranularity;
s32 nSampleRate;
s32 nMaxModules;
};
struct SceNgsRackDescription
{
vm::psv::ptr<const SceNgsVoiceDefinition> pVoiceDefn;
s32 nVoices;
s32 nChannelsPerVoice;
s32 nMaxPatchesPerInput;
s32 nPatchesPerOutput;
vm::psv::ptr<void> pUserReleaseData;
};
struct SceNgsPatchSetupInfo
{
SceNgsHVoice hVoiceSource;
s32 nSourceOutputIndex;
s32 nSourceOutputSubIndex;
SceNgsHVoice hVoiceDestination;
s32 nTargetInputIndex;
};
struct SceNgsVolumeMatrix
{
float m[2][2];
};
struct SceNgsPatchRouteInfo
{
s32 nOutputChannels;
s32 nInputChannels;
SceNgsVolumeMatrix vols;
};
struct SceNgsVoiceInfo
{
u32 uVoiceState;
u32 uNumModules;
u32 uNumInputs;
u32 uNumOutputs;
u32 uNumPatchesPerOutput;
};
struct SceNgsCallbackInfo
{
SceNgsHVoice hVoiceHandle;
SceNgsHRack hRackHandle;
SceNgsModuleID uModuleID;
s32 nCallbackData;
s32 nCallbackData2;
vm::psv::ptr<void> pCallbackPtr;
vm::psv::ptr<void> pUserData;
};
typedef vm::psv::ptr<void(vm::psv::ptr<const SceNgsCallbackInfo> pCallbackInfo)> SceNgsCallbackFunc;
typedef SceNgsCallbackFunc SceNgsRackReleaseCallbackFunc;
typedef SceNgsCallbackFunc SceNgsModuleCallbackFunc;
typedef SceNgsCallbackFunc SceNgsParamsErrorCallbackFunc;
struct SceSulphaNgsConfig
{
u32 maxNamedObjects;
u32 maxTraceBufferBytes;
};
s32 sceNgsSystemGetRequiredMemorySize(vm::psv::ptr<const SceNgsSystemInitParams> pSynthParams, vm::psv::ptr<u32> pnSize)
s32 sceNgsSystemGetRequiredMemorySize(vm::ptr<const SceNgsSystemInitParams> pSynthParams, vm::ptr<u32> pnSize)
{
throw __FUNCTION__;
}
s32 sceNgsSystemInit(vm::psv::ptr<void> pSynthSysMemory, const u32 uMemSize, vm::psv::ptr<const SceNgsSystemInitParams> pSynthParams, vm::psv::ptr<SceNgsHSynSystem> pSystemHandle)
s32 sceNgsSystemInit(vm::ptr<void> pSynthSysMemory, const u32 uMemSize, vm::ptr<const SceNgsSystemInitParams> pSynthParams, vm::ptr<SceNgsHSynSystem> pSystemHandle)
{
throw __FUNCTION__;
}
@ -143,7 +34,7 @@ s32 sceNgsSystemUnlock(SceNgsHSynSystem hSystemHandle)
throw __FUNCTION__;
}
s32 sceNgsSystemSetParamErrorCallback(SceNgsHSynSystem hSystemHandle, const SceNgsParamsErrorCallbackFunc callbackFuncPtr)
s32 sceNgsSystemSetParamErrorCallback(SceNgsHSynSystem hSystemHandle, vm::ptr<SceNgsCallbackFunc> callbackFuncPtr)
{
throw __FUNCTION__;
}
@ -153,32 +44,32 @@ s32 sceNgsSystemSetFlags(SceNgsHSynSystem hSystemHandle, const u32 uSystemFlags)
throw __FUNCTION__;
}
s32 sceNgsRackGetRequiredMemorySize(SceNgsHSynSystem hSystemHandle, vm::psv::ptr<const SceNgsRackDescription> pRackDesc, vm::psv::ptr<u32> pnSize)
s32 sceNgsRackGetRequiredMemorySize(SceNgsHSynSystem hSystemHandle, vm::ptr<const SceNgsRackDescription> pRackDesc, vm::ptr<u32> pnSize)
{
throw __FUNCTION__;
}
s32 sceNgsRackInit(SceNgsHSynSystem hSystemHandle, vm::psv::ptr<SceNgsBufferInfo> pRackBuffer, vm::psv::ptr<const SceNgsRackDescription> pRackDesc, vm::psv::ptr<SceNgsHRack> pRackHandle)
s32 sceNgsRackInit(SceNgsHSynSystem hSystemHandle, vm::ptr<SceNgsBufferInfo> pRackBuffer, vm::ptr<const SceNgsRackDescription> pRackDesc, vm::ptr<SceNgsHRack> pRackHandle)
{
throw __FUNCTION__;
}
s32 sceNgsRackGetVoiceHandle(SceNgsHRack hRackHandle, const u32 uIndex, vm::psv::ptr<SceNgsHVoice> pVoiceHandle)
s32 sceNgsRackGetVoiceHandle(SceNgsHRack hRackHandle, const u32 uIndex, vm::ptr<SceNgsHVoice> pVoiceHandle)
{
throw __FUNCTION__;
}
s32 sceNgsRackRelease(SceNgsHRack hRackHandle, const SceNgsRackReleaseCallbackFunc callbackFuncPtr)
s32 sceNgsRackRelease(SceNgsHRack hRackHandle, vm::ptr<SceNgsCallbackFunc> callbackFuncPtr)
{
throw __FUNCTION__;
}
s32 sceNgsRackSetParamErrorCallback(SceNgsHRack hRackHandle, const SceNgsParamsErrorCallbackFunc callbackFuncPtr)
s32 sceNgsRackSetParamErrorCallback(SceNgsHRack hRackHandle, vm::ptr<SceNgsCallbackFunc> callbackFuncPtr)
{
throw __FUNCTION__;
}
s32 sceNgsVoiceInit(SceNgsHVoice hVoiceHandle, vm::psv::ptr<const SceNgsVoicePreset> pPreset, const u32 uInitFlags)
s32 sceNgsVoiceInit(SceNgsHVoice hVoiceHandle, vm::ptr<const SceNgsVoicePreset> pPreset, const u32 uInitFlags)
{
throw __FUNCTION__;
}
@ -208,12 +99,12 @@ s32 sceNgsVoiceResume(SceNgsHVoice hVoiceHandle)
throw __FUNCTION__;
}
s32 sceNgsVoiceSetPreset(SceNgsHVoice hVoiceHandle, vm::psv::ptr<const SceNgsVoicePreset> pVoicePreset)
s32 sceNgsVoiceSetPreset(SceNgsHVoice hVoiceHandle, vm::ptr<const SceNgsVoicePreset> pVoicePreset)
{
throw __FUNCTION__;
}
s32 sceNgsVoiceLockParams(SceNgsHVoice hVoiceHandle, const u32 uModule, const SceNgsParamsID uParamsInterfaceId, vm::psv::ptr<SceNgsBufferInfo> pParamsBuffer)
s32 sceNgsVoiceLockParams(SceNgsHVoice hVoiceHandle, const u32 uModule, const u32 uParamsInterfaceId, vm::ptr<SceNgsBufferInfo> pParamsBuffer)
{
throw __FUNCTION__;
}
@ -223,7 +114,7 @@ s32 sceNgsVoiceUnlockParams(SceNgsHVoice hVoiceHandle, const u32 uModule)
throw __FUNCTION__;
}
s32 sceNgsVoiceSetParamsBlock(SceNgsHVoice hVoiceHandle, vm::psv::ptr<const SceNgsModuleParamHeader> pParamData, const u32 uSize, vm::psv::ptr<s32> pnErrorCount)
s32 sceNgsVoiceSetParamsBlock(SceNgsHVoice hVoiceHandle, vm::ptr<const SceNgsModuleParamHeader> pParamData, const u32 uSize, vm::ptr<s32> pnErrorCount)
{
throw __FUNCTION__;
}
@ -233,52 +124,52 @@ s32 sceNgsVoiceBypassModule(SceNgsHVoice hVoiceHandle, const u32 uModule, const
throw __FUNCTION__;
}
s32 sceNgsVoiceSetModuleCallback(SceNgsHVoice hVoiceHandle, const u32 uModule, const SceNgsModuleCallbackFunc callbackFuncPtr, vm::psv::ptr<void> pUserData)
s32 sceNgsVoiceSetModuleCallback(SceNgsHVoice hVoiceHandle, const u32 uModule, vm::ptr<SceNgsCallbackFunc> callbackFuncPtr, vm::ptr<void> pUserData)
{
throw __FUNCTION__;
}
s32 sceNgsVoiceSetFinishedCallback(SceNgsHVoice hVoiceHandle, const SceNgsCallbackFunc callbackFuncPtr, vm::psv::ptr<void> pUserData)
s32 sceNgsVoiceSetFinishedCallback(SceNgsHVoice hVoiceHandle, vm::ptr<SceNgsCallbackFunc> callbackFuncPtr, vm::ptr<void> pUserData)
{
throw __FUNCTION__;
}
s32 sceNgsVoiceGetStateData(SceNgsHVoice hVoiceHandle, const u32 uModule, vm::psv::ptr<void> pMem, const u32 uMemSize)
s32 sceNgsVoiceGetStateData(SceNgsHVoice hVoiceHandle, const u32 uModule, vm::ptr<void> pMem, const u32 uMemSize)
{
throw __FUNCTION__;
}
s32 sceNgsVoiceGetInfo(SceNgsHVoice hVoiceHandle, vm::psv::ptr<SceNgsVoiceInfo> pInfo)
s32 sceNgsVoiceGetInfo(SceNgsHVoice hVoiceHandle, vm::ptr<SceNgsVoiceInfo> pInfo)
{
throw __FUNCTION__;
}
s32 sceNgsVoiceGetModuleType(SceNgsHVoice hVoiceHandle, const u32 uModule, vm::psv::ptr<SceNgsModuleID> pModuleType)
s32 sceNgsVoiceGetModuleType(SceNgsHVoice hVoiceHandle, const u32 uModule, vm::ptr<u32> pModuleType)
{
throw __FUNCTION__;
}
s32 sceNgsVoiceGetModuleBypass(SceNgsHVoice hVoiceHandle, const u32 uModule, vm::psv::ptr<u32> puBypassFlag)
s32 sceNgsVoiceGetModuleBypass(SceNgsHVoice hVoiceHandle, const u32 uModule, vm::ptr<u32> puBypassFlag)
{
throw __FUNCTION__;
}
s32 sceNgsVoiceGetParamsOutOfRange(SceNgsHVoice hVoiceHandle, const u32 uModule, vm::psv::ptr<char> pszMessageBuffer)
s32 sceNgsVoiceGetParamsOutOfRange(SceNgsHVoice hVoiceHandle, const u32 uModule, vm::ptr<char> pszMessageBuffer)
{
throw __FUNCTION__;
}
s32 sceNgsPatchCreateRouting(vm::psv::ptr<const SceNgsPatchSetupInfo> pPatchInfo, vm::psv::ptr<SceNgsHPatch> pPatchHandle)
s32 sceNgsPatchCreateRouting(vm::ptr<const SceNgsPatchSetupInfo> pPatchInfo, vm::ptr<SceNgsHPatch> pPatchHandle)
{
throw __FUNCTION__;
}
s32 sceNgsPatchGetInfo(SceNgsHPatch hPatchHandle, vm::psv::ptr<SceNgsPatchRouteInfo> pRouteInfo, vm::psv::ptr<SceNgsPatchSetupInfo> pSetup)
s32 sceNgsPatchGetInfo(SceNgsHPatch hPatchHandle, vm::ptr<SceNgsPatchRouteInfo> pRouteInfo, vm::ptr<SceNgsPatchSetupInfo> pSetup)
{
throw __FUNCTION__;
}
s32 sceNgsVoiceGetOutputPatch(SceNgsHVoice hVoiceHandle, const s32 nOutputIndex, const s32 nSubIndex, vm::psv::ptr<SceNgsHPatch> pPatchHandle)
s32 sceNgsVoiceGetOutputPatch(SceNgsHVoice hVoiceHandle, const s32 nOutputIndex, const s32 nSubIndex, vm::ptr<SceNgsHPatch> pPatchHandle)
{
throw __FUNCTION__;
}
@ -288,112 +179,112 @@ s32 sceNgsPatchRemoveRouting(SceNgsHPatch hPatchHandle)
throw __FUNCTION__;
}
//s32 sceNgsVoicePatchSetVolume(SceNgsHPatch hPatchHandle, const s32 nOutputChannel, const s32 nInputChannel, const float fVol)
//{
// throw __FUNCTION__;
//}
s32 sceNgsVoicePatchSetVolumes(SceNgsHPatch hPatchHandle, const s32 nOutputChannel, vm::psv::ptr<const float> pVolumes, const s32 nVols)
s32 sceNgsVoicePatchSetVolume(SceNgsHPatch hPatchHandle, const s32 nOutputChannel, const s32 nInputChannel, const float fVol)
{
throw __FUNCTION__;
}
s32 sceNgsVoicePatchSetVolumesMatrix(SceNgsHPatch hPatchHandle, vm::psv::ptr<const SceNgsVolumeMatrix> pMatrix)
s32 sceNgsVoicePatchSetVolumes(SceNgsHPatch hPatchHandle, const s32 nOutputChannel, vm::ptr<const float> pVolumes, const s32 nVols)
{
throw __FUNCTION__;
}
s32 sceNgsModuleGetNumPresets(SceNgsHSynSystem hSystemHandle, const SceNgsModuleID uModuleID, vm::psv::ptr<u32> puNumPresets)
s32 sceNgsVoicePatchSetVolumesMatrix(SceNgsHPatch hPatchHandle, vm::ptr<const SceNgsVolumeMatrix> pMatrix)
{
throw __FUNCTION__;
}
s32 sceNgsModuleGetPreset(SceNgsHSynSystem hSystemHandle, const SceNgsModuleID uModuleID, const u32 uPresetIndex, vm::psv::ptr<SceNgsBufferInfo> pParamsBuffer)
s32 sceNgsModuleGetNumPresets(SceNgsHSynSystem hSystemHandle, const u32 uModuleID, vm::ptr<u32> puNumPresets)
{
throw __FUNCTION__;
}
vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetCompressorBuss()
s32 sceNgsModuleGetPreset(SceNgsHSynSystem hSystemHandle, const u32 uModuleID, const u32 uPresetIndex, vm::ptr<SceNgsBufferInfo> pParamsBuffer)
{
throw __FUNCTION__;
}
vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetCompressorSideChainBuss()
vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetCompressorBuss()
{
throw __FUNCTION__;
}
vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetDelayBuss()
vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetCompressorSideChainBuss()
{
throw __FUNCTION__;
}
vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetDistortionBuss()
vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetDelayBuss()
{
throw __FUNCTION__;
}
vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetEnvelopeBuss()
vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetDistortionBuss()
{
throw __FUNCTION__;
}
vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetEqBuss()
vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetEnvelopeBuss()
{
throw __FUNCTION__;
}
vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetMasterBuss()
vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetEqBuss()
{
throw __FUNCTION__;
}
vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetMixerBuss()
vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetMasterBuss()
{
throw __FUNCTION__;
}
vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetPauserBuss()
vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetMixerBuss()
{
throw __FUNCTION__;
}
vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetReverbBuss()
vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetPauserBuss()
{
throw __FUNCTION__;
}
vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetSasEmuVoice()
vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetReverbBuss()
{
throw __FUNCTION__;
}
vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetSimpleVoice()
vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetSasEmuVoice()
{
throw __FUNCTION__;
}
vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetTemplate1()
vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetSimpleVoice()
{
throw __FUNCTION__;
}
vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetAtrac9Voice()
vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetTemplate1()
{
throw __FUNCTION__;
}
s32 sceSulphaNgsGetDefaultConfig(vm::psv::ptr<SceSulphaNgsConfig> config)
vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetAtrac9Voice()
{
throw __FUNCTION__;
}
s32 sceSulphaNgsGetNeededMemory(vm::psv::ptr<const SceSulphaNgsConfig> config, vm::psv::ptr<u32> sizeInBytes)
s32 sceSulphaNgsGetDefaultConfig(vm::ptr<SceSulphaNgsConfig> config)
{
throw __FUNCTION__;
}
s32 sceSulphaNgsInit(vm::psv::ptr<const SceSulphaNgsConfig> config, vm::psv::ptr<void> buffer, u32 sizeInBytes)
s32 sceSulphaNgsGetNeededMemory(vm::ptr<const SceSulphaNgsConfig> config, vm::ptr<u32> sizeInBytes)
{
throw __FUNCTION__;
}
s32 sceSulphaNgsInit(vm::ptr<const SceSulphaNgsConfig> config, vm::ptr<void> buffer, u32 sizeInBytes)
{
throw __FUNCTION__;
}
@ -403,27 +294,27 @@ s32 sceSulphaNgsShutdown()
throw __FUNCTION__;
}
s32 sceSulphaNgsSetSynthName(SceNgsHSynSystem synthHandle, vm::psv::ptr<const char> name)
s32 sceSulphaNgsSetSynthName(SceNgsHSynSystem synthHandle, vm::ptr<const char> name)
{
throw __FUNCTION__;
}
s32 sceSulphaNgsSetRackName(SceNgsHRack rackHandle, vm::psv::ptr<const char> name)
s32 sceSulphaNgsSetRackName(SceNgsHRack rackHandle, vm::ptr<const char> name)
{
throw __FUNCTION__;
}
s32 sceSulphaNgsSetVoiceName(SceNgsHVoice voiceHandle, vm::psv::ptr<const char> name)
s32 sceSulphaNgsSetVoiceName(SceNgsHVoice voiceHandle, vm::ptr<const char> name)
{
throw __FUNCTION__;
}
s32 sceSulphaNgsSetSampleName(vm::psv::ptr<const void> location, u32 length, vm::psv::ptr<const char> name)
s32 sceSulphaNgsSetSampleName(vm::ptr<const void> location, u32 length, vm::ptr<const char> name)
{
throw __FUNCTION__;
}
s32 sceSulphaNgsTrace(vm::psv::ptr<const char> message)
s32 sceSulphaNgsTrace(vm::ptr<const char> message)
{
throw __FUNCTION__;
}
@ -436,6 +327,7 @@ psv_log_base sceNgs("SceNgs", []()
sceNgs.on_load = nullptr;
sceNgs.on_unload = nullptr;
sceNgs.on_stop = nullptr;
sceNgs.on_error = nullptr;
REG_FUNC(0x6CE8B36F, sceNgsSystemGetRequiredMemorySize);
REG_FUNC(0xED14CF4A, sceNgsSystemInit);

106
rpcs3/Emu/ARMv7/Modules/sceNgs.h Normal file
View File

@ -0,0 +1,106 @@
#pragma once
struct SceNgsVoiceDefinition;
using SceNgsHVoice = vm::ptr<void>;
using SceNgsHPatch = vm::ptr<void>;
using SceNgsHSynSystem = vm::ptr<void>;
using SceNgsHRack = vm::ptr<void>;
struct SceNgsModuleParamHeader
{
le_t<s32> moduleId;
le_t<s32> chan;
};
struct SceNgsParamsDescriptor
{
le_t<u32> id;
le_t<u32> size;
};
struct SceNgsBufferInfo
{
vm::lptr<void> data;
le_t<u32> size;
};
struct SceNgsVoicePreset
{
le_t<s32> nNameOffset;
le_t<u32> uNameLength;
le_t<s32> nPresetDataOffset;
le_t<u32> uSizePresetData;
le_t<s32> nBypassFlagsOffset;
le_t<u32> uNumBypassFlags;
};
struct SceNgsSystemInitParams
{
le_t<s32> nMaxRacks;
le_t<s32> nMaxVoices;
le_t<s32> nGranularity;
le_t<s32> nSampleRate;
le_t<s32> nMaxModules;
};
struct SceNgsRackDescription
{
vm::lptr<const SceNgsVoiceDefinition> pVoiceDefn;
le_t<s32> nVoices;
le_t<s32> nChannelsPerVoice;
le_t<s32> nMaxPatchesPerInput;
le_t<s32> nPatchesPerOutput;
vm::lptr<void> pUserReleaseData;
};
struct SceNgsPatchSetupInfo
{
SceNgsHVoice hVoiceSource;
le_t<s32> nSourceOutputIndex;
le_t<s32> nSourceOutputSubIndex;
SceNgsHVoice hVoiceDestination;
le_t<s32> nTargetInputIndex;
};
struct SceNgsVolumeMatrix
{
le_t<float> m[2][2];
};
struct SceNgsPatchRouteInfo
{
le_t<s32> nOutputChannels;
le_t<s32> nInputChannels;
SceNgsVolumeMatrix vols;
};
struct SceNgsVoiceInfo
{
le_t<u32> uVoiceState;
le_t<u32> uNumModules;
le_t<u32> uNumInputs;
le_t<u32> uNumOutputs;
le_t<u32> uNumPatchesPerOutput;
};
struct SceNgsCallbackInfo
{
SceNgsHVoice hVoiceHandle;
SceNgsHRack hRackHandle;
le_t<u32> uModuleID;
le_t<s32> nCallbackData;
le_t<s32> nCallbackData2;
vm::lptr<void> pCallbackPtr;
vm::lptr<void> pUserData;
};
using SceNgsCallbackFunc = func_def<void(vm::cptr<SceNgsCallbackInfo> pCallbackInfo)>;
struct SceSulphaNgsConfig
{
le_t<u32> maxNamedObjects;
le_t<u32> maxTraceBufferBytes;
};
extern psv_log_base sceNgs;

145
rpcs3/Emu/ARMv7/Modules/sceNpBasic.cpp
View File

@ -2,123 +2,9 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
#include "sceNpCommon.h"
#include "sceNpBasic.h"
extern psv_log_base sceNpBasic;
enum SceNpBasicFriendListEventType : s32
{
SCE_NP_BASIC_FRIEND_LIST_EVENT_TYPE_SYNC = 1,
SCE_NP_BASIC_FRIEND_LIST_EVENT_TYPE_SYNC_DONE = 2,
SCE_NP_BASIC_FRIEND_LIST_EVENT_TYPE_ADDED = 3,
SCE_NP_BASIC_FRIEND_LIST_EVENT_TYPE_DELETED = 4
};
typedef vm::psv::ptr<void(SceNpBasicFriendListEventType eventType, vm::psv::ptr<const SceNpId> friendId, vm::psv::ptr<void> userdata)> SceNpBasicFriendListEventHandler;
enum SceNpBasicFriendOnlineStatusEventType : s32
{
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_EVENT_TYPE_SYNC = 1,
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_EVENT_TYPE_SYNC_DONE = 2,
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_EVENT_TYPE_UPDATED = 3
};
enum SceNpBasicFriendOnlineStatus : s32
{
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_UNKNOWN = 0,
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_OFFLINE = 1,
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_STANDBY = 2,
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_ONLINE_OUT_OF_CONTEXT = 3,
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_ONLINE_IN_CONTEXT = 4
};
typedef vm::psv::ptr<void(SceNpBasicFriendOnlineStatusEventType eventType, vm::psv::ptr<const SceNpId> friendId, SceNpBasicFriendOnlineStatus status, vm::psv::ptr<void> userdata)> SceNpBasicFriendOnlineStatusEventHandler;
enum SceNpBasicBlockListEventType : s32
{
SCE_NP_BASIC_BLOCK_LIST_EVENT_TYPE_SYNC = 1,
SCE_NP_BASIC_BLOCK_LIST_EVENT_TYPE_SYNC_DONE = 2,
SCE_NP_BASIC_BLOCK_LIST_EVENT_TYPE_ADDED = 3,
SCE_NP_BASIC_BLOCK_LIST_EVENT_TYPE_DELETED = 4
};
typedef vm::psv::ptr<void(SceNpBasicBlockListEventType eventType, vm::psv::ptr<const SceNpId> playerId, vm::psv::ptr<void> userdata)> SceNpBasicBlockListEventHandler;
enum SceNpBasicFriendGamePresenceEventType : s32
{
SCE_NP_BASIC_FRIEND_GAME_PRESENCE_EVENT_TYPE_SYNC = 1,
SCE_NP_BASIC_FRIEND_GAME_PRESENCE_EVENT_TYPE_SYNC_DONE = 2,
SCE_NP_BASIC_FRIEND_GAME_PRESENCE_EVENT_TYPE_UPDATED = 3
};
enum SceNpBasicInGamePresenceType
{
SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_UNKNOWN = -1,
SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_NONE = 0,
SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_DEFAULT = 1,
SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_JOINABLE = 2,
SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_MAX = 3
};
struct SceNpBasicInGamePresence
{
u32 sdkVersion;
SceNpBasicInGamePresenceType type;
char status[192];
u8 data[128];
u32 dataSize;
};
struct SceNpBasicGamePresence
{
u32 size;
char title[128];
SceNpBasicInGamePresence inGamePresence;
};
typedef vm::psv::ptr<void(SceNpBasicFriendGamePresenceEventType eventtype, vm::psv::ptr<const SceNpId> friendId, vm::psv::ptr<const SceNpBasicGamePresence> presence, vm::psv::ptr<void> userdata)> SceNpBasicFriendGamePresenceEventHandler;
struct SceNpBasicInGameDataMessage
{
u8 data[128];
u32 dataSize;
};
typedef vm::psv::ptr<void(vm::psv::ptr<const SceNpId> from, vm::psv::ptr<const SceNpBasicInGameDataMessage> message, vm::psv::ptr<void> userdata)> SceNpBasicInGameDataMessageEventHandler;
struct SceNpBasicEventHandlers
{
u32 sdkVersion;
SceNpBasicFriendListEventHandler friendListEventHandler;
SceNpBasicFriendOnlineStatusEventHandler friendOnlineStatusEventHandler;
SceNpBasicBlockListEventHandler blockListEventHandler;
SceNpBasicFriendGamePresenceEventHandler friendGamePresenceEventHandler;
SceNpBasicInGameDataMessageEventHandler inGameDataMessageEventHandler;
};
struct SceNpBasicPlaySessionLogDescription
{
char text[512];
};
struct SceNpBasicPlaySessionLog
{
u64 date;
SceNpId withWhom;
SceNpCommunicationId commId;
char title[128];
SceNpBasicPlaySessionLogDescription description;
};
enum SceNpBasicPlaySessionLogType : s32
{
SCE_NP_BASIC_PLAY_SESSION_LOG_TYPE_INVALID = -1,
SCE_NP_BASIC_PLAY_SESSION_LOG_TYPE_ALL = 0,
SCE_NP_BASIC_PLAY_SESSION_LOG_TYPE_BY_NP_COMM_ID = 1,
SCE_NP_BASIC_PLAY_SESSION_LOG_TYPE_MAX = 2
};
s32 sceNpBasicInit(vm::psv::ptr<void> opt)
s32 sceNpBasicInit(vm::ptr<void> opt)
{
throw __FUNCTION__;
}
@ -128,7 +14,7 @@ s32 sceNpBasicTerm(ARMv7Context&)
throw __FUNCTION__;
}
s32 sceNpBasicRegisterHandler(vm::psv::ptr<const SceNpBasicEventHandlers> handlers, vm::psv::ptr<const SceNpCommunicationId> context, vm::psv::ptr<void> userdata)
s32 sceNpBasicRegisterHandler(vm::ptr<const SceNpBasicEventHandlers> handlers, vm::ptr<const SceNpCommunicationId> context, vm::ptr<void> userdata)
{
throw __FUNCTION__;
}
@ -143,42 +29,42 @@ s32 sceNpBasicCheckCallback()
throw __FUNCTION__;
}
s32 sceNpBasicGetFriendOnlineStatus(vm::psv::ptr<const SceNpId> friendId, vm::psv::ptr<SceNpBasicFriendOnlineStatus> status)
s32 sceNpBasicGetFriendOnlineStatus(vm::ptr<const SceNpId> friendId, vm::ptr<SceNpBasicFriendOnlineStatus> status)
{
throw __FUNCTION__;
}
s32 sceNpBasicGetGamePresenceOfFriend(vm::psv::ptr<const SceNpId> friendId, vm::psv::ptr<SceNpBasicGamePresence> presence)
s32 sceNpBasicGetGamePresenceOfFriend(vm::ptr<const SceNpId> friendId, vm::ptr<SceNpBasicGamePresence> presence)
{
throw __FUNCTION__;
}
s32 sceNpBasicGetFriendListEntryCount(vm::psv::ptr<u32> count)
s32 sceNpBasicGetFriendListEntryCount(vm::ptr<u32> count)
{
throw __FUNCTION__;
}
s32 sceNpBasicGetFriendListEntries(u32 startIndex, vm::psv::ptr<SceNpId> entries, u32 numEntries, vm::psv::ptr<u32> retrieved)
s32 sceNpBasicGetFriendListEntries(u32 startIndex, vm::ptr<SceNpId> entries, u32 numEntries, vm::ptr<u32> retrieved)
{
throw __FUNCTION__;
}
s32 sceNpBasicGetBlockListEntryCount(vm::psv::ptr<u32> count)
s32 sceNpBasicGetBlockListEntryCount(vm::ptr<u32> count)
{
throw __FUNCTION__;
}
s32 sceNpBasicGetBlockListEntries(u32 startIndex, vm::psv::ptr<SceNpId> entries, u32 numEntries, vm::psv::ptr<u32> retrieved)
s32 sceNpBasicGetBlockListEntries(u32 startIndex, vm::ptr<SceNpId> entries, u32 numEntries, vm::ptr<u32> retrieved)
{
throw __FUNCTION__;
}
s32 sceNpBasicCheckIfPlayerIsBlocked(vm::psv::ptr<const SceNpId> player, vm::psv::ptr<u8> playerIsBlocked)
s32 sceNpBasicCheckIfPlayerIsBlocked(vm::ptr<const SceNpId> player, vm::ptr<u8> playerIsBlocked)
{
throw __FUNCTION__;
}
s32 sceNpBasicSetInGamePresence(vm::psv::ptr<const SceNpBasicInGamePresence> presence)
s32 sceNpBasicSetInGamePresence(vm::ptr<const SceNpBasicInGamePresence> presence)
{
throw __FUNCTION__;
}
@ -188,22 +74,22 @@ s32 sceNpBasicUnsetInGamePresence()
throw __FUNCTION__;
}
s32 sceNpBasicSendInGameDataMessage(vm::psv::ptr<const SceNpId> to, vm::psv::ptr<const SceNpBasicInGameDataMessage> message)
s32 sceNpBasicSendInGameDataMessage(vm::ptr<const SceNpId> to, vm::ptr<const SceNpBasicInGameDataMessage> message)
{
throw __FUNCTION__;
}
s32 sceNpBasicRecordPlaySessionLog(vm::psv::ptr<const SceNpId> withWhom, vm::psv::ptr<const SceNpBasicPlaySessionLogDescription> description)
s32 sceNpBasicRecordPlaySessionLog(vm::ptr<const SceNpId> withWhom, vm::ptr<const SceNpBasicPlaySessionLogDescription> description)
{
throw __FUNCTION__;
}
s32 sceNpBasicGetPlaySessionLogSize(SceNpBasicPlaySessionLogType type, vm::psv::ptr<u32> size)
s32 sceNpBasicGetPlaySessionLogSize(SceNpBasicPlaySessionLogType type, vm::ptr<u32> size)
{
throw __FUNCTION__;
}
s32 sceNpBasicGetPlaySessionLog(SceNpBasicPlaySessionLogType type, u32 index, vm::psv::ptr<SceNpBasicPlaySessionLog> log)
s32 sceNpBasicGetPlaySessionLog(SceNpBasicPlaySessionLogType type, u32 index, vm::ptr<SceNpBasicPlaySessionLog> log)
{
throw __FUNCTION__;
}
@ -215,6 +101,7 @@ psv_log_base sceNpBasic("SceNpBasic", []()
sceNpBasic.on_load = nullptr;
sceNpBasic.on_unload = nullptr;
sceNpBasic.on_stop = nullptr;
sceNpBasic.on_error = nullptr;
REG_FUNC(0xEFB91A99, sceNpBasicInit);
REG_FUNC(0x389BCB3B, sceNpBasicTerm);

117
rpcs3/Emu/ARMv7/Modules/sceNpBasic.h Normal file
View File

@ -0,0 +1,117 @@
#pragma once
#include "sceNpCommon.h"
enum SceNpBasicFriendListEventType : s32
{
SCE_NP_BASIC_FRIEND_LIST_EVENT_TYPE_SYNC = 1,
SCE_NP_BASIC_FRIEND_LIST_EVENT_TYPE_SYNC_DONE = 2,
SCE_NP_BASIC_FRIEND_LIST_EVENT_TYPE_ADDED = 3,
SCE_NP_BASIC_FRIEND_LIST_EVENT_TYPE_DELETED = 4
};
using SceNpBasicFriendListEventHandler = func_def<void(SceNpBasicFriendListEventType eventType, vm::cptr<SceNpId> friendId, vm::ptr<void> userdata)>;
enum SceNpBasicFriendOnlineStatusEventType : s32
{
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_EVENT_TYPE_SYNC = 1,
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_EVENT_TYPE_SYNC_DONE = 2,
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_EVENT_TYPE_UPDATED = 3
};
enum SceNpBasicFriendOnlineStatus : s32
{
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_UNKNOWN = 0,
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_OFFLINE = 1,
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_STANDBY = 2,
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_ONLINE_OUT_OF_CONTEXT = 3,
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_ONLINE_IN_CONTEXT = 4
};
using SceNpBasicFriendOnlineStatusEventHandler = func_def<void(SceNpBasicFriendOnlineStatusEventType eventType, vm::cptr<SceNpId> friendId, SceNpBasicFriendOnlineStatus status, vm::ptr<void> userdata)>;
enum SceNpBasicBlockListEventType : s32
{
SCE_NP_BASIC_BLOCK_LIST_EVENT_TYPE_SYNC = 1,
SCE_NP_BASIC_BLOCK_LIST_EVENT_TYPE_SYNC_DONE = 2,
SCE_NP_BASIC_BLOCK_LIST_EVENT_TYPE_ADDED = 3,
SCE_NP_BASIC_BLOCK_LIST_EVENT_TYPE_DELETED = 4
};
using SceNpBasicBlockListEventHandler = func_def<void(SceNpBasicBlockListEventType eventType, vm::cptr<SceNpId> playerId, vm::ptr<void> userdata)>;
enum SceNpBasicFriendGamePresenceEventType : s32
{
SCE_NP_BASIC_FRIEND_GAME_PRESENCE_EVENT_TYPE_SYNC = 1,
SCE_NP_BASIC_FRIEND_GAME_PRESENCE_EVENT_TYPE_SYNC_DONE = 2,
SCE_NP_BASIC_FRIEND_GAME_PRESENCE_EVENT_TYPE_UPDATED = 3
};
enum SceNpBasicInGamePresenceType : s32
{
SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_UNKNOWN = -1,
SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_NONE = 0,
SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_DEFAULT = 1,
SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_JOINABLE = 2,
SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_MAX = 3
};
struct SceNpBasicInGamePresence
{
le_t<u32> sdkVersion;
le_t<s32> type; // SceNpBasicInGamePresenceType
char status[192];
u8 data[128];
le_t<u32> dataSize;
};
struct SceNpBasicGamePresence
{
le_t<u32> size;
char title[128];
SceNpBasicInGamePresence inGamePresence;
};
using SceNpBasicFriendGamePresenceEventHandler = func_def<void(SceNpBasicFriendGamePresenceEventType eventtype, vm::cptr<SceNpId> friendId, vm::cptr<SceNpBasicGamePresence> presence, vm::ptr<void> userdata)>;
struct SceNpBasicInGameDataMessage
{
u8 data[128];
le_t<u32> dataSize;
};
using SceNpBasicInGameDataMessageEventHandler = func_def<void(vm::cptr<SceNpId> from, vm::cptr<SceNpBasicInGameDataMessage> message, vm::ptr<void> userdata)>;
struct SceNpBasicEventHandlers
{
le_t<u32> sdkVersion;
vm::lptr<SceNpBasicFriendListEventHandler> friendListEventHandler;
vm::lptr<SceNpBasicFriendOnlineStatusEventHandler> friendOnlineStatusEventHandler;
vm::lptr<SceNpBasicBlockListEventHandler> blockListEventHandler;
vm::lptr<SceNpBasicFriendGamePresenceEventHandler> friendGamePresenceEventHandler;
vm::lptr<SceNpBasicInGameDataMessageEventHandler> inGameDataMessageEventHandler;
};
struct SceNpBasicPlaySessionLogDescription
{
char text[512];
};
struct SceNpBasicPlaySessionLog
{
le_t<u64> date;
SceNpId withWhom;
SceNpCommunicationId commId;
char title[128];
SceNpBasicPlaySessionLogDescription description;
};
enum SceNpBasicPlaySessionLogType : s32
{
SCE_NP_BASIC_PLAY_SESSION_LOG_TYPE_INVALID = -1,
SCE_NP_BASIC_PLAY_SESSION_LOG_TYPE_ALL = 0,
SCE_NP_BASIC_PLAY_SESSION_LOG_TYPE_BY_NP_COMM_ID = 1,
SCE_NP_BASIC_PLAY_SESSION_LOG_TYPE_MAX = 2
};
extern psv_log_base sceNpBasic;

19
rpcs3/Emu/ARMv7/Modules/sceNpCommon.cpp
View File

@ -14,47 +14,47 @@ s32 sceNpAuthTerm()
throw __FUNCTION__;
}
s32 sceNpAuthCreateStartRequest(vm::psv::ptr<const SceNpAuthRequestParameter> param)
s32 sceNpAuthCreateStartRequest(vm::ptr<const SceNpAuthRequestParameter> param)
{
throw __FUNCTION__;
}
s32 sceNpAuthDestroyRequest(SceNpAuthRequestId id)
s32 sceNpAuthDestroyRequest(s32 id)
{
throw __FUNCTION__;
}
s32 sceNpAuthAbortRequest(SceNpAuthRequestId id)
s32 sceNpAuthAbortRequest(s32 id)
{
throw __FUNCTION__;
}
s32 sceNpAuthGetTicket(SceNpAuthRequestId id, vm::psv::ptr<void> buf, u32 len)
s32 sceNpAuthGetTicket(s32 id, vm::ptr<void> buf, u32 len)
{
throw __FUNCTION__;
}
s32 sceNpAuthGetTicketParam(vm::psv::ptr<const u8> ticket, u32 ticketSize, s32 paramId, vm::psv::ptr<SceNpTicketParam> param)
s32 sceNpAuthGetTicketParam(vm::ptr<const u8> ticket, u32 ticketSize, s32 paramId, vm::ptr<SceNpTicketParam> param)
{
throw __FUNCTION__;
}
s32 sceNpAuthGetEntitlementIdList(vm::psv::ptr<const u8> ticket, u32 ticketSize, vm::psv::ptr<SceNpEntitlementId> entIdList, u32 entIdListNum)
s32 sceNpAuthGetEntitlementIdList(vm::ptr<const u8> ticket, u32 ticketSize, vm::ptr<SceNpEntitlementId> entIdList, u32 entIdListNum)
{
throw __FUNCTION__;
}
s32 sceNpAuthGetEntitlementById(vm::psv::ptr<const u8> ticket, u32 ticketSize, vm::psv::ptr<const char> entId, vm::psv::ptr<SceNpEntitlement> ent)
s32 sceNpAuthGetEntitlementById(vm::ptr<const u8> ticket, u32 ticketSize, vm::ptr<const char> entId, vm::ptr<SceNpEntitlement> ent)
{
throw __FUNCTION__;
}
s32 sceNpCmpNpId(vm::psv::ptr<const SceNpId> npid1, vm::psv::ptr<const SceNpId> npid2)
s32 sceNpCmpNpId(vm::ptr<const SceNpId> npid1, vm::ptr<const SceNpId> npid2)
{
throw __FUNCTION__;
}
s32 sceNpCmpNpIdInOrder(vm::psv::ptr<const SceNpId> npid1, vm::psv::ptr<const SceNpId> npid2, vm::psv::ptr<s32> order)
s32 sceNpCmpNpIdInOrder(vm::ptr<const SceNpId> npid1, vm::ptr<const SceNpId> npid2, vm::ptr<s32> order)
{
throw __FUNCTION__;
}
@ -66,6 +66,7 @@ psv_log_base sceNpCommon("SceNpCommon", []()
sceNpCommon.on_load = nullptr;
sceNpCommon.on_unload = nullptr;
sceNpCommon.on_stop = nullptr;
sceNpCommon.on_error = nullptr;
REG_FUNC(0x441D8B4E, sceNpAuthInit);
REG_FUNC(0x6093B689, sceNpAuthTerm);

59
rpcs3/Emu/ARMv7/Modules/sceNpCommon.h
View File

@ -28,9 +28,9 @@ struct SceNpCommunicationSignature
struct SceNpCommunicationConfig
{
vm::psv::ptr<const SceNpCommunicationId> commId;
vm::psv::ptr<const SceNpCommunicationPassphrase> commPassphrase;
vm::psv::ptr<const SceNpCommunicationSignature> commSignature;
vm::lptr<const SceNpCommunicationId> commId;
vm::lptr<const SceNpCommunicationPassphrase> commPassphrase;
vm::lptr<const SceNpCommunicationSignature> commSignature;
};
struct SceNpCountryCode
@ -69,16 +69,16 @@ struct SceNpUserInformation
struct SceNpMyLanguages
{
s32 language1;
s32 language2;
s32 language3;
le_t<s32> language1;
le_t<s32> language2;
le_t<s32> language3;
u8 padding[4];
};
struct SceNpAvatarImage
{
u8 data[200 * 1024];
u32 size;
le_t<u32> size;
u8 reserved[12];
};
@ -94,45 +94,42 @@ struct SceNpAboutMe
char data[64];
};
typedef s32 SceNpAuthRequestId;
typedef u64 SceNpTime;
struct SceNpDate
{
u16 year;
le_t<u16> year;
u8 month;
u8 day;
};
union SceNpTicketParam
{
s32 _s32;
s64 _s64;
u32 _u32;
u64 _u64;
le_t<s32> _s32;
le_t<s64> _s64;
le_t<u32> _u32;
le_t<u64> _u64;
SceNpDate date;
u8 data[256];
};
struct SceNpTicketVersion
{
u16 major;
u16 minor;
le_t<u16> major;
le_t<u16> minor;
};
typedef vm::psv::ptr<s32(SceNpAuthRequestId id, s32 result, vm::psv::ptr<void> arg)> SceNpAuthCallback;
using SceNpAuthCallback = func_def<s32(s32 id, s32 result, vm::ptr<void> arg)>;
struct SceNpAuthRequestParameter
{
u32 size;
le_t<u32> size;
SceNpTicketVersion version;
vm::psv::ptr<const char> serviceId;
vm::psv::ptr<const void> cookie;
u32 cookieSize;
vm::psv::ptr<const char> entitlementId;
u32 consumedCount;
SceNpAuthCallback ticketCb;
vm::psv::ptr<void> cbArg;
vm::lptr<const char> serviceId;
vm::lptr<const void> cookie;
le_t<u32> cookieSize;
vm::lptr<const char> entitlementId;
le_t<u32> consumedCount;
vm::lptr<SceNpAuthCallback> ticketCb;
vm::lptr<void> cbArg;
};
struct SceNpEntitlementId
@ -143,11 +140,11 @@ struct SceNpEntitlementId
struct SceNpEntitlement
{
SceNpEntitlementId id;
SceNpTime createdDate;
SceNpTime expireDate;
u32 type;
s32 remainingCount;
u32 consumedCount;
le_t<u64> createdDate;
le_t<u64> expireDate;
le_t<u32> type;
le_t<s32> remainingCount;
le_t<u32> consumedCount;
char padding[4];
};

26
rpcs3/Emu/ARMv7/Modules/sceNpManager.cpp
View File

@ -2,18 +2,9 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
#include "sceNpCommon.h"
#include "sceNpManager.h"
extern psv_log_base sceNpManager;
struct SceNpOptParam
{
u32 optParamSize;
};
typedef vm::psv::ptr<void(SceNpServiceState state, vm::psv::ptr<void> userdata)> SceNpServiceStateCallback;
s32 sceNpInit(vm::psv::ptr<const SceNpCommunicationConfig> commConf, vm::psv::ptr<SceNpOptParam> opt)
s32 sceNpInit(vm::ptr<const SceNpCommunicationConfig> commConf, vm::ptr<SceNpOptParam> opt)
{
throw __FUNCTION__;
}
@ -28,12 +19,12 @@ s32 sceNpCheckCallback()
throw __FUNCTION__;
}
s32 sceNpGetServiceState(vm::psv::ptr<SceNpServiceState> state)
s32 sceNpGetServiceState(vm::ptr<SceNpServiceState> state)
{
throw __FUNCTION__;
}
s32 sceNpRegisterServiceStateCallback(SceNpServiceStateCallback callback, vm::psv::ptr<void> userdata)
s32 sceNpRegisterServiceStateCallback(vm::ptr<SceNpServiceStateCallback> callback, vm::ptr<void> userdata)
{
throw __FUNCTION__;
}
@ -43,22 +34,22 @@ s32 sceNpUnregisterServiceStateCallback()
throw __FUNCTION__;
}
s32 sceNpManagerGetNpId(vm::psv::ptr<SceNpId> npId)
s32 sceNpManagerGetNpId(vm::ptr<SceNpId> npId)
{
throw __FUNCTION__;
}
s32 sceNpManagerGetAccountRegion(vm::psv::ptr<SceNpCountryCode> countryCode, vm::psv::ptr<s32> languageCode)
s32 sceNpManagerGetAccountRegion(vm::ptr<SceNpCountryCode> countryCode, vm::ptr<s32> languageCode)
{
throw __FUNCTION__;
}
s32 sceNpManagerGetContentRatingFlag(vm::psv::ptr<s32> isRestricted, vm::psv::ptr<s32> age)
s32 sceNpManagerGetContentRatingFlag(vm::ptr<s32> isRestricted, vm::ptr<s32> age)
{
throw __FUNCTION__;
}
s32 sceNpManagerGetChatRestrictionFlag(vm::psv::ptr<s32> isRestricted)
s32 sceNpManagerGetChatRestrictionFlag(vm::ptr<s32> isRestricted)
{
throw __FUNCTION__;
}
@ -70,6 +61,7 @@ psv_log_base sceNpManager("SceNpManager", []()
sceNpManager.on_load = nullptr;
sceNpManager.on_unload = nullptr;
sceNpManager.on_stop = nullptr;
sceNpManager.on_error = nullptr;
REG_FUNC(0x04D9F484, sceNpInit);
REG_FUNC(0x19E40AE1, sceNpTerm);

12
rpcs3/Emu/ARMv7/Modules/sceNpManager.h Normal file
View File

@ -0,0 +1,12 @@
#pragma once
#include "sceNpCommon.h"
struct SceNpOptParam
{
le_t<u32> optParamSize;
};
using SceNpServiceStateCallback = func_def<void(SceNpServiceState state, vm::ptr<void> userdata)>;
extern psv_log_base sceNpManager;

1233
rpcs3/Emu/ARMv7/Modules/sceNpMatching.cpp
View File

File diff suppressed because it is too large Load Diff

989
rpcs3/Emu/ARMv7/Modules/sceNpMatching.h Normal file
View File

@ -0,0 +1,989 @@
#pragma once
#include "sceNet.h"
#include "sceNpCommon.h"
struct SceNpMatching2MemoryInfo
{
le_t<u32> totalMemSize;
le_t<u32> curMemUsage;
le_t<u32> maxMemUsage;
u8 reserved[12];
};
struct SceNpMatching2SessionPassword
{
u8 data[8];
};
struct SceNpMatching2PresenceOptionData
{
u8 data[16];
le_t<u32> len;
};
struct SceNpMatching2IntAttr
{
le_t<u16> id;
u8 padding[2];
le_t<u32> num;
};
struct SceNpMatching2BinAttr
{
le_t<u16> id;
u8 padding[2];
vm::lptr<void> ptr;
le_t<u32> size;
};
struct SceNpMatching2RangeFilter
{
le_t<u32> startIndex;
le_t<u32> max;
};
struct SceNpMatching2IntSearchFilter
{
u8 searchOperator;
u8 padding[3];
SceNpMatching2IntAttr attr;
};
struct SceNpMatching2BinSearchFilter
{
u8 searchOperator;
u8 padding[3];
SceNpMatching2BinAttr attr;
};
struct SceNpMatching2Range
{
le_t<u32> startIndex;
le_t<u32> total;
le_t<u32> resultCount;
};
struct SceNpMatching2JoinedSessionInfo
{
u8 sessionType;
u8 padding1[1];
le_t<u16> serverId;
le_t<u32> worldId;
le_t<u64> lobbyId;
le_t<u64> roomId;
le_t<u64> joinDate;
};
struct SceNpMatching2UserInfo
{
vm::lptr<SceNpMatching2UserInfo> next;
SceNpId npId;
vm::lptr<SceNpMatching2BinAttr> userBinAttr;
le_t<u32> userBinAttrNum;
vm::lptr<SceNpMatching2JoinedSessionInfo> joinedSessionInfo;
le_t<u32> joinedSessionInfoNum;
};
struct SceNpMatching2Server
{
le_t<u16> serverId;
u8 status;
u8 padding[1];
};
struct SceNpMatching2World
{
vm::lptr<SceNpMatching2World> next;
le_t<u32> worldId;
le_t<u32> numOfLobby;
le_t<u32> maxNumOfTotalLobbyMember;
le_t<u32> curNumOfTotalLobbyMember;
le_t<u32> curNumOfRoom;
le_t<u32> curNumOfTotalRoomMember;
bool withEntitlementId;
SceNpEntitlementId entitlementId;
u8 padding[3];
};
struct SceNpMatching2LobbyMemberBinAttrInternal
{
le_t<u64> updateDate;
SceNpMatching2BinAttr data;
u8 padding[4];
};
struct SceNpMatching2LobbyMemberDataInternal
{
vm::lptr<SceNpMatching2LobbyMemberDataInternal> next;
SceNpId npId;
le_t<u64> joinDate;
le_t<u16> memberId;
u8 padding[2];
le_t<u32> flagAttr;
vm::lptr<SceNpMatching2JoinedSessionInfo> joinedSessionInfo;
le_t<u32> joinedSessionInfoNum;
vm::lptr<SceNpMatching2LobbyMemberBinAttrInternal> lobbyMemberBinAttrInternal;
le_t<u32> lobbyMemberBinAttrInternalNum;
};
struct SceNpMatching2LobbyMemberIdList
{
vm::lptr<u16> memberId;
le_t<u32> memberIdNum;
le_t<u16> me;
u8 padding[6];
};
struct SceNpMatching2LobbyBinAttrInternal
{
le_t<u64> updateDate;
le_t<u16> updateMemberId;
u8 padding[2];
SceNpMatching2BinAttr data;
};
struct SceNpMatching2LobbyDataExternal
{
vm::lptr<SceNpMatching2LobbyDataExternal> next;
le_t<u16> serverId;
u8 padding1[2];
le_t<u32> worldId;
u8 padding2[4];
le_t<u64> lobbyId;
le_t<u32> maxSlot;
le_t<u32> curMemberNum;
le_t<u32> flagAttr;
vm::lptr<SceNpMatching2IntAttr> lobbySearchableIntAttrExternal;
le_t<u32> lobbySearchableIntAttrExternalNum;
vm::lptr<SceNpMatching2BinAttr> lobbySearchableBinAttrExternal;
le_t<u32> lobbySearchableBinAttrExternalNum;
vm::lptr<SceNpMatching2BinAttr> lobbyBinAttrExternal;
le_t<u32> lobbyBinAttrExternalNum;
u8 padding3[4];
};
struct SceNpMatching2LobbyDataInternal
{
le_t<u16> serverId;
u8 padding1[2];
le_t<u32> worldId;
le_t<u64> lobbyId;
le_t<u32> maxSlot;
SceNpMatching2LobbyMemberIdList memberIdList;
le_t<u32> flagAttr;
vm::lptr<SceNpMatching2LobbyBinAttrInternal> lobbyBinAttrInternal;
le_t<u32> lobbyBinAttrInternalNum;
};
union SceNpMatching2LobbyMessageDestination
{
le_t<u16> unicastTarget;
struct
{
vm::lptr<u16> memberId;
le_t<u32> memberIdNum;
}
multicastTarget;
};
struct SceNpMatching2GroupLabel
{
u8 data[8];
};
struct SceNpMatching2RoomGroupConfig
{
le_t<u32> slotNum;
bool withLabel;
SceNpMatching2GroupLabel label;
bool withPassword;
u8 padding[2];
};
struct SceNpMatching2RoomGroupPasswordConfig
{
u8 groupId;
bool withPassword;
u8 padding[1];
};
struct SceNpMatching2RoomMemberBinAttrInternal
{
le_t<u64> updateDate;
SceNpMatching2BinAttr data;
u8 padding[4];
};
struct SceNpMatching2RoomGroup
{
u8 groupId;
bool withPassword;
bool withLabel;
u8 padding[1];
SceNpMatching2GroupLabel label;
le_t<u32> slotNum;
le_t<u32> curGroupMemberNum;
};
struct SceNpMatching2RoomMemberDataExternal
{
vm::lptr<SceNpMatching2RoomMemberDataExternal> next;
SceNpId npId;
le_t<u64> joinDate;
u8 role;
u8 padding[7];
};
struct SceNpMatching2RoomMemberDataInternal
{
vm::lptr<SceNpMatching2RoomMemberDataInternal> next;
SceNpId npId;
le_t<u64> joinDate;
le_t<u16> memberId;
u8 teamId;
u8 padding1[1];
vm::lptr<SceNpMatching2RoomGroup> roomGroup;
u8 natType;
u8 padding2[3];
le_t<u32> flagAttr;
vm::lptr<SceNpMatching2RoomMemberBinAttrInternal> roomMemberBinAttrInternal;
le_t<u32> roomMemberBinAttrInternalNum;
};
struct SceNpMatching2RoomMemberDataInternalList
{
vm::lptr<SceNpMatching2RoomMemberDataInternal> members;
le_t<u32> membersNum;
vm::lptr<SceNpMatching2RoomMemberDataInternal> me;
vm::lptr<SceNpMatching2RoomMemberDataInternal> owner;
};
struct SceNpMatching2RoomBinAttrInternal
{
le_t<u64> updateDate;
le_t<u16> updateMemberId;
u8 padding[2];
SceNpMatching2BinAttr data;
};
struct SceNpMatching2RoomDataExternal
{
vm::lptr<SceNpMatching2RoomDataExternal> next;
le_t<u16> maxSlot;
le_t<u16> curMemberNum;
le_t<u16> serverId;
u8 padding[2];
le_t<u32> worldId;
le_t<u64> lobbyId;
le_t<u64> roomId;
le_t<u64> passwordSlotMask;
le_t<u64> joinedSlotMask;
le_t<u16> publicSlotNum;
le_t<u16> privateSlotNum;
le_t<u16> openPublicSlotNum;
le_t<u16> openPrivateSlotNum;
vm::lptr<SceNpId> owner;
le_t<u32> flagAttr;
vm::lptr<SceNpMatching2RoomGroup> roomGroup;
le_t<u32> roomGroupNum;
vm::lptr<SceNpMatching2IntAttr> roomSearchableIntAttrExternal;
le_t<u32> roomSearchableIntAttrExternalNum;
vm::lptr<SceNpMatching2BinAttr> roomSearchableBinAttrExternal;
le_t<u32> roomSearchableBinAttrExternalNum;
vm::lptr<SceNpMatching2BinAttr> roomBinAttrExternal;
le_t<u32> roomBinAttrExternalNum;
};
struct SceNpMatching2RoomDataInternal
{
le_t<u16> maxSlot;
le_t<u16> serverId;
le_t<u32> worldId;
le_t<u64> lobbyId;
le_t<u64> roomId;
le_t<u64> passwordSlotMask;
le_t<u64> joinedSlotMask;
le_t<u16> publicSlotNum;
le_t<u16> privateSlotNum;
le_t<u16> openPublicSlotNum;
le_t<u16> openPrivateSlotNum;
SceNpMatching2RoomMemberDataInternalList memberList;
vm::lptr<SceNpMatching2RoomGroup> roomGroup;
le_t<u32> roomGroupNum;
le_t<u32> flagAttr;
u8 padding[4];
vm::lptr<SceNpMatching2RoomBinAttrInternal> roomBinAttrInternal;
le_t<u32> roomBinAttrInternalNum;
};
union SceNpMatching2RoomMessageDestination
{
le_t<u16> unicastTarget;
struct
{
vm::lptr<u16> memberId;
le_t<u32> memberIdNum;
}
multicastTarget;
u8 multicastTargetTeamId;
};
struct SceNpMatching2InvitationData
{
vm::lptr<SceNpMatching2JoinedSessionInfo> targetSession;
le_t<u32> targetSessionNum;
vm::lptr<void> optData;
le_t<u32> optDataLen;
};
using SceNpMatching2RequestCallback = func_def<void(u16 ctxId, u32 reqId, u16 event, s32 errorCode, vm::cptr<void> data, vm::ptr<void> arg)>;
using SceNpMatching2LobbyEventCallback = func_def<void(u16 ctxId, u64 lobbyId, u16 event, s32 errorCode, vm::cptr<void> data, vm::ptr<void> arg)>;
using SceNpMatching2RoomEventCallback = func_def<void(u16 ctxId, u64 roomId, u16 event, s32 errorCode, vm::cptr<void> data, vm::ptr<void> arg)>;
using SceNpMatching2LobbyMessageCallback = func_def<void(u16 ctxId, u64 lobbyId, u16 srcMemberId, u16 event, s32 errorCode, vm::cptr<void> data, vm::ptr<void> arg)>;
using SceNpMatching2RoomMessageCallback = func_def<void(u16 ctxId, u64 roomId, u16 srcMemberId, u16 event, s32 errorCode, vm::cptr<void> data, vm::ptr<void> arg)>;
using SceNpMatching2SignalingCallback = func_def<void(u16 ctxId, u64 roomId, u16 peerMemberId, u16 event, s32 errorCode, vm::ptr<void> arg)>;
using SceNpMatching2ContextCallback = func_def<void(u16 ctxId, u16 event, u8 eventCause, s32 errorCode, vm::ptr<void> arg)>;
struct SceNpMatching2RequestOptParam
{
vm::lptr<SceNpMatching2RequestCallback> cbFunc;
vm::lptr<void> cbFuncArg;
le_t<u32> timeout;
le_t<u16> appReqId;
u8 padding[2];
};
struct SceNpMatching2GetWorldInfoListRequest
{
le_t<u16> serverId;
};
struct SceNpMatching2GetWorldInfoListResponse
{
vm::lptr<SceNpMatching2World> world;
le_t<u32> worldNum;
};
struct SceNpMatching2SetUserInfoRequest
{
le_t<u16> serverId;
u8 padding[2];
vm::lptr<SceNpMatching2BinAttr> userBinAttr;
le_t<u32> userBinAttrNum;
};
struct SceNpMatching2GetUserInfoListRequest
{
le_t<u16> serverId;
u8 padding[2];
vm::lptr<SceNpId> npId;
le_t<u32> npIdNum;
vm::lptr<u16> attrId;
le_t<u32> attrIdNum;
le_t<s32> option;
};
struct SceNpMatching2GetUserInfoListResponse
{
vm::lptr<SceNpMatching2UserInfo> userInfo;
le_t<u32> userInfoNum;
};
struct SceNpMatching2GetRoomMemberDataExternalListRequest
{
le_t<u64> roomId;
};
struct SceNpMatching2GetRoomMemberDataExternalListResponse
{
vm::lptr<SceNpMatching2RoomMemberDataExternal> roomMemberDataExternal;
le_t<u32> roomMemberDataExternalNum;
};
struct SceNpMatching2SetRoomDataExternalRequest
{
le_t<u64> roomId;
vm::lptr<SceNpMatching2IntAttr> roomSearchableIntAttrExternal;
le_t<u32> roomSearchableIntAttrExternalNum;
vm::lptr<SceNpMatching2BinAttr> roomSearchableBinAttrExternal;
le_t<u32> roomSearchableBinAttrExternalNum;
vm::lptr<SceNpMatching2BinAttr> roomBinAttrExternal;
le_t<u32> roomBinAttrExternalNum;
};
struct SceNpMatching2GetRoomDataExternalListRequest
{
vm::lptr<u64> roomId;
le_t<u32> roomIdNum;
vm::lptr<const u16> attrId;
le_t<u32> attrIdNum;
};
struct SceNpMatching2GetRoomDataExternalListResponse
{
vm::lptr<SceNpMatching2RoomDataExternal> roomDataExternal;
le_t<u32> roomDataExternalNum;
};
struct SceNpMatching2SignalingOptParam
{
u8 type;
u8 flag;
le_t<u16> hubMemberId;
u8 reserved2[4];
};
struct SceNpMatching2CreateJoinRoomRequest
{
le_t<u32> worldId;
u8 padding1[4];
le_t<u64> lobbyId;
le_t<u32> maxSlot;
le_t<u32> flagAttr;
vm::lptr<SceNpMatching2BinAttr> roomBinAttrInternal;
le_t<u32> roomBinAttrInternalNum;
vm::lptr<SceNpMatching2IntAttr> roomSearchableIntAttrExternal;
le_t<u32> roomSearchableIntAttrExternalNum;
vm::lptr<SceNpMatching2BinAttr> roomSearchableBinAttrExternal;
le_t<u32> roomSearchableBinAttrExternalNum;
vm::lptr<SceNpMatching2BinAttr> roomBinAttrExternal;
le_t<u32> roomBinAttrExternalNum;
vm::lptr<SceNpMatching2SessionPassword> roomPassword;
vm::lptr<SceNpMatching2RoomGroupConfig> groupConfig;
le_t<u32> groupConfigNum;
vm::lptr<u64> passwordSlotMask;
vm::lptr<SceNpId> allowedUser;
le_t<u32> allowedUserNum;
vm::lptr<SceNpId> blockedUser;
le_t<u32> blockedUserNum;
vm::lptr<SceNpMatching2GroupLabel> joinRoomGroupLabel;
vm::lptr<SceNpMatching2BinAttr> roomMemberBinAttrInternal;
le_t<u32> roomMemberBinAttrInternalNum;
u8 teamId;
u8 padding2[3];
vm::lptr<SceNpMatching2SignalingOptParam> sigOptParam;
u8 padding3[4];
};
struct SceNpMatching2CreateJoinRoomResponse
{
vm::lptr<SceNpMatching2RoomDataInternal> roomDataInternal;
};
struct SceNpMatching2JoinRoomRequest
{
le_t<u64> roomId;
vm::lptr<SceNpMatching2SessionPassword> roomPassword;
vm::lptr<SceNpMatching2GroupLabel> joinRoomGroupLabel;
vm::lptr<SceNpMatching2BinAttr> roomMemberBinAttrInternal;
le_t<u32> roomMemberBinAttrInternalNum;
SceNpMatching2PresenceOptionData optData;
u8 teamId;
u8 padding[3];
vm::lptr<SceNpId> blockedUser;
le_t<u32> blockedUserNum;
};
struct SceNpMatching2JoinRoomResponse
{
vm::lptr<SceNpMatching2RoomDataInternal> roomDataInternal;
};
struct SceNpMatching2LeaveRoomRequest
{
le_t<u64> roomId;
SceNpMatching2PresenceOptionData optData;
u8 padding[4];
};
struct SceNpMatching2GrantRoomOwnerRequest
{
le_t<u64> roomId;
le_t<u16> newOwner;
u8 padding[2];
SceNpMatching2PresenceOptionData optData;
};
struct SceNpMatching2KickoutRoomMemberRequest
{
le_t<u64> roomId;
le_t<u16> target;
u8 blockKickFlag;
u8 padding[1];
SceNpMatching2PresenceOptionData optData;
};
struct SceNpMatching2SearchRoomRequest
{
le_t<s32> option;
le_t<u32> worldId;
le_t<u64> lobbyId;
SceNpMatching2RangeFilter rangeFilter;
le_t<u32> flagFilter;
le_t<u32> flagAttr;
vm::lptr<SceNpMatching2IntSearchFilter> intFilter;
le_t<u32> intFilterNum;
vm::lptr<SceNpMatching2BinSearchFilter> binFilter;
le_t<u32> binFilterNum;
vm::lptr<u16> attrId;
le_t<u32> attrIdNum;
};
struct SceNpMatching2SearchRoomResponse
{
SceNpMatching2Range range;
vm::lptr<SceNpMatching2RoomDataExternal> roomDataExternal;
};
struct SceNpMatching2SendRoomMessageRequest
{
le_t<u64> roomId;
u8 castType;
u8 padding[3];
SceNpMatching2RoomMessageDestination dst;
vm::lcptr<void> msg;
le_t<u32> msgLen;
le_t<s32> option;
};
struct SceNpMatching2SendRoomChatMessageRequest
{
le_t<u64> roomId;
u8 castType;
u8 padding[3];
SceNpMatching2RoomMessageDestination dst;
vm::lptr<const void> msg;
le_t<u32> msgLen;
le_t<s32> option;
};
struct SceNpMatching2SendRoomChatMessageResponse
{
bool filtered;
};
struct SceNpMatching2SetRoomDataInternalRequest
{
le_t<u64> roomId;
le_t<u32> flagFilter;
le_t<u32> flagAttr;
vm::lptr<SceNpMatching2BinAttr> roomBinAttrInternal;
le_t<u32> roomBinAttrInternalNum;
vm::lptr<SceNpMatching2RoomGroupPasswordConfig> passwordConfig;
le_t<u32> passwordConfigNum;
vm::lptr<u64> passwordSlotMask;
vm::lptr<u16> ownerPrivilegeRank;
le_t<u32> ownerPrivilegeRankNum;
u8 padding[4];
};
struct SceNpMatching2GetRoomDataInternalRequest
{
le_t<u64> roomId;
vm::lcptr<u16> attrId;
le_t<u32> attrIdNum;
};
struct SceNpMatching2GetRoomDataInternalResponse
{
vm::lptr<SceNpMatching2RoomDataInternal> roomDataInternal;
};
struct SceNpMatching2SetRoomMemberDataInternalRequest
{
le_t<u64> roomId;
le_t<u16> memberId;
u8 teamId;
u8 padding[5];
le_t<u32> flagFilter;
le_t<u32> flagAttr;
vm::lptr<SceNpMatching2BinAttr> roomMemberBinAttrInternal;
le_t<u32> roomMemberBinAttrInternalNum;
};
struct SceNpMatching2GetRoomMemberDataInternalRequest
{
le_t<u64> roomId;
le_t<u16> memberId;
u8 padding[6];
vm::lcptr<u16> attrId;
le_t<u32> attrIdNum;
};
struct SceNpMatching2GetRoomMemberDataInternalResponse
{
vm::lptr<SceNpMatching2RoomMemberDataInternal> roomMemberDataInternal;
};
struct SceNpMatching2SetSignalingOptParamRequest
{
le_t<u64> roomId;
SceNpMatching2SignalingOptParam sigOptParam;
};
struct SceNpMatching2GetLobbyInfoListRequest
{
le_t<u32> worldId;
SceNpMatching2RangeFilter rangeFilter;
vm::lptr<u16> attrId;
le_t<u32> attrIdNum;
};
struct SceNpMatching2GetLobbyInfoListResponse
{
SceNpMatching2Range range;
vm::lptr<SceNpMatching2LobbyDataExternal> lobbyDataExternal;
};
struct SceNpMatching2JoinLobbyRequest
{
le_t<u64> lobbyId;
vm::lptr<SceNpMatching2JoinedSessionInfo> joinedSessionInfo;
le_t<u32> joinedSessionInfoNum;
vm::lptr<SceNpMatching2BinAttr> lobbyMemberBinAttrInternal;
le_t<u32> lobbyMemberBinAttrInternalNum;
SceNpMatching2PresenceOptionData optData;
u8 padding[4];
};
struct SceNpMatching2JoinLobbyResponse
{
vm::lptr<SceNpMatching2LobbyDataInternal> lobbyDataInternal;
};
struct SceNpMatching2LeaveLobbyRequest
{
le_t<u64> lobbyId;
SceNpMatching2PresenceOptionData optData;
u8 padding[4];
};
struct SceNpMatching2SetLobbyMemberDataInternalRequest
{
le_t<u64> lobbyId;
le_t<u16> memberId;
u8 padding1[2];
le_t<u32> flagFilter;
le_t<u32> flagAttr;
vm::lptr<SceNpMatching2JoinedSessionInfo> joinedSessionInfo;
le_t<u32> joinedSessionInfoNum;
vm::lptr<SceNpMatching2BinAttr> lobbyMemberBinAttrInternal;
le_t<u32> lobbyMemberBinAttrInternalNum;
u8 padding2[4];
};
struct SceNpMatching2GetLobbyMemberDataInternalRequest
{
le_t<u64> lobbyId;
le_t<u16> memberId;
u8 padding[6];
vm::lcptr<u16> attrId;
le_t<u32> attrIdNum;
};
struct SceNpMatching2GetLobbyMemberDataInternalResponse
{
vm::lptr<SceNpMatching2LobbyMemberDataInternal> lobbyMemberDataInternal;
};
struct SceNpMatching2GetLobbyMemberDataInternalListRequest
{
le_t<u64> lobbyId;
vm::lptr<u16> memberId;
le_t<u32> memberIdNum;
vm::lcptr<u16> attrId;
le_t<u32> attrIdNum;
bool extendedData;
u8 padding[7];
};
struct SceNpMatching2GetLobbyMemberDataInternalListResponse
{
vm::lptr<SceNpMatching2LobbyMemberDataInternal> lobbyMemberDataInternal;
le_t<u32> lobbyMemberDataInternalNum;
};
struct SceNpMatching2SendLobbyChatMessageRequest
{
le_t<u64> lobbyId;
u8 castType;
u8 padding[3];
SceNpMatching2LobbyMessageDestination dst;
vm::lcptr<void> msg;
le_t<u32> msgLen;
le_t<s32> option;
};
struct SceNpMatching2SendLobbyChatMessageResponse
{
bool filtered;
};
struct SceNpMatching2SendLobbyInvitationRequest
{
le_t<u64> lobbyId;
u8 castType;
u8 padding[3];
SceNpMatching2LobbyMessageDestination dst;
SceNpMatching2InvitationData invitationData;
le_t<s32> option;
};
struct SceNpMatching2RoomMemberUpdateInfo
{
vm::lptr<SceNpMatching2RoomMemberDataInternal> roomMemberDataInternal;
u8 eventCause;
u8 padding[3];
SceNpMatching2PresenceOptionData optData;
};
struct SceNpMatching2RoomOwnerUpdateInfo
{
le_t<u16> prevOwner;
le_t<u16> newOwner;
u8 eventCause;
u8 padding[3];
vm::lptr<SceNpMatching2SessionPassword> roomPassword;
SceNpMatching2PresenceOptionData optData;
};
struct SceNpMatching2RoomUpdateInfo
{
u8 eventCause;
u8 padding[3];
le_t<s32> errorCode;
SceNpMatching2PresenceOptionData optData;
};
struct SceNpMatching2RoomDataInternalUpdateInfo
{
vm::lptr<SceNpMatching2RoomDataInternal> newRoomDataInternal;
vm::lptr<u32> newFlagAttr;
vm::lptr<u32> prevFlagAttr;
vm::lptr<u64> newRoomPasswordSlotMask;
vm::lptr<u64> prevRoomPasswordSlotMask;
vm::lptr<SceNpMatching2RoomGroup> *newRoomGroup;
le_t<u32> newRoomGroupNum;
vm::lptr<SceNpMatching2RoomBinAttrInternal> *newRoomBinAttrInternal;
le_t<u32> newRoomBinAttrInternalNum;
};
struct SceNpMatching2RoomMemberDataInternalUpdateInfo
{
vm::lptr<SceNpMatching2RoomMemberDataInternal> newRoomMemberDataInternal;
vm::lptr<u32> newFlagAttr;
vm::lptr<u32> prevFlagAttr;
vm::lptr<u8> newTeamId;
vm::lptr<SceNpMatching2RoomMemberBinAttrInternal> *newRoomMemberBinAttrInternal;
le_t<u32> newRoomMemberBinAttrInternalNum;
};
struct SceNpMatching2SignalingOptParamUpdateInfo
{
SceNpMatching2SignalingOptParam newSignalingOptParam;
};
struct SceNpMatching2RoomMessageInfo
{
bool filtered;
u8 castType;
u8 padding[2];
vm::lptr<SceNpMatching2RoomMessageDestination> dst;
vm::lptr<SceNpId> srcMember;
vm::lcptr<void> msg;
le_t<u32> msgLen;
};
struct SceNpMatching2LobbyMemberUpdateInfo
{
vm::lptr<SceNpMatching2LobbyMemberDataInternal> lobbyMemberDataInternal;
u8 eventCause;
u8 padding[3];
SceNpMatching2PresenceOptionData optData;
};
struct SceNpMatching2LobbyUpdateInfo
{
u8 eventCause;
u8 padding[3];
le_t<s32> errorCode;
};
struct SceNpMatching2LobbyMemberDataInternalUpdateInfo
{
le_t<u16> memberId;
u8 padding[2];
SceNpId npId;
le_t<u32> flagFilter;
le_t<u32> newFlagAttr;
vm::lptr<SceNpMatching2JoinedSessionInfo> newJoinedSessionInfo;
le_t<u32> newJoinedSessionInfoNum;
vm::lptr<SceNpMatching2LobbyMemberBinAttrInternal> newLobbyMemberBinAttrInternal;
le_t<u32> newLobbyMemberBinAttrInternalNum;
};
struct SceNpMatching2LobbyMessageInfo
{
bool filtered;
u8 castType;
u8 padding[2];
vm::lptr<SceNpMatching2LobbyMessageDestination> dst;
vm::lptr<SceNpId> srcMember;
vm::lcptr<void> msg;
le_t<u32> msgLen;
};
struct SceNpMatching2LobbyInvitationInfo
{
u8 castType;
u8 padding[3];
vm::lptr<SceNpMatching2LobbyMessageDestination> dst;
vm::lptr<SceNpId> srcMember;
SceNpMatching2InvitationData invitationData;
};
union SceNpMatching2SignalingConnectionInfo
{
le_t<u32> rtt;
le_t<u32> bandwidth;
SceNpId npId;
struct
{
SceNetInAddr addr;
le_t<u16> port;
u8 padding[2];
}
address;
le_t<u32> packetLoss;
};
struct SceNpMatching2SignalingNetInfo
{
le_t<u32> size;
SceNetInAddr localAddr;
SceNetInAddr mappedAddr;
le_t<s32> natStatus;
};
extern psv_log_base sceNpMatching;

242
rpcs3/Emu/ARMv7/Modules/sceNpScore.cpp
View File

@ -2,66 +2,9 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
#include "sceNpCommon.h"
#include "sceNpScore.h"
extern psv_log_base sceNpScore;
typedef u32 SceNpScoreBoardId;
typedef s64 SceNpScoreValue;
typedef u32 SceNpScoreRankNumber;
typedef s32 SceNpScorePcId;
struct SceNpScoreGameInfo
{
u32 infoSize;
u8 pad[4];
u8 data[192];
};
struct SceNpScoreComment
{
char utf8Comment[64];
};
struct SceNpScoreRankData
{
SceNpId npId;
u8 reserved[49];
u8 pad0[3];
SceNpScorePcId pcId;
SceNpScoreRankNumber serialRank;
SceNpScoreRankNumber rank;
SceNpScoreRankNumber highestRank;
s32 hasGameData;
u8 pad1[4];
SceNpScoreValue scoreValue;
u64 recordDate;
};
struct SceNpScorePlayerRankData
{
s32 hasData;
u8 pad0[4];
SceNpScoreRankData rankData;
};
struct SceNpScoreBoardInfo
{
u32 rankLimit;
u32 updateMode;
u32 sortMode;
u32 uploadNumLimit;
u32 uploadSizeLimit;
};
struct SceNpScoreNpIdPcId
{
SceNpId npId;
SceNpScorePcId pcId;
u8 pad[4];
};
s32 sceNpScoreInit(s32 threadPriority, s32 cpuAffinityMask, vm::psv::ptr<void> option)
s32 sceNpScoreInit(s32 threadPriority, s32 cpuAffinityMask, vm::ptr<void> option)
{
throw __FUNCTION__;
}
@ -71,7 +14,7 @@ s32 sceNpScoreTerm(ARMv7Context&)
throw __FUNCTION__;
}
s32 sceNpScoreCreateTitleCtx(vm::psv::ptr<const SceNpCommunicationId> titleId, vm::psv::ptr<const SceNpCommunicationPassphrase> passphrase, vm::psv::ptr<const SceNpId> selfNpId)
s32 sceNpScoreCreateTitleCtx(vm::ptr<const SceNpCommunicationId> titleId, vm::ptr<const SceNpCommunicationPassphrase> passphrase, vm::ptr<const SceNpId> selfNpId)
{
throw __FUNCTION__;
}
@ -101,86 +44,86 @@ s32 sceNpScoreSetTimeout(s32 id, s32 resolveRetry, s32 resolveTimeout, s32 connT
throw __FUNCTION__;
}
s32 sceNpScoreSetPlayerCharacterId(s32 id, SceNpScorePcId pcId)
s32 sceNpScoreSetPlayerCharacterId(s32 id, s32 pcId)
{
throw __FUNCTION__;
}
s32 sceNpScoreGetBoardInfo(s32 reqId, SceNpScoreBoardId boardId, vm::psv::ptr<SceNpScoreBoardInfo> boardInfo, vm::psv::ptr<void> option)
s32 sceNpScoreGetBoardInfo(s32 reqId, u32 boardId, vm::ptr<SceNpScoreBoardInfo> boardInfo, vm::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreRecordScore(
s32 reqId,
SceNpScoreBoardId boardId,
SceNpScoreValue score,
vm::psv::ptr<const SceNpScoreComment> scoreComment,
vm::psv::ptr<const SceNpScoreGameInfo> gameInfo,
vm::psv::ptr<SceNpScoreRankNumber> tmpRank,
vm::psv::ptr<const u64> compareDate,
vm::psv::ptr<void> option)
u32 boardId,
s64 score,
vm::ptr<const SceNpScoreComment> scoreComment,
vm::ptr<const SceNpScoreGameInfo> gameInfo,
vm::ptr<u32> tmpRank,
vm::ptr<const u64> compareDate,
vm::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreRecordGameData(
s32 reqId,
SceNpScoreBoardId boardId,
SceNpScoreValue score,
u32 boardId,
s64 score,
u32 totalSize,
u32 sendSize,
vm::psv::ptr<const void> data,
vm::psv::ptr<void> option)
vm::ptr<const void> data,
vm::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreGetGameData(
s32 reqId,
SceNpScoreBoardId boardId,
vm::psv::ptr<const SceNpId> npId,
vm::psv::ptr<u32> totalSize,
u32 boardId,
vm::ptr<const SceNpId> npId,
vm::ptr<u32> totalSize,
u32 recvSize,
vm::psv::ptr<void> data,
vm::psv::ptr<void> option)
vm::ptr<void> data,
vm::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreGetRankingByNpId(
s32 reqId,
SceNpScoreBoardId boardId,
vm::psv::ptr<const SceNpId> npIdArray,
u32 boardId,
vm::ptr<const SceNpId> npIdArray,
u32 npIdArraySize,
vm::psv::ptr<SceNpScorePlayerRankData> rankArray,
vm::ptr<SceNpScorePlayerRankData> rankArray,
u32 rankArraySize,
vm::psv::ptr<SceNpScoreComment> commentArray,
vm::ptr<SceNpScoreComment> commentArray,
u32 commentArraySize,
vm::psv::ptr<SceNpScoreGameInfo> infoArray,
vm::ptr<SceNpScoreGameInfo> infoArray,
u32 infoArraySize,
u32 arrayNum,
vm::psv::ptr<u64> lastSortDate,
vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
vm::psv::ptr<void> option)
vm::ptr<u64> lastSortDate,
vm::ptr<u32> totalRecord,
vm::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreGetRankingByRange(
s32 reqId,
SceNpScoreBoardId boardId,
SceNpScoreRankNumber startSerialRank,
vm::psv::ptr<SceNpScoreRankData> rankArray,
u32 boardId,
u32 startSerialRank,
vm::ptr<SceNpScoreRankData> rankArray,
u32 rankArraySize,
vm::psv::ptr<SceNpScoreComment> commentArray,
vm::ptr<SceNpScoreComment> commentArray,
u32 commentArraySize,
vm::psv::ptr<SceNpScoreGameInfo> infoArray,
vm::ptr<SceNpScoreGameInfo> infoArray,
u32 infoArraySize,
u32 arrayNum,
vm::psv::ptr<u64> lastSortDate,
vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
vm::psv::ptr<void> option)
vm::ptr<u64> lastSortDate,
vm::ptr<u32> totalRecord,
vm::ptr<void> option)
{
throw __FUNCTION__;
}
@ -188,147 +131,147 @@ s32 sceNpScoreGetRankingByRange(
s32 sceNpScoreGetRankingByNpIdPcId(
s32 reqId,
SceNpScoreBoardId boardId,
vm::psv::ptr<const SceNpScoreNpIdPcId> idArray,
u32 boardId,
vm::ptr<const SceNpScoreNpIdPcId> idArray,
u32 idArraySize,
vm::psv::ptr<SceNpScorePlayerRankData> rankArray,
vm::ptr<SceNpScorePlayerRankData> rankArray,
u32 rankArraySize,
vm::psv::ptr<SceNpScoreComment> commentArray,
vm::ptr<SceNpScoreComment> commentArray,
u32 commentArraySize,
vm::psv::ptr<SceNpScoreGameInfo> infoArray,
vm::ptr<SceNpScoreGameInfo> infoArray,
u32 infoArraySize,
u32 arrayNum,
vm::psv::ptr<u64> lastSortDate,
vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
vm::psv::ptr<void> option)
vm::ptr<u64> lastSortDate,
vm::ptr<u32> totalRecord,
vm::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreCensorComment(s32 reqId, vm::psv::ptr<const char> comment, vm::psv::ptr<void> option)
s32 sceNpScoreCensorComment(s32 reqId, vm::ptr<const char> comment, vm::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreSanitizeComment(s32 reqId, vm::psv::ptr<const char> comment, vm::psv::ptr<char> sanitizedComment, vm::psv::ptr<void> option)
s32 sceNpScoreSanitizeComment(s32 reqId, vm::ptr<const char> comment, vm::ptr<char> sanitizedComment, vm::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreWaitAsync(s32 id, vm::psv::ptr<s32> result)
s32 sceNpScoreWaitAsync(s32 id, vm::ptr<s32> result)
{
throw __FUNCTION__;
}
s32 sceNpScorePollAsync(s32 reqId, vm::psv::ptr<s32> result)
s32 sceNpScorePollAsync(s32 reqId, vm::ptr<s32> result)
{
throw __FUNCTION__;
}
s32 sceNpScoreGetBoardInfoAsync(s32 reqId, SceNpScoreBoardId boardId, vm::psv::ptr<SceNpScoreBoardInfo> boardInfo, vm::psv::ptr<void> option)
s32 sceNpScoreGetBoardInfoAsync(s32 reqId, u32 boardId, vm::ptr<SceNpScoreBoardInfo> boardInfo, vm::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreRecordScoreAsync(
s32 reqId,
SceNpScoreBoardId boardId,
SceNpScoreValue score,
vm::psv::ptr<const SceNpScoreComment> scoreComment,
vm::psv::ptr<const SceNpScoreGameInfo> gameInfo,
vm::psv::ptr<SceNpScoreRankNumber> tmpRank,
vm::psv::ptr<const u64> compareDate,
vm::psv::ptr<void> option)
u32 boardId,
s64 score,
vm::ptr<const SceNpScoreComment> scoreComment,
vm::ptr<const SceNpScoreGameInfo> gameInfo,
vm::ptr<u32> tmpRank,
vm::ptr<const u64> compareDate,
vm::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreRecordGameDataAsync(
s32 reqId,
SceNpScoreBoardId boardId,
SceNpScoreValue score,
u32 boardId,
s64 score,
u32 totalSize,
u32 sendSize,
vm::psv::ptr<const void> data,
vm::psv::ptr<void> option)
vm::ptr<const void> data,
vm::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreGetGameDataAsync(
s32 reqId,
SceNpScoreBoardId boardId,
vm::psv::ptr<const SceNpId> npId,
vm::psv::ptr<u32> totalSize,
u32 boardId,
vm::ptr<const SceNpId> npId,
vm::ptr<u32> totalSize,
u32 recvSize,
vm::psv::ptr<void> data,
vm::psv::ptr<void> option)
vm::ptr<void> data,
vm::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreGetRankingByNpIdAsync(
s32 reqId,
SceNpScoreBoardId boardId,
vm::psv::ptr<const SceNpId> npIdArray,
u32 boardId,
vm::ptr<const SceNpId> npIdArray,
u32 npIdArraySize,
vm::psv::ptr<SceNpScorePlayerRankData> rankArray,
vm::ptr<SceNpScorePlayerRankData> rankArray,
u32 rankArraySize,
vm::psv::ptr<SceNpScoreComment> commentArray,
vm::ptr<SceNpScoreComment> commentArray,
u32 commentArraySize,
vm::psv::ptr<SceNpScoreGameInfo> infoArray,
vm::ptr<SceNpScoreGameInfo> infoArray,
u32 infoArraySize,
u32 arrayNum,
vm::psv::ptr<u64> lastSortDate,
vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
vm::psv::ptr<void> option)
vm::ptr<u64> lastSortDate,
vm::ptr<u32> totalRecord,
vm::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreGetRankingByRangeAsync(
s32 reqId,
SceNpScoreBoardId boardId,
SceNpScoreRankNumber startSerialRank,
vm::psv::ptr<SceNpScoreRankData> rankArray,
u32 boardId,
u32 startSerialRank,
vm::ptr<SceNpScoreRankData> rankArray,
u32 rankArraySize,
vm::psv::ptr<SceNpScoreComment> commentArray,
vm::ptr<SceNpScoreComment> commentArray,
u32 commentArraySize,
vm::psv::ptr<SceNpScoreGameInfo> infoArray,
vm::ptr<SceNpScoreGameInfo> infoArray,
u32 infoArraySize,
u32 arrayNum,
vm::psv::ptr<u64> lastSortDate,
vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
vm::psv::ptr<void> option)
vm::ptr<u64> lastSortDate,
vm::ptr<u32> totalRecord,
vm::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreGetRankingByNpIdPcIdAsync(
s32 reqId,
SceNpScoreBoardId boardId,
vm::psv::ptr<const SceNpScoreNpIdPcId> idArray,
u32 boardId,
vm::ptr<const SceNpScoreNpIdPcId> idArray,
u32 idArraySize,
vm::psv::ptr<SceNpScorePlayerRankData> rankArray,
vm::ptr<SceNpScorePlayerRankData> rankArray,
u32 rankArraySize,
vm::psv::ptr<SceNpScoreComment> commentArray,
vm::ptr<SceNpScoreComment> commentArray,
u32 commentArraySize,
vm::psv::ptr<SceNpScoreGameInfo> infoArray,
vm::ptr<SceNpScoreGameInfo> infoArray,
u32 infoArraySize,
u32 arrayNum,
vm::psv::ptr<u64> lastSortDate,
vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
vm::psv::ptr<void> option)
vm::ptr<u64> lastSortDate,
vm::ptr<u32> totalRecord,
vm::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreCensorCommentAsync(s32 reqId, vm::psv::ptr<const char> comment, vm::psv::ptr<void> option)
s32 sceNpScoreCensorCommentAsync(s32 reqId, vm::ptr<const char> comment, vm::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreSanitizeCommentAsync(s32 reqId, vm::psv::ptr<const char> comment, vm::psv::ptr<char> sanitizedComment, vm::psv::ptr<void> option)
s32 sceNpScoreSanitizeCommentAsync(s32 reqId, vm::ptr<const char> comment, vm::ptr<char> sanitizedComment, vm::ptr<void> option)
{
throw __FUNCTION__;
}
@ -340,6 +283,7 @@ psv_log_base sceNpScore("SceNpScore", []()
sceNpScore.on_load = nullptr;
sceNpScore.on_unload = nullptr;
sceNpScore.on_stop = nullptr;
sceNpScore.on_error = nullptr;
REG_FUNC(0x0433069F, sceNpScoreInit);
REG_FUNC(0x2050F98F, sceNpScoreTerm);

55
rpcs3/Emu/ARMv7/Modules/sceNpScore.h Normal file
View File

@ -0,0 +1,55 @@
#pragma once
#include "sceNpCommon.h"
struct SceNpScoreGameInfo
{
le_t<u32> infoSize;
u8 pad[4];
u8 data[192];
};
struct SceNpScoreComment
{
char utf8Comment[64];
};
struct SceNpScoreRankData
{
SceNpId npId;
u8 reserved[49];
u8 pad0[3];
le_t<s32> pcId;
le_t<u32> serialRank;
le_t<u32> rank;
le_t<u32> highestRank;
le_t<s32> hasGameData;
u8 pad1[4];
le_t<s64> scoreValue;
le_t<u64> recordDate;
};
struct SceNpScorePlayerRankData
{
le_t<s32> hasData;
u8 pad0[4];
SceNpScoreRankData rankData;
};
struct SceNpScoreBoardInfo
{
le_t<u32> rankLimit;
le_t<u32> updateMode;
le_t<u32> sortMode;
le_t<u32> uploadNumLimit;
le_t<u32> uploadSizeLimit;
};
struct SceNpScoreNpIdPcId
{
SceNpId npId;
le_t<s32> pcId;
u8 pad[4];
};
extern psv_log_base sceNpScore;

63
rpcs3/Emu/ARMv7/Modules/sceNpUtility.cpp
View File

@ -2,19 +2,9 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
#include "sceNpCommon.h"
#include "sceNpUtility.h"
extern psv_log_base sceNpUtility;
struct SceNpBandwidthTestResult
{
double uploadBps;
double downloadBps;
s32 result;
char padding[4];
};
s32 sceNpLookupInit(s32 usesAsync, s32 threadPriority, s32 cpuAffinityMask, vm::psv::ptr<void> option)
s32 sceNpLookupInit(s32 usesAsync, s32 threadPriority, s32 cpuAffinityMask, vm::ptr<void> option)
{
throw __FUNCTION__;
}
@ -24,7 +14,7 @@ s32 sceNpLookupTerm(ARMv7Context&)
throw __FUNCTION__;
}
s32 sceNpLookupCreateTitleCtx(vm::psv::ptr<const SceNpCommunicationId> titleId, vm::psv::ptr<const SceNpId> selfNpId)
s32 sceNpLookupCreateTitleCtx(vm::ptr<const SceNpCommunicationId> titleId, vm::ptr<const SceNpId> selfNpId)
{
throw __FUNCTION__;
}
@ -54,22 +44,22 @@ s32 sceNpLookupSetTimeout(s32 id, s32 resolveRetry, u32 resolveTimeout, u32 conn
throw __FUNCTION__;
}
s32 sceNpLookupWaitAsync(s32 reqId, vm::psv::ptr<s32> result)
s32 sceNpLookupWaitAsync(s32 reqId, vm::ptr<s32> result)
{
throw __FUNCTION__;
}
s32 sceNpLookupPollAsync(s32 reqId, vm::psv::ptr<s32> result)
s32 sceNpLookupPollAsync(s32 reqId, vm::ptr<s32> result)
{
throw __FUNCTION__;
}
s32 sceNpLookupNpId(s32 reqId, vm::psv::ptr<const SceNpOnlineId> onlineId, vm::psv::ptr<SceNpId> npId, vm::psv::ptr<void> option)
s32 sceNpLookupNpId(s32 reqId, vm::ptr<const SceNpOnlineId> onlineId, vm::ptr<SceNpId> npId, vm::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpLookupNpIdAsync(s32 reqId, vm::psv::ptr<const SceNpOnlineId> onlineId, vm::psv::ptr<SceNpId> npId, vm::psv::ptr<void> option)
s32 sceNpLookupNpIdAsync(s32 reqId, vm::ptr<const SceNpOnlineId> onlineId, vm::ptr<SceNpId> npId, vm::ptr<void> option)
{
throw __FUNCTION__;
}
@ -77,15 +67,15 @@ s32 sceNpLookupNpIdAsync(s32 reqId, vm::psv::ptr<const SceNpOnlineId> onlineId,
s32 sceNpLookupUserProfile(
s32 reqId,
s32 avatarSizeType,
vm::psv::ptr<const SceNpId> npId,
vm::psv::ptr<SceNpUserInformation> userInfo,
vm::psv::ptr<SceNpAboutMe> aboutMe,
vm::psv::ptr<SceNpMyLanguages> languages,
vm::psv::ptr<SceNpCountryCode> countryCode,
vm::psv::ptr<void> avatarImageData,
vm::ptr<const SceNpId> npId,
vm::ptr<SceNpUserInformation> userInfo,
vm::ptr<SceNpAboutMe> aboutMe,
vm::ptr<SceNpMyLanguages> languages,
vm::ptr<SceNpCountryCode> countryCode,
vm::ptr<void> avatarImageData,
u32 avatarImageDataMaxSize,
vm::psv::ptr<u32> avatarImageDataSize,
vm::psv::ptr<void> option)
vm::ptr<u32> avatarImageDataSize,
vm::ptr<void> option)
{
throw __FUNCTION__;
}
@ -93,25 +83,25 @@ s32 sceNpLookupUserProfile(
s32 sceNpLookupUserProfileAsync(
s32 reqId,
s32 avatarSizeType,
vm::psv::ptr<const SceNpId> npId,
vm::psv::ptr<SceNpUserInformation> userInfo,
vm::psv::ptr<SceNpAboutMe> aboutMe,
vm::psv::ptr<SceNpMyLanguages> languages,
vm::psv::ptr<SceNpCountryCode> countryCode,
vm::psv::ptr<void> avatarImageData,
vm::ptr<const SceNpId> npId,
vm::ptr<SceNpUserInformation> userInfo,
vm::ptr<SceNpAboutMe> aboutMe,
vm::ptr<SceNpMyLanguages> languages,
vm::ptr<SceNpCountryCode> countryCode,
vm::ptr<void> avatarImageData,
u32 avatarImageDataMaxSize,
vm::psv::ptr<u32> avatarImageDataSize,
vm::psv::ptr<void> option)
vm::ptr<u32> avatarImageDataSize,
vm::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpLookupAvatarImage(s32 reqId, vm::psv::ptr<const SceNpAvatarUrl> avatarUrl, vm::psv::ptr<SceNpAvatarImage> avatarImage, vm::psv::ptr<void> option)
s32 sceNpLookupAvatarImage(s32 reqId, vm::ptr<const SceNpAvatarUrl> avatarUrl, vm::ptr<SceNpAvatarImage> avatarImage, vm::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpLookupAvatarImageAsync(s32 reqId, vm::psv::ptr<const SceNpAvatarUrl> avatarUrl, vm::psv::ptr<SceNpAvatarImage> avatarImage, vm::psv::ptr<void> option)
s32 sceNpLookupAvatarImageAsync(s32 reqId, vm::ptr<const SceNpAvatarUrl> avatarUrl, vm::ptr<SceNpAvatarImage> avatarImage, vm::ptr<void> option)
{
throw __FUNCTION__;
}
@ -126,7 +116,7 @@ s32 sceNpBandwidthTestGetStatus()
throw __FUNCTION__;
}
s32 sceNpBandwidthTestShutdown(vm::psv::ptr<SceNpBandwidthTestResult> result)
s32 sceNpBandwidthTestShutdown(vm::ptr<SceNpBandwidthTestResult> result)
{
throw __FUNCTION__;
}
@ -143,6 +133,7 @@ psv_log_base sceNpUtility("SceNpUtility", []()
sceNpUtility.on_load = nullptr;
sceNpUtility.on_unload = nullptr;
sceNpUtility.on_stop = nullptr;
sceNpUtility.on_error = nullptr;
REG_FUNC(0x9246A673, sceNpLookupInit);
REG_FUNC(0x0158B61B, sceNpLookupTerm);

13
rpcs3/Emu/ARMv7/Modules/sceNpUtility.h Normal file
View File

@ -0,0 +1,13 @@
#pragma once
#include "sceNpCommon.h"
struct SceNpBandwidthTestResult
{
le_t<double> uploadBps;
le_t<double> downloadBps;
le_t<s32> result;
char padding[4];
};
extern psv_log_base sceNpUtility;

109
rpcs3/Emu/ARMv7/Modules/scePerf.cpp
View File

@ -2,102 +2,10 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
#include "scePerf.h"
extern u64 get_system_time();
#define RETURN_ERROR(code) { Emu.Pause(); scePerf.Error("%s() failed: %s", __FUNCTION__, #code); return code; }
extern psv_log_base scePerf;
enum
{
// Error Codes
SCE_PERF_ERROR_INVALID_ARGUMENT = 0x80580000,
};
enum : s32
{
// Thread IDs
SCE_PERF_ARM_PMON_THREAD_ID_ALL = -1,
SCE_PERF_ARM_PMON_THREAD_ID_SELF = 0,
};
enum : u32
{
// Counter Numbers
SCE_PERF_ARM_PMON_CYCLE_COUNTER = 31,
SCE_PERF_ARM_PMON_COUNTER_5 = 5,
SCE_PERF_ARM_PMON_COUNTER_4 = 4,
SCE_PERF_ARM_PMON_COUNTER_3 = 3,
SCE_PERF_ARM_PMON_COUNTER_2 = 2,
SCE_PERF_ARM_PMON_COUNTER_1 = 1,
SCE_PERF_ARM_PMON_COUNTER_0 = 0,
// Counter Masks
SCE_PERF_ARM_PMON_COUNTER_MASK_5 = 0x20,
SCE_PERF_ARM_PMON_COUNTER_MASK_4 = 0x10,
SCE_PERF_ARM_PMON_COUNTER_MASK_3 = 0x08,
SCE_PERF_ARM_PMON_COUNTER_MASK_2 = 0x04,
SCE_PERF_ARM_PMON_COUNTER_MASK_1 = 0x02,
SCE_PERF_ARM_PMON_COUNTER_MASK_0 = 0x01,
SCE_PERF_ARM_PMON_COUNTER_MASK_ALL = 0x3f,
};
enum : u8
{
// Performance Counter Events
SCE_PERF_ARM_PMON_SOFT_INCREMENT = 0x00,
SCE_PERF_ARM_PMON_ICACHE_MISS = 0x01,
SCE_PERF_ARM_PMON_ITLB_MISS = 0x02,
SCE_PERF_ARM_PMON_DCACHE_MISS = 0x03,
SCE_PERF_ARM_PMON_DCACHE_ACCESS = 0x04,
SCE_PERF_ARM_PMON_DTLB_MISS = 0x05,
SCE_PERF_ARM_PMON_DATA_READ = 0x06,
SCE_PERF_ARM_PMON_DATA_WRITE = 0x07,
SCE_PERF_ARM_PMON_EXCEPTION_TAKEN = 0x09,
SCE_PERF_ARM_PMON_EXCEPTION_RETURN = 0x0A,
SCE_PERF_ARM_PMON_WRITE_CONTEXTID = 0x0B,
SCE_PERF_ARM_PMON_SOFT_CHANGEPC = 0x0C,
SCE_PERF_ARM_PMON_IMMEDIATE_BRANCH = 0x0D,
SCE_PERF_ARM_PMON_UNALIGNED = 0x0F,
SCE_PERF_ARM_PMON_BRANCH_MISPREDICT = 0x10,
SCE_PERF_ARM_PMON_PREDICT_BRANCH = 0x12,
SCE_PERF_ARM_PMON_COHERENT_LF_MISS = 0x50,
SCE_PERF_ARM_PMON_COHERENT_LF_HIT = 0x51,
SCE_PERF_ARM_PMON_ICACHE_STALL = 0x60,
SCE_PERF_ARM_PMON_DCACHE_STALL = 0x61,
SCE_PERF_ARM_PMON_MAINTLB_STALL = 0x62,
SCE_PERF_ARM_PMON_STREX_PASSED = 0x63,
SCE_PERF_ARM_PMON_STREX_FAILED = 0x64,
SCE_PERF_ARM_PMON_DATA_EVICTION = 0x65,
SCE_PERF_ARM_PMON_ISSUE_NO_DISPATCH = 0x66,
SCE_PERF_ARM_PMON_ISSUE_EMPTY = 0x67,
SCE_PERF_ARM_PMON_INST_RENAME = 0x68,
SCE_PERF_ARM_PMON_PREDICT_FUNC_RET = 0x6E,
SCE_PERF_ARM_PMON_MAIN_PIPE = 0x70,
SCE_PERF_ARM_PMON_SECOND_PIPE = 0x71,
SCE_PERF_ARM_PMON_LS_PIPE = 0x72,
SCE_PERF_ARM_PMON_FPU_RENAME = 0x73,
SCE_PERF_ARM_PMON_PLD_STALL = 0x80,
SCE_PERF_ARM_PMON_WRITE_STALL = 0x81,
SCE_PERF_ARM_PMON_INST_MAINTLB_STALL = 0x82,
SCE_PERF_ARM_PMON_DATA_MAINTLB_STALL = 0x83,
SCE_PERF_ARM_PMON_INST_UTLB_STALL = 0x84,
SCE_PERF_ARM_PMON_DATA_UTLB_STALL = 0x85,
SCE_PERF_ARM_PMON_DMB_STALL = 0x86,
SCE_PERF_ARM_PMON_INTEGER_CLOCK = 0x8A,
SCE_PERF_ARM_PMON_DATAENGINE_CLOCK = 0x8B,
SCE_PERF_ARM_PMON_ISB = 0x90,
SCE_PERF_ARM_PMON_DSB = 0x91,
SCE_PERF_ARM_PMON_DMB = 0x92,
SCE_PERF_ARM_PMON_EXT_INTERRUPT = 0x93,
SCE_PERF_ARM_PMON_PLE_LINE_REQ_COMPLETED = 0xA0,
SCE_PERF_ARM_PMON_PLE_CHANNEL_SKIPPED = 0xA1,
SCE_PERF_ARM_PMON_PLE_FIFO_FLUSH = 0xA2,
SCE_PERF_ARM_PMON_PLE_REQ_COMPLETED = 0xA3,
SCE_PERF_ARM_PMON_PLE_FIFO_OVERFLOW = 0xA4,
SCE_PERF_ARM_PMON_PLE_REQ_PROGRAMMED = 0xA5,
};
s32 scePerfArmPmonReset(ARMv7Context& context, s32 threadId)
{
scePerf.Warning("scePerfArmPmonReset(threadId=0x%x)", threadId);
@ -123,7 +31,7 @@ s32 scePerfArmPmonSelectEvent(ARMv7Context& context, s32 threadId, u32 counter,
if (counter >= 6)
{
RETURN_ERROR(SCE_PERF_ERROR_INVALID_ARGUMENT);
return SCE_PERF_ERROR_INVALID_ARGUMENT;
}
u32 value = 0; // initial value
@ -185,7 +93,7 @@ s32 scePerfArmPmonStop(ARMv7Context& context, s32 threadId)
return SCE_OK;
}
s32 scePerfArmPmonGetCounterValue(ARMv7Context& context, s32 threadId, u32 counter, vm::psv::ptr<u32> pValue)
s32 scePerfArmPmonGetCounterValue(ARMv7Context& context, s32 threadId, u32 counter, vm::ptr<u32> pValue)
{
scePerf.Warning("scePerfArmPmonGetCounterValue(threadId=0x%x, counter=%d, pValue=*0x%x)", threadId, counter, pValue);
@ -196,7 +104,7 @@ s32 scePerfArmPmonGetCounterValue(ARMv7Context& context, s32 threadId, u32 count
if (counter >= 6 && counter != SCE_PERF_ARM_PMON_CYCLE_COUNTER)
{
RETURN_ERROR(SCE_PERF_ERROR_INVALID_ARGUMENT);
return SCE_PERF_ERROR_INVALID_ARGUMENT;
}
if (counter < 6)
@ -217,7 +125,7 @@ s32 scePerfArmPmonSoftwareIncrement(ARMv7Context& context, u32 mask)
if (mask > SCE_PERF_ARM_PMON_COUNTER_MASK_ALL)
{
RETURN_ERROR(SCE_PERF_ERROR_INVALID_ARGUMENT);
return SCE_PERF_ERROR_INVALID_ARGUMENT;
}
for (u32 i = 0; i < 6; i++, mask >>= 1)
@ -245,12 +153,12 @@ u32 scePerfGetTimebaseFrequency()
return 1;
}
s32 _sceRazorCpuInit(vm::psv::ptr<const void> pBufferBase, u32 bufferSize, u32 numPerfCounters, vm::psv::pptr<u32> psceRazorVars)
s32 _sceRazorCpuInit(vm::cptr<void> pBufferBase, u32 bufferSize, u32 numPerfCounters, vm::pptr<u32> psceRazorVars)
{
throw __FUNCTION__;
}
s32 sceRazorCpuPushMarker(vm::psv::ptr<const char> szLabel)
s32 sceRazorCpuPushMarker(vm::cptr<char> szLabel)
{
throw __FUNCTION__;
}
@ -272,6 +180,7 @@ psv_log_base scePerf("ScePerf", []()
scePerf.on_load = nullptr;
scePerf.on_unload = nullptr;
scePerf.on_stop = nullptr;
//scePerf.on_error = nullptr; // keep default error handler
REG_FUNC(0x35151735, scePerfArmPmonReset);
REG_FUNC(0x63CBEA8B, scePerfArmPmonSelectEvent);

93
rpcs3/Emu/ARMv7/Modules/scePerf.h Normal file
View File

@ -0,0 +1,93 @@
#pragma once
enum
{
// Error Codes
SCE_PERF_ERROR_INVALID_ARGUMENT = 0x80580000,
};
enum : s32
{
// Thread IDs
SCE_PERF_ARM_PMON_THREAD_ID_ALL = -1,
SCE_PERF_ARM_PMON_THREAD_ID_SELF = 0,
};
enum : u32
{
// Counter Numbers
SCE_PERF_ARM_PMON_CYCLE_COUNTER = 31,
SCE_PERF_ARM_PMON_COUNTER_5 = 5,
SCE_PERF_ARM_PMON_COUNTER_4 = 4,
SCE_PERF_ARM_PMON_COUNTER_3 = 3,
SCE_PERF_ARM_PMON_COUNTER_2 = 2,
SCE_PERF_ARM_PMON_COUNTER_1 = 1,
SCE_PERF_ARM_PMON_COUNTER_0 = 0,
// Counter Masks
SCE_PERF_ARM_PMON_COUNTER_MASK_5 = 0x20,
SCE_PERF_ARM_PMON_COUNTER_MASK_4 = 0x10,
SCE_PERF_ARM_PMON_COUNTER_MASK_3 = 0x08,
SCE_PERF_ARM_PMON_COUNTER_MASK_2 = 0x04,
SCE_PERF_ARM_PMON_COUNTER_MASK_1 = 0x02,
SCE_PERF_ARM_PMON_COUNTER_MASK_0 = 0x01,
SCE_PERF_ARM_PMON_COUNTER_MASK_ALL = 0x3f,
};
enum : u8
{
// Performance Counter Events
SCE_PERF_ARM_PMON_SOFT_INCREMENT = 0x00,
SCE_PERF_ARM_PMON_ICACHE_MISS = 0x01,
SCE_PERF_ARM_PMON_ITLB_MISS = 0x02,
SCE_PERF_ARM_PMON_DCACHE_MISS = 0x03,
SCE_PERF_ARM_PMON_DCACHE_ACCESS = 0x04,
SCE_PERF_ARM_PMON_DTLB_MISS = 0x05,
SCE_PERF_ARM_PMON_DATA_READ = 0x06,
SCE_PERF_ARM_PMON_DATA_WRITE = 0x07,
SCE_PERF_ARM_PMON_EXCEPTION_TAKEN = 0x09,
SCE_PERF_ARM_PMON_EXCEPTION_RETURN = 0x0A,
SCE_PERF_ARM_PMON_WRITE_CONTEXTID = 0x0B,
SCE_PERF_ARM_PMON_SOFT_CHANGEPC = 0x0C,
SCE_PERF_ARM_PMON_IMMEDIATE_BRANCH = 0x0D,
SCE_PERF_ARM_PMON_UNALIGNED = 0x0F,
SCE_PERF_ARM_PMON_BRANCH_MISPREDICT = 0x10,
SCE_PERF_ARM_PMON_PREDICT_BRANCH = 0x12,
SCE_PERF_ARM_PMON_COHERENT_LF_MISS = 0x50,
SCE_PERF_ARM_PMON_COHERENT_LF_HIT = 0x51,
SCE_PERF_ARM_PMON_ICACHE_STALL = 0x60,
SCE_PERF_ARM_PMON_DCACHE_STALL = 0x61,
SCE_PERF_ARM_PMON_MAINTLB_STALL = 0x62,
SCE_PERF_ARM_PMON_STREX_PASSED = 0x63,
SCE_PERF_ARM_PMON_STREX_FAILED = 0x64,
SCE_PERF_ARM_PMON_DATA_EVICTION = 0x65,
SCE_PERF_ARM_PMON_ISSUE_NO_DISPATCH = 0x66,
SCE_PERF_ARM_PMON_ISSUE_EMPTY = 0x67,
SCE_PERF_ARM_PMON_INST_RENAME = 0x68,
SCE_PERF_ARM_PMON_PREDICT_FUNC_RET = 0x6E,
SCE_PERF_ARM_PMON_MAIN_PIPE = 0x70,
SCE_PERF_ARM_PMON_SECOND_PIPE = 0x71,
SCE_PERF_ARM_PMON_LS_PIPE = 0x72,
SCE_PERF_ARM_PMON_FPU_RENAME = 0x73,
SCE_PERF_ARM_PMON_PLD_STALL = 0x80,
SCE_PERF_ARM_PMON_WRITE_STALL = 0x81,
SCE_PERF_ARM_PMON_INST_MAINTLB_STALL = 0x82,
SCE_PERF_ARM_PMON_DATA_MAINTLB_STALL = 0x83,
SCE_PERF_ARM_PMON_INST_UTLB_STALL = 0x84,
SCE_PERF_ARM_PMON_DATA_UTLB_STALL = 0x85,
SCE_PERF_ARM_PMON_DMB_STALL = 0x86,
SCE_PERF_ARM_PMON_INTEGER_CLOCK = 0x8A,
SCE_PERF_ARM_PMON_DATAENGINE_CLOCK = 0x8B,
SCE_PERF_ARM_PMON_ISB = 0x90,
SCE_PERF_ARM_PMON_DSB = 0x91,
SCE_PERF_ARM_PMON_DMB = 0x92,
SCE_PERF_ARM_PMON_EXT_INTERRUPT = 0x93,
SCE_PERF_ARM_PMON_PLE_LINE_REQ_COMPLETED = 0xA0,
SCE_PERF_ARM_PMON_PLE_CHANNEL_SKIPPED = 0xA1,
SCE_PERF_ARM_PMON_PLE_FIFO_FLUSH = 0xA2,
SCE_PERF_ARM_PMON_PLE_REQ_COMPLETED = 0xA3,
SCE_PERF_ARM_PMON_PLE_FIFO_OVERFLOW = 0xA4,
SCE_PERF_ARM_PMON_PLE_REQ_PROGRAMMED = 0xA5,
};
extern psv_log_base scePerf;

3
rpcs3/Emu/ARMv7/Modules/scePgf.cpp
View File

@ -2,7 +2,7 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base scePgf;
#include "scePgf.h"
#define REG_FUNC(nid, name) reg_psv_func(nid, &scePgf, #name, name)
@ -11,6 +11,7 @@ psv_log_base scePgf("ScePgf", []()
scePgf.on_load = nullptr;
scePgf.on_unload = nullptr;
scePgf.on_stop = nullptr;
scePgf.on_error = nullptr;
//REG_FUNC(0x1055ABA3, sceFontNewLib);
//REG_FUNC(0x07EE1733, sceFontDoneLib);

3
rpcs3/Emu/ARMv7/Modules/scePgf.h Normal file
View File

@ -0,0 +1,3 @@
#pragma once
extern psv_log_base scePgf;

38
rpcs3/Emu/ARMv7/Modules/scePhotoExport.cpp
View File

@ -2,39 +2,28 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base scePhotoExport;
struct ScePhotoExportParam
{
u32 version;
vm::psv::ptr<const char> photoTitle;
vm::psv::ptr<const char> gameTitle;
vm::psv::ptr<const char> gameComment;
char reserved[32];
};
typedef vm::psv::ptr<s32(vm::psv::ptr<void>)> ScePhotoExportCancelFunc;
#include "scePhotoExport.h"
s32 scePhotoExportFromData(
vm::psv::ptr<const void> photodata,
vm::ptr<const void> photodata,
s32 photodataSize,
vm::psv::ptr<const ScePhotoExportParam> param,
vm::psv::ptr<void> workMemory,
ScePhotoExportCancelFunc cancelFunc,
vm::psv::ptr<void> userdata,
vm::psv::ptr<char> exportedPath,
vm::ptr<const ScePhotoExportParam> param,
vm::ptr<void> workMemory,
vm::ptr<ScePhotoExportCancelFunc> cancelFunc,
vm::ptr<void> userdata,
vm::ptr<char> exportedPath,
s32 exportedPathLength)
{
throw __FUNCTION__;
}
s32 scePhotoExportFromFile(
vm::psv::ptr<const char> photodataPath,
vm::psv::ptr<const ScePhotoExportParam> param,
vm::psv::ptr<void> workMemory,
ScePhotoExportCancelFunc cancelFunc,
vm::psv::ptr<void> userdata,
vm::psv::ptr<char> exportedPath,
vm::ptr<const char> photodataPath,
vm::ptr<const ScePhotoExportParam> param,
vm::ptr<void> workMemory,
vm::ptr<ScePhotoExportCancelFunc> cancelFunc,
vm::ptr<void> userdata,
vm::ptr<char> exportedPath,
s32 exportedPathLength)
{
throw __FUNCTION__;
@ -47,6 +36,7 @@ psv_log_base scePhotoExport("ScePhotoExport", []()
scePhotoExport.on_load = nullptr;
scePhotoExport.on_unload = nullptr;
scePhotoExport.on_stop = nullptr;
scePhotoExport.on_error = nullptr;
REG_FUNC(0x70512321, scePhotoExportFromData);
REG_FUNC(0x84FD9FC5, scePhotoExportFromFile);

14
rpcs3/Emu/ARMv7/Modules/scePhotoExport.h Normal file
View File

@ -0,0 +1,14 @@
#pragma once
struct ScePhotoExportParam
{
le_t<u32> version;
vm::lcptr<char> photoTitle;
vm::lcptr<char> gameTitle;
vm::lcptr<char> gameComment;
char reserved[32];
};
using ScePhotoExportCancelFunc = func_def<s32(vm::ptr<void>)>;
extern psv_log_base scePhotoExport;

7
rpcs3/Emu/ARMv7/Modules/sceRazorCapture.cpp
View File

@ -2,14 +2,14 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceRazorCapture;
#include "sceRazorCapture.h"
void sceRazorCaptureSetTrigger(u32 frameIndex, vm::psv::ptr<const char> captureFilename)
void sceRazorCaptureSetTrigger(u32 frameIndex, vm::ptr<const char> captureFilename)
{
throw __FUNCTION__;
}
void sceRazorCaptureSetTriggerNextFrame(vm::psv::ptr<const char> captureFilename)
void sceRazorCaptureSetTriggerNextFrame(vm::ptr<const char> captureFilename)
{
throw __FUNCTION__;
}
@ -26,6 +26,7 @@ psv_log_base sceRazorCapture("SceRazorCapture", []()
sceRazorCapture.on_load = nullptr;
sceRazorCapture.on_unload = nullptr;
sceRazorCapture.on_stop = nullptr;
sceRazorCapture.on_error = nullptr;
REG_FUNC(0x911E0AA0, sceRazorCaptureIsInProgress);
REG_FUNC(0xE916B538, sceRazorCaptureSetTrigger);

3
rpcs3/Emu/ARMv7/Modules/sceRazorCapture.h Normal file
View File

@ -0,0 +1,3 @@
#pragma once
extern psv_log_base sceRazorCapture;

69
rpcs3/Emu/ARMv7/Modules/sceRtc.cpp
View File

@ -2,39 +2,39 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceRtc;
#include "sceRtc.h"
u32 sceRtcGetTickResolution()
{
throw __FUNCTION__;
}
s32 sceRtcGetCurrentTick(vm::psv::ptr<u64> pTick)
s32 sceRtcGetCurrentTick(vm::ptr<u64> pTick)
{
throw __FUNCTION__;
}
s32 sceRtcGetCurrentClock(vm::psv::ptr<SceDateTime> pTime, s32 iTimeZone)
s32 sceRtcGetCurrentClock(vm::ptr<SceDateTime> pTime, s32 iTimeZone)
{
throw __FUNCTION__;
}
s32 sceRtcGetCurrentClockLocalTime(vm::psv::ptr<SceDateTime> pTime)
s32 sceRtcGetCurrentClockLocalTime(vm::ptr<SceDateTime> pTime)
{
throw __FUNCTION__;
}
s32 sceRtcGetCurrentNetworkTick(vm::psv::ptr<u64> pTick)
s32 sceRtcGetCurrentNetworkTick(vm::ptr<u64> pTick)
{
throw __FUNCTION__;
}
s32 sceRtcConvertUtcToLocalTime(vm::psv::ptr<const u64> pUtc, vm::psv::ptr<u64> pLocalTime)
s32 sceRtcConvertUtcToLocalTime(vm::ptr<const u64> pUtc, vm::ptr<u64> pLocalTime)
{
throw __FUNCTION__;
}
s32 sceRtcConvertLocalTimeToUtc(vm::psv::ptr<const u64> pLocalTime, vm::psv::ptr<u64> pUtc)
s32 sceRtcConvertLocalTimeToUtc(vm::ptr<const u64> pLocalTime, vm::ptr<u64> pUtc)
{
throw __FUNCTION__;
}
@ -54,137 +54,137 @@ s32 sceRtcGetDayOfWeek(s32 year, s32 month, s32 day)
throw __FUNCTION__;
}
s32 sceRtcCheckValid(vm::psv::ptr<const SceDateTime> pTime)
s32 sceRtcCheckValid(vm::ptr<const SceDateTime> pTime)
{
throw __FUNCTION__;
}
s32 sceRtcSetTime_t(vm::psv::ptr<SceDateTime> pTime, u32 iTime)
s32 sceRtcSetTime_t(vm::ptr<SceDateTime> pTime, u32 iTime)
{
throw __FUNCTION__;
}
s32 sceRtcSetTime64_t(vm::psv::ptr<SceDateTime> pTime, u64 ullTime)
s32 sceRtcSetTime64_t(vm::ptr<SceDateTime> pTime, u64 ullTime)
{
throw __FUNCTION__;
}
s32 sceRtcGetTime_t(vm::psv::ptr<const SceDateTime> pTime, vm::psv::ptr<u32> piTime)
s32 sceRtcGetTime_t(vm::ptr<const SceDateTime> pTime, vm::ptr<u32> piTime)
{
throw __FUNCTION__;
}
s32 sceRtcGetTime64_t(vm::psv::ptr<const SceDateTime> pTime, vm::psv::ptr<u64> pullTime)
s32 sceRtcGetTime64_t(vm::ptr<const SceDateTime> pTime, vm::ptr<u64> pullTime)
{
throw __FUNCTION__;
}
s32 sceRtcSetDosTime(vm::psv::ptr<SceDateTime> pTime, u32 uiDosTime)
s32 sceRtcSetDosTime(vm::ptr<SceDateTime> pTime, u32 uiDosTime)
{
throw __FUNCTION__;
}
s32 sceRtcGetDosTime(vm::psv::ptr<const SceDateTime> pTime, vm::psv::ptr<u32> puiDosTime)
s32 sceRtcGetDosTime(vm::ptr<const SceDateTime> pTime, vm::ptr<u32> puiDosTime)
{
throw __FUNCTION__;
}
s32 sceRtcSetWin32FileTime(vm::psv::ptr<SceDateTime> pTime, u64 ulWin32Time)
s32 sceRtcSetWin32FileTime(vm::ptr<SceDateTime> pTime, u64 ulWin32Time)
{
throw __FUNCTION__;
}
s32 sceRtcGetWin32FileTime(vm::psv::ptr<const SceDateTime> pTime, vm::psv::ptr<u64> ulWin32Time)
s32 sceRtcGetWin32FileTime(vm::ptr<const SceDateTime> pTime, vm::ptr<u64> ulWin32Time)
{
throw __FUNCTION__;
}
s32 sceRtcSetTick(vm::psv::ptr<SceDateTime> pTime, vm::psv::ptr<const u64> pTick)
s32 sceRtcSetTick(vm::ptr<SceDateTime> pTime, vm::ptr<const u64> pTick)
{
throw __FUNCTION__;
}
s32 sceRtcGetTick(vm::psv::ptr<const SceDateTime> pTime, vm::psv::ptr<u64> pTick)
s32 sceRtcGetTick(vm::ptr<const SceDateTime> pTime, vm::ptr<u64> pTick)
{
throw __FUNCTION__;
}
s32 sceRtcCompareTick(vm::psv::ptr<const u64> pTick1, vm::psv::ptr<const u64> pTick2)
s32 sceRtcCompareTick(vm::ptr<const u64> pTick1, vm::ptr<const u64> pTick2)
{
throw __FUNCTION__;
}
s32 sceRtcTickAddTicks(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, u64 lAdd)
s32 sceRtcTickAddTicks(vm::ptr<u64> pTick0, vm::ptr<const u64> pTick1, u64 lAdd)
{
throw __FUNCTION__;
}
s32 sceRtcTickAddMicroseconds(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, u64 lAdd)
s32 sceRtcTickAddMicroseconds(vm::ptr<u64> pTick0, vm::ptr<const u64> pTick1, u64 lAdd)
{
throw __FUNCTION__;
}
s32 sceRtcTickAddSeconds(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, u64 lAdd)
s32 sceRtcTickAddSeconds(vm::ptr<u64> pTick0, vm::ptr<const u64> pTick1, u64 lAdd)
{
throw __FUNCTION__;
}
s32 sceRtcTickAddMinutes(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, u64 lAdd)
s32 sceRtcTickAddMinutes(vm::ptr<u64> pTick0, vm::ptr<const u64> pTick1, u64 lAdd)
{
throw __FUNCTION__;
}
s32 sceRtcTickAddHours(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, s32 lAdd)
s32 sceRtcTickAddHours(vm::ptr<u64> pTick0, vm::ptr<const u64> pTick1, s32 lAdd)
{
throw __FUNCTION__;
}
s32 sceRtcTickAddDays(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, s32 lAdd)
s32 sceRtcTickAddDays(vm::ptr<u64> pTick0, vm::ptr<const u64> pTick1, s32 lAdd)
{
throw __FUNCTION__;
}
s32 sceRtcTickAddWeeks(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, s32 lAdd)
s32 sceRtcTickAddWeeks(vm::ptr<u64> pTick0, vm::ptr<const u64> pTick1, s32 lAdd)
{
throw __FUNCTION__;
}
s32 sceRtcTickAddMonths(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, s32 lAdd)
s32 sceRtcTickAddMonths(vm::ptr<u64> pTick0, vm::ptr<const u64> pTick1, s32 lAdd)
{
throw __FUNCTION__;
}
s32 sceRtcTickAddYears(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, s32 lAdd)
s32 sceRtcTickAddYears(vm::ptr<u64> pTick0, vm::ptr<const u64> pTick1, s32 lAdd)
{
throw __FUNCTION__;
}
s32 sceRtcFormatRFC2822(vm::psv::ptr<char> pszDateTime, vm::psv::ptr<const u64> pUtc, s32 iTimeZoneMinutes)
s32 sceRtcFormatRFC2822(vm::ptr<char> pszDateTime, vm::ptr<const u64> pUtc, s32 iTimeZoneMinutes)
{
throw __FUNCTION__;
}
s32 sceRtcFormatRFC2822LocalTime(vm::psv::ptr<char> pszDateTime, vm::psv::ptr<const u64> pUtc)
s32 sceRtcFormatRFC2822LocalTime(vm::ptr<char> pszDateTime, vm::ptr<const u64> pUtc)
{
throw __FUNCTION__;
}
s32 sceRtcFormatRFC3339(vm::psv::ptr<char> pszDateTime, vm::psv::ptr<const u64> pUtc, s32 iTimeZoneMinutes)
s32 sceRtcFormatRFC3339(vm::ptr<char> pszDateTime, vm::ptr<const u64> pUtc, s32 iTimeZoneMinutes)
{
throw __FUNCTION__;
}
s32 sceRtcFormatRFC3339LocalTime(vm::psv::ptr<char> pszDateTime, vm::psv::ptr<const u64> pUtc)
s32 sceRtcFormatRFC3339LocalTime(vm::ptr<char> pszDateTime, vm::ptr<const u64> pUtc)
{
throw __FUNCTION__;
}
s32 sceRtcParseDateTime(vm::psv::ptr<u64> pUtc, vm::psv::ptr<const char> pszDateTime)
s32 sceRtcParseDateTime(vm::ptr<u64> pUtc, vm::ptr<const char> pszDateTime)
{
throw __FUNCTION__;
}
s32 sceRtcParseRFC3339(vm::psv::ptr<u64> pUtc, vm::psv::ptr<const char> pszDateTime)
s32 sceRtcParseRFC3339(vm::ptr<u64> pUtc, vm::ptr<const char> pszDateTime)
{
throw __FUNCTION__;
}
@ -197,6 +197,7 @@ psv_log_base sceRtc("SceRtc", []()
sceRtc.on_load = nullptr;
sceRtc.on_unload = nullptr;
sceRtc.on_stop = nullptr;
sceRtc.on_error = nullptr;
REG_FUNC(0x23F79274, sceRtcGetCurrentTick);
REG_FUNC(0xCDDD25FE, sceRtcGetCurrentNetworkTick);

3
rpcs3/Emu/ARMv7/Modules/sceRtc.h Normal file
View File

@ -0,0 +1,3 @@
#pragma once
extern psv_log_base sceRtc;

19
rpcs3/Emu/ARMv7/Modules/sceSas.cpp
View File

@ -2,24 +2,24 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceSas;
#include "sceSas.h"
s32 sceSasGetNeededMemorySize(vm::psv::ptr<const char> config, vm::psv::ptr<u32> outSize)
s32 sceSasGetNeededMemorySize(vm::ptr<const char> config, vm::ptr<u32> outSize)
{
throw __FUNCTION__;
}
s32 sceSasInit(vm::psv::ptr<const char> config, vm::psv::ptr<void> buffer, u32 bufferSize)
s32 sceSasInit(vm::ptr<const char> config, vm::ptr<void> buffer, u32 bufferSize)
{
throw __FUNCTION__;
}
s32 sceSasInitWithGrain(vm::psv::ptr<const char> config, u32 grain, vm::psv::ptr<void> buffer, u32 bufferSize)
s32 sceSasInitWithGrain(vm::ptr<const char> config, u32 grain, vm::ptr<void> buffer, u32 bufferSize)
{
throw __FUNCTION__;
}
s32 sceSasExit(vm::psv::pptr<void> outBuffer, vm::psv::ptr<u32> outBufferSize)
s32 sceSasExit(vm::pptr<void> outBuffer, vm::ptr<u32> outBufferSize)
{
throw __FUNCTION__;
}
@ -44,22 +44,22 @@ s32 sceSasGetOutputmode()
throw __FUNCTION__;
}
s32 sceSasCore(vm::psv::ptr<s16> out)
s32 sceSasCore(vm::ptr<s16> out)
{
throw __FUNCTION__;
}
s32 sceSasCoreWithMix(vm::psv::ptr<s16> inOut, s32 lvol, s32 rvol)
s32 sceSasCoreWithMix(vm::ptr<s16> inOut, s32 lvol, s32 rvol)
{
throw __FUNCTION__;
}
s32 sceSasSetVoice(s32 iVoiceNum, vm::psv::ptr<const void> vagBuf, u32 size, u32 loopflag)
s32 sceSasSetVoice(s32 iVoiceNum, vm::ptr<const void> vagBuf, u32 size, u32 loopflag)
{
throw __FUNCTION__;
}
s32 sceSasSetVoicePCM(s32 iVoiceNum, vm::psv::ptr<const void> pcmBuf, u32 size, s32 loopsize)
s32 sceSasSetVoicePCM(s32 iVoiceNum, vm::ptr<const void> pcmBuf, u32 size, s32 loopsize)
{
throw __FUNCTION__;
}
@ -157,6 +157,7 @@ psv_log_base sceSas("SceSas", []()
sceSas.on_load = nullptr;
sceSas.on_unload = nullptr;
sceSas.on_stop = nullptr;
sceSas.on_error = nullptr;
//REG_FUNC(0xA2209C58, sceAsSetRegisterReportHandler);
//REG_FUNC(0xBB635544, sceAsSetUnregisterReportHandler);

3
rpcs3/Emu/ARMv7/Modules/sceSas.h Normal file
View File

@ -0,0 +1,3 @@
#pragma once
extern psv_log_base sceSas;

15
rpcs3/Emu/ARMv7/Modules/sceScreenShot.cpp
View File

@ -2,22 +2,14 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceScreenShot;
#include "sceScreenShot.h"
struct SceScreenShotParam
{
vm::psv::ptr<const char> photoTitle;
vm::psv::ptr<const char> gameTitle;
vm::psv::ptr<const char> gameComment;
vm::psv::ptr<void> reserved;
};
s32 sceScreenShotSetParam(vm::psv::ptr<const SceScreenShotParam> param)
s32 sceScreenShotSetParam(vm::ptr<const SceScreenShotParam> param)
{
throw __FUNCTION__;
}
s32 sceScreenShotSetOverlayImage(vm::psv::ptr<const char> filePath, s32 offsetX, s32 offsetY)
s32 sceScreenShotSetOverlayImage(vm::ptr<const char> filePath, s32 offsetX, s32 offsetY)
{
throw __FUNCTION__;
}
@ -40,6 +32,7 @@ psv_log_base sceScreenShot("SceScreenShot", []()
sceScreenShot.on_load = nullptr;
sceScreenShot.on_unload = nullptr;
sceScreenShot.on_stop = nullptr;
sceScreenShot.on_error = nullptr;
REG_FUNC(0x05DB59C7, sceScreenShotSetParam);
REG_FUNC(0x7061665B, sceScreenShotSetOverlayImage);

11
rpcs3/Emu/ARMv7/Modules/sceScreenShot.h Normal file
View File

@ -0,0 +1,11 @@
#pragma once
struct SceScreenShotParam
{
vm::lcptr<char> photoTitle;
vm::lcptr<char> gameTitle;
vm::lcptr<char> gameComment;
vm::lptr<void> reserved;
};
extern psv_log_base sceScreenShot;

1
rpcs3/Emu/ARMv7/Modules/sceSfmt.cpp
View File

@ -11,6 +11,7 @@ psv_log_base sceSfmt("SceSfmt", []()
sceSfmt.on_load = nullptr;
sceSfmt.on_unload = nullptr;
sceSfmt.on_stop = nullptr;
sceSfmt.on_error = nullptr;
//REG_FUNC(0x8FF464C9, sceSfmt11213InitGenRand);
//REG_FUNC(0xBAF5F058, sceSfmt11213InitByArray);

1
rpcs3/Emu/ARMv7/Modules/sceSha.cpp
View File

@ -11,6 +11,7 @@ psv_log_base sceSha("SceSha", []()
sceSha.on_load = nullptr;
sceSha.on_unload = nullptr;
sceSha.on_stop = nullptr;
sceSha.on_error = nullptr;
//REG_FUNC(0xD19A9AA8, sceSha0Digest);
//REG_FUNC(0xBCF6DB3A, sceSha0BlockInit);

3
rpcs3/Emu/ARMv7/Modules/sceSqlite.cpp
View File

@ -2,7 +2,7 @@
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceSqlite;
#include "sceSqlite.h"
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceSqlite, #name, name)
@ -11,6 +11,7 @@ psv_log_base sceSqlite("SceSqlite", []()
sceSqlite.on_load = nullptr;
sceSqlite.on_unload = nullptr;
sceSqlite.on_stop = nullptr;
sceSqlite.on_error = nullptr;
//REG_FUNC(0x26E46324, sqlite3_libversion);
//REG_FUNC(0x4CCB58A2, sqlite3_sourceid);

Some files were not shown because too many files have changed in this diff Show More