PSP汉化项目架构：可执行文件的处理
汉化项目往往演变成游戏的Mod，对可执行文件静态的字符串和机器指令修改往往难以满足需求。
PSP的模块（Module）为我们提供类似动态链接库的机制，允许我们在同一地址空间加载多个可执行与可链接文件，他们之间可以相互跳转。
UMD镜像中的EBOOT.BIN默认会加载到0x08804000地址处，后续加载的PRX模块将加载到更高的内存地址。
三模块架构
为了对可执行文件进行修改，引入两个新的组件。
- 运行时补丁插件（Runtime Patch）：用于保存游戏加载的基地址，修改游戏内存，提供新的函数等。
- 加载器（Loader）：用于加载游戏和补丁插件，可以用于在游戏启动前添加欢迎界面和菜单。
游戏的启动流程变为：
- 启动加载器，将游戏载入内存。
- 将运行时补丁插件载入内存。
- 启动运行时补丁，传入游戏的模块ID
- 运行时补丁通过模块ID获取游戏的基地址并修改游戏内存
- 启动游戏
// 加载游戏
SceUID eboot_mid = sceKernelLoadModule(PathOldBoot, 0, NULL);
if (eboot_mid >= 0) {
// 加载运行时补丁插件
SceUID runtime_mid = sceKernelLoadModule(PathRuntime, 0, NULL);
Eva2RuntimeStartArgs runtime_args;
runtime_args.boot_mid = eboot_mid;
if (runtime_mid >= 0) {
sceKernelStartModule(runtime_mid, sizeof(runtime_args), &runtime_args, NULL, NULL);
}
sceKernelStartModule(eboot_mid, 0, NULL, NULL, NULL);
}
内存布局如下
|------|
|Plugin|
|------|
|Game |
|------|
|Loader| - Base Addr 0x08004000
|------|
这种设计的缺点是游戏的基地址会发生改变，金手指（CWCheat）将失效。优点是所有内容可以嵌入镜像中，使得补丁的发布和用户的使用更为便捷。
该架构受到了ZhenjianYang/ZeroAoVoice-PSP的启发。
游戏可执行文件的分析
对于标准的UMD游戏镜像，可执行文件储存在SYSDIR/EBOOT.BIN，格式为加密后的PRX（PlayStation Relocatable Executable）。
为分析该PRX文件，首先需要对文件进行解密。
可以使用Linblow/pspdecrypt或者PPSSPP进行解密。
pspdecrypt 'SYSDIR/EBOOT.BIN' -o '$(EXPORT_SYSDIR)/BOOT.BIN'
解密后的文件可以使用IDA Pro打开。
导入表（Import Table）解析
前面提到了PSP拥有动态链接库机制，游戏本体也充分利用了这一点。游戏会以桩函数（Stub）的形式导入外部函数，这些函数以模块名+PID的格式标注，IDA Pro无法直接解析。
此时需要使用prxtool结合已有的PID函数名映射表来标注这些函数。
首先，获取PSPLibDoc.xml，其中包括了历年来逆向得到的PSP系统提供的函数所属的模块名、PID和对应的函数名
运行下列命令，即可得到boot.idc文件
prxtool --xmlfile PSPLibDoc.xml BOOT.BIN > boot.idc
在 IDA Pro 中运行File -> Script file...导入该idc文件，即可加载相关函数名
函数名加载后，还需要添加函数定义便于 IDA Pro 进行进一步解析。
IDA Pro 支持从.h头文件中导入函数定义。使用预处理器处理PSPSDK中的头文件可以获得符合要求的头文件。处理后的头文件见附录。
在 IDA Pro 中运行File -> Load file -> Parse C header file...导入该头文件，即可加载相关函数定义，导入后的结构体定义可以在Local Types窗口中查看。
执行上述步骤后，建议运行Edit -> Segments -> Rebase program... 并将Image base设置为0x08004000与实际机器和模拟器保持一致。
分析可执行文件
游戏的启动入口位于module_start函数。通常会根据分析出来的导入表中的函数定位需要修改的相关功能的具体位置。例如通过分析sceFont函数的调用链寻找文本显示相关的函数，通过分析sceIo函数的调用链寻找资源文件解析相关的函数。
通过使用 IDA Pro MCP 配合Codex或Claude Code可以实现自动化分析。
使用 Ghidra 配合插件也可以实现类似的操作。
附录
PSPSDK函数签名头文件
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"
typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef short int __int16_t;
typedef short unsigned int __uint16_t;
typedef long int __int32_t;
typedef long unsigned int __uint32_t;
typedef long long int __int64_t;
typedef long long unsigned int __uint64_t;
typedef signed char __int_least8_t;
typedef unsigned char __uint_least8_t;
typedef short int __int_least16_t;
typedef short unsigned int __uint_least16_t;
typedef long int __int_least32_t;
typedef long unsigned int __uint_least32_t;
typedef long long int __int_least64_t;
typedef long long unsigned int __uint_least64_t;
typedef long long int __intmax_t;
typedef long long unsigned int __uintmax_t;
typedef int __intptr_t;
typedef unsigned int __uintptr_t;
typedef __int8_t int8_t ;
typedef __uint8_t uint8_t ;
typedef __int16_t int16_t ;
typedef __uint16_t uint16_t ;
typedef __int32_t int32_t ;
typedef __uint32_t uint32_t ;
typedef __int64_t int64_t ;
typedef __uint64_t uint64_t ;
typedef __intmax_t intmax_t;
typedef __uintmax_t uintmax_t;
typedef __intptr_t intptr_t;
typedef __uintptr_t uintptr_t;
typedef __int_least8_t int_least8_t;
typedef __uint_least8_t uint_least8_t;
typedef __int_least16_t int_least16_t;
typedef __uint_least16_t uint_least16_t;
typedef __int_least32_t int_least32_t;
typedef __uint_least32_t uint_least32_t;
typedef __int_least64_t int_least64_t;
typedef __uint_least64_t uint_least64_t;
typedef int int_fast8_t;
typedef unsigned int uint_fast8_t;
typedef int int_fast16_t;
typedef unsigned int uint_fast16_t;
typedef int int_fast32_t;
typedef unsigned int uint_fast32_t;
typedef long long int int_fast64_t;
typedef long long unsigned int uint_fast64_t;
#pragma GCC diagnostic pop
typedef uint8_t u8;
typedef uint16_t u16;
typedef uint32_t u32;
typedef uint64_t u64;
typedef int8_t s8;
typedef int16_t s16;
typedef int32_t s32;
typedef int64_t s64;
typedef volatile uint8_t vu8;
typedef volatile uint16_t vu16;
typedef volatile uint32_t vu32;
typedef volatile uint64_t vu64;
typedef volatile int8_t vs8;
typedef volatile int16_t vs16;
typedef volatile int32_t vs32;
typedef volatile int64_t vs64;
u8 _lb(u32 addr) { return *(vu8 *)addr; }
u16 _lh(u32 addr) { return *(vu16 *)addr; }
u32 _lw(u32 addr) { return *(vu32 *)addr; }
u64 _ld(u32 addr) { return *(vu64 *)addr; }
void _sb(u8 val, u32 addr) { *(vu8 *)addr = val; }
void _sh(u16 val, u32 addr) { *(vu16 *)addr = val; }
void _sw(u32 val, u32 addr) { *(vu32 *)addr = val; }
void _sd(u64 val, u32 addr) { *(vu64 *)addr = val; }
typedef unsigned char SceUChar8;
typedef uint16_t SceUShort16;
typedef uint32_t SceUInt32;
typedef uint64_t SceUInt64;
typedef uint64_t SceULong64;
typedef char SceChar8;
typedef int16_t SceShort16;
typedef int32_t SceInt32;
typedef int64_t SceInt64;
typedef int64_t SceLong64;
typedef float SceFloat;
typedef float SceFloat32;
typedef short unsigned int SceWChar16;
typedef unsigned int SceWChar32;
typedef int SceBool;
typedef void SceVoid;
typedef void * ScePVoid;
typedef unsigned int SceSize;
typedef struct ScePspSRect {
short int x;
short int y;
short int w;
short int h;
} ScePspSRect;
typedef struct ScePspIRect {
int x;
int y;
int w;
int h;
} ScePspIRect;
typedef struct ScePspL64Rect {
SceLong64 x;
SceLong64 y;
SceLong64 w;
SceLong64 h;
} ScePspL64Rect;
typedef struct ScePspFRect {
float x;
float y;
float w;
float h;
} ScePspFRect;
typedef struct ScePspSVector2 {
short int x;
short int y;
} ScePspSVector2;
typedef struct ScePspIVector2 {
int x;
int y;
} ScePspIVector2;
typedef struct ScePspL64Vector2 {
SceLong64 x;
SceLong64 y;
} ScePspL64Vector2;
typedef struct ScePspFVector2 {
float x;
float y;
} ScePspFVector2;
typedef union ScePspVector2 {
ScePspFVector2 fv;
ScePspIVector2 iv;
float f[2];
int i[2];
} ScePspVector2;
typedef struct ScePspSVector3 {
short int x;
short int y;
short int z;
} ScePspSVector3;
typedef struct ScePspIVector3 {
int x;
int y;
int z;
} ScePspIVector3;
typedef struct ScePspL64Vector3 {
SceLong64 x;
SceLong64 y;
SceLong64 z;
} ScePspL64Vector3;
typedef struct ScePspFVector3 {
float x;
float y;
float z;
} ScePspFVector3;
typedef union ScePspVector3 {
ScePspFVector3 fv;
ScePspIVector3 iv;
float f[3];
int i[3];
} ScePspVector3;
typedef struct ScePspSVector4 {
short int x;
short int y;
short int z;
short int w;
} ScePspSVector4;
typedef struct ScePspIVector4 {
int x;
int y;
int z;
int w;
} ScePspIVector4;
typedef struct ScePspL64Vector4 {
SceLong64 x;
SceLong64 y;
SceLong64 z;
SceLong64 w;
} ScePspL64Vector4;
typedef struct ScePspFVector4 {
float x;
float y;
float z;
float w;
} ScePspFVector4 ;
typedef struct ScePspFVector4Unaligned {
float x;
float y;
float z;
float w;
} ScePspFVector4Unaligned;
typedef union ScePspVector4 {
ScePspFVector4 fv;
ScePspIVector4 iv;
float f[4];
int i[4];
} ScePspVector4 ;
typedef struct ScePspIMatrix2 {
ScePspIVector2 x;
ScePspIVector2 y;
} ScePspIMatrix2;
typedef struct ScePspFMatrix2 {
ScePspFVector2 x;
ScePspFVector2 y;
} ScePspFMatrix2;
typedef union ScePspMatrix2 {
ScePspFMatrix2 fm;
ScePspIMatrix2 im;
ScePspFVector2 fv[2];
ScePspIVector2 iv[2];
ScePspVector2 v[2];
float f[2][2];
int i[2][2];
} ScePspMatrix2;
typedef struct ScePspIMatrix3 {
ScePspIVector3 x;
ScePspIVector3 y;
ScePspIVector3 z;
} ScePspIMatrix3;
typedef struct ScePspFMatrix3 {
ScePspFVector3 x;
ScePspFVector3 y;
ScePspFVector3 z;
} ScePspFMatrix3;
typedef union ScePspMatrix3 {
ScePspFMatrix3 fm;
ScePspIMatrix3 im;
ScePspFVector3 fv[3];
ScePspIVector3 iv[3];
ScePspVector3 v[3];
float f[3][3];
int i[3][3];
} ScePspMatrix3;
typedef struct ScePspIMatrix4 {
ScePspIVector4 x;
ScePspIVector4 y;
ScePspIVector4 z;
ScePspIVector4 w;
} ScePspIMatrix4 ;
typedef struct ScePspIMatrix4Unaligned {
ScePspIVector4 x;
ScePspIVector4 y;
ScePspIVector4 z;
ScePspIVector4 w;
} ScePspIMatrix4Unaligned;
typedef struct ScePspFMatrix4 {
ScePspFVector4 x;
ScePspFVector4 y;
ScePspFVector4 z;
ScePspFVector4 w;
} ScePspFMatrix4 ;
typedef struct ScePspFMatrix4Unaligned {
ScePspFVector4 x;
ScePspFVector4 y;
ScePspFVector4 z;
ScePspFVector4 w;
} ScePspFMatrix4Unaligned;
typedef union ScePspMatrix4 {
ScePspFMatrix4 fm;
ScePspIMatrix4 im;
ScePspFVector4 fv[4];
ScePspIVector4 iv[4];
ScePspVector4 v[4];
float f[4][4];
int i[4][4];
} ScePspMatrix4;
typedef struct ScePspFQuaternion {
float x;
float y;
float z;
float w;
} ScePspFQuaternion ;
typedef struct ScePspFQuaternionUnaligned {
float x;
float y;
float z;
float w;
} ScePspFQuaternionUnaligned;
typedef struct ScePspFColor {
float r;
float g;
float b;
float a;
} ScePspFColor ;
typedef struct ScePspFColorUnaligned {
float r;
float g;
float b;
float a;
} ScePspFColorUnaligned;
typedef unsigned int ScePspRGBA8888;
typedef unsigned short ScePspRGBA4444;
typedef unsigned short ScePspRGBA5551;
typedef unsigned short ScePspRGB565;
typedef union ScePspUnion32 {
unsigned int ui;
int i;
unsigned short us[2];
short int s[2];
unsigned char uc[4];
char c[4];
float f;
ScePspRGBA8888 rgba8888;
ScePspRGBA4444 rgba4444[2];
ScePspRGBA5551 rgba5551[2];
ScePspRGB565 rgb565[2];
} ScePspUnion32;
typedef union ScePspUnion64 {
SceULong64 ul;
SceLong64 l;
unsigned int ui[2];
int i[2];
unsigned short us[4];
short int s[4];
unsigned char uc[8];
char c[8];
float f[2];
ScePspSRect sr;
ScePspSVector4 sv;
ScePspRGBA8888 rgba8888[2];
ScePspRGBA4444 rgba4444[4];
ScePspRGBA5551 rgba5551[4];
ScePspRGB565 rgb565[4];
} ScePspUnion64;
typedef union ScePspUnion128 {
SceULong64 ul[2];
SceLong64 l[2];
unsigned int ui[4];
int i[4];
unsigned short us[8];
short int s[8];
unsigned char uc[16];
char c[16];
float f[4];
ScePspFRect fr;
ScePspIRect ir;
ScePspFVector4 fv;
ScePspIVector4 iv;
ScePspFQuaternion fq;
ScePspFColor fc;
ScePspRGBA8888 rgba8888[4];
ScePspRGBA4444 rgba4444[8];
ScePspRGBA5551 rgba5551[8];
ScePspRGB565 rgb565[8];
} ScePspUnion128 ;
typedef struct ScePspDateTime {
unsigned short year;
unsigned short month;
unsigned short day;
unsigned short hour;
unsigned short minute;
unsigned short second;
unsigned int microsecond;
} ScePspDateTime;
typedef int (*SceKernelThreadEntry)(SceSize args, void *argp);
typedef int SceUID;
typedef unsigned int SceSize;
typedef int SceSSize;
typedef unsigned char SceUChar;
typedef unsigned int SceUInt;
typedef int SceMode;
typedef SceInt64 SceOff;
typedef SceInt64 SceIores;
int sceKernelRegisterExitCallback(int cbid);
void sceKernelExitGame(void);
struct SceKernelLoadExecParam {
SceSize size;
SceSize args;
void * argp;
const char * key;
};
int sceKernelLoadExec(const char *file, struct SceKernelLoadExecParam *param);
typedef int ptrdiff_t;
typedef unsigned int size_t;
typedef int wchar_t;
typedef struct {
long long __max_align_ll ;
long double __max_align_ld ;
} max_align_t;
// typedef __typeof__(0) nullptr_t;
typedef unsigned int wint_t;
typedef long __blkcnt_t;
typedef long __blksize_t;
typedef __uint64_t __fsblkcnt_t;
typedef __uint32_t __fsfilcnt_t;
typedef long _off_t;
typedef int __pid_t;
typedef short __dev_t;
typedef unsigned short __uid_t;
typedef unsigned short __gid_t;
typedef __uint32_t __id_t;
typedef unsigned short __ino_t;
typedef __uint32_t __mode_t;
typedef long long _off64_t;
typedef _off_t __off_t;
typedef _off64_t __loff_t;
typedef long __key_t;
typedef long _fpos_t;
typedef unsigned int __size_t;
typedef signed int _ssize_t;
typedef _ssize_t __ssize_t;
typedef struct
{
int __count;
union
{
wint_t __wch;
unsigned char __wchb[4];
} __value;
} _mbstate_t;
typedef void *_iconv_t;
typedef unsigned long __clock_t;
typedef __int_least64_t __time_t;
typedef unsigned long __clockid_t;
typedef long __daddr_t;
typedef unsigned long __timer_t;
typedef __uint8_t __sa_family_t;
typedef __uint32_t __socklen_t;
typedef int __nl_item;
typedef unsigned short __nlink_t;
typedef long __suseconds_t;
typedef unsigned long __useconds_t;
typedef void* __va_list;
typedef __suseconds_t suseconds_t;
typedef __int_least64_t time_t;
struct timeval {
time_t tv_sec;
suseconds_t tv_usec;
};
typedef __uint8_t u_int8_t;
typedef __uint16_t u_int16_t;
typedef __uint32_t u_int32_t;
typedef __uint64_t u_int64_t;
typedef __intptr_t register_t;
typedef unsigned long __sigset_t;
struct timespec {
time_t tv_sec;
long tv_nsec;
};
struct itimerspec {
struct timespec it_interval;
struct timespec it_value;
};
typedef __sigset_t sigset_t;
typedef unsigned long __fd_mask;
typedef __fd_mask fd_mask;
typedef struct fd_set {
__fd_mask __fds_bits[(((64) + ((((int)sizeof(__fd_mask) * 8)) - 1)) / (((int)sizeof(__fd_mask) * 8)))];
} fd_set;
int select (int __n, fd_set *__readfds, fd_set *__writefds, fd_set *__exceptfds, struct timeval *__timeout);
int pselect (int __n, fd_set *__readfds, fd_set *__writefds, fd_set *__exceptfds, const struct timespec *__timeout, const sigset_t *__set);
typedef __uint32_t in_addr_t;
typedef __uint16_t in_port_t;
typedef __uintptr_t u_register_t;
typedef unsigned char u_char;
typedef unsigned short u_short;
typedef unsigned int u_int;
typedef unsigned long u_long;
typedef unsigned short ushort;
typedef unsigned int uint;
typedef unsigned long ulong;
typedef __blkcnt_t blkcnt_t;
typedef __blksize_t blksize_t;
typedef unsigned long clock_t;
typedef __daddr_t daddr_t;
typedef char * caddr_t;
typedef __fsblkcnt_t fsblkcnt_t;
typedef __fsfilcnt_t fsfilcnt_t;
typedef __id_t id_t;
typedef __ino_t ino_t;
typedef __off_t off_t;
typedef __dev_t dev_t;
typedef __uid_t uid_t;
typedef __gid_t gid_t;
typedef __pid_t pid_t;
typedef __key_t key_t;
typedef _ssize_t ssize_t;
typedef __mode_t mode_t;
typedef __nlink_t nlink_t;
typedef __clockid_t clockid_t;
typedef __timer_t timer_t;
typedef __useconds_t useconds_t;
typedef __int64_t sbintime_t;
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"
#pragma GCC diagnostic pop
enum
{
SCHED_OTHER = 0,
SCHED_FIFO,
SCHED_RR,
SCHED_MIN = SCHED_OTHER,
SCHED_MAX = SCHED_RR
};
struct sched_param
{
int sched_priority;
};
typedef struct pthread_t_ * pthread_t;
typedef struct pthread_attr_t_ * pthread_attr_t;
enum
{
PTHREAD_MUTEX_FAST_NP,
PTHREAD_MUTEX_RECURSIVE_NP,
PTHREAD_MUTEX_ERRORCHECK_NP,
PTHREAD_MUTEX_TIMED_NP = PTHREAD_MUTEX_FAST_NP,
PTHREAD_MUTEX_ADAPTIVE_NP = PTHREAD_MUTEX_FAST_NP,
PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_FAST_NP,
PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL
};
typedef struct pthread_mutex_t_ * pthread_mutex_t;
typedef struct pthread_mutexattr_t_ * pthread_mutexattr_t;
typedef struct pthread_cond_t_ * pthread_cond_t;
typedef struct pthread_condattr_t_ * pthread_condattr_t;
struct pthread_once_t_ {
int state;
void * semaphore;
int numSemaphoreUsers;
int done;
};
typedef struct pthread_once_t_ pthread_once_t;
typedef struct pthread_key_t_ * pthread_key_t;
typedef struct pthread_barrier_t_ * pthread_barrier_t;
typedef struct pthread_barrierattr_t_ * pthread_barrierattr_t;
typedef struct pthread_spinlock_t_ * pthread_spinlock_t;
typedef struct pthread_rwlock_t_ * pthread_rwlock_t;
typedef struct pthread_rwlockattr_t_ * pthread_rwlockattr_t;
struct timezone {
int tz_minuteswest;
int tz_dsttime;
};
struct bintime {
time_t sec;
uint64_t frac;
};
struct itimerval {
struct timeval it_interval;
struct timeval it_value;
};
typedef unsigned long __ULong;
struct __lock;
typedef struct __lock * _LOCK_T;
extern void __retarget_lock_init(_LOCK_T *lock);
extern void __retarget_lock_init_recursive(_LOCK_T *lock);
extern void __retarget_lock_close(_LOCK_T lock);
extern void __retarget_lock_close_recursive(_LOCK_T lock);
extern void __retarget_lock_acquire(_LOCK_T lock);
extern void __retarget_lock_acquire_recursive(_LOCK_T lock);
extern int __retarget_lock_try_acquire(_LOCK_T lock);
extern int __retarget_lock_try_acquire_recursive(_LOCK_T lock);
extern void __retarget_lock_release(_LOCK_T lock);
extern void __retarget_lock_release_recursive(_LOCK_T lock);
typedef _LOCK_T _flock_t;
struct _reent;
struct __locale_t;
struct _Bigint
{
struct _Bigint *_next;
int _k, _maxwds, _sign, _wds;
__ULong _x[1];
};
struct __tm
{
int __tm_sec;
int __tm_min;
int __tm_hour;
int __tm_mday;
int __tm_mon;
int __tm_year;
int __tm_wday;
int __tm_yday;
int __tm_isdst;
};
struct _on_exit_args {
void * _fnargs[32];
void * _dso_handle[32];
__ULong _fntypes;
__ULong _is_cxa;
};
struct _atexit {
struct _atexit *_next;
int _ind;
void (*_fns[32])(void);
struct _on_exit_args _on_exit_args;
};
struct __sbuf {
unsigned char *_base;
int _size;
};
struct __sFILE {
unsigned char *_p;
int _r;
int _w;
short _flags;
short _file;
struct __sbuf _bf;
int _lbfsize;
void * _cookie;
int (*_read) (struct _reent *, void *,
char *, int);
int (*_write) (struct _reent *, void *,
const char *,
int);
_fpos_t (*_seek) (struct _reent *, void *, _fpos_t, int);
int (*_close) (struct _reent *, void *);
struct __sbuf _ub;
unsigned char *_up;
int _ur;
unsigned char _ubuf[3];
unsigned char _nbuf[1];
struct __sbuf _lb;
int _blksize;
_off_t _offset;
struct _reent *_data;
_flock_t _lock;
_mbstate_t _mbstate;
int _flags2;
};
typedef struct __sFILE __FILE;
extern __FILE __sf[3];
struct _glue
{
struct _glue *_next;
int _niobs;
__FILE *_iobs;
};
extern struct _glue __sglue;
struct _rand48 {
unsigned short _seed[3];
unsigned short _mult[3];
unsigned short _add;
};
struct _reent
{
int _errno;
__FILE *_stdin, *_stdout, *_stderr;
int _inc;
char _emergency[25];
struct __locale_t *_locale;
void (*__cleanup) (struct _reent *);
struct _Bigint *_result;
int _result_k;
struct _Bigint *_p5s;
struct _Bigint **_freelist;
int _cvtlen;
char *_cvtbuf;
union
{
struct
{
char * _strtok_last;
char _asctime_buf[26];
struct __tm _localtime_buf;
int _gamma_signgam;
unsigned long long _rand_next;
struct _rand48 _r48;
_mbstate_t _mblen_state;
_mbstate_t _mbtowc_state;
_mbstate_t _wctomb_state;
char _l64a_buf[8];
char _signal_buf[24];
int _getdate_err;
_mbstate_t _mbrlen_state;
_mbstate_t _mbrtowc_state;
_mbstate_t _mbsrtowcs_state;
_mbstate_t _wcrtomb_state;
_mbstate_t _wcsrtombs_state;
int _h_errno;
char _getlocalename_l_buf[32 ];
} _reent;
} _new;
void (**_sig_func)(int);
};
extern struct _reent *_impure_ptr ;
extern struct _reent _impure_data ;
extern struct _atexit *__atexit;
extern struct _atexit __atexit0;
extern void (*__stdio_exit_handler) (void);
void _reclaim_reent (struct _reent *);
extern int _fwalk_sglue (struct _reent *, int (*)(struct _reent *, __FILE *),
struct _glue *);
struct __locale_t;
typedef struct __locale_t *locale_t;
struct tm
{
int tm_sec;
int tm_min;
int tm_hour;
int tm_mday;
int tm_mon;
int tm_year;
int tm_wday;
int tm_yday;
int tm_isdst;
};
clock_t clock (void);
double difftime (time_t _time2, time_t _time1);
time_t mktime (struct tm *_timeptr);
time_t time (time_t *_timer);
char *asctime (const struct tm *_tblock);
char *ctime (const time_t *_time);
struct tm *gmtime (const time_t *_timer);
struct tm *localtime (const time_t *_timer);
size_t strftime (char * _s,
size_t _maxsize, const char * _fmt,
const struct tm * _t);
extern size_t strftime_l (char * _s, size_t _maxsize,
const char * _fmt,
const struct tm * _t, locale_t _l);
char *asctime_r (const struct tm *,
char *);
char *ctime_r (const time_t *, char *);
struct tm *gmtime_r (const time_t *,
struct tm *);
struct tm *localtime_r (const time_t *,
struct tm *);
void tzset (void);
void _tzset_r (struct _reent *);
extern long _timezone;
extern int _daylight;
extern char *_tzname[2];
union sigval {
int sival_int;
void *sival_ptr;
};
struct sigevent {
int sigev_notify;
int sigev_signo;
union sigval sigev_value;
void (*sigev_notify_function)( union sigval );
pthread_attr_t *sigev_notify_attributes;
};
typedef struct {
int si_signo;
int si_code;
union sigval si_value;
} siginfo_t;
typedef void (*_sig_func_ptr)(int);
struct sigaction
{
_sig_func_ptr sa_handler;
sigset_t sa_mask;
int sa_flags;
};
typedef struct sigaltstack {
void *ss_sp;
int ss_flags;
size_t ss_size;
} stack_t;
int sigprocmask (int, const sigset_t *, sigset_t *);
int pthread_sigmask (int, const sigset_t *, sigset_t *);
int kill (pid_t, int);
int killpg (pid_t, int);
int sigaction (int, const struct sigaction *, struct sigaction *);
int sigaddset (sigset_t *, const int);
int sigdelset (sigset_t *, const int);
int sigismember (const sigset_t *, int);
int sigfillset (sigset_t *);
int sigemptyset (sigset_t *);
int sigpending (sigset_t *);
int sigsuspend (const sigset_t *);
int sigwait (const sigset_t *, int *);
int sigpause (int);
int sigaltstack (const stack_t *, stack_t *);
int pthread_kill (pthread_t, int);
int sigwaitinfo (const sigset_t *, siginfo_t *);
int sigtimedwait (const sigset_t *, siginfo_t *, const struct timespec *);
int sigqueue (pid_t, int, const union sigval);
int sig2str(int, char *);
int str2sig(const char *, int *);
typedef int sig_atomic_t;
typedef _sig_func_ptr sig_t;
struct _reent;
_sig_func_ptr _signal_r (struct _reent *, int, _sig_func_ptr);
int _raise_r (struct _reent *, int);
_sig_func_ptr signal (int, _sig_func_ptr);
int raise (int);
void psignal (int, const char *);
int clock_settime (clockid_t clock_id, const struct timespec *tp);
int clock_gettime (clockid_t clock_id, struct timespec *tp);
int clock_getres (clockid_t clock_id, struct timespec *res);
int timer_create (clockid_t clock_id,
struct sigevent * evp,
timer_t * timerid);
int timer_delete (timer_t timerid);
int timer_settime (timer_t timerid, int flags,
const struct itimerspec * value,
struct itimerspec * ovalue);
int timer_gettime (timer_t timerid, struct itimerspec *value);
int timer_getoverrun (timer_t timerid);
int nanosleep (const struct timespec *rqtp, struct timespec *rmtp);
int utimes (const char *, const struct timeval [2]);
int adjtime (const struct timeval *, struct timeval *);
int futimes (int, const struct timeval [2]);
int lutimes (const char *, const struct timeval [2]);
int settimeofday (const struct timeval *, const struct timezone *);
int getitimer (int __which, struct itimerval *__value);
int setitimer (int __which, const struct itimerval * __value,
struct itimerval * __ovalue);
int gettimeofday (struct timeval * __p,
void * __tz);
typedef struct SceKernelTimeval {
uint32_t tv_sec;
uint32_t tv_usec;
} SceKernelTimeval;
time_t sceKernelLibcTime(time_t *t);
clock_t sceKernelLibcClock(void);
int sceKernelLibcGettimeofday(struct SceKernelTimeval *tp, struct timezone *tzp);
void sceKernelDcacheWritebackAll(void);
void sceKernelDcacheWritebackInvalidateAll(void);
void sceKernelDcacheWritebackRange(const void *p, unsigned int size);
void sceKernelDcacheWritebackInvalidateRange(const void *p, unsigned int size);
void sceKernelDcacheInvalidateRange(const void *p, unsigned int size);
void sceKernelIcacheInvalidateAll(void);
void sceKernelIcacheInvalidateRange(const void *p, unsigned int size);
typedef struct _SceKernelUtilsMt19937Context {
unsigned int count;
unsigned int state[624];
} SceKernelUtilsMt19937Context;
int sceKernelUtilsMt19937Init(SceKernelUtilsMt19937Context *ctx, u32 seed);
u32 sceKernelUtilsMt19937UInt(SceKernelUtilsMt19937Context *ctx);
typedef struct _SceKernelUtilsMd5Context {
unsigned int h[4];
unsigned int pad;
SceUShort16 usRemains;
SceUShort16 usComputed;
SceULong64 ullTotalLen;
unsigned char buf[64];
} SceKernelUtilsMd5Context;
int sceKernelUtilsMd5Digest(u8 *data, u32 size, u8 *digest);
int sceKernelUtilsMd5BlockInit(SceKernelUtilsMd5Context *ctx);
int sceKernelUtilsMd5BlockUpdate(SceKernelUtilsMd5Context *ctx, u8 *data, u32 size);
int sceKernelUtilsMd5BlockResult(SceKernelUtilsMd5Context *ctx, u8 *digest);
typedef struct _SceKernelUtilsSha1Context {
unsigned int h[5];
SceUShort16 usRemains;
SceUShort16 usComputed;
SceULong64 ullTotalLen;
unsigned char buf[64];
} SceKernelUtilsSha1Context;
int sceKernelUtilsSha1Digest(u8 *data, u32 size, u8 *digest);
int sceKernelUtilsSha1BlockInit(SceKernelUtilsSha1Context *ctx);
int sceKernelUtilsSha1BlockUpdate(SceKernelUtilsSha1Context *ctx, u8 *data, u32 size);
int sceKernelUtilsSha1BlockResult(SceKernelUtilsSha1Context *ctx, u8 *digest);
typedef struct _scemoduleinfo {
unsigned short modattribute;
unsigned char modversion[2];
char modname[27];
char terminal;
void * gp_value;
void * ent_top;
void * ent_end;
void * stub_top;
void * stub_end;
} _sceModuleInfo;
typedef const _sceModuleInfo SceModuleInfo;
extern char _gp[];
enum PspModuleInfoAttr
{
PSP_MODULE_USER = 0,
PSP_MODULE_NO_STOP = 0x0001,
PSP_MODULE_SINGLE_LOAD = 0x0002,
PSP_MODULE_SINGLE_START = 0x0004,
PSP_MODULE_KERNEL = 0x1000,
};
void pspDebugScreenInit(void);
void pspDebugScreenInitEx(void *vram_base, int mode, int setup);
void pspDebugScreenPrintf(const char *fmt, ...) ;
void pspDebugScreenKprintf(const char *format, ...) ;
void pspDebugScreenEnableBackColor(int enable);
void pspDebugScreenSetBackColor(u32 color);
void pspDebugScreenSetTextColor(u32 color);
void pspDebugScreenSetColorMode(int mode);
void pspDebugScreenPutChar(int x, int y, u32 color, u8 ch);
void pspDebugScreenSetXY(int x, int y);
void pspDebugScreenSetOffset(int offset);
void pspDebugScreenSetBase(u32* base);
int pspDebugScreenGetX(void);
int pspDebugScreenGetY(void);
void pspDebugScreenClear(void);
int pspDebugScreenPrintData(const char *buff, int size);
int pspDebugScreenPuts(const char *str);
int pspDebugGetStackTrace(unsigned int* results, int max);
void pspDebugScreenClearLineEnable(void);
void pspDebugScreenClearLineDisable(void);
typedef struct _PspDebugRegBlock
{
u32 frame[6];
u32 r[32];
u32 status;
u32 lo;
u32 hi;
u32 badvaddr;
u32 cause;
u32 epc;
float fpr[32];
u32 fsr;
u32 fir;
u32 frame_ptr;
u32 unused;
u32 index;
u32 random;
u32 entrylo0;
u32 entrylo1;
u32 context;
u32 pagemask;
u32 wired;
u32 cop0_7;
u32 cop0_8;
u32 cop0_9;
u32 entryhi;
u32 cop0_11;
u32 cop0_12;
u32 cop0_13;
u32 cop0_14;
u32 prid;
u32 padding[100];
} PspDebugRegBlock;
typedef void (*PspDebugErrorHandler)(PspDebugRegBlock *regs);
int pspDebugInstallErrorHandler(PspDebugErrorHandler handler);
void pspDebugDumpException(PspDebugRegBlock *regs);
typedef int (*PspDebugKprintfHandler)(const char *format, u32 *args);
int pspDebugInstallKprintfHandler(PspDebugKprintfHandler handler);
typedef struct _PspDebugStackTrace
{
u32 call_addr;
u32 func_addr;
} PspDebugStackTrace;
int pspDebugGetStackTrace2(PspDebugRegBlock *regs, PspDebugStackTrace *trace, int max);
typedef struct _PspDebugProfilerRegs
{
volatile u32 enable;
volatile u32 systemck;
volatile u32 cpuck;
volatile u32 internal;
volatile u32 memory;
volatile u32 copz;
volatile u32 vfpu;
volatile u32 sleep;
volatile u32 bus_access;
volatile u32 uncached_load;
volatile u32 uncached_store;
volatile u32 cached_load;
volatile u32 cached_store;
volatile u32 i_miss;
volatile u32 d_miss;
volatile u32 d_writeback;
volatile u32 cop0_inst;
volatile u32 fpu_inst;
volatile u32 vfpu_inst;
volatile u32 local_bus;
} PspDebugProfilerRegs;
void pspDebugProfilerEnable(void);
void pspDebugProfilerDisable(void);
void pspDebugProfilerClear(void);
void pspDebugProfilerGetRegs(PspDebugProfilerRegs *regs);
void pspDebugProfilerPrint(void);
typedef int (*PspDebugPrintHandler)(const char *data, int len);
typedef int (*PspDebugInputHandler)(char *data, int len);
int pspDebugInstallStdinHandler(PspDebugInputHandler handler);
int pspDebugInstallStdoutHandler(PspDebugPrintHandler handler);
int pspDebugInstallStderrHandler(PspDebugPrintHandler handler);
void pspDebugSioPutchar(int ch);
int pspDebugSioGetchar(void);
void pspDebugSioPuts(const char *str);
int pspDebugSioPutData(const char *data, int len);
int pspDebugSioPutText(const char *data, int len);
void pspDebugSioInit(void);
void pspDebugSioSetBaud(int baud);
void pspDebugEnablePutchar(void);
void pspDebugSioInstallKprintf(void);
void pspDebugGdbStubInit(void);
void pspDebugBreakpoint(void);
void pspDebugSioEnableKprintf(void);
void pspDebugSioDisableKprintf(void);
int pspScreenshotSave(const char *filename);
typedef struct SceKernelSysClock {
SceUInt32 low;
SceUInt32 hi;
} SceKernelSysClock;
enum PspThreadAttributes
{
PSP_THREAD_ATTR_VFPU = 0x00004000,
PSP_THREAD_ATTR_USER = 0x80000000,
PSP_THREAD_ATTR_USBWLAN = 0xa0000000,
PSP_THREAD_ATTR_VSH = 0xc0000000,
PSP_THREAD_ATTR_SCRATCH_SRAM = 0x00008000,
PSP_THREAD_ATTR_NO_FILLSTACK = 0x00100000,
PSP_THREAD_ATTR_CLEAR_STACK = 0x00200000,
};
typedef struct SceKernelThreadOptParam {
SceSize size;
SceUID stackMpid;
} SceKernelThreadOptParam;
typedef struct SceKernelThreadInfo {
SceSize size;
char name[32];
SceUInt attr;
int status;
SceKernelThreadEntry entry;
void * stack;
int stackSize;
void * gpReg;
int initPriority;
int currentPriority;
int waitType;
SceUID waitId;
int wakeupCount;
int exitStatus;
SceKernelSysClock runClocks;
SceUInt intrPreemptCount;
SceUInt threadPreemptCount;
SceUInt releaseCount;
} SceKernelThreadInfo;
typedef struct SceKernelThreadRunStatus {
SceSize size;
int status;
int currentPriority;
int waitType;
int waitId;
int wakeupCount;
SceKernelSysClock runClocks;
SceUInt intrPreemptCount;
SceUInt threadPreemptCount;
SceUInt releaseCount;
} SceKernelThreadRunStatus;
enum PspThreadStatus
{
PSP_THREAD_RUNNING = 1,
PSP_THREAD_READY = 2,
PSP_THREAD_WAITING = 4,
PSP_THREAD_SUSPEND = 8,
PSP_THREAD_STOPPED = 16,
PSP_THREAD_KILLED = 32,
};
SceUID sceKernelCreateThread(const char *name, SceKernelThreadEntry entry, int initPriority,
int stackSize, SceUInt attr, SceKernelThreadOptParam *option);
int sceKernelDeleteThread(SceUID thid);
int sceKernelStartThread(SceUID thid, SceSize arglen, void *argp);
int sceKernelExitThread(int status);
int sceKernelExitDeleteThread(int status);
int sceKernelTerminateThread(SceUID thid);
int sceKernelTerminateDeleteThread(SceUID thid);
int sceKernelSuspendDispatchThread(void);
int sceKernelResumeDispatchThread(int state);
int sceKernelSleepThread(void);
int sceKernelSleepThreadCB(void);
int sceKernelWakeupThread(SceUID thid);
int sceKernelCancelWakeupThread(SceUID thid);
int sceKernelSuspendThread(SceUID thid);
int sceKernelResumeThread(SceUID thid);
int sceKernelWaitThreadEnd(SceUID thid, SceUInt *timeout);
int sceKernelWaitThreadEndCB(SceUID thid, SceUInt *timeout);
int sceKernelDelayThread(SceUInt delay);
int sceKernelDelayThreadCB(SceUInt delay);
int sceKernelDelaySysClockThread(SceKernelSysClock *delay);
int sceKernelDelaySysClockThreadCB(SceKernelSysClock *delay);
int sceKernelChangeCurrentThreadAttr(int unknown, SceUInt attr);
int sceKernelChangeThreadPriority(SceUID thid, int priority);
int sceKernelRotateThreadReadyQueue(int priority);
int sceKernelReleaseWaitThread(SceUID thid);
int sceKernelGetThreadId(void);
int sceKernelGetThreadCurrentPriority(void);
int sceKernelGetThreadExitStatus(SceUID thid);
int sceKernelCheckThreadStack(void);
int sceKernelGetThreadStackFreeSize(SceUID thid);
int sceKernelReferThreadStatus(SceUID thid, SceKernelThreadInfo *info);
int sceKernelReferThreadRunStatus(SceUID thid, SceKernelThreadRunStatus *status);
typedef struct SceKernelSemaOptParam {
SceSize size;
} SceKernelSemaOptParam;
typedef struct SceKernelSemaInfo {
SceSize size;
char name[32];
SceUInt attr;
int initCount;
int currentCount;
int maxCount;
int numWaitThreads;
} SceKernelSemaInfo;
SceUID sceKernelCreateSema(const char *name, SceUInt attr, int initVal, int maxVal, SceKernelSemaOptParam *option);
int sceKernelDeleteSema(SceUID semaid);
int sceKernelSignalSema(SceUID semaid, int signal);
int sceKernelWaitSema(SceUID semaid, int signal, SceUInt *timeout);
int sceKernelWaitSemaCB(SceUID semaid, int signal, SceUInt *timeout);
int sceKernelPollSema(SceUID semaid, int signal);
int sceKernelReferSemaStatus(SceUID semaid, SceKernelSemaInfo *info);
enum PspLwMutexAttributes
{
PSP_LW_MUTEX_ATTR_THFIFO = 0x0000U,
PSP_LW_MUTEX_ATTR_THPRI = 0x0100U,
PSP_LW_MUTEX_ATTR_RECURSIVE = 0x0200U
};
typedef struct {
int lockLevel;
SceUID lockThread;
int attr;
int numWaitThreads;
SceUID uid;
int pad[3];
} SceLwMutexWorkarea;
int sceKernelCreateLwMutex(SceLwMutexWorkarea *workarea, const char *name, SceUInt32 attr, int initialCount, u32 *optionsPtr);
int sceKernelDeleteLwMutex(SceLwMutexWorkarea *workarea);
int sceKernelTryLockLwMutex(SceLwMutexWorkarea *workarea, int lockCount);
int sceKernelLockLwMutex(SceLwMutexWorkarea *workarea, int lockCount, unsigned int *pTimeout);
int sceKernelUnlockLwMutex(SceLwMutexWorkarea *workarea, int lockCount);
typedef struct SceKernelEventFlagInfo {
SceSize size;
char name[32];
SceUInt attr;
SceUInt initPattern;
SceUInt currentPattern;
int numWaitThreads;
} SceKernelEventFlagInfo;
struct SceKernelEventFlagOptParam {
SceSize size;
};
typedef struct SceKernelEventFlagOptParam SceKernelEventFlagOptParam;
enum PspEventFlagAttributes
{
PSP_EVENT_WAITSINGLE = 0x00,
PSP_EVENT_WAITMULTIPLE = 0x200
};
enum PspEventFlagWaitTypes
{
PSP_EVENT_WAITAND = 0,
PSP_EVENT_WAITOR = 1,
PSP_EVENT_WAITCLEAR = 0x20
};
SceUID sceKernelCreateEventFlag(const char *name, int attr, int bits, SceKernelEventFlagOptParam *opt);
int sceKernelSetEventFlag(SceUID evid, u32 bits);
int sceKernelClearEventFlag(SceUID evid, u32 bits);
int sceKernelPollEventFlag(int evid, u32 bits, u32 wait, u32 *outBits);
int sceKernelWaitEventFlag(int evid, u32 bits, u32 wait, u32 *outBits, SceUInt *timeout);
int sceKernelWaitEventFlagCB(int evid, u32 bits, u32 wait, u32 *outBits, SceUInt *timeout);
int sceKernelDeleteEventFlag(int evid);
int sceKernelReferEventFlagStatus(SceUID event, SceKernelEventFlagInfo *status);
typedef struct SceKernelMbxOptParam {
SceSize size;
} SceKernelMbxOptParam;
typedef struct SceKernelMbxInfo {
SceSize size;
char name[32];
SceUInt attr;
int numWaitThreads;
int numMessages;
void *firstMessage;
} SceKernelMbxInfo;
typedef struct SceKernelMsgPacket {
struct SceKernelMsgPacket *next;
SceUChar msgPriority;
SceUChar dummy[3];
} SceKernelMsgPacket;
SceUID sceKernelCreateMbx(const char *name, SceUInt attr, SceKernelMbxOptParam *option);
int sceKernelDeleteMbx(SceUID mbxid);
int sceKernelSendMbx(SceUID mbxid, void *message);
int sceKernelReceiveMbx(SceUID mbxid, void **pmessage, SceUInt *timeout);
int sceKernelReceiveMbxCB(SceUID mbxid, void **pmessage, SceUInt *timeout);
int sceKernelPollMbx(SceUID mbxid, void **pmessage);
int sceKernelCancelReceiveMbx(SceUID mbxid, int *pnum);
int sceKernelReferMbxStatus(SceUID mbxid, SceKernelMbxInfo *info);
typedef SceUInt (*SceKernelAlarmHandler)(void *common);
typedef struct SceKernelAlarmInfo {
SceSize size;
SceKernelSysClock schedule;
SceKernelAlarmHandler handler;
void * common;
} SceKernelAlarmInfo;
SceUID sceKernelSetAlarm(SceUInt clock, SceKernelAlarmHandler handler, void *common);
SceUID sceKernelSetSysClockAlarm(SceKernelSysClock *clock, SceKernelAlarmHandler handler, void *common);
int sceKernelCancelAlarm(SceUID alarmid);
int sceKernelReferAlarmStatus(SceUID alarmid, SceKernelAlarmInfo *info);
typedef int (*SceKernelCallbackFunction)(int arg1, int arg2, void *arg);
typedef struct SceKernelCallbackInfo {
SceSize size;
char name[32];
SceUID threadId;
SceKernelCallbackFunction callback;
void * common;
int notifyCount;
int notifyArg;
} SceKernelCallbackInfo;
int sceKernelCreateCallback(const char *name, SceKernelCallbackFunction func, void *arg);
int sceKernelReferCallbackStatus(SceUID cb, SceKernelCallbackInfo *status);
int sceKernelDeleteCallback(SceUID cb);
int sceKernelNotifyCallback(SceUID cb, int arg2);
int sceKernelCancelCallback(SceUID cb);
int sceKernelGetCallbackCount(SceUID cb);
int sceKernelCheckCallback(void);
enum SceKernelIdListType
{
SCE_KERNEL_TMID_Thread = 1,
SCE_KERNEL_TMID_Semaphore = 2,
SCE_KERNEL_TMID_EventFlag = 3,
SCE_KERNEL_TMID_Mbox = 4,
SCE_KERNEL_TMID_Vpl = 5,
SCE_KERNEL_TMID_Fpl = 6,
SCE_KERNEL_TMID_Mpipe = 7,
SCE_KERNEL_TMID_Callback = 8,
SCE_KERNEL_TMID_ThreadEventHandler = 9,
SCE_KERNEL_TMID_Alarm = 10,
SCE_KERNEL_TMID_VTimer = 11,
SCE_KERNEL_TMID_SleepThread = 64,
SCE_KERNEL_TMID_DelayThread = 65,
SCE_KERNEL_TMID_SuspendThread = 66,
SCE_KERNEL_TMID_DormantThread = 67,
};
int sceKernelGetThreadmanIdList(enum SceKernelIdListType type, SceUID *readbuf, int readbufsize, int *idcount);
typedef struct SceKernelSystemStatus {
SceSize size;
SceUInt status;
SceKernelSysClock idleClocks;
SceUInt comesOutOfIdleCount;
SceUInt threadSwitchCount;
SceUInt vfpuSwitchCount;
} SceKernelSystemStatus;
int sceKernelReferSystemStatus(SceKernelSystemStatus *status);
SceUID sceKernelCreateMsgPipe(const char *name, int part, int attr, void *unk1, void *opt);
int sceKernelDeleteMsgPipe(SceUID uid);
int sceKernelSendMsgPipe(SceUID uid, void *message, unsigned int size, int unk1, void *unk2, unsigned int *timeout);
int sceKernelSendMsgPipeCB(SceUID uid, void *message, unsigned int size, int unk1, void *unk2, unsigned int *timeout);
int sceKernelTrySendMsgPipe(SceUID uid, void *message, unsigned int size, int unk1, void *unk2);
int sceKernelReceiveMsgPipe(SceUID uid, void *message, unsigned int size, int unk1, void *unk2, unsigned int *timeout);
int sceKernelReceiveMsgPipeCB(SceUID uid, void *message, unsigned int size, int unk1, void *unk2, unsigned int *timeout);
int sceKernelTryReceiveMsgPipe(SceUID uid, void *message, unsigned int size, int unk1, void *unk2);
int sceKernelCancelMsgPipe(SceUID uid, int *psend, int *precv);
typedef struct SceKernelMppInfo {
SceSize size;
char name[32];
SceUInt attr;
int bufSize;
int freeSize;
int numSendWaitThreads;
int numReceiveWaitThreads;
} SceKernelMppInfo;
int sceKernelReferMsgPipeStatus(SceUID uid, SceKernelMppInfo *info);
struct SceKernelVplOptParam {
SceSize size;
};
SceUID sceKernelCreateVpl(const char *name, int part, int attr, unsigned int size, struct SceKernelVplOptParam *opt);
int sceKernelDeleteVpl(SceUID uid);
int sceKernelAllocateVpl(SceUID uid, unsigned int size, void **data, unsigned int *timeout);
int sceKernelAllocateVplCB(SceUID uid, unsigned int size, void **data, unsigned int *timeout);
int sceKernelTryAllocateVpl(SceUID uid, unsigned int size, void **data);
int sceKernelFreeVpl(SceUID uid, void *data);
int sceKernelCancelVpl(SceUID uid, int *pnum);
typedef struct SceKernelVplInfo {
SceSize size;
char name[32];
SceUInt attr;
int poolSize;
int freeSize;
int numWaitThreads;
} SceKernelVplInfo;
int sceKernelReferVplStatus(SceUID uid, SceKernelVplInfo *info);
struct SceKernelFplOptParam {
SceSize size;
};
int sceKernelCreateFpl(const char *name, int part, int attr, unsigned int size, unsigned int blocks, struct SceKernelFplOptParam *opt);
int sceKernelDeleteFpl(SceUID uid);
int sceKernelAllocateFpl(SceUID uid, void **data, unsigned int *timeout);
int sceKernelAllocateFplCB(SceUID uid, void **data, unsigned int *timeout);
int sceKernelTryAllocateFpl(SceUID uid, void **data);
int sceKernelFreeFpl(SceUID uid, void *data);
int sceKernelCancelFpl(SceUID uid, int *pnum);
typedef struct SceKernelFplInfo {
SceSize size;
char name[32];
SceUInt attr;
int blockSize;
int numBlocks;
int freeBlocks;
int numWaitThreads;
} SceKernelFplInfo;
int sceKernelReferFplStatus(SceUID uid, SceKernelFplInfo *info);
void _sceKernelReturnFromTimerHandler(void);
void _sceKernelReturnFromCallback(void);
int sceKernelUSec2SysClock(unsigned int usec, SceKernelSysClock *clock);
SceInt64 sceKernelUSec2SysClockWide(unsigned int usec);
int sceKernelSysClock2USec(SceKernelSysClock *clock, unsigned int *low, unsigned int *high);
int sceKernelSysClock2USecWide(SceInt64 clock, unsigned *low, unsigned int *high);
int sceKernelGetSystemTime(SceKernelSysClock *time);
SceInt64 sceKernelGetSystemTimeWide(void);
unsigned int sceKernelGetSystemTimeLow(void);
struct SceKernelVTimerOptParam {
SceSize size;
};
SceUID sceKernelCreateVTimer(const char *name, struct SceKernelVTimerOptParam *opt);
int sceKernelDeleteVTimer(SceUID uid);
int sceKernelGetVTimerBase(SceUID uid, SceKernelSysClock *base);
SceInt64 sceKernelGetVTimerBaseWide(SceUID uid);
int sceKernelGetVTimerTime(SceUID uid, SceKernelSysClock *time);
SceInt64 sceKernelGetVTimerTimeWide(SceUID uid);
int sceKernelSetVTimerTime(SceUID uid, SceKernelSysClock *time);
SceInt64 sceKernelSetVTimerTimeWide(SceUID uid, SceInt64 time);
int sceKernelStartVTimer(SceUID uid);
int sceKernelStopVTimer(SceUID uid);
typedef SceUInt (*SceKernelVTimerHandler)(SceUID uid, SceKernelSysClock *, SceKernelSysClock *, void *);
typedef SceUInt (*SceKernelVTimerHandlerWide)(SceUID uid, SceInt64, SceInt64, void *);
int sceKernelSetVTimerHandler(SceUID uid, SceKernelSysClock *time, SceKernelVTimerHandler handler, void *common);
int sceKernelSetVTimerHandlerWide(SceUID uid, SceInt64 time, SceKernelVTimerHandlerWide handler, void *common);
int sceKernelCancelVTimerHandler(SceUID uid);
typedef struct SceKernelVTimerInfo {
SceSize size;
char name[32];
int active;
SceKernelSysClock base;
SceKernelSysClock current;
SceKernelSysClock schedule;
SceKernelVTimerHandler handler;
void * common;
} SceKernelVTimerInfo;
int sceKernelReferVTimerStatus(SceUID uid, SceKernelVTimerInfo *info);
void _sceKernelExitThread(void);
enum SceKernelIdListType sceKernelGetThreadmanIdType(SceUID uid);
typedef int (*SceKernelThreadEventHandler)(int mask, SceUID thid, void *common);
typedef struct SceKernelThreadEventHandlerInfo {
SceSize size;
char name[32];
SceUID threadId;
int mask;
SceKernelThreadEventHandler handler;
void * common;
} SceKernelThreadEventHandlerInfo;
enum ThreadEventIds
{
THREADEVENT_ALL = 0xFFFFFFFF,
THREADEVENT_KERN = 0xFFFFFFF8,
THREADEVENT_USER = 0xFFFFFFF0,
THREADEVENT_CURRENT = 0
};
enum ThreadEvents
{
THREAD_CREATE = 1,
THREAD_START = 2,
THREAD_EXIT = 4,
THREAD_DELETE = 8,
};
SceUID sceKernelRegisterThreadEventHandler(const char *name, SceUID threadID, int mask, SceKernelThreadEventHandler handler, void *common);
int sceKernelReleaseThreadEventHandler(SceUID uid);
int sceKernelReferThreadEventHandlerStatus(SceUID uid, struct SceKernelThreadEventHandlerInfo *info);
PspDebugProfilerRegs *sceKernelReferThreadProfiler(void);
PspDebugProfilerRegs *sceKernelReferGlobalProfiler(void);
typedef struct SceKernelLMOption {
SceSize size;
SceUID mpidtext;
SceUID mpiddata;
unsigned int flags;
char position;
char access;
char creserved[2];
} SceKernelLMOption;
typedef struct SceKernelSMOption {
SceSize size;
SceUID mpidstack;
SceSize stacksize;
int priority;
unsigned int attribute;
} SceKernelSMOption;
SceUID sceKernelLoadModule(const char *path, int flags, SceKernelLMOption *option);
SceUID sceKernelLoadModuleMs(const char *path, int flags, SceKernelLMOption *option);
SceUID sceKernelLoadModuleByID(SceUID fid, int flags, SceKernelLMOption *option);
SceUID sceKernelLoadModuleBufferUsbWlan(SceSize bufsize, void *buf, int flags, SceKernelLMOption *option);
int sceKernelStartModule(SceUID modid, SceSize argsize, void *argp, int *status, SceKernelSMOption *option);
int sceKernelStopModule(SceUID modid, SceSize argsize, void *argp, int *status, SceKernelSMOption *option);
int sceKernelUnloadModule(SceUID modid);
int sceKernelSelfStopUnloadModule(int unknown, SceSize argsize, void *argp);
int sceKernelStopUnloadSelfModule(SceSize argsize, void *argp, int *status, SceKernelSMOption *option);
typedef struct SceKernelModuleInfo {
SceSize size;
char nsegment;
char reserved[3];
int segmentaddr[4];
int segmentsize[4];
unsigned int entry_addr;
unsigned int gp_value;
unsigned int text_addr;
unsigned int text_size;
unsigned int data_size;
unsigned int bss_size;
unsigned short attribute;
unsigned char version[2];
char name[28];
} SceKernelModuleInfo;
int sceKernelQueryModuleInfo(SceUID modid, SceKernelModuleInfo *info);
int sceKernelGetModuleIdList(SceUID *readbuf, int readbufsize, int *idcount);
int sceKernelGetModuleIdByAddress(const void *moduleAddr);
enum IOAccessModes
{
FIO_S_IFMT = 0xF000,
FIO_S_IFLNK = 0x4000,
FIO_S_IFDIR = 0x1000,
FIO_S_IFREG = 0x2000,
FIO_S_ISUID = 0x0800,
FIO_S_ISGID = 0x0400,
FIO_S_ISVTX = 0x0200,
FIO_S_IRWXU = 0x01C0,
FIO_S_IRUSR = 0x0100,
FIO_S_IWUSR = 0x0080,
FIO_S_IXUSR = 0x0040,
FIO_S_IRWXG = 0x0038,
FIO_S_IRGRP = 0x0020,
FIO_S_IWGRP = 0x0010,
FIO_S_IXGRP = 0x0008,
FIO_S_IRWXO = 0x0007,
FIO_S_IROTH = 0x0004,
FIO_S_IWOTH = 0x0002,
FIO_S_IXOTH = 0x0001,
};
enum IOFileModes
{
FIO_SO_IFMT = 0x0038,
FIO_SO_IFLNK = 0x0008,
FIO_SO_IFDIR = 0x0010,
FIO_SO_IFREG = 0x0020,
FIO_SO_IROTH = 0x0004,
FIO_SO_IWOTH = 0x0002,
FIO_SO_IXOTH = 0x0001,
};
typedef struct SceIoStat {
SceMode st_mode;
unsigned int st_attr;
SceOff st_size;
ScePspDateTime sce_st_ctime;
ScePspDateTime sce_st_atime;
ScePspDateTime sce_st_mtime;
unsigned int st_private[6];
} SceIoStat;
typedef struct SceIoDirent {
SceIoStat d_stat;
char d_name[256];
void * d_private;
int dummy;
} SceIoDirent;
typedef struct SceDevInf {
uint32_t maxClusters;
uint32_t freeClusters;
uint32_t maxSectors;
int32_t sectorSize;
int32_t sectorCount;
} SceDevInf;
typedef struct SceDevctlCmd {
SceDevInf *dev_inf;
} SceDevctlCmd;
enum IoAssignPerms
{
IOASSIGN_RDWR = 0,
IOASSIGN_RDONLY = 1
};
SceUID sceIoOpen(const char *file, int flags, SceMode mode);
SceUID sceIoOpenAsync(const char *file, int flags, SceMode mode);
int sceIoClose(SceUID fd);
int sceIoCloseAsync(SceUID fd);
int sceIoRead(SceUID fd, void *data, SceSize size);
int sceIoReadAsync(SceUID fd, void *data, SceSize size);
int sceIoWrite(SceUID fd, const void *data, SceSize size);
int sceIoWriteAsync(SceUID fd, const void *data, SceSize size);
SceOff sceIoLseek(SceUID fd, SceOff offset, int whence);
int sceIoLseekAsync(SceUID fd, SceOff offset, int whence);
int sceIoLseek32(SceUID fd, int offset, int whence);
int sceIoLseek32Async(SceUID fd, int offset, int whence);
int sceIoRemove(const char *file);
int sceIoMkdir(const char *dir, SceMode mode);
int sceIoRmdir(const char *path);
int sceIoChdir(const char *path);
int sceIoRename(const char *oldname, const char *newname);
SceUID sceIoDopen(const char *dirname);
int sceIoDread(SceUID fd, SceIoDirent *dir);
int sceIoDclose(SceUID fd);
int sceIoDevctl(const char *dev, unsigned int cmd, void *indata, int inlen, void *outdata, int outlen);
int sceIoAssign(const char *dev1, const char *dev2, const char *dev3, int mode, void* unk1, long unk2);
int sceIoUnassign(const char *dev);
int sceIoGetstat(const char *file, SceIoStat *stat);
int sceIoChstat(const char *file, SceIoStat *stat, int bits);
int sceIoIoctl(SceUID fd, unsigned int cmd, void *indata, int inlen, void *outdata, int outlen);
int sceIoIoctlAsync(SceUID fd, unsigned int cmd, void *indata, int inlen, void *outdata, int outlen);
int sceIoSync(const char *device, unsigned int unk);
int sceIoWaitAsync(SceUID fd, SceInt64 *res);
int sceIoWaitAsyncCB(SceUID fd, SceInt64 *res);
int sceIoPollAsync(SceUID fd, SceInt64 *res);
int sceIoGetAsyncStat(SceUID fd, int poll, SceInt64 *res);
int sceIoCancel(SceUID fd);
int sceIoGetDevType(SceUID fd);
int sceIoChangeAsyncPriority(SceUID fd, int pri);
int sceIoSetAsyncCallback(SceUID fd, SceUID cb, void *argp);
SceUID sceKernelStdin(void);
SceUID sceKernelStdout(void);
SceUID sceKernelStderr(void);
extern const char* PspInterruptNames[67];
enum PspInterrupts
{
PSP_GPIO_INT = 4,
PSP_ATA_INT = 5,
PSP_UMD_INT = 6,
PSP_MSCM0_INT = 7,
PSP_WLAN_INT = 8,
PSP_AUDIO_INT = 10,
PSP_I2C_INT = 12,
PSP_SIRCS_INT = 14,
PSP_SYSTIMER0_INT = 15,
PSP_SYSTIMER1_INT = 16,
PSP_SYSTIMER2_INT = 17,
PSP_SYSTIMER3_INT = 18,
PSP_THREAD0_INT = 19,
PSP_NAND_INT = 20,
PSP_DMACPLUS_INT = 21,
PSP_DMA0_INT = 22,
PSP_DMA1_INT = 23,
PSP_MEMLMD_INT = 24,
PSP_GE_INT = 25,
PSP_VBLANK_INT = 30,
PSP_MECODEC_INT = 31,
PSP_HPREMOTE_INT = 36,
PSP_MSCM1_INT = 60,
PSP_MSCM2_INT = 61,
PSP_THREAD1_INT = 65,
PSP_INTERRUPT_INT = 66
};
enum PspSubInterrupts
{
PSP_GPIO_SUBINT = PSP_GPIO_INT,
PSP_ATA_SUBINT = PSP_ATA_INT,
PSP_UMD_SUBINT = PSP_UMD_INT,
PSP_DMACPLUS_SUBINT = PSP_DMACPLUS_INT,
PSP_GE_SUBINT = PSP_GE_INT,
PSP_DISPLAY_SUBINT = PSP_VBLANK_INT
};
unsigned int sceKernelCpuSuspendIntr(void);
void sceKernelCpuResumeIntr(unsigned int flags);
void sceKernelCpuResumeIntrWithSync(unsigned int flags);
int sceKernelIsCpuIntrSuspended(unsigned int flags);
int sceKernelIsCpuIntrEnable(void);
int sceKernelRegisterSubIntrHandler(int intno, int no, void *handler, void *arg);
int sceKernelReleaseSubIntrHandler(int intno, int no);
int sceKernelEnableSubIntr(int intno, int no);
int sceKernelDisableSubIntr(int intno, int no);
typedef struct tag_IntrHandlerOptionParam{
int size;
u32 entry;
u32 common;
u32 gp;
u16 intr_code;
u16 sub_count;
u16 intr_level;
u16 enabled;
u32 calls;
u32 field_1C;
u32 total_clock_lo;
u32 total_clock_hi;
u32 min_clock_lo;
u32 min_clock_hi;
u32 max_clock_lo;
u32 max_clock_hi;
} PspIntrHandlerOptionParam;
int QueryIntrHandlerInfo(SceUID intr_code, SceUID sub_intr_code, PspIntrHandlerOptionParam *data);
enum PspDisplayPixelFormats {
PSP_DISPLAY_PIXEL_FORMAT_565 = 0,
PSP_DISPLAY_PIXEL_FORMAT_5551,
PSP_DISPLAY_PIXEL_FORMAT_4444,
PSP_DISPLAY_PIXEL_FORMAT_8888
};
enum PspDisplaySetBufSync {
PSP_DISPLAY_SETBUF_NEXTHSYNC = 0,
PSP_DISPLAY_SETBUF_NEXTVSYNC = 1
};
enum PspDisplayMode
{
PSP_DISPLAY_MODE_LCD = 0,
PSP_DISPLAY_MODE_VESA1A = 0x1A,
PSP_DISPLAY_MODE_PSEUDO_VGA = 0x60
};
enum PspDisplayErrorCodes
{
SCE_DISPLAY_ERROR_OK = 0,
SCE_DISPLAY_ERROR_POINTER = 0x80000103,
SCE_DISPLAY_ERROR_ARGUMENT = 0x80000107
};
int sceDisplaySetMode(int mode, int width, int height);
int sceDisplayGetMode(int *pmode, int *pwidth, int *pheight);
int sceDisplaySetFrameBuf(void *topaddr, int bufferwidth, int pixelformat, int sync);
int sceDisplayGetFrameBuf(void **topaddr, int *bufferwidth, int *pixelformat, int sync);
unsigned int sceDisplayGetVcount(void);
int sceDisplayWaitVblankStart(void);
int sceDisplayWaitVblankStartCB(void);
int sceDisplayWaitVblank(void);
int sceDisplayWaitVblankCB(void);
int sceDisplayGetAccumulatedHcount(void);
int sceDisplayGetCurrentHcount(void);
float sceDisplayGetFramePerSec(void);
int sceDisplayIsForeground(void);
int sceDisplayIsVblank(void);
typedef struct PspGeContext {
unsigned int context[512];
} PspGeContext;
typedef struct
{
unsigned int stack[8];
} SceGeStack;
typedef void (*PspGeCallback)(int id, void *arg);
typedef struct PspGeCallbackData
{
PspGeCallback signal_func;
void *signal_arg;
PspGeCallback finish_func;
void *finish_arg;
} PspGeCallbackData;
typedef struct PspGeListArgs
{
unsigned int size;
PspGeContext* context;
u32 numStacks;
SceGeStack *stacks;
} PspGeListArgs;
typedef struct PspGeBreakParam {
unsigned int buf[4];
} PspGeBreakParam;
unsigned int sceGeEdramGetSize(void);
int sceGeEdramSetSize(int size);
void * sceGeEdramGetAddr(void);
unsigned int sceGeGetCmd(int cmd);
typedef enum PspGeMatrixTypes {
PSP_GE_MATRIX_BONE0 = 0,
PSP_GE_MATRIX_BONE1,
PSP_GE_MATRIX_BONE2,
PSP_GE_MATRIX_BONE3,
PSP_GE_MATRIX_BONE4,
PSP_GE_MATRIX_BONE5,
PSP_GE_MATRIX_BONE6,
PSP_GE_MATRIX_BONE7,
PSP_GE_MATRIX_WORLD,
PSP_GE_MATRIX_VIEW,
PSP_GE_MATRIX_PROJECTION,
PSP_GE_MATRIX_TEXGEN
} PspGeMatrixTypes;
int sceGeGetMtx(int type, void *matrix);
typedef struct
{
unsigned int stack[8];
} PspGeStack;
int sceGeGetStack(int stackId, PspGeStack *stack);
int sceGeSaveContext(PspGeContext *context);
int sceGeRestoreContext(const PspGeContext *context);
int sceGeListEnQueue(const void *list, void *stall, int cbid, PspGeListArgs *arg);
int sceGeListEnQueueHead(const void *list, void *stall, int cbid, PspGeListArgs *arg);
int sceGeListDeQueue(int qid);
int sceGeListUpdateStallAddr(int qid, void *stall);
typedef enum PspGeListState {
PSP_GE_LIST_DONE = 0,
PSP_GE_LIST_QUEUED,
PSP_GE_LIST_DRAWING_DONE,
PSP_GE_LIST_STALL_REACHED,
PSP_GE_LIST_CANCEL_DONE
} PspGeListState;
int sceGeListSync(int qid, int syncType);
int sceGeDrawSync(int syncType);
int sceGeSetCallback(PspGeCallbackData *cb);
int sceGeUnsetCallback(int cbid);
int sceGeBreak(int mode, PspGeBreakParam *pParam);
int sceGeContinue(void);
int sceGeEdramSetAddrTranslation(int width);
typedef void (*GuSwapBuffersCallback)(void** display,void** render);
void sceGuDepthBuffer(void* zbp, int zbw);
void sceGuDispBuffer(int width, int height, void* dispbp, int dispbw);
void sceGuDrawBuffer(int psm, void* fbp, int fbw);
void sceGuDrawBufferList(int psm, void* fbp, int fbw);
int sceGuDisplay(int state);
void sceGuDepthFunc(int function);
void sceGuDepthMask(int mask);
void sceGuDepthOffset(unsigned int offset);
void sceGuDepthRange(int near, int far);
void sceGuFog(float near, float far, unsigned int color);
int sceGuInit(void);
void sceGuTerm(void);
int sceGuBreak(int mode);
int sceGuContinue(void);
void* sceGuSetCallback(int signal, void (*callback)(int));
void sceGuSignal(int mode, int id);
void sceGuSendCommandf(int cmd, float argument);
void sceGuSendCommandi(int cmd, int argument);
void* sceGuGetMemory(int size);
int sceGuStart(int ctype, void* list);
int sceGuFinish(void);
int sceGuFinishId(unsigned int id);
int sceGuCallList(const void* list);
void sceGuCallMode(int mode);
int sceGuCheckList(void);
int sceGuSendList(int mode, const void* list, PspGeContext* context);
void* sceGuSwapBuffers(void);
int sceGuSync(int mode, int what);
void sceGuDrawArray(int prim, int vtype, int count, const void* indices, const void* vertices);
void sceGuBeginObject(int vtype, int count, const void* indices, const void* vertices);
int sceGuEndObject(void);
void sceGuSetStatus(int state, int status);
int sceGuGetStatus(int state);
void sceGuSetAllStatus(int status);
int sceGuGetAllStatus(void);
void sceGuEnable(int state);
void sceGuDisable(int state);
void sceGuLight(int light, int type, int components, const ScePspFVector3* position);
void sceGuLightAtt(int light, float atten0, float atten1, float atten2);
void sceGuLightColor(int light, int component, unsigned int color);
void sceGuLightMode(int mode);
void sceGuLightSpot(int light, const ScePspFVector3* direction, float exponent, float cutoff);
void sceGuClear(int flags);
void sceGuClearColor(unsigned int color);
void sceGuClearDepth(unsigned int depth);
void sceGuClearStencil(unsigned int stencil);
void sceGuPixelMask(unsigned int mask);
void sceGuColor(unsigned int color);
void sceGuColorFunc(int func, unsigned int color, unsigned int mask);
void sceGuColorMaterial(int components);
void sceGuAlphaFunc(int func, int value, int mask);
void sceGuAmbient(unsigned int color);
void sceGuAmbientColor(unsigned int color);
void sceGuBlendFunc(int op, int src, int dest, unsigned int srcfix, unsigned int destfix);
void sceGuMaterial(int mode, int color);
void sceGuModelColor(unsigned int emissive, unsigned int ambient, unsigned int diffuse, unsigned int specular);
void sceGuStencilFunc(int func, int ref, int mask);
void sceGuStencilOp(int fail, int zfail, int zpass);
void sceGuSpecular(float power);
void sceGuFrontFace(int order);
void sceGuLogicalOp(int op);
void sceGuSetDither(const ScePspIMatrix4* matrix);
void sceGuShadeModel(int mode);
void sceGuCopyImage(int psm, int sx, int sy, int width, int height, int srcw, void* src, int dx, int dy, int destw, void* dest);
void sceGuTexEnvColor(unsigned int color);
void sceGuTexFilter(int min, int mag);
void sceGuTexFlush(void);
void sceGuTexFunc(int tfx, int tcc);
void sceGuTexImage(int mipmap, int width, int height, int tbw, const void* tbp);
void sceGuTexLevelMode(unsigned int mode, float bias);
void sceGuTexMapMode(int mode, unsigned int lu, unsigned int lv);
void sceGuTexMode(int tpsm, int maxmips, int mc, int swizzle);
void sceGuTexOffset(float u, float v);
void sceGuTexProjMapMode(int mode);
void sceGuTexScale(float u, float v);
void sceGuTexSlope(float slope);
void sceGuTexSync();
void sceGuTexWrap(int u, int v);
void sceGuClutLoad(int num_blocks, const void* cbp);
void sceGuClutMode(unsigned int cpsm, unsigned int shift, unsigned int mask, unsigned int csa);
void sceGuOffset(unsigned int x, unsigned int y);
void sceGuScissor(int x, int y, int w, int h);
void sceGuViewport(int cx, int cy, int width, int height);
void sceGuDrawBezier(int vtype, int ucount, int vcount, const void* indices, const void* vertices);
void sceGuPatchDivide(unsigned int ulevel, unsigned int vlevel);
void sceGuPatchFrontFace(unsigned int mode);
void sceGuPatchPrim(int prim);
void sceGuDrawSpline(int vtype, int ucount, int vcount, int uedge, int vedge, const void* indices, const void* vertices);
void sceGuSetMatrix(int type, const ScePspFMatrix4* matrix);
void sceGuBoneMatrix(unsigned int index, const ScePspFMatrix4* matrix);
void sceGuMorphWeight(int index, float weight);
void sceGuDrawArrayN(int primitive_type, int vertex_type, int vcount, int primcount, const void* indices, const void* vertices);
void guSwapBuffersBehaviour(int behaviour);
void guSwapBuffersCallback(GuSwapBuffersCallback callback);
void* guGetStaticVramBuffer(unsigned int width, unsigned int height, unsigned int psm);
void* guGetStaticVramTexture(unsigned int width, unsigned int height, unsigned int psm);
int guGetDisplayState();
enum PspCtrlButtons
{
PSP_CTRL_SELECT = 0x000001,
PSP_CTRL_START = 0x000008,
PSP_CTRL_UP = 0x000010,
PSP_CTRL_RIGHT = 0x000020,
PSP_CTRL_DOWN = 0x000040,
PSP_CTRL_LEFT = 0x000080,
PSP_CTRL_LTRIGGER = 0x000100,
PSP_CTRL_RTRIGGER = 0x000200,
PSP_CTRL_TRIANGLE = 0x001000,
PSP_CTRL_CIRCLE = 0x002000,
PSP_CTRL_CROSS = 0x004000,
PSP_CTRL_SQUARE = 0x008000,
PSP_CTRL_HOME = 0x010000,
PSP_CTRL_HOLD = 0x020000,
PSP_CTRL_NOTE = 0x800000,
PSP_CTRL_SCREEN = 0x400000,
PSP_CTRL_VOLUP = 0x100000,
PSP_CTRL_VOLDOWN = 0x200000,
PSP_CTRL_WLAN_UP = 0x040000,
PSP_CTRL_REMOTE = 0x080000,
PSP_CTRL_DISC = 0x1000000,
PSP_CTRL_MS = 0x2000000,
};
enum PspCtrlMode
{
PSP_CTRL_MODE_DIGITAL = 0,
PSP_CTRL_MODE_ANALOG = 1,
};
typedef struct SceCtrlData {
unsigned int TimeStamp;
unsigned int Buttons;
unsigned char Lx;
unsigned char Ly;
union {
struct {
unsigned char Rx;
unsigned char Ry;
unsigned char Reserved[4];
};
unsigned char Rsrv[6];
};
} SceCtrlData;
typedef struct SceCtrlLatch {
unsigned int uiMake;
unsigned int uiBreak;
unsigned int uiPress;
unsigned int uiRelease;
} SceCtrlLatch;
int sceCtrlSetSamplingCycle(int cycle);
int sceCtrlGetSamplingCycle(int *pcycle);
int sceCtrlSetSamplingMode(int mode);
int sceCtrlGetSamplingMode(int *pmode);
int sceCtrlPeekBufferPositive(SceCtrlData *pad_data, int count);
int sceCtrlPeekBufferNegative(SceCtrlData *pad_data, int count);
int sceCtrlReadBufferPositive(SceCtrlData *pad_data, int count);
int sceCtrlReadBufferNegative(SceCtrlData *pad_data, int count);
int sceCtrlPeekLatch(SceCtrlLatch *latch_data);
int sceCtrlReadLatch(SceCtrlLatch *latch_data);
int sceCtrlSetIdleCancelThreshold(int idlereset, int idleback);
int sceCtrlGetIdleCancelThreshold(int *idlerest, int *idleback);
typedef struct
{
unsigned int size;
int language;
int buttonSwap;
int graphicsThread;
int accessThread;
int fontThread;
int soundThread;
int result;
int reserved[4];
} pspUtilityDialogCommon;
typedef enum
{
PSP_UTILITY_MSGDIALOG_MODE_ERROR = 0,
PSP_UTILITY_MSGDIALOG_MODE_TEXT
} pspUtilityMsgDialogMode;
typedef enum
{
PSP_UTILITY_MSGDIALOG_OPTION_ERROR = 0,
PSP_UTILITY_MSGDIALOG_OPTION_TEXT = 0x00000001,
PSP_UTILITY_MSGDIALOG_OPTION_YESNO_BUTTONS = 0x00000010,
PSP_UTILITY_MSGDIALOG_OPTION_DEFAULT_NO = 0x00000100
} pspUtilityMsgDialogOption;
typedef enum
{
PSP_UTILITY_MSGDIALOG_RESULT_UNKNOWN1 = 0,
PSP_UTILITY_MSGDIALOG_RESULT_YES,
PSP_UTILITY_MSGDIALOG_RESULT_NO,
PSP_UTILITY_MSGDIALOG_RESULT_BACK
} pspUtilityMsgDialogPressed;
typedef struct _pspUtilityMsgDialogParams
{
pspUtilityDialogCommon base;
int unknown;
pspUtilityMsgDialogMode mode;
unsigned int errorValue;
char message[512];
int options;
pspUtilityMsgDialogPressed buttonPressed;
} pspUtilityMsgDialogParams;
int sceUtilityMsgDialogInitStart(pspUtilityMsgDialogParams *params);
void sceUtilityMsgDialogShutdownStart(void);
int sceUtilityMsgDialogGetStatus(void);
void sceUtilityMsgDialogUpdate(int n);
int sceUtilityMsgDialogAbort(void);
enum pspUtilityNetconfActions
{
PSP_NETCONF_ACTION_CONNECTAP,
PSP_NETCONF_ACTION_DISPLAYSTATUS,
PSP_NETCONF_ACTION_CONNECT_ADHOC
};
struct pspUtilityNetconfAdhoc
{
unsigned char name[8];
unsigned int timeout;
};
typedef struct _pspUtilityNetconfData
{
pspUtilityDialogCommon base;
int action;
struct pspUtilityNetconfAdhoc *adhocparam;
int hotspot;
int hotspot_connected;
int wifisp;
} pspUtilityNetconfData;
int sceUtilityNetconfInitStart (pspUtilityNetconfData *data);
int sceUtilityNetconfShutdownStart (void);
int sceUtilityNetconfUpdate (int unknown);
int sceUtilityNetconfGetStatus (void);
typedef union {
u32 asUint;
char asString[128];
} netData;
int sceUtilityCheckNetParam(int id);
int sceUtilityGetNetParam(int conf, int param, netData *data);
int sceUtilityCreateNetParam(int conf);
int sceUtilitySetNetParam(int param, const void *val);
int sceUtilityCopyNetParam(int src, int dest);
int sceUtilityDeleteNetParam(int conf);
typedef enum
{
PSP_UTILITY_SAVEDATA_AUTOLOAD = 0,
PSP_UTILITY_SAVEDATA_AUTOSAVE,
PSP_UTILITY_SAVEDATA_LOAD,
PSP_UTILITY_SAVEDATA_SAVE,
PSP_UTILITY_SAVEDATA_LISTLOAD,
PSP_UTILITY_SAVEDATA_LISTSAVE,
PSP_UTILITY_SAVEDATA_LISTDELETE,
PSP_UTILITY_SAVEDATA_LISTALLDELETE,
SCE_UTILITY_SAVEDATA_SIZES,
SCE_UTILITY_SAVEDATA_AUTODELETE,
SCE_UTILITY_SAVEDATA_DELETE,
SCE_UTILITY_SAVEDATA_LIST,
SCE_UTILITY_SAVEDATA_FILES,
SCE_UTILITY_SAVEDATA_MAKEDATASECURE,
SCE_UTILITY_SAVEDATA_MAKEDATA,
SCE_UTILITY_SAVEDATA_READDATASECURE,
SCE_UTILITY_SAVEDATA_READDATA,
SCE_UTILITY_SAVEDATA_WRITEDATASECURE,
SCE_UTILITY_SAVEDATA_WRITEDATA,
SCE_UTILITY_SAVEDATA_ERASESECURE,
SCE_UTILITY_SAVEDATA_ERASE,
SCE_UTILITY_SAVEDATA_DELETEDATA,
SCE_UTILITY_SAVEDATA_GETSIZE,
} PspUtilitySavedataMode;
typedef enum
{
PSP_UTILITY_SAVEDATA_FOCUS_UNKNOWN = 0,
PSP_UTILITY_SAVEDATA_FOCUS_FIRSTLIST,
PSP_UTILITY_SAVEDATA_FOCUS_LASTLIST,
PSP_UTILITY_SAVEDATA_FOCUS_LATEST,
PSP_UTILITY_SAVEDATA_FOCUS_OLDEST,
PSP_UTILITY_SAVEDATA_FOCUS_FIRSTDATA,
PSP_UTILITY_SAVEDATA_FOCUS_LASTDATA,
PSP_UTILITY_SAVEDATA_FOCUS_FIRSTEMPTY,
PSP_UTILITY_SAVEDATA_FOCUS_LASTEMPTY,
} PspUtilitySavedataFocus;
typedef struct PspUtilitySavedataSFOParam
{
char title[0x80];
char savedataTitle[0x80];
char detail[0x400];
unsigned char parentalLevel;
unsigned char unknown[3];
} PspUtilitySavedataSFOParam;
typedef struct PspUtilitySavedataFileData {
void *buf;
SceSize bufSize;
SceSize size;
int unknown;
} PspUtilitySavedataFileData;
typedef struct PspUtilitySavedataSizeEntry {
uint64_t size;
char name[16];
} PspUtilitySavedataSizeEntry;
typedef struct PspUtilitySavedataSizeInfo {
int numSecureEntries;
int numNormalEntries;
PspUtilitySavedataSizeEntry *secureEntries;
PspUtilitySavedataSizeEntry *normalEntries;
int sectorSize;
int freeSectors;
int freeKB;
char freeString[8];
int neededKB;
char neededString[8];
int overwriteKB;
char overwriteString[8];
} PspUtilitySavedataSizeInfo;
typedef struct SceUtilitySavedataIdListEntry
{
int st_mode;
ScePspDateTime sce_st_ctime;
ScePspDateTime sce_st_atime;
ScePspDateTime sce_st_mtime;
char name[20];
} SceUtilitySavedataIdListEntry;
typedef struct SceUtilitySavedataIdListInfo
{
int maxCount;
int resultCount;
SceUtilitySavedataIdListEntry *entries;
} SceUtilitySavedataIdListInfo;
typedef struct SceUtilitySavedataFileListEntry
{
int st_mode;
uint32_t st_unk0;
uint64_t st_size;
ScePspDateTime sce_st_ctime;
ScePspDateTime sce_st_atime;
ScePspDateTime sce_st_mtime;
char name[16];
} SceUtilitySavedataFileListEntry;
typedef struct SceUtilitySavedataFileListInfo
{
uint32_t maxSecureEntries;
uint32_t maxNormalEntries;
uint32_t maxSystemEntries;
uint32_t resultNumSecureEntries;
uint32_t resultNumNormalEntries;
uint32_t resultNumSystemEntries;
SceUtilitySavedataFileListEntry *secureEntries;
SceUtilitySavedataFileListEntry *normalEntries;
SceUtilitySavedataFileListEntry *systemEntries;
} SceUtilitySavedataFileListInfo;
typedef struct SceUtilitySavedataMsFreeInfo
{
int clusterSize;
int freeClusters;
int freeSpaceKB;
char freeSpaceStr[8];
} SceUtilitySavedataMsFreeInfo;
typedef struct SceUtilitySavedataUsedDataInfo
{
int usedClusters;
int usedSpaceKB;
char usedSpaceStr[8];
int usedSpace32KB;
char usedSpace32Str[8];
} SceUtilitySavedataUsedDataInfo;
typedef struct SceUtilitySavedataMsDataInfo
{
char gameName[13];
char pad[3];
char saveName[20];
SceUtilitySavedataUsedDataInfo info;
} SceUtilitySavedataMsDataInfo;
typedef struct PspUtilitySavedataListSaveNewData
{
PspUtilitySavedataFileData icon0;
char *title;
} PspUtilitySavedataListSaveNewData;
typedef struct SceUtilitySavedataParam
{
pspUtilityDialogCommon base;
PspUtilitySavedataMode mode;
int bind;
int overwrite;
char gameName[13];
char reserved[3];
char saveName[20];
char (*saveNameList)[20];
char fileName[13];
char reserved1[3];
void *dataBuf;
SceSize dataBufSize;
SceSize dataSize;
PspUtilitySavedataSFOParam sfoParam;
PspUtilitySavedataFileData icon0FileData;
PspUtilitySavedataFileData icon1FileData;
PspUtilitySavedataFileData pic1FileData;
PspUtilitySavedataFileData snd0FileData;
PspUtilitySavedataListSaveNewData *newData;
PspUtilitySavedataFocus focus;
int abortStatus;
SceUtilitySavedataMsFreeInfo *msFree;
SceUtilitySavedataMsDataInfo *msData;
SceUtilitySavedataUsedDataInfo *utilityData;
char key[16];
uint32_t secureVersion;
int multiStatus;
SceUtilitySavedataIdListInfo *idList;
SceUtilitySavedataFileListInfo *fileList;
PspUtilitySavedataSizeInfo *sizeInfo;
} SceUtilitySavedataParam;
int sceUtilitySavedataInitStart(SceUtilitySavedataParam * params);
int sceUtilitySavedataGetStatus(void);
int sceUtilitySavedataShutdownStart(void);
void sceUtilitySavedataUpdate(int unknown);
typedef enum
{
PSP_UTILITY_GAMESHARING_MODE_SINGLE = 1,
PSP_UTILITY_GAMESHARING_MODE_MULTIPLE = 2
} pspUtilityGameSharingMode;
typedef enum
{
PSP_UTILITY_GAMESHARING_DATA_TYPE_FILE = 1,
PSP_UTILITY_GAMESHARING_DATA_TYPE_MEMORY = 2,
} pspUtilityGameSharingDataType;
typedef struct _pspUtilityGameSharingParams
{
pspUtilityDialogCommon base;
int unknown1;
int unknown2;
char name[8];
int unknown3;
int unknown4;
int unknown5;
int result;
char *filepath;
pspUtilityGameSharingMode mode;
pspUtilityGameSharingDataType datatype;
void *data;
unsigned int datasize;
} pspUtilityGameSharingParams;
int sceUtilityGameSharingInitStart(pspUtilityGameSharingParams *params);
void sceUtilityGameSharingShutdownStart(void);
int sceUtilityGameSharingGetStatus(void);
void sceUtilityGameSharingUpdate(int n);
enum pspUtilityHtmlViewerDisconnectModes
{
PSP_UTILITY_HTMLVIEWER_DISCONNECTMODE_ENABLE = 0,
PSP_UTILITY_HTMLVIEWER_DISCONNECTMODE_DISABLE,
PSP_UTILITY_HTMLVIEWER_DISCONNECTMODE_CONFIRM
};
enum pspUtilityHtmlViewerInterfaceModes
{
PSP_UTILITY_HTMLVIEWER_INTERFACEMODE_FULL = 0,
PSP_UTILITY_HTMLVIEWER_INTERFACEMODE_LIMITED,
PSP_UTILITY_HTMLVIEWER_INTERFACEMODE_NONE
};
enum pspUtilityHtmlViewerCookieModes
{
PSP_UTILITY_HTMLVIEWER_COOKIEMODE_DISABLED = 0,
PSP_UTILITY_HTMLVIEWER_COOKIEMODE_ENABLED,
PSP_UTILITY_HTMLVIEWER_COOKIEMODE_CONFIRM,
PSP_UTILITY_HTMLVIEWER_COOKIEMODE_DEFAULT
};
enum pspUtilityHtmlViewerTextSizes
{
PSP_UTILITY_HTMLVIEWER_TEXTSIZE_LARGE = 0,
PSP_UTILITY_HTMLVIEWER_TEXTSIZE_NORMAL,
PSP_UTILITY_HTMLVIEWER_TEXTSIZE_SMALL
};
enum pspUtilityHtmlViewerDisplayModes
{
PSP_UTILITY_HTMLVIEWER_DISPLAYMODE_NORMAL = 0,
PSP_UTILITY_HTMLVIEWER_DISPLAYMODE_FIT,
PSP_UTILITY_HTMLVIEWER_DISPLAYMODE_SMART_FIT
};
enum pspUtilityHtmlViewerConnectModes
{
PSP_UTILITY_HTMLVIEWER_CONNECTMODE_LAST = 0,
PSP_UTILITY_HTMLVIEWER_CONNECTMODE_MANUAL_ONCE,
PSP_UTILITY_HTMLVIEWER_CONNECTMODE_MANUAL_ALL
};
enum pspUtilityHtmlViewerOptions
{
PSP_UTILITY_HTMLVIEWER_OPEN_SCE_START_PAGE = 0x000001,
PSP_UTILITY_HTMLVIEWER_DISABLE_STARTUP_LIMITS = 0x000002,
PSP_UTILITY_HTMLVIEWER_DISABLE_EXIT_DIALOG = 0x000004,
PSP_UTILITY_HTMLVIEWER_DISABLE_CURSOR = 0x000008,
PSP_UTILITY_HTMLVIEWER_DISABLE_DOWNLOAD_COMPLETE_DIALOG = 0x000010,
PSP_UTILITY_HTMLVIEWER_DISABLE_DOWNLOAD_START_DIALOG = 0x000020,
PSP_UTILITY_HTMLVIEWER_DISABLE_DOWNLOAD_DESTINATION_DIALOG = 0x000040,
PSP_UTILITY_HTMLVIEWER_LOCK_DOWNLOAD_DESTINATION_DIALOG = 0x000080,
PSP_UTILITY_HTMLVIEWER_DISABLE_TAB_DISPLAY = 0x000100,
PSP_UTILITY_HTMLVIEWER_ENABLE_ANALOG_HOLD = 0x000200,
PSP_UTILITY_HTMLVIEWER_ENABLE_FLASH = 0x000400,
PSP_UTILITY_HTMLVIEWER_DISABLE_LRTRIGGER = 0x000800
};
typedef struct pspUtilityHtmlViewerParam
{
pspUtilityDialogCommon base;
void* memaddr;
unsigned int memsize;
int unknown1;
int unknown2;
char* initialurl;
unsigned int numtabs;
unsigned int interfacemode;
unsigned int options;
char* dldirname;
char* dlfilename;
char* uldirname;
char* ulfilename;
unsigned int cookiemode;
unsigned int unknown3;
char* homeurl;
unsigned int textsize;
unsigned int displaymode;
unsigned int connectmode;
unsigned int disconnectmode;
unsigned int memused;
int unknown4[10];
} pspUtilityHtmlViewerParam;
int sceUtilityHtmlViewerInitStart(pspUtilityHtmlViewerParam *params);
int sceUtilityHtmlViewerShutdownStart(void);
int sceUtilityHtmlViewerUpdate(int n);
int sceUtilityHtmlViewerGetStatus(void);
int sceUtilitySetSystemParamInt(int id, int value);
int sceUtilitySetSystemParamString(int id, const char *str);
int sceUtilityGetSystemParamInt( int id, int *value );
int sceUtilityGetSystemParamString(int id, char *str, int len);
enum SceUtilityOskInputLanguage
{
PSP_UTILITY_OSK_LANGUAGE_DEFAULT = 0x00,
PSP_UTILITY_OSK_LANGUAGE_JAPANESE = 0x01,
PSP_UTILITY_OSK_LANGUAGE_ENGLISH = 0x02,
PSP_UTILITY_OSK_LANGUAGE_FRENCH = 0x03,
PSP_UTILITY_OSK_LANGUAGE_SPANISH = 0x04,
PSP_UTILITY_OSK_LANGUAGE_GERMAN = 0x05,
PSP_UTILITY_OSK_LANGUAGE_ITALIAN = 0x06,
PSP_UTILITY_OSK_LANGUAGE_DUTCH = 0x07,
PSP_UTILITY_OSK_LANGUAGE_PORTUGESE = 0x08,
PSP_UTILITY_OSK_LANGUAGE_RUSSIAN = 0x09,
PSP_UTILITY_OSK_LANGUAGE_KOREAN = 0x0a
};
enum SceUtilityOskState
{
PSP_UTILITY_OSK_DIALOG_NONE = 0,
PSP_UTILITY_OSK_DIALOG_INITING,
PSP_UTILITY_OSK_DIALOG_INITED,
PSP_UTILITY_OSK_DIALOG_VISIBLE,
PSP_UTILITY_OSK_DIALOG_QUIT,
PSP_UTILITY_OSK_DIALOG_FINISHED
};
enum SceUtilityOskResult
{
PSP_UTILITY_OSK_RESULT_UNCHANGED = 0,
PSP_UTILITY_OSK_RESULT_CANCELLED,
PSP_UTILITY_OSK_RESULT_CHANGED
};
enum SceUtilityOskInputType
{
PSP_UTILITY_OSK_INPUTTYPE_ALL = 0x00000000,
PSP_UTILITY_OSK_INPUTTYPE_LATIN_DIGIT = 0x00000001,
PSP_UTILITY_OSK_INPUTTYPE_LATIN_SYMBOL = 0x00000002,
PSP_UTILITY_OSK_INPUTTYPE_LATIN_LOWERCASE = 0x00000004,
PSP_UTILITY_OSK_INPUTTYPE_LATIN_UPPERCASE = 0x00000008,
PSP_UTILITY_OSK_INPUTTYPE_JAPANESE_DIGIT = 0x00000100,
PSP_UTILITY_OSK_INPUTTYPE_JAPANESE_SYMBOL = 0x00000200,
PSP_UTILITY_OSK_INPUTTYPE_JAPANESE_LOWERCASE = 0x00000400,
PSP_UTILITY_OSK_INPUTTYPE_JAPANESE_UPPERCASE = 0x00000800,
PSP_UTILITY_OSK_INPUTTYPE_JAPANESE_HIRAGANA = 0x00001000,
PSP_UTILITY_OSK_INPUTTYPE_JAPANESE_HALF_KATAKANA = 0x00002000,
PSP_UTILITY_OSK_INPUTTYPE_JAPANESE_KATAKANA = 0x00004000,
PSP_UTILITY_OSK_INPUTTYPE_JAPANESE_KANJI = 0x00008000,
PSP_UTILITY_OSK_INPUTTYPE_RUSSIAN_LOWERCASE = 0x00010000,
PSP_UTILITY_OSK_INPUTTYPE_RUSSIAN_UPPERCASE = 0x00020000,
PSP_UTILITY_OSK_INPUTTYPE_KOREAN = 0x00040000,
PSP_UTILITY_OSK_INPUTTYPE_URL = 0x00080000
};
typedef struct _SceUtilityOskData
{
int unk_00;
int unk_04;
int language;
int unk_12;
int inputtype;
int lines;
int unk_24;
unsigned short* desc;
unsigned short* intext;
int outtextlength;
unsigned short* outtext;
int result;
int outtextlimit;
} SceUtilityOskData;
typedef struct _SceUtilityOskParams
{
pspUtilityDialogCommon base;
int datacount;
SceUtilityOskData* data;
int state;
int unk_60;
} SceUtilityOskParams;
int sceUtilityOskInitStart(SceUtilityOskParams* params);
int sceUtilityOskShutdownStart(void);
int sceUtilityOskUpdate(int n);
int sceUtilityOskGetStatus(void);
int sceUtilityLoadNetModule(int module);
int sceUtilityUnloadNetModule(int module);
int sceUtilityLoadAvModule(int module);
int sceUtilityUnloadAvModule(int module);
int sceUtilityLoadUsbModule(int module);
int sceUtilityUnloadUsbModule(int module);
int sceUtilityLoadModule(int module);
int sceUtilityUnloadModule(int module);
typedef enum
{
PSP_UTILITY_DIALOG_NONE = 0,
PSP_UTILITY_DIALOG_INIT,
PSP_UTILITY_DIALOG_VISIBLE,
PSP_UTILITY_DIALOG_QUIT,
PSP_UTILITY_DIALOG_FINISHED
} pspUtilityDialogState;
浙公网安备 33010602011771号