Add PSP user mode API
This commit is contained in:
parent
9f581e6256
commit
6b6fe5bf0e
|
@ -0,0 +1,120 @@
|
|||
use super::c_void;
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct Atrac3BufferInfo {
|
||||
pub puc_write_position_first_buf: *mut u8,
|
||||
pub ui_writable_byte_first_buf: u32,
|
||||
pub ui_min_write_byte_first_buf: u32,
|
||||
pub ui_read_position_first_buf: u32,
|
||||
pub puc_write_position_second_buf: *mut u8,
|
||||
pub ui_writable_byte_second_buf: u32,
|
||||
pub ui_min_write_byte_second_buf: u32,
|
||||
pub ui_read_position_second_buf: u32,
|
||||
}
|
||||
|
||||
extern {
|
||||
pub fn sceAtracGetAtracID(ui_codec_type: u32) -> i32;
|
||||
pub fn sceAtracSetDataAndGetID(
|
||||
buf: *mut c_void,
|
||||
bufsize: usize,
|
||||
) -> i32;
|
||||
pub fn sceAtracDecodeData(
|
||||
atrac_id: i32,
|
||||
out_samples: *mut u16,
|
||||
out_n: *mut i32,
|
||||
out_end: *mut i32,
|
||||
out_remain_frame: *mut i32,
|
||||
) -> i32;
|
||||
pub fn sceAtracGetRemainFrame(
|
||||
atrac_id: i32,
|
||||
out_remain_frame: *mut i32,
|
||||
) -> i32;
|
||||
pub fn sceAtracGetStreamDataInfo(
|
||||
atrac_id: i32,
|
||||
write_pointer: *mut *mut u8,
|
||||
available_bytes: *mut u32,
|
||||
read_offset: *mut u32,
|
||||
) -> i32;
|
||||
pub fn sceAtracAddStreamData(
|
||||
atrac_id: i32,
|
||||
bytes_to_add: u32,
|
||||
) -> i32;
|
||||
pub fn sceAtracGetBitrate(
|
||||
atrac_id: i32,
|
||||
out_bitrate: *mut i32,
|
||||
) -> i32;
|
||||
pub fn sceAtracSetLoopNum(
|
||||
atrac_id: i32,
|
||||
nloops: i32,
|
||||
) -> i32;
|
||||
pub fn sceAtracReleaseAtracID(atrac_id: i32) -> i32;
|
||||
pub fn sceAtracGetNextSample(
|
||||
atrac_id: i32,
|
||||
out_n: *mut i32,
|
||||
) -> i32;
|
||||
pub fn sceAtracGetMaxSample(
|
||||
atrac_id: i32,
|
||||
out_max: *mut i32,
|
||||
) -> i32;
|
||||
pub fn sceAtracGetBufferInfoForReseting(
|
||||
atrac_id: i32,
|
||||
ui_sample: u32,
|
||||
pbuffer_info: *mut Atrac3BufferInfo,
|
||||
) -> i32;
|
||||
pub fn sceAtracGetChannel(
|
||||
atrac_id: i32,
|
||||
pui_channel: *mut u32,
|
||||
) -> i32;
|
||||
pub fn sceAtracGetInternalErrorInfo(
|
||||
atrac_id: i32,
|
||||
pi_result: *mut i32,
|
||||
) -> i32;
|
||||
pub fn sceAtracGetLoopStatus(
|
||||
atrac_id: i32,
|
||||
pi_loop_num: *mut i32,
|
||||
pui_loop_status: *mut u32,
|
||||
) -> i32;
|
||||
pub fn sceAtracGetNextDecodePosition(
|
||||
atrac_id: i32,
|
||||
pui_sample_position: *mut u32,
|
||||
) -> i32;
|
||||
pub fn sceAtracGetSecondBufferInfo(
|
||||
atrac_id: i32,
|
||||
pui_position: *mut u32,
|
||||
pui_data_byte: *mut u32,
|
||||
) -> i32;
|
||||
pub fn sceAtracGetSoundSample(
|
||||
atrac_id: i32,
|
||||
pi_end_sample: *mut i32,
|
||||
pi_loop_start_sample: *mut i32,
|
||||
pi_loop_end_sample: *mut i32,
|
||||
) -> i32;
|
||||
pub fn sceAtracResetPlayPosition(
|
||||
atrac_id: i32,
|
||||
ui_sample: u32,
|
||||
ui_write_byte_first_buf: u32,
|
||||
ui_write_byte_second_buf: u32,
|
||||
) -> i32;
|
||||
pub fn sceAtracSetData(
|
||||
atrac_id: i32,
|
||||
puc_buffer_addr: *mut u8,
|
||||
ui_buffer_byte: u32,
|
||||
) -> i32;
|
||||
pub fn sceAtracSetHalfwayBuffer(
|
||||
atrac_id: i32,
|
||||
puc_buffer_addr: *mut u8,
|
||||
ui_read_byte: u32,
|
||||
ui_buffer_byte: u32,
|
||||
) -> i32;
|
||||
pub fn sceAtracSetHalfwayBufferAndGetID(
|
||||
puc_buffer_addr: *mut u8,
|
||||
ui_read_byte: u32,
|
||||
ui_buffer_byte: u32,
|
||||
) -> i32;
|
||||
pub fn sceAtracSetSecondBuffer(
|
||||
atrac_id: i32,
|
||||
puc_second_buffer_addr: *mut u8,
|
||||
ui_second_buffer_byte: u32,
|
||||
) -> i32;
|
||||
}
|
|
@ -0,0 +1,76 @@
|
|||
use super::c_void;
|
||||
|
||||
pub const AUDIO_VOLUME_MAX: u32 = 0x8000;
|
||||
pub const AUDIO_CHANNEL_MAX: u32 = 8;
|
||||
pub const AUDIO_NEXT_CHANNEL: i32 = -1;
|
||||
pub const AUDIO_SAMPLE_MIN: u32 = 64;
|
||||
pub const AUDIO_SAMPLE_MAX: u32 = 65472;
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(u32)]
|
||||
pub enum AudioFormat {
|
||||
Stereo = 0,
|
||||
Mono = 0x10,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct AudioInputParams {
|
||||
pub unknown1: i32,
|
||||
pub gain: i32,
|
||||
pub unknown2: i32,
|
||||
pub unknown3: i32,
|
||||
pub unknown4: i32,
|
||||
pub unknown5: i32,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(i32)]
|
||||
pub enum AudioOutputFrequency {
|
||||
Khz48 = 48000,
|
||||
Khz44_1 = 44100,
|
||||
Khz32 = 32000,
|
||||
Khz24 = 24000,
|
||||
Khz22_05 = 22050,
|
||||
Khz16 = 16000,
|
||||
Khz12 = 12000,
|
||||
Khz11_025 = 11025,
|
||||
Khz8 = 8000,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(i32)]
|
||||
pub enum AudioInputFrequency {
|
||||
Khz44_1 = 44100,
|
||||
Khz22_05 = 22050,
|
||||
Khz11_025 = 11025,
|
||||
}
|
||||
|
||||
extern {
|
||||
pub fn sceAudioChReserve(channel: i32, sample_count: i32, format: AudioFormat) -> i32;
|
||||
pub fn sceAudioChRelease(channel: i32) -> i32;
|
||||
pub fn sceAudioOutput(channel: i32, vol: i32, buf: *mut c_void) -> i32;
|
||||
pub fn sceAudioOutputBlocking(channel: i32, vol: i32, buf: *mut c_void) -> i32;
|
||||
pub fn sceAudioOutputPanned(channel: i32, left_vol: i32, right_vol: i32, buf: *mut c_void) -> i32;
|
||||
pub fn sceAudioOutputPannedBlocking(channel: i32, left_vol: i32, right_vol: i32, buf: *mut c_void) -> i32;
|
||||
pub fn sceAudioGetChannelRestLen(channel: i32) -> i32;
|
||||
pub fn sceAudioGetChannelRestLength(channel: i32) -> i32;
|
||||
pub fn sceAudioSetChannelDataLen(channel: i32, sample_count: i32) -> i32;
|
||||
pub fn sceAudioChangeChannelConfig(channel: i32, format: AudioFormat) -> i32;
|
||||
pub fn sceAudioChangeChannelVolume(channel:i32, left_vol: i32, right_vol:i32) -> i32;
|
||||
pub fn sceAudioOutput2Reserve(sample_count: i32) -> i32;
|
||||
pub fn sceAudioOutput2Release() -> i32;
|
||||
pub fn sceAudioOutput2ChangeLength(sample_count: i32) -> i32;
|
||||
pub fn sceAudioOutput2OutputBlocking(vol: i32, buf: *mut c_void) -> i32;
|
||||
pub fn sceAudioOutput2GetRestSample() -> i32;
|
||||
pub fn sceAudioSRCChReserve(sample_count: i32, freq: AudioOutputFrequency, channels: i32) -> i32;
|
||||
pub fn sceAudioSRCChRelease() -> i32;
|
||||
pub fn sceAudioSRCOutputBlocking(vol: i32, buf: *mut c_void) -> i32;
|
||||
pub fn sceAudioInputInit(unknown1: i32, gain: i32, unknown2: i32) -> i32;
|
||||
pub fn sceAudioInputInitEx(params: *mut AudioInputParams) -> i32;
|
||||
pub fn sceAudioInputBlocking(sample_count: i32, freq: AudioInputFrequency, buf: *mut c_void);
|
||||
pub fn sceAudioInput(sample_count: i32, freq: AudioInputFrequency, buf: *mut c_void);
|
||||
pub fn sceAudioGetInputLength() -> i32;
|
||||
pub fn sceAudioWaitInputEnd() -> i32;
|
||||
pub fn sceAudioPollInputEnd() -> i32;
|
||||
}
|
|
@ -0,0 +1,46 @@
|
|||
extern {
|
||||
pub fn sceVideocodecOpen(
|
||||
buffer: *mut u32,
|
||||
type_: i32,
|
||||
) -> i32;
|
||||
pub fn sceVideocodecGetEDRAM(
|
||||
buffer: *mut u32,
|
||||
type_: i32,
|
||||
) -> i32;
|
||||
pub fn sceVideocodecInit(
|
||||
buffer: *mut u32,
|
||||
type_: i32,
|
||||
) -> i32;
|
||||
pub fn sceVideocodecDecode(
|
||||
buffer: *mut u32,
|
||||
type_: i32,
|
||||
) -> i32;
|
||||
pub fn sceVideocodecReleaseEDRAM(buffer: *mut u32) -> i32;
|
||||
}
|
||||
|
||||
pub enum AudioCodec {
|
||||
At3Plus = 0x00001000,
|
||||
At3 = 0x00001001,
|
||||
Mp3 = 0x00001002,
|
||||
Aac = 0x00001003,
|
||||
}
|
||||
|
||||
extern {
|
||||
pub fn sceAudiocodecCheckNeedMem(
|
||||
buffer: *mut u32,
|
||||
type_: i32,
|
||||
) -> i32;
|
||||
pub fn sceAudiocodecInit(
|
||||
buffer: *mut u32,
|
||||
type_: i32,
|
||||
) -> i32;
|
||||
pub fn sceAudiocodecDecode(
|
||||
buffer: *mut u32,
|
||||
type_: i32,
|
||||
) -> i32;
|
||||
pub fn sceAudiocodecGetEDRAM(
|
||||
buffer: *mut u32,
|
||||
type_: i32,
|
||||
) -> i32;
|
||||
pub fn sceAudiocodecReleaseEDRAM(buffer: *mut u32) -> i32;
|
||||
}
|
|
@ -0,0 +1,63 @@
|
|||
pub const PSP_CTRL_SELECT: i32 = 0x000001;
|
||||
pub const PSP_CTRL_START: i32 = 0x000008;
|
||||
pub const PSP_CTRL_UP: i32 = 0x000010;
|
||||
pub const PSP_CTRL_RIGHT: i32 = 0x000020;
|
||||
pub const PSP_CTRL_DOWN: i32 = 0x000040;
|
||||
pub const PSP_CTRL_LEFT: i32 = 0x000080;
|
||||
pub const PSP_CTRL_LTRIGGER: i32 = 0x000100;
|
||||
pub const PSP_CTRL_RTRIGGER: i32 = 0x000200;
|
||||
pub const PSP_CTRL_TRIANGLE: i32 = 0x001000;
|
||||
pub const PSP_CTRL_CIRCLE: i32 = 0x002000;
|
||||
pub const PSP_CTRL_CROSS: i32 = 0x004000;
|
||||
pub const PSP_CTRL_SQUARE: i32 = 0x008000;
|
||||
pub const PSP_CTRL_HOME: i32 = 0x010000;
|
||||
pub const PSP_CTRL_HOLD: i32 = 0x020000;
|
||||
pub const PSP_CTRL_NOTE: i32 = 0x800000;
|
||||
pub const PSP_CTRL_SCREEN: i32 = 0x400000;
|
||||
pub const PSP_CTRL_VOLUP: i32 = 0x100000;
|
||||
pub const PSP_CTRL_VOLDOWN: i32 = 0x200000;
|
||||
pub const PSP_CTRL_WLAN_UP: i32 = 0x040000;
|
||||
pub const PSP_CTRL_REMOTE: i32 = 0x080000;
|
||||
pub const PSP_CTRL_DISC: i32 = 0x1000000;
|
||||
pub const PSP_CTRL_MS: i32 = 0x2000000;
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(u32)]
|
||||
pub enum CtrlMode {
|
||||
Digital = 0,
|
||||
Analaog
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct SceCtrlData {
|
||||
pub timestamp: u32,
|
||||
pub buttons: i32,
|
||||
pub lx: u8,
|
||||
pub ly: u8,
|
||||
pub rsrv: [u8;
|
||||
6],
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct SceCtrlLatch {
|
||||
pub ui_make: u32,
|
||||
pub ui_break: u32,
|
||||
pub ui_press: u32,
|
||||
pub ui_release: u32,
|
||||
}
|
||||
|
||||
extern {
|
||||
pub fn sceCtrlSetSamplingCycle(cycle: i32) -> i32;
|
||||
pub fn sceCtrlGetSamplingCycle(pcycle: *mut i32) -> i32;
|
||||
pub fn sceCtrlSetSamplingMode(mode: CtrlMode) -> i32;
|
||||
pub fn sceCtrlGetSamplingMode(pmode: *mut i32) -> i32;
|
||||
pub fn sceCtrlPeekBufferPositive(pad_data: *mut SceCtrlData, count: i32) -> i32;
|
||||
pub fn sceCtrlPeekBufferNegative(pad_data: *mut SceCtrlData, count: i32) -> i32;
|
||||
pub fn sceCtrlReadBufferPositive(pad_data: *mut SceCtrlData, count: i32) -> i32;
|
||||
pub fn sceCtrlReadBufferNegative(pad_data: *mut SceCtrlData, count: i32) -> i32;
|
||||
pub fn sceCtrlPeekLatch(latch_data: *mut SceCtrlLatch) -> i32;
|
||||
pub fn sceCtrlReadLatch(latch_data: *mut SceCtrlLatch) -> i32;
|
||||
pub fn sceCtrlSetIdleCancelThreshold(idlereset: i32, idleback: i32) -> i32;
|
||||
pub fn sceCtrlGetIdleCancelThreshold(idlereset: *mut i32, idleback: *mut i32) -> i32;
|
||||
}
|
|
@ -0,0 +1,50 @@
|
|||
use super::c_void;
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
#[repr(u32)]
|
||||
pub enum DisplayMode {
|
||||
Lcd = 0,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(u32)]
|
||||
pub enum DisplayPixelFormat {
|
||||
Psm5650 = 0,
|
||||
Psm5551 = 1,
|
||||
Psm4444 = 2,
|
||||
Psm8888 = 3,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
#[repr(u32)]
|
||||
pub enum DisplaySetBufSync {
|
||||
Immediate = 0,
|
||||
NextFrame = 1,
|
||||
}
|
||||
|
||||
extern {
|
||||
pub fn sceDisplaySetMode(mode: DisplayMode, width: usize, height: usize) -> u32;
|
||||
pub fn sceDisplayGetMode(pmode: *mut i32, pwidth: *mut i32, pheight: *mut i32) -> i32;
|
||||
pub fn sceDisplaySetFrameBuf(
|
||||
top_addr: *const u8,
|
||||
buffer_width: usize,
|
||||
pixel_format: DisplayPixelFormat,
|
||||
sync: DisplaySetBufSync,
|
||||
) -> u32;
|
||||
pub fn sceDisplayGetFrameBuf(
|
||||
top_addr: *mut *mut c_void,
|
||||
buffer_width: *mut usize,
|
||||
pixel_format: *mut DisplayPixelFormat,
|
||||
sync: DisplaySetBufSync,
|
||||
) -> i32;
|
||||
pub fn sceDisplayGetVcount() -> u32;
|
||||
pub fn sceDisplayWaitVblank() -> i32;
|
||||
pub fn sceDisplayWaitVblankCB() -> i32;
|
||||
pub fn sceDisplayWaitVblankStart() -> i32;
|
||||
pub fn sceDisplayWaitVblankStartCB() -> i32;
|
||||
pub fn sceDisplayGetAccumulatedHcount() -> i32;
|
||||
pub fn sceDisplayGetCurrentHcount() -> i32;
|
||||
pub fn sceDisplayGetFramePerSec() -> f32;
|
||||
pub fn sceDisplayIsForeground() -> i32;
|
||||
pub fn sceDisplayIsVblank() -> i32;
|
||||
}
|
|
@ -0,0 +1,352 @@
|
|||
use super::c_void;
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct GeContext {
|
||||
pub context: [u32; 512],
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct GeStack {
|
||||
pub stack: [u32;8]
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct GeCallbackData {
|
||||
pub signal_func: Option<extern fn(id: i32, arg: *mut c_void)>,
|
||||
pub signal_arg: *mut c_void,
|
||||
pub finish_func: Option<extern fn(id: i32, arg: *mut c_void)>,
|
||||
pub finish_arg: *mut c_void,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct GeListArgs {
|
||||
pub size: u32,
|
||||
pub context: *mut GeContext,
|
||||
pub num_stacks: u32,
|
||||
pub stacks: *mut GeStack,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct GeBreakParam {
|
||||
pub buf: [u32;4]
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(i32)]
|
||||
pub enum GeMatrixType {
|
||||
Bone0 = 0,
|
||||
Bone1,
|
||||
Bone2,
|
||||
Bone3,
|
||||
Bone4,
|
||||
Bone5,
|
||||
Bone6,
|
||||
Bone7,
|
||||
World,
|
||||
View,
|
||||
Projection,
|
||||
TexGen,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(i32)]
|
||||
pub enum GeListState {
|
||||
Done = 0,
|
||||
Queued,
|
||||
DrawingDone,
|
||||
StallReached,
|
||||
CancelDone,
|
||||
}
|
||||
|
||||
#[repr(u8)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub enum GeCommand {
|
||||
Nop = 0,
|
||||
Vaddr = 0x1,
|
||||
Iaddr = 0x2,
|
||||
Prim = 0x4,
|
||||
Bezier = 0x5,
|
||||
Spline = 0x6,
|
||||
BoundingBox = 0x7,
|
||||
Jump = 0x8,
|
||||
BJump = 0x9,
|
||||
Call = 0xa,
|
||||
Ret = 0xb,
|
||||
End = 0xc,
|
||||
Signal = 0xe,
|
||||
Finish = 0xf,
|
||||
Base = 0x10,
|
||||
VertexType = 0x12,
|
||||
OffsetAddr = 0x13,
|
||||
Origin = 0x14,
|
||||
Region1 = 0x15,
|
||||
Region2 = 0x16,
|
||||
LightingEnable = 0x17,
|
||||
LightEnable0 = 0x18,
|
||||
LightEnable1 = 0x19,
|
||||
LightEnable2 = 0x1a,
|
||||
LightEnable3 = 0x1b,
|
||||
DepthClampEnable = 0x1c,
|
||||
CullFaceEnable = 0x1d,
|
||||
TextureMapEnable = 0x1e,
|
||||
FogEnable = 0x1f,
|
||||
DitherEnable = 0x20,
|
||||
AlphaBlendEnable = 0x21,
|
||||
AlphaTestEnable = 0x22,
|
||||
ZTestEnable = 0x23,
|
||||
StencilTestEnable = 0x24,
|
||||
AntiAliasEnable = 0x25,
|
||||
PatchCullEnable = 0x26,
|
||||
ColorTestEnable = 0x27,
|
||||
LogicOpEnable = 0x28,
|
||||
BoneMatrixNumber = 0x2a,
|
||||
BoneMatrixData = 0x2b,
|
||||
MorphWeight0 = 0x2c,
|
||||
MorphWeight1 = 0x2d,
|
||||
MorphWeight2 = 0x2e,
|
||||
MorphWeight3 = 0x2f,
|
||||
MorphWeight4 = 0x30,
|
||||
MorphWeight5 = 0x31,
|
||||
MorphWeight6 = 0x32,
|
||||
MorphWeight7 = 0x33,
|
||||
PatchDivision = 0x36,
|
||||
PatchPrimitive = 0x37,
|
||||
PatchFacing = 0x38,
|
||||
WorldMatrixNumber = 0x3a,
|
||||
WorldMatrixData = 0x3b,
|
||||
ViewMatrixNumber = 0x3c,
|
||||
ViewMatrixData = 0x3d,
|
||||
ProjMatrixNumber = 0x3e,
|
||||
ProjMatrixData = 0x3f,
|
||||
TGenMatrixNumber = 0x40,
|
||||
TGenMatrixData = 0x41,
|
||||
ViewportXScale = 0x42,
|
||||
ViewportYScale = 0x43,
|
||||
ViewportZScale = 0x44,
|
||||
ViewportXCenter = 0x45,
|
||||
ViewportYCenter = 0x46,
|
||||
ViewportZCenter = 0x47,
|
||||
TexScaleU = 0x48,
|
||||
TexScaleV = 0x49,
|
||||
TexOffsetU = 0x4a,
|
||||
TexOffsetV = 0x4b,
|
||||
OffsetX = 0x4c,
|
||||
OffsetY = 0x4d,
|
||||
ShadeMode = 0x50,
|
||||
ReverseNormal = 0x51,
|
||||
MaterialUpdate = 0x53,
|
||||
MaterialEmissive = 0x54,
|
||||
MaterialAmbient = 0x55,
|
||||
MaterialDiffuse = 0x56,
|
||||
MaterialSpecular = 0x57,
|
||||
MaterialAlpha = 0x58,
|
||||
MaterialSpecularCoef = 0x5b,
|
||||
AmbientColor = 0x5c,
|
||||
AmbientAlpha = 0x5d,
|
||||
LightMode = 0x5e,
|
||||
LightType0 = 0x5f,
|
||||
LightType1 = 0x60,
|
||||
LightType2 = 0x61,
|
||||
LightType3 = 0x62,
|
||||
Light0X = 0x63,
|
||||
Light0Y,
|
||||
Light0Z,
|
||||
Light1X,
|
||||
Light1Y,
|
||||
Light1Z,
|
||||
Light2X,
|
||||
Light2Y,
|
||||
Light2Z,
|
||||
Light3X,
|
||||
Light3Y,
|
||||
Light3Z,
|
||||
Light0DirectionX = 0x6f,
|
||||
Light0DirectionY,
|
||||
Light0DirectionZ,
|
||||
Light1DirectionX,
|
||||
Light1DirectionY,
|
||||
Light1DirectionZ,
|
||||
Light2DirectionX,
|
||||
Light2DirectionY,
|
||||
Light2DirectionZ,
|
||||
Light3DirectionX,
|
||||
Light3DirectionY,
|
||||
Light3DirectionZ,
|
||||
Light0ConstantAtten = 0x7b,
|
||||
Light0LinearAtten,
|
||||
Light0QuadtraticAtten,
|
||||
Light1ConstantAtten,
|
||||
Light1LinearAtten,
|
||||
Light1QuadtraticAtten,
|
||||
Light2ConstantAtten,
|
||||
Light2LinearAtten,
|
||||
Light2QuadtraticAtten,
|
||||
Light3ConstantAtten,
|
||||
Light3LinearAtten,
|
||||
Light3QuadtraticAtten,
|
||||
Light0ExponentAtten = 0x87,
|
||||
Light1ExponentAtten,
|
||||
Light2ExponentAtten,
|
||||
Light3ExponentAtten,
|
||||
Light0CutoffAtten = 0x8b,
|
||||
Light1CutoffAtten,
|
||||
Light2CutoffAtten,
|
||||
Light3CutoffAtten,
|
||||
Light0Ambient = 0x8f,
|
||||
Light0Diffuse,
|
||||
Light0Specular,
|
||||
Light1Ambient,
|
||||
Light1Diffuse,
|
||||
Light1Specular,
|
||||
Light2Ambient,
|
||||
Light2Diffuse,
|
||||
Light2Specular,
|
||||
Light3Ambient,
|
||||
Light3Diffuse,
|
||||
Light3Specular,
|
||||
Cull = 0x9b,
|
||||
FrameBufPtr = 0x9c,
|
||||
FrameBufWidth = 0x9d,
|
||||
ZBufPtr = 0x9e,
|
||||
ZBufWidth = 0x9f,
|
||||
TexAddr0 = 0xa0,
|
||||
TexAddr1,
|
||||
TexAddr2,
|
||||
TexAddr3,
|
||||
TexAddr4,
|
||||
TexAddr5,
|
||||
TexAddr6,
|
||||
TexAddr7,
|
||||
TexBufWidth0 = 0xa8,
|
||||
TexBufWidth1,
|
||||
TexBufWidth2,
|
||||
TexBufWidth3,
|
||||
TexBufWidth4,
|
||||
TexBufWidth5,
|
||||
TexBufWidth6,
|
||||
TexBufWidth7,
|
||||
ClutAddr = 0xb0,
|
||||
ClutAddrUpper = 0xb1,
|
||||
TransferSrc,
|
||||
TransferSrcW,
|
||||
TransferDst,
|
||||
TransferDstW,
|
||||
TexSize0 = 0xb8,
|
||||
TexSize1,
|
||||
TexSize2,
|
||||
TexSize3,
|
||||
TexSize4,
|
||||
TexSize5,
|
||||
TexSize6,
|
||||
TexSize7,
|
||||
TexMapMode = 0xc0,
|
||||
TexShadeLs = 0xc1,
|
||||
TexMode = 0xc2,
|
||||
TexFormat = 0xc3,
|
||||
LoadClut = 0xc4,
|
||||
ClutFormat = 0xc5,
|
||||
TexFilter = 0xc6,
|
||||
TexWrap = 0xc7,
|
||||
TexLevel = 0xc8,
|
||||
TexFunc = 0xc9,
|
||||
TexEnvColor = 0xca,
|
||||
TexFlush = 0xcb,
|
||||
TexSync = 0xcc,
|
||||
Fog1 = 0xcd,
|
||||
Fog2 = 0xce,
|
||||
FogColor = 0xcf,
|
||||
TexLodSlope = 0xd0,
|
||||
FramebufPixFormat = 0xd2,
|
||||
ClearMode = 0xd3,
|
||||
Scissor1 = 0xd4,
|
||||
Scissor2 = 0xd5,
|
||||
MinZ = 0xd6,
|
||||
MaxZ = 0xd7,
|
||||
ColorTest = 0xd8,
|
||||
ColorRef = 0xd9,
|
||||
ColorTestmask = 0xda,
|
||||
AlphaTest = 0xdb,
|
||||
StencilTest = 0xdc,
|
||||
StencilOp = 0xdd,
|
||||
ZTest = 0xde,
|
||||
BlendMode = 0xdf,
|
||||
BlendFixedA = 0xe0,
|
||||
BlendFixedB = 0xe1,
|
||||
Dith0 = 0xe2,
|
||||
Dith1,
|
||||
Dith2,
|
||||
Dith3,
|
||||
LogicOp = 0xe6,
|
||||
ZWriteDisable = 0xe7,
|
||||
MaskRgb = 0xe8,
|
||||
MaskAlpha = 0xe9,
|
||||
TransferStart = 0xea,
|
||||
TransferSrcPos = 0xeb,
|
||||
TransferDstPos = 0xec,
|
||||
TransferSize = 0xee,
|
||||
Vscx = 0xf0,
|
||||
Vscy = 0xf1,
|
||||
Vscz = 0xf2,
|
||||
Vtcs = 0xf3,
|
||||
Vtct = 0xf4,
|
||||
Vtcq = 0xf5,
|
||||
Vcv = 0xf6,
|
||||
Vap = 0xf7,
|
||||
Vfc = 0xf8,
|
||||
Vscv = 0xf9,
|
||||
|
||||
Unknown03 = 0x03,
|
||||
Unknown0D = 0x0d,
|
||||
Unknown11 = 0x11,
|
||||
Unknown29 = 0x29,
|
||||
Unknown34 = 0x34,
|
||||
Unknown35 = 0x35,
|
||||
Unknown39 = 0x39,
|
||||
Unknown4E = 0x4e,
|
||||
Unknown4F = 0x4f,
|
||||
Unknown52 = 0x52,
|
||||
Unknown59 = 0x59,
|
||||
Unknown5A = 0x5a,
|
||||
UnknownB6 = 0xb6,
|
||||
UnknownB7 = 0xb7,
|
||||
UnknownD1 = 0xd1,
|
||||
UnknownED = 0xed,
|
||||
UnknownEF = 0xef,
|
||||
UnknownFA = 0xfa,
|
||||
UnknownFB = 0xfb,
|
||||
UnknownFC = 0xfc,
|
||||
UnknownFD = 0xfd,
|
||||
UnknownFE = 0xfe,
|
||||
NopFF = 0xff,
|
||||
}
|
||||
|
||||
extern {
|
||||
pub fn sceGeEdramGetSize() -> u32;
|
||||
pub fn sceGeEdramGetAddr() -> *mut u8;
|
||||
pub fn sceGeEdramSetAddrTranslation(width: i32) -> i32;
|
||||
pub fn sceGeGetCmd(cmd: i32) -> u32;
|
||||
pub fn sceGeGetMtx(type_: GeMatrixType, matrix: *mut c_void) -> i32;
|
||||
pub fn sceGeGetStack(stack_id: i32, stack: *mut GeStack) -> i32;
|
||||
pub fn sceGeSaveContext(context: *mut GeContext) -> i32;
|
||||
pub fn sceGeRestoreContext(context: *const GeContext) -> i32;
|
||||
pub fn sceGeListEnQueue(
|
||||
list: *const c_void,
|
||||
stall: *mut c_void,
|
||||
cbid: i32,
|
||||
arg: *mut GeListArgs,
|
||||
) -> i32;
|
||||
pub fn sceGeListEnQueueHead(list: *const c_void, stall: *mut c_void, cbid: i32, arg: *mut GeListArgs) -> i32;
|
||||
pub fn sceGeListDeQueue(qid: i32) -> i32;
|
||||
pub fn sceGeListUpdateStallAddr(qid: i32, stall: *mut c_void) -> i32;
|
||||
pub fn sceGeListSync(qid: i32, sync_type: i32) -> GeListState;
|
||||
pub fn sceGeDrawSync(sync_type: i32) -> GeListState;
|
||||
pub fn sceGeBreak(mode: i32, p_param: *mut GeBreakParam) -> i32;
|
||||
pub fn sceGeContinue() -> i32;
|
||||
pub fn sceGeSetCallback(cb: *mut GeCallbackData) -> i32;
|
||||
pub fn sceGeUnsetCallback(cbid: i32) -> i32;
|
||||
}
|
|
@ -0,0 +1,580 @@
|
|||
use super::{
|
||||
c_void,
|
||||
ge::{GeContext, GeCommand, GeListState},
|
||||
display::DisplayPixelFormat,
|
||||
types::{ScePspFMatrix4, ScePspFVector3, ScePspIMatrix4},
|
||||
};
|
||||
|
||||
pub const GU_PI: f32 = 3.141593;
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub enum GuPrimitive {
|
||||
Points = 0,
|
||||
Lines = 1,
|
||||
LineStrip = 2,
|
||||
Triangles = 3,
|
||||
TriangleStrip = 4,
|
||||
TriangleFan = 5,
|
||||
Sprites = 6,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub enum PatchPrimitive {
|
||||
Points = 0,
|
||||
LineStrip = 2,
|
||||
TriangleStrip = 4,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Eq, PartialEq)]
|
||||
#[repr(u32)]
|
||||
pub enum GuState {
|
||||
AlphaTest = 0,
|
||||
DepthTest = 1,
|
||||
ScissorTest = 2,
|
||||
StencilTest = 3,
|
||||
Blend = 4,
|
||||
CullFace = 5,
|
||||
Dither = 6,
|
||||
Fog = 7,
|
||||
ClipPlanes = 8,
|
||||
Texture2D = 9,
|
||||
Lighting = 10,
|
||||
Light0 = 11,
|
||||
Light1 = 12,
|
||||
Light2 = 13,
|
||||
Light3 = 14,
|
||||
LineSmooth = 15,
|
||||
PatchCullFace = 16,
|
||||
ColorTest = 17,
|
||||
ColorLogicOp = 18,
|
||||
FaceNormalReverse = 19,
|
||||
PatchFace = 20,
|
||||
Fragment2X = 21,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub enum MatrixMode {
|
||||
Projection = 0,
|
||||
View = 1,
|
||||
Model = 2,
|
||||
Texture = 3,
|
||||
}
|
||||
|
||||
pub const GU_TEXTURE_8BIT: i32 = 1;
|
||||
pub const GU_TEXTURE_16BIT: i32 = 2;
|
||||
pub const GU_TEXTURE_32BITF: i32 = 3;
|
||||
pub const GU_COLOR_5650: i32 = 4 << 2;
|
||||
pub const GU_COLOR_5551: i32 = 5 << 2;
|
||||
pub const GU_COLOR_4444: i32 = 6 << 2;
|
||||
pub const GU_COLOR_8888: i32 = 7 << 2;
|
||||
pub const GU_NORMAL_8BIT: i32 = 1 << 5;
|
||||
pub const GU_NORMAL_16BIT: i32 = 2 << 5;
|
||||
pub const GU_NORMAL_32BITF: i32 = 3 << 5;
|
||||
pub const GU_VERTEX_8BIT: i32 = 1 << 7;
|
||||
pub const GU_VERTEX_16BIT: i32 = 2 << 7;
|
||||
pub const GU_VERTEX_32BITF: i32 = 3 << 7;
|
||||
pub const GU_WEIGHT_8BIT: i32 = 1 << 9;
|
||||
pub const GU_WEIGHT_16BIT: i32 = 2 << 9;
|
||||
pub const GU_WEIGHT_32BITF: i32 = 3 << 9;
|
||||
pub const GU_INDEX_8BIT: i32 = 1 << 11;
|
||||
pub const GU_INDEX_16BIT: i32 = 2 << 11;
|
||||
pub const GU_WEIGHTS1: i32 = num_weights(1);
|
||||
pub const GU_WEIGHTS2: i32 = num_weights(2);
|
||||
pub const GU_WEIGHTS3: i32 = num_weights(3);
|
||||
pub const GU_WEIGHTS4: i32 = num_weights(4);
|
||||
pub const GU_WEIGHTS5: i32 = num_weights(5);
|
||||
pub const GU_WEIGHTS6: i32 = num_weights(6);
|
||||
pub const GU_WEIGHTS7: i32 = num_weights(7);
|
||||
pub const GU_WEIGHTS8: i32 = num_weights(8);
|
||||
pub const GU_VERTICES1: i32 = num_vertices(1);
|
||||
pub const GU_VERTICES2: i32 = num_vertices(2);
|
||||
pub const GU_VERTICES3: i32 = num_vertices(3);
|
||||
pub const GU_VERTICES4: i32 = num_vertices(4);
|
||||
pub const GU_VERTICES5: i32 = num_vertices(5);
|
||||
pub const GU_VERTICES6: i32 = num_vertices(6);
|
||||
pub const GU_VERTICES7: i32 = num_vertices(7);
|
||||
pub const GU_VERTICES8: i32 = num_vertices(8);
|
||||
pub const GU_TRANSFORM_2D: i32 = 1 << 23;
|
||||
pub const GU_TRANSFORM_3D: i32 = 0;
|
||||
|
||||
const fn num_weights(n: u32) -> i32 {
|
||||
(((n - 1) & 7) << 14) as i32
|
||||
}
|
||||
|
||||
const fn num_vertices(n: u32) -> i32 {
|
||||
(((n - 1) & 7) << 18) as i32
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
#[repr(u32)]
|
||||
pub enum TexturePixelFormat {
|
||||
Psm5650 = 0,
|
||||
Psm5551 = 1,
|
||||
Psm4444 = 2,
|
||||
Psm8888 = 3,
|
||||
PsmT4 = 4,
|
||||
PsmT8 = 5,
|
||||
PsmT16 = 6,
|
||||
PsmT32 = 7,
|
||||
PsmDxt1 = 8,
|
||||
PsmDxt3 = 9,
|
||||
PsmDxt5 = 10,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(u32)]
|
||||
pub enum SplineMode {
|
||||
FillFill = 0,
|
||||
OpenFill = 1,
|
||||
FillOpen = 2,
|
||||
OpenOpen = 3,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(u32)]
|
||||
pub enum ShadingModel {
|
||||
Flat = 0,
|
||||
Smooth = 1,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(u32)]
|
||||
pub enum LogicalOperation {
|
||||
Clear = 0,
|
||||
And = 1,
|
||||
AndReverse = 2,
|
||||
Copy = 3,
|
||||
AndInverted = 4,
|
||||
Noop = 5,
|
||||
Xor = 6,
|
||||
Or = 7,
|
||||
Nor = 8,
|
||||
Equiv = 9,
|
||||
Inverted = 10,
|
||||
OrReverse = 11,
|
||||
CopyInverted = 12,
|
||||
OrInverted = 13,
|
||||
Nand = 14,
|
||||
Set = 15,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(u32)]
|
||||
pub enum TextureFilter {
|
||||
Nearest = 0,
|
||||
Linear = 1,
|
||||
NearestMipmapNearest = 4,
|
||||
LinearMipmapNearest = 5,
|
||||
NearestMipmapLinear = 6,
|
||||
LinearMipmapLinear = 7,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
#[repr(u32)]
|
||||
pub enum TextureMapMode {
|
||||
TextureCoords = 0,
|
||||
TextureMatrix = 1,
|
||||
EnvironmentMap = 2,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(u32)]
|
||||
pub enum TextureLevelMode {
|
||||
Auto = 0,
|
||||
Const = 1,
|
||||
Slope = 2,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
#[repr(u32)]
|
||||
pub enum TextureProjectionMapMode {
|
||||
Position = 0,
|
||||
Uv = 1,
|
||||
NormalizedNormal = 2,
|
||||
Normal = 3,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(u32)]
|
||||
pub enum GuTexWrapMode {
|
||||
Repeat = 0,
|
||||
Clamp = 1,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(u32)]
|
||||
pub enum FrontFaceDirection {
|
||||
Clockwise = 0,
|
||||
CounterClockwise = 1,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(u32)]
|
||||
pub enum AlphaFunc {
|
||||
Never = 0,
|
||||
Always,
|
||||
Equal,
|
||||
NotEqual,
|
||||
Less,
|
||||
LessOrEqual,
|
||||
Greater,
|
||||
GreaterOrEqual,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(u32)]
|
||||
pub enum StencilFunc {
|
||||
Never = 0,
|
||||
Always,
|
||||
Equal,
|
||||
NotEqual,
|
||||
Less,
|
||||
LessOrEqual,
|
||||
Greater,
|
||||
GreaterOrEqual,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(u32)]
|
||||
pub enum ColorFunc {
|
||||
Never = 0,
|
||||
Always,
|
||||
Equal,
|
||||
NotEqual,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(u32)]
|
||||
pub enum DepthFunc {
|
||||
Never = 0,
|
||||
Always,
|
||||
Equal,
|
||||
NotEqual,
|
||||
Less,
|
||||
LessOrEqual,
|
||||
Greater,
|
||||
GreaterOrEqual,
|
||||
}
|
||||
|
||||
pub const GU_COLOR_BUFFER_BIT: i32 = 1;
|
||||
pub const GU_STENCIL_BUFFER_BIT: i32 = 2;
|
||||
pub const GU_DEPTH_BUFFER_BIT: i32 = 4;
|
||||
pub const GU_FAST_CLEAR_BIT: i32 = 16;
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
#[repr(u32)]
|
||||
pub enum TextureEffect {
|
||||
Modulate = 0,
|
||||
Decal = 1,
|
||||
Blend = 2,
|
||||
Replace = 3,
|
||||
Add = 4,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
#[repr(u32)]
|
||||
pub enum TextureColorComponent {
|
||||
Rgb = 0,
|
||||
Rgba = 1,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
#[repr(u32)]
|
||||
pub enum MipmapLevel {
|
||||
None = 0,
|
||||
Level1,
|
||||
Level2,
|
||||
Level3,
|
||||
Level4,
|
||||
Level5,
|
||||
Level6,
|
||||
Level7,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(u32)]
|
||||
pub enum BlendOp {
|
||||
Add = 0,
|
||||
Subtract = 1,
|
||||
ReverseSubtract = 2,
|
||||
Min = 3,
|
||||
Max = 4,
|
||||
Abs = 5,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(u32)]
|
||||
pub enum BlendSrc {
|
||||
SrcColor = 0,
|
||||
OneMinusSrcColor = 1,
|
||||
SrcAlpha = 2,
|
||||
OneMinusSrcAlpha = 3,
|
||||
Fix = 10,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(u32)]
|
||||
pub enum BlendDst {
|
||||
DstColor = 0,
|
||||
OneMinusDstColor = 1,
|
||||
DstAlpha = 4,
|
||||
OneMinusDstAlpha = 5,
|
||||
Fix = 10,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(u32)]
|
||||
pub enum StencilOperation {
|
||||
Keep = 0,
|
||||
Zero = 1,
|
||||
Replace = 2,
|
||||
Invert = 3,
|
||||
Incr = 4,
|
||||
Decr = 5,
|
||||
}
|
||||
|
||||
pub const GU_AMBIENT: i32 = 1;
|
||||
pub const GU_DIFFUSE: i32 = 2;
|
||||
pub const GU_SPECULAR: i32 = 4;
|
||||
pub const GU_UNKNOWN_LIGHT_COMPONENT: i32 = 8;
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(u32)]
|
||||
pub enum LightMode {
|
||||
SingleColor = 0,
|
||||
SeparateSpecularColor = 1,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(u32)]
|
||||
pub enum LightType {
|
||||
Directional = 0,
|
||||
Pointlight = 1,
|
||||
Spotlight = 2,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub enum GuContextType {
|
||||
Direct = 0,
|
||||
Call = 1,
|
||||
Send = 2,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(u32)]
|
||||
pub enum GuQueueMode {
|
||||
Tail = 0,
|
||||
Head = 1,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(u32)]
|
||||
pub enum GuSyncMode {
|
||||
Finish = 0,
|
||||
Signal = 1,
|
||||
Done = 2,
|
||||
List = 3,
|
||||
Send = 4,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(u32)]
|
||||
pub enum GuSyncBehavior {
|
||||
Wait = 0,
|
||||
NoWait = 1,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(u32)]
|
||||
pub enum GuCallbackId {
|
||||
Signal = 1,
|
||||
Finish = 4,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(u32)]
|
||||
pub enum SignalBehavior {
|
||||
Suspend = 1,
|
||||
Continue = 2,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(u32)]
|
||||
pub enum ClutPixelFormat {
|
||||
Psm5650 = 0,
|
||||
Psm5551 = 1,
|
||||
Psm4444 = 2,
|
||||
Psm8888 = 3,
|
||||
}
|
||||
|
||||
pub type GuCallback = Option<extern fn(id: i32, arg: *mut c_void)>;
|
||||
pub type GuSwapBuffersCallback = Option<extern fn(display: *mut *mut c_void, render: *mut *mut c_void)>;
|
||||
|
||||
extern {
|
||||
pub fn sceGuDepthBuffer(zbp: *mut c_void, zbw: i32);
|
||||
pub fn sceGuDispBuffer(width: i32, height: i32, dispbp: *mut c_void, dispbw: i32);
|
||||
pub fn sceGuDrawBuffer(psm: DisplayPixelFormat, fbp: *mut c_void, fbw: i32);
|
||||
pub fn sceGuDrawBufferList(psm: DisplayPixelFormat, fbp: *mut c_void, fbw: i32);
|
||||
pub fn sceGuDisplay(state: bool) -> bool;
|
||||
pub fn sceGuDepthFunc(function: DepthFunc);
|
||||
pub fn sceGuDepthMask(mask: i32);
|
||||
|
||||
pub fn sceGuDepthOffset(offset: i32);
|
||||
pub fn sceGuDepthRange(near: i32, far: i32);
|
||||
|
||||
pub fn sceGuFog(near: f32, far: f32, color: u32);
|
||||
pub fn sceGuInit();
|
||||
pub fn sceGuTerm();
|
||||
pub fn sceGuBreak(mode: i32);
|
||||
|
||||
pub fn sceGuContinue();
|
||||
pub fn sceGuSetCallback(
|
||||
signal: GuCallbackId,
|
||||
callback: GuCallback,
|
||||
) -> GuCallback;
|
||||
pub fn sceGuSignal(behavior: SignalBehavior, signal: i32);
|
||||
pub fn sceGuSendCommandf(cmd: GeCommand, argument: f32);
|
||||
pub fn sceGuSendCommandi(cmd: GeCommand, argument: i32);
|
||||
pub fn sceGuGetMemory(size: i32) -> *mut c_void;
|
||||
pub fn sceGuStart(context_type: GuContextType, list: *mut c_void);
|
||||
pub fn sceGuFinish() -> i32;
|
||||
pub fn sceGuFinishId(id: u32) -> i32;
|
||||
pub fn sceGuCallList(list: *const c_void);
|
||||
pub fn sceGuCallMode(mode: i32);
|
||||
pub fn sceGuCheckList() -> i32;
|
||||
pub fn sceGuSendList(mode: GuQueueMode, list: *const c_void, context: *mut GeContext);
|
||||
pub fn sceGuSwapBuffers() -> *mut c_void;
|
||||
pub fn sceGuSync(mode: GuSyncMode, behavior: GuSyncBehavior) -> GeListState;
|
||||
pub fn sceGuDrawArray(
|
||||
prim: GuPrimitive,
|
||||
vtype: i32,
|
||||
count: i32,
|
||||
indices: *const c_void,
|
||||
vertices: *const c_void,
|
||||
);
|
||||
pub fn sceGuBeginObject(
|
||||
vtype: i32,
|
||||
count: i32,
|
||||
indices: *const c_void,
|
||||
vertices: *const c_void,
|
||||
);
|
||||
pub fn sceGuEndObject();
|
||||
pub fn sceGuSetStatus(state: GuState, status: i32);
|
||||
pub fn sceGuGetStatus(state: GuState) -> bool;
|
||||
pub fn sceGuSetAllStatus(status: i32);
|
||||
pub fn sceGuGetAllStatus() -> i32;
|
||||
pub fn sceGuEnable(state: GuState);
|
||||
pub fn sceGuDisable(state: GuState);
|
||||
pub fn sceGuLight(
|
||||
light: i32,
|
||||
type_: LightType,
|
||||
components: i32,
|
||||
position: &ScePspFVector3,
|
||||
);
|
||||
pub fn sceGuLightAtt(light: i32, atten0: f32, atten1: f32, atten2: f32);
|
||||
pub fn sceGuLightColor(light: i32, component: i32, color: u32);
|
||||
pub fn sceGuLightMode(mode: LightMode);
|
||||
pub fn sceGuLightSpot(light: i32, direction: &ScePspFVector3, exponent: f32, cutoff: f32);
|
||||
pub fn sceGuClear(flags: i32);
|
||||
pub fn sceGuClearColor(color: u32);
|
||||
pub fn sceGuClearDepth(depth: u32);
|
||||
pub fn sceGuClearStencil(stencil: u32);
|
||||
pub fn sceGuPixelMask(mask: u32);
|
||||
pub fn sceGuColor(color: u32);
|
||||
pub fn sceGuColorFunc(func: ColorFunc, color: u32, mask: u32);
|
||||
pub fn sceGuColorMaterial(components: i32);
|
||||
pub fn sceGuAlphaFunc(func: AlphaFunc, value: i32, mask: i32);
|
||||
|
||||
pub fn sceGuAmbient(color: u32);
|
||||
|
||||
pub fn sceGuAmbientColor(color: u32);
|
||||
pub fn sceGuBlendFunc(
|
||||
op: BlendOp,
|
||||
src: BlendSrc,
|
||||
dest: BlendDst,
|
||||
src_fix: u32,
|
||||
dest_fix: u32,
|
||||
);
|
||||
pub fn sceGuMaterial(components: i32, color: u32);
|
||||
pub fn sceGuModelColor(emissive: u32, ambient: u32, diffuse: u32, specular: u32);
|
||||
pub fn sceGuStencilFunc(func: StencilFunc, ref_: i32, mask: i32);
|
||||
pub fn sceGuStencilOp(
|
||||
fail: StencilOperation,
|
||||
zfail: StencilOperation,
|
||||
zpass: StencilOperation,
|
||||
);
|
||||
pub fn sceGuSpecular(power: f32);
|
||||
pub fn sceGuFrontFace(order: FrontFaceDirection);
|
||||
pub fn sceGuLogicalOp(op: LogicalOperation);
|
||||
pub fn sceGuSetDither(matrix: &ScePspIMatrix4);
|
||||
pub fn sceGuShadeModel(mode: ShadingModel);
|
||||
pub fn sceGuCopyImage(
|
||||
psm: DisplayPixelFormat,
|
||||
sx: i32,
|
||||
sy: i32,
|
||||
width: i32,
|
||||
height: i32,
|
||||
srcw: i32,
|
||||
src: *mut c_void,
|
||||
dx: i32,
|
||||
dy: i32,
|
||||
destw: i32,
|
||||
dest: *mut c_void,
|
||||
);
|
||||
pub fn sceGuTexEnvColor(color: u32);
|
||||
pub fn sceGuTexFilter(min: TextureFilter, mag: TextureFilter);
|
||||
pub fn sceGuTexFlush();
|
||||
pub fn sceGuTexFunc(tfx: TextureEffect, tcc: TextureColorComponent);
|
||||
pub fn sceGuTexImage(mipmap: MipmapLevel, width: i32, height: i32, tbw: i32, tbp: *const c_void);
|
||||
pub fn sceGuTexLevelMode(mode: TextureLevelMode, bias: f32);
|
||||
pub fn sceGuTexMapMode(mode: TextureMapMode, a1: u32, a2: u32);
|
||||
pub fn sceGuTexMode(tpsm: TexturePixelFormat, maxmips: i32, a2: i32, swizzle: i32);
|
||||
pub fn sceGuTexOffset(u: f32, v: f32);
|
||||
pub fn sceGuTexProjMapMode(mode: TextureProjectionMapMode);
|
||||
pub fn sceGuTexScale(u: f32, v: f32);
|
||||
|
||||
pub fn sceGuTexSlope(slope: f32);
|
||||
pub fn sceGuTexSync();
|
||||
pub fn sceGuTexWrap(u: GuTexWrapMode, v: GuTexWrapMode);
|
||||
pub fn sceGuClutLoad(num_blocks: i32, cbp: *const c_void);
|
||||
pub fn sceGuClutMode(cpsm: ClutPixelFormat, shift: u32, mask: u32, a3: u32);
|
||||
pub fn sceGuOffset(x: u32, y: u32);
|
||||
pub fn sceGuScissor(x: i32, y: i32, w: i32, h: i32);
|
||||
pub fn sceGuViewport(cx: i32, cy: i32, width: i32, height: i32);
|
||||
pub fn sceGuDrawBezier(
|
||||
v_type: i32,
|
||||
u_count: i32,
|
||||
v_count: i32,
|
||||
indices: *const c_void,
|
||||
vertices: *const c_void,
|
||||
);
|
||||
pub fn sceGuPatchDivide(ulevel: u32, vlevel: u32);
|
||||
|
||||
pub fn sceGuPatchFrontFace(a0: u32);
|
||||
pub fn sceGuPatchPrim(prim: PatchPrimitive);
|
||||
|
||||
pub fn sceGuDrawSpline(
|
||||
v_type: i32,
|
||||
u_count: i32,
|
||||
v_count: i32,
|
||||
u_edge: i32,
|
||||
v_edge: i32,
|
||||
indices: *const c_void,
|
||||
vertices: *const c_void,
|
||||
);
|
||||
pub fn sceGuSetMatrix(type_: MatrixMode, matrix: &ScePspFMatrix4);
|
||||
pub fn sceGuBoneMatrix(index: u32, matrix: &ScePspFMatrix4);
|
||||
pub fn sceGuMorphWeight(index: i32, weight: f32);
|
||||
pub fn sceGuDrawArrayN(
|
||||
primitive_type: GuPrimitive,
|
||||
v_type: i32,
|
||||
count: i32,
|
||||
a3: i32,
|
||||
indices: *const c_void,
|
||||
vertices: *const c_void,
|
||||
);
|
||||
}
|
|
@ -0,0 +1,66 @@
|
|||
use super::{c_void, ScePspFMatrix4, ScePspFVector3, MatrixMode, GuPrimitive};
|
||||
|
||||
extern {
|
||||
pub fn sceGumDrawArray(
|
||||
prim: GuPrimitive,
|
||||
v_type: i32,
|
||||
count: i32,
|
||||
indices: *const c_void,
|
||||
vertices: *const c_void,
|
||||
);
|
||||
|
||||
pub fn sceGumDrawArrayN(
|
||||
prim: GuPrimitive,
|
||||
v_type: i32,
|
||||
count: i32,
|
||||
a3: i32,
|
||||
indices: *const c_void,
|
||||
vertices: *const c_void,
|
||||
);
|
||||
|
||||
pub fn sceGumDrawBezier(
|
||||
v_type: i32,
|
||||
u_count: i32,
|
||||
v_count: i32,
|
||||
indices: *const c_void,
|
||||
vertices: *const c_void,
|
||||
);
|
||||
|
||||
pub fn sceGumDrawSpline(
|
||||
v_type: i32,
|
||||
u_count: i32,
|
||||
v_count: i32,
|
||||
u_edge: i32,
|
||||
v_edge: i32,
|
||||
indices: *const c_void,
|
||||
vertices: *const c_void,
|
||||
);
|
||||
|
||||
pub fn sceGumFastInverse();
|
||||
pub fn sceGumFullInverse();
|
||||
pub fn sceGumLoadIdentity();
|
||||
pub fn sceGumLoadMatrix(m: &ScePspFMatrix4);
|
||||
pub fn sceGumLookAt(eye: &ScePspFVector3, center: &ScePspFVector3, up: &ScePspFVector3);
|
||||
pub fn sceGumMatrixMode(mode: MatrixMode);
|
||||
pub fn sceGumMultMatrix(m: &ScePspFMatrix4);
|
||||
pub fn sceGumOrtho(
|
||||
left: f32,
|
||||
right: f32,
|
||||
bottom: f32,
|
||||
top: f32,
|
||||
near: f32,
|
||||
far: f32
|
||||
);
|
||||
pub fn sceGumPerspective(fovy: f32, aspect: f32, near: f32, far: f32);
|
||||
pub fn sceGumPopMatrix();
|
||||
pub fn sceGumPushMatrix();
|
||||
pub fn sceGumRotateX(angle: f32);
|
||||
pub fn sceGumRotateY(angle: f32);
|
||||
pub fn sceGumRotateZ(angle: f32);
|
||||
pub fn sceGumRotateXYZ(v: &ScePspFVector3);
|
||||
pub fn sceGumRotateZYX(v: &ScePspFVector3);
|
||||
pub fn sceGumScale(v: &ScePspFVector3);
|
||||
pub fn sceGumStoreMatrix(m: &mut ScePspFMatrix4);
|
||||
pub fn sceGumTranslate(v: &ScePspFVector3);
|
||||
pub fn sceGumUpdateMatrix();
|
||||
}
|
|
@ -0,0 +1,15 @@
|
|||
pub const PLAY_PAUSE: i32 = 0x1;
|
||||
pub const FORWARD: i32 = 0x4;
|
||||
pub const BACK: i32 = 0x8;
|
||||
pub const VOL_UP: i32 = 0x10;
|
||||
pub const VOL_DOWN: i32 = 0x20;
|
||||
pub const HOLD: i32 = 0x80;
|
||||
|
||||
extern {
|
||||
pub fn sceHprmPeekCurrentKey(key: *mut i32) -> i32;
|
||||
pub fn sceHprmPeekLatch(latch: *mut [u32;4]) -> i32;
|
||||
pub fn sceHprmReadLatch(latch: *mut [u32;4]) -> i32;
|
||||
pub fn sceHprmIsHeadphoneExist() -> i32;
|
||||
pub fn sceHprmIsRemoteExist() -> i32;
|
||||
pub fn sceHprmIsMicrophoneExist() -> i32;
|
||||
}
|
|
@ -0,0 +1,148 @@
|
|||
use super::{c_void, SceUid, ScePspDateTime};
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceIoDirent {
|
||||
pub d_stat: SceIoStat,
|
||||
pub d_name: [u8; 256usize],
|
||||
pub d_private: *mut c_void,
|
||||
pub dummy: i32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceIoStat {
|
||||
pub st_mode: i32,
|
||||
pub st_attr: i32,
|
||||
pub st_size: i64,
|
||||
pub st_ctime: ScePspDateTime,
|
||||
pub st_atime: ScePspDateTime,
|
||||
pub st_mtime: ScePspDateTime,
|
||||
pub st_private: [u32; 6usize],
|
||||
}
|
||||
|
||||
pub const FIO_S_IFLNK: i32 = 0x4000;
|
||||
pub const FIO_S_IFDIR: i32 = 0x1000;
|
||||
pub const FIO_S_IFREG: i32 = 0x2000;
|
||||
pub const FIO_S_ISUID: i32 = 0x0800;
|
||||
pub const FIO_S_ISGID: i32 = 0x0400;
|
||||
pub const FIO_S_ISVTX: i32 = 0x0200;
|
||||
pub const FIO_S_IRUSR: i32 = 0x0100;
|
||||
pub const FIO_S_IWUSR: i32 = 0x0080;
|
||||
pub const FIO_S_IXUSR: i32 = 0x0040;
|
||||
pub const FIO_S_IRGRP: i32 = 0x0020;
|
||||
pub const FIO_S_IWGRP: i32 = 0x0010;
|
||||
pub const FIO_S_IXGRP: i32 = 0x0008;
|
||||
pub const FIO_S_IROTH: i32 = 0x0004;
|
||||
pub const FIO_S_IWOTH: i32 = 0x0002;
|
||||
pub const FIO_S_IXOTH: i32 = 0x0001;
|
||||
|
||||
pub const FIO_SO_IFLNK: i32 = 0x0008;
|
||||
pub const FIO_SO_IFDIR: i32 = 0x0010;
|
||||
pub const FIO_SO_IFREG: i32 = 0x0020;
|
||||
pub const FIO_SO_IROTH: i32 = 0x0004;
|
||||
pub const FIO_SO_IWOTH: i32 = 0x0002;
|
||||
pub const FIO_SO_IXOTH: i32 = 0x0001;
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub enum IoAssignPerms {
|
||||
RdWr = 0,
|
||||
RdOnly = 1,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(u32)]
|
||||
pub enum IoWhence {
|
||||
Set = 0,
|
||||
Cur = 1,
|
||||
End = 2,
|
||||
}
|
||||
|
||||
pub const PSP_O_RD_ONLY: i32 = 0x0001;
|
||||
pub const PSP_O_WR_ONLY: i32 = 0x0002;
|
||||
pub const PSP_O_RD_WR: i32 = 0x0003;
|
||||
pub const PSP_O_NBLOCK: i32 = 0x0004;
|
||||
pub const PSP_O_DIR: i32 = 0x0008;
|
||||
pub const PSP_O_APPEND: i32 = 0x0100;
|
||||
pub const PSP_O_CREAT: i32 = 0x0200;
|
||||
pub const PSP_O_TRUNC: i32 = 0x0400;
|
||||
pub const PSP_O_EXCL: i32 = 0x0800;
|
||||
pub const PSP_O_NO_WAIT: i32 = 0x8000;
|
||||
|
||||
pub type IoPermissions = i32;
|
||||
|
||||
extern {
|
||||
pub fn sceIoOpen(file: *const u8, flags: i32, permissions: IoPermissions) -> SceUid;
|
||||
pub fn sceIoOpenAsync(
|
||||
file: *const u8,
|
||||
flags: i32,
|
||||
permissions: IoPermissions
|
||||
) -> SceUid;
|
||||
pub fn sceIoClose(fd: SceUid) -> i32;
|
||||
pub fn sceIoCloseAsync(fd: SceUid) -> i32;
|
||||
pub fn sceIoRead(fd: SceUid, data: *mut c_void, size: u32) -> i32;
|
||||
pub fn sceIoReadAsync(fd: SceUid, data: *mut c_void, size: u32) -> i32;
|
||||
pub fn sceIoWrite(fd: SceUid, data: *const c_void, size: usize) -> i32;
|
||||
pub fn sceIoWriteAsync(fd: SceUid, data: *const c_void, size: u32) -> i32;
|
||||
pub fn sceIoLseek(fd: SceUid, offset: i64, whence: IoWhence) -> i64;
|
||||
pub fn sceIoLseekAsync(fd: SceUid, offset: i64, whence: IoWhence) -> i32;
|
||||
pub fn sceIoLseek32(fd: SceUid, offset: i32, whence: IoWhence) -> i32;
|
||||
pub fn sceIoLseek32Async(fd: SceUid, offset: i32, whence: IoWhence) -> i32;
|
||||
pub fn sceIoRemove(file: *const u8) -> i32;
|
||||
pub fn sceIoMkdir(dir: *const u8, mode: IoPermissions) -> i32;
|
||||
pub fn sceIoRmdir(path: *const u8) -> i32;
|
||||
pub fn sceIoChdir(path: *const u8) -> i32;
|
||||
pub fn sceIoRename(oldname: *const u8, newname: *const u8) -> i32;
|
||||
pub fn sceIoDopen(dirname: *const u8) -> SceUid;
|
||||
pub fn sceIoDread(fd: SceUid, dir: *mut SceIoDirent) -> i32;
|
||||
pub fn sceIoDclose(fd: SceUid) -> i32;
|
||||
pub fn sceIoDevctl(
|
||||
dev: *const u8,
|
||||
cmd: u32,
|
||||
indata: *mut c_void,
|
||||
inlen: i32,
|
||||
outdata: *mut c_void,
|
||||
outlen: i32
|
||||
) -> i32;
|
||||
pub fn sceIoAssign(
|
||||
dev1: *const u8,
|
||||
dev2: *const u8,
|
||||
dev3: *const u8,
|
||||
mode: IoAssignPerms,
|
||||
unk1: *mut c_void,
|
||||
unk2: i32
|
||||
) -> i32;
|
||||
pub fn sceIoUnassign(dev: *const u8) -> i32;
|
||||
pub fn sceIoGetstat(file: *const u8, stat: *mut SceIoStat) -> i32;
|
||||
pub fn sceIoChstat(file: *const u8, stat: *mut SceIoStat, bits: i32) -> i32;
|
||||
pub fn sceIoIoctl(
|
||||
fd: SceUid,
|
||||
cmd: u32,
|
||||
indata: *mut c_void,
|
||||
inlen: i32,
|
||||
outdata: *mut c_void,
|
||||
outlen: i32
|
||||
) -> i32;
|
||||
pub fn sceIoIoctlAsync(
|
||||
fd: SceUid,
|
||||
cmd: u32,
|
||||
indata: *mut c_void,
|
||||
inlen: i32,
|
||||
outdata: *mut c_void,
|
||||
outlen: i32
|
||||
) -> i32;
|
||||
pub fn sceIoSync(device: *const u8, unk: u32) -> i32;
|
||||
pub fn sceIoWaitAsync(fd: SceUid, res: *mut i64) -> i32;
|
||||
pub fn sceIoWaitAsyncCB(fd: SceUid, res: *mut i64) -> i32;
|
||||
pub fn sceIoPollAsync(fd: SceUid, res: *mut i64) -> i32;
|
||||
pub fn sceIoGetAsyncStat(fd: SceUid, poll: i32, res: *mut i64) -> i32;
|
||||
pub fn sceIoCancel(fd: SceUid) -> i32;
|
||||
pub fn sceIoGetDevType(fd: SceUid) -> i32;
|
||||
pub fn sceIoChangeAsyncPriority(fd: SceUid, pri: i32) -> i32;
|
||||
pub fn sceIoSetAsyncCallback(
|
||||
fd: SceUid,
|
||||
cb: SceUid,
|
||||
argp: *mut c_void
|
||||
) -> i32;
|
||||
}
|
|
@ -0,0 +1,13 @@
|
|||
use super::c_void;
|
||||
extern {
|
||||
pub fn sceJpegInitMJpeg() -> i32;
|
||||
pub fn sceJpegFinishMJpeg() -> i32;
|
||||
pub fn sceJpegCreateMJpeg(width: i32, height: i32) -> i32;
|
||||
pub fn sceJpegDeleteMJpeg() -> i32;
|
||||
pub fn sceJpegDecodeMJpeg(
|
||||
jpeg_buf: *mut u8,
|
||||
size: usize,
|
||||
rgba: *mut c_void,
|
||||
unk: u32,
|
||||
) -> i32;
|
||||
}
|
|
@ -0,0 +1,387 @@
|
|||
use super::c_void;
|
||||
|
||||
mod thread;
|
||||
pub use self::thread::*;
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceKernelLoadExecParam {
|
||||
pub size: usize,
|
||||
pub args: usize,
|
||||
pub argp: *mut c_void,
|
||||
pub key: *const u8,
|
||||
}
|
||||
|
||||
extern {
|
||||
pub fn sceKernelExitGame();
|
||||
pub fn sceKernelRegisterExitCallback(id: SceUid) -> i32;
|
||||
pub fn sceKernelLoadExec(
|
||||
file: *const u8,
|
||||
param: *mut SceKernelLoadExecParam,
|
||||
) -> i32;
|
||||
}
|
||||
|
||||
#[repr(transparent)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceUid(pub i32);
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(i32)]
|
||||
pub enum SceSysMemPartitionId {
|
||||
SceKernelUnknownPartition = 0,
|
||||
SceKernelPrimaryKernelPartition = 1,
|
||||
SceKernelPrimaryUserPartition = 2,
|
||||
SceKernelOtherKernelPartition1 = 3,
|
||||
SceKernelOtherKernelPartition2 = 4,
|
||||
SceKernelVshellPARTITION = 5,
|
||||
SceKernelScUserPartition = 6,
|
||||
SceKernelMeUserPartition = 7,
|
||||
SceKernelExtendedScKernelPartition = 8,
|
||||
SceKernelExtendedSc2KernelPartition = 9,
|
||||
SceKernelExtendedMeKernelPartition = 10,
|
||||
SceKernelVshellKernelPartition = 11,
|
||||
SceKernelExtendedKernelPartition = 12,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(i32)]
|
||||
pub enum SceSysMemBlockTypes {
|
||||
Low = 0,
|
||||
High,
|
||||
Addr,
|
||||
}
|
||||
|
||||
extern {
|
||||
pub fn sceKernelAllocPartitionMemory(
|
||||
partition: SceSysMemPartitionId,
|
||||
name: *const u8,
|
||||
type_: SceSysMemBlockTypes,
|
||||
size: u32,
|
||||
addr: *mut c_void,
|
||||
) -> SceUid;
|
||||
pub fn sceKernelGetBlockHeadAddr(blockid: SceUid) -> *mut c_void;
|
||||
pub fn sceKernelFreePartitionMemory(blockid: SceUid) -> i32;
|
||||
pub fn sceKernelTotalFreeMemSize() -> usize;
|
||||
pub fn sceKernelMaxFreeMemSize() -> usize;
|
||||
pub fn sceKernelDevkitVersion() -> u32;
|
||||
pub fn sceKernelSetCompiledSdkVersion(version: u32) -> i32;
|
||||
pub fn sceKernelGetCompiledSdkVersion() -> u32;
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct timeval {
|
||||
pub tv_sec: i32,
|
||||
pub tv_usec: i32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct timezone {
|
||||
pub tz_minutes_west: i32,
|
||||
pub tz_dst_time: i32,
|
||||
}
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceKernelUtilsSha1Context {
|
||||
pub h: [u32; 5usize],
|
||||
pub us_remains: u16,
|
||||
pub us_computed: u16,
|
||||
pub ull_total_len: u64,
|
||||
pub buf: [u8; 64usize],
|
||||
}
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceKernelUtilsMt19937Context {
|
||||
pub count: u32,
|
||||
pub state: [u32; 624usize],
|
||||
}
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceKernelUtilsMd5Context {
|
||||
pub h: [u32; 4usize],
|
||||
pub pad: u32,
|
||||
pub us_remains: u16,
|
||||
pub us_computed: u16,
|
||||
pub ull_total_len: u64,
|
||||
pub buf: [u8; 64usize],
|
||||
}
|
||||
|
||||
extern {
|
||||
pub fn sceKernelLibcTime(t: *mut i32) -> i32;
|
||||
pub fn sceKernelLibcClock() -> u32;
|
||||
pub fn sceKernelLibcGettimeofday(tp: *mut timeval, tzp: *mut timezone) -> i32;
|
||||
pub fn sceKernelDcacheWritebackAll();
|
||||
pub fn sceKernelDcacheWritebackInvalidateAll();
|
||||
pub fn sceKernelDcacheWritebackRange(
|
||||
p: *const c_void,
|
||||
size: u32,
|
||||
);
|
||||
pub fn sceKernelDcacheWritebackInvalidateRange(
|
||||
p: *const c_void,
|
||||
size: u32,
|
||||
);
|
||||
pub fn sceKernelDcacheInvalidateRange(
|
||||
p: *const c_void,
|
||||
size: u32,
|
||||
);
|
||||
pub fn sceKernelIcacheInvalidateAll();
|
||||
pub fn sceKernelIcacheInvalidateRange(
|
||||
p: *const c_void,
|
||||
size: u32,
|
||||
);
|
||||
pub fn sceKernelUtilsMt19937Init(
|
||||
ctx: *mut SceKernelUtilsMt19937Context,
|
||||
seed: u32,
|
||||
) -> i32;
|
||||
pub fn sceKernelUtilsMt19937UInt(ctx: *mut SceKernelUtilsMt19937Context) -> u32;
|
||||
pub fn sceKernelUtilsMd5Digest(
|
||||
data: *mut u8,
|
||||
size: u32,
|
||||
digest: *mut u8,
|
||||
) -> i32;
|
||||
pub fn sceKernelUtilsMd5BlockInit(ctx: *mut SceKernelUtilsMd5Context) -> i32;
|
||||
pub fn sceKernelUtilsMd5BlockUpdate(
|
||||
ctx: *mut SceKernelUtilsMd5Context,
|
||||
data: *mut u8,
|
||||
size: u32,
|
||||
) -> i32;
|
||||
pub fn sceKernelUtilsMd5BlockResult(
|
||||
ctx: *mut SceKernelUtilsMd5Context,
|
||||
digest: *mut u8,
|
||||
) -> i32;
|
||||
pub fn sceKernelUtilsSha1Digest(
|
||||
data: *mut u8,
|
||||
size: u32,
|
||||
digest: *mut u8,
|
||||
) -> i32;
|
||||
pub fn sceKernelUtilsSha1BlockInit(
|
||||
ctx: *mut SceKernelUtilsSha1Context,
|
||||
) -> i32;
|
||||
pub fn sceKernelUtilsSha1BlockUpdate(
|
||||
ctx: *mut SceKernelUtilsSha1Context,
|
||||
data: *mut u8,
|
||||
size: u32,
|
||||
) -> i32;
|
||||
pub fn sceKernelUtilsSha1BlockResult(
|
||||
ctx: *mut SceKernelUtilsSha1Context,
|
||||
digest: *mut u8,
|
||||
) -> i32;
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(packed, C)]
|
||||
pub struct IntrHandlerOptionParam {
|
||||
size: i32,
|
||||
entry: u32,
|
||||
common: u32,
|
||||
gp: u32,
|
||||
intr_code: u16,
|
||||
sub_count: u16,
|
||||
intr_level: u16,
|
||||
enabled: u16,
|
||||
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: u32,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(u32)]
|
||||
pub enum Interrupt {
|
||||
Gpio = 4,
|
||||
Ata = 5,
|
||||
Umd = 6,
|
||||
Mscm0 = 7,
|
||||
Wlan = 8,
|
||||
Audio = 10,
|
||||
I2c = 12,
|
||||
Sircs = 14,
|
||||
Systimer0 = 15,
|
||||
Systimer1 = 16,
|
||||
Systimer2 = 17,
|
||||
Systimer3 = 18,
|
||||
Thread0 = 19,
|
||||
Nand = 20,
|
||||
Dmacplus = 21,
|
||||
Dma0 = 22,
|
||||
Dma1 = 23,
|
||||
Memlmd = 24,
|
||||
Ge = 25,
|
||||
Vblank = 30,
|
||||
Mecodec = 31,
|
||||
Hpremote = 36,
|
||||
Mscm1 = 60,
|
||||
Mscm2 = 61,
|
||||
Thread1 = 65,
|
||||
Interrupt = 66,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(u32)]
|
||||
pub enum SubInterrupt {
|
||||
Gpio = Interrupt::Gpio as u32,
|
||||
Ata = Interrupt::Ata as u32,
|
||||
Umd = Interrupt::Umd as u32,
|
||||
Dmacplus = Interrupt::Dmacplus as u32,
|
||||
Ge = Interrupt::Ge as u32,
|
||||
Display = Interrupt::Vblank as u32,
|
||||
}
|
||||
|
||||
extern {
|
||||
pub fn sceKernelRegisterSubIntrHandler(
|
||||
int_no: i32,
|
||||
no: i32,
|
||||
handler: *mut c_void,
|
||||
arg: *mut c_void,
|
||||
) -> i32;
|
||||
pub fn sceKernelReleaseSubIntrHandler(
|
||||
int_no: i32,
|
||||
no: i32,
|
||||
) -> i32;
|
||||
pub fn sceKernelEnableSubIntr(
|
||||
int_no: i32,
|
||||
no: i32,
|
||||
) -> i32;
|
||||
pub fn sceKernelDisableSubIntr(
|
||||
int_no: i32,
|
||||
no: i32,
|
||||
) -> i32;
|
||||
pub fn QueryIntrHandlerInfo(
|
||||
intr_code: SceUid,
|
||||
sub_intr_code: SceUid,
|
||||
data: *mut IntrHandlerOptionParam,
|
||||
) -> i32;
|
||||
}
|
||||
|
||||
extern {
|
||||
pub fn sceKernelCpuSuspendIntr() -> u32;
|
||||
pub fn sceKernelCpuResumeIntr(flags: u32);
|
||||
pub fn sceKernelCpuResumeIntrWithSync(flags: u32);
|
||||
pub fn sceKernelIsCpuIntrSuspended(flags: u32) -> i32;
|
||||
pub fn sceKernelIsCpuIntrEnable() -> i32;
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceKernelLMOption {
|
||||
pub size: usize,
|
||||
pub m_pid_text: SceUid,
|
||||
pub m_pid_data: SceUid,
|
||||
pub flags: u32,
|
||||
pub position: u8,
|
||||
pub access: u8,
|
||||
pub c_reserved: [u8; 2usize],
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceKernelSMOption {
|
||||
pub size: usize,
|
||||
pub m_pid_stack: SceUid,
|
||||
pub stack_size: usize,
|
||||
pub priority: i32,
|
||||
pub attribute: u32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceKernelModuleInfo {
|
||||
pub size: usize,
|
||||
pub n_segment: u8,
|
||||
pub reserved: [u8; 3usize],
|
||||
pub segment_addr: [i32; 4usize],
|
||||
pub segment_size: [i32; 4usize],
|
||||
pub entry_addr: u32,
|
||||
pub gp_value: u32,
|
||||
pub text_addr: u32,
|
||||
pub text_size: u32,
|
||||
pub data_size: u32,
|
||||
pub bss_size: u32,
|
||||
pub attribute: u16,
|
||||
pub version: [u8; 2usize],
|
||||
pub name: [u8; 28usize],
|
||||
}
|
||||
|
||||
extern {
|
||||
pub fn sceKernelLoadModule(
|
||||
path: *const u8,
|
||||
flags: i32,
|
||||
option: *mut SceKernelLMOption,
|
||||
) -> SceUid;
|
||||
pub fn sceKernelLoadModuleMs(
|
||||
path: *const u8,
|
||||
flags: i32,
|
||||
option: *mut SceKernelLMOption,
|
||||
) -> SceUid;
|
||||
pub fn sceKernelLoadModuleByID(
|
||||
fid: SceUid,
|
||||
flags: i32,
|
||||
option: *mut SceKernelLMOption,
|
||||
) -> SceUid;
|
||||
pub fn sceKernelLoadModuleBufferUsbWlan(
|
||||
buf_size: usize,
|
||||
buf: *mut c_void,
|
||||
flags: i32,
|
||||
option: *mut SceKernelLMOption,
|
||||
) -> SceUid;
|
||||
pub fn sceKernelStartModule(
|
||||
mod_id: SceUid,
|
||||
arg_size: usize,
|
||||
argp: *mut c_void,
|
||||
status: *mut i32,
|
||||
option: *mut SceKernelSMOption,
|
||||
) -> i32;
|
||||
pub fn sceKernelStopModule(
|
||||
mod_id: SceUid,
|
||||
arg_size: usize,
|
||||
argp: *mut c_void,
|
||||
status: *mut i32,
|
||||
option: *mut SceKernelSMOption,
|
||||
) -> i32;
|
||||
pub fn sceKernelUnloadModule(mod_id: SceUid) -> i32;
|
||||
pub fn sceKernelSelfStopUnloadModule(
|
||||
unknown: i32,
|
||||
arg_size: usize,
|
||||
argp: *mut c_void,
|
||||
) -> i32;
|
||||
pub fn sceKernelStopUnloadSelfModule(
|
||||
arg_size: usize,
|
||||
argp: *mut c_void,
|
||||
status: *mut i32,
|
||||
option: *mut SceKernelSMOption,
|
||||
) -> i32;
|
||||
pub fn sceKernelQueryModuleInfo(
|
||||
mod_id: SceUid,
|
||||
info: *mut SceKernelModuleInfo,
|
||||
) -> i32;
|
||||
pub fn sceKernelGetModuleIdList(
|
||||
read_buf: *mut SceUid,
|
||||
read_buf_size: i32,
|
||||
id_count: *mut i32,
|
||||
) -> i32;
|
||||
}
|
||||
|
||||
extern {
|
||||
pub fn sceKernelVolatileMemLock(
|
||||
unk: i32,
|
||||
ptr: *mut *mut c_void,
|
||||
size: *mut i32,
|
||||
) -> i32;
|
||||
pub fn sceKernelVolatileMemTryLock(
|
||||
unk: i32,
|
||||
ptr: *mut *mut c_void,
|
||||
size: *mut i32,
|
||||
) -> i32;
|
||||
pub fn sceKernelVolatileMemUnlock(unk: i32) -> i32;
|
||||
}
|
||||
|
||||
extern {
|
||||
pub fn sceKernelStdin() -> SceUid;
|
||||
pub fn sceKernelStdout() -> SceUid;
|
||||
pub fn sceKernelStderr() -> SceUid;
|
||||
}
|
|
@ -0,0 +1,703 @@
|
|||
use super::{SceUid, c_void};
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct DebugProfilerRegs {
|
||||
pub enable: u32,
|
||||
pub systemck: u32,
|
||||
pub cpuck: u32,
|
||||
pub internal: u32,
|
||||
pub memory: u32,
|
||||
pub copz: u32,
|
||||
pub vfpu: u32,
|
||||
pub sleep: u32,
|
||||
pub bus_access: u32,
|
||||
pub uncached_load: u32,
|
||||
pub uncached_store: u32,
|
||||
pub cached_load: u32,
|
||||
pub cached_store: u32,
|
||||
pub i_miss: u32,
|
||||
pub d_miss: u32,
|
||||
pub d_writeback: u32,
|
||||
pub cop0_inst: u32,
|
||||
pub fpu_inst: u32,
|
||||
pub vfpu_inst: u32,
|
||||
pub local_bus: u32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceKernelSysClock {
|
||||
pub low: u32,
|
||||
pub hi: u32,
|
||||
}
|
||||
|
||||
pub type SceKernelThreadEntry = unsafe extern "C" fn(args: usize, argp: *mut c_void) -> i32;
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceKernelThreadOptParam {
|
||||
pub size: usize,
|
||||
pub stack_mpid: SceUid,
|
||||
}
|
||||
|
||||
pub const THREAD_ATTR_VFPU: i32 = 0x00004000;
|
||||
pub const THREAD_ATTR_USER: i32 = 0x80000000;
|
||||
pub const THREAD_ATTR_USBWLAN: i32 = 0xa0000000;
|
||||
pub const THREAD_ATTR_VSH: i32 = 0xc0000000;
|
||||
pub const THREAD_ATTR_SCRATCH_SRAM: i32 = 0x00008000;
|
||||
pub const THREAD_ATTR_NO_FILLSTACK: i32 = 0x00100000;
|
||||
pub const THREAD_ATTR_CLEAR_STACK: i32 = 0x00200000;
|
||||
|
||||
pub const EVENT_WAIT_MULTIPLE: i32 = 0x200;
|
||||
|
||||
pub const EVENT_WAIT_AND: i32 = 0;
|
||||
pub const EVENT_WAIT_OR: i32 = 1;
|
||||
pub const EVENT_WAIT_CLEAR: i32 = 0x20;
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceKernelThreadInfo {
|
||||
pub size: usize,
|
||||
pub name: [u8; 32],
|
||||
pub attr: u32,
|
||||
pub status: i32,
|
||||
pub entry: SceKernelThreadEntry,
|
||||
pub stack: *mut c_void,
|
||||
pub stack_size: i32,
|
||||
pub gp_reg: *mut c_void,
|
||||
pub init_priority: i32,
|
||||
pub current_priority: i32,
|
||||
pub wait_type: i32,
|
||||
pub wait_id: SceUid,
|
||||
pub wakeup_count: i32,
|
||||
pub exit_status: i32,
|
||||
pub run_clocks: SceKernelSysClock,
|
||||
pub intr_preempt_count: u32,
|
||||
pub thread_preempt_count: u32,
|
||||
pub release_count: u32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceKernelThreadRunStatus {
|
||||
pub size: usize,
|
||||
pub status: i32,
|
||||
pub current_priority: i32,
|
||||
pub wait_type: i32,
|
||||
pub wait_id: i32,
|
||||
pub wakeup_count: i32,
|
||||
pub run_clocks: SceKernelSysClock,
|
||||
pub intr_preempt_count: u32,
|
||||
pub thread_preempt_count: u32,
|
||||
pub release_count: u32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceKernelSemaOptParam {
|
||||
pub size: usize,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceKernelSemaInfo {
|
||||
pub size: usize,
|
||||
pub name: [u8; 32],
|
||||
pub attr: u32,
|
||||
pub init_count: i32,
|
||||
pub current_count: i32,
|
||||
pub max_count: i32,
|
||||
pub num_wait_threads: i32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceKernelEventFlagInfo {
|
||||
pub size: usize,
|
||||
pub name: [u8; 32],
|
||||
pub attr: u32,
|
||||
pub init_pattern: u32,
|
||||
pub current_pattern: u32,
|
||||
pub num_wait_threads: i32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceKernelEventFlagOptParam {
|
||||
pub size: usize,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceKernelMbxOptParam {
|
||||
pub size: usize,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceKernelMbxInfo {
|
||||
pub size: usize,
|
||||
pub name: [u8; 32usize],
|
||||
pub attr: u32,
|
||||
pub num_wait_threads: i32,
|
||||
pub num_messages: i32,
|
||||
pub first_message: *mut c_void,
|
||||
}
|
||||
|
||||
pub type SceKernelVTimerHandler = unsafe extern "C" fn(
|
||||
uid: SceUid,
|
||||
arg1: *mut SceKernelSysClock,
|
||||
arg2: *mut SceKernelSysClock,
|
||||
arg3: *mut c_void,
|
||||
) -> u32;
|
||||
|
||||
pub type SceKernelVTimerHandlerWide = unsafe extern "C" fn(
|
||||
uid: SceUid,
|
||||
arg1: i64,
|
||||
arg2: i64,
|
||||
arg3: *mut c_void,
|
||||
) -> u32;
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceKernelVTimerInfo {
|
||||
pub size: usize,
|
||||
pub name: [u8; 32],
|
||||
pub active: i32,
|
||||
pub base: SceKernelSysClock,
|
||||
pub current: SceKernelSysClock,
|
||||
pub schedule: SceKernelSysClock,
|
||||
pub handler: SceKernelVTimerHandler,
|
||||
pub common: *mut c_void,
|
||||
}
|
||||
|
||||
pub type SceKernelThreadEventHandler = unsafe extern "C" fn(
|
||||
mask: i32,
|
||||
thid: SceUid,
|
||||
common: *mut c_void
|
||||
) -> i32;
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceKernelThreadEventHandlerInfo {
|
||||
pub size: usize,
|
||||
pub name: [u8; 32],
|
||||
pub thread_id: SceUid,
|
||||
pub mask: i32,
|
||||
pub handler: SceKernelThreadEventHandler,
|
||||
pub common: *mut c_void,
|
||||
}
|
||||
|
||||
pub type SceKernelAlarmHandler = unsafe extern "C" fn(common: *mut c_void) -> u32;
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceKernelAlarmInfo {
|
||||
pub size: usize,
|
||||
pub schedule: SceKernelSysClock,
|
||||
pub handler: SceKernelAlarmHandler,
|
||||
pub common: *mut c_void,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub enum SceKernelIdListType {
|
||||
Thread = 1,
|
||||
Semaphore = 2,
|
||||
EventFlag = 3,
|
||||
Mbox = 4,
|
||||
Vpl = 5,
|
||||
Fpl = 6,
|
||||
Mpipe = 7,
|
||||
Callback = 8,
|
||||
ThreadEventHandler = 9,
|
||||
Alarm = 10,
|
||||
VTimer = 11,
|
||||
SleepThread = 64,
|
||||
DelayThread = 65,
|
||||
SuspendThread = 66,
|
||||
DormantThread = 67,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceKernelSystemStatus {
|
||||
pub size: usize,
|
||||
pub status: u32,
|
||||
pub idle_clocks: SceKernelSysClock,
|
||||
pub comes_out_of_idle_count: u32,
|
||||
pub thread_switch_count: u32,
|
||||
pub vfpu_switch_count: u32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceKernelMppInfo {
|
||||
pub size: usize,
|
||||
pub name: [u8; 32],
|
||||
pub attr: u32,
|
||||
pub buf_size: i32,
|
||||
pub free_size: i32,
|
||||
pub num_send_wait_threads: i32,
|
||||
pub num_receive_wait_threads: i32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceKernelVplOptParam {
|
||||
pub size: usize,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceKernelVplInfo {
|
||||
pub size: usize,
|
||||
pub name: [u8; 32],
|
||||
pub attr: u32,
|
||||
pub pool_size: i32,
|
||||
pub free_size: i32,
|
||||
pub num_wait_threads: i32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceKernelFplOptParam {
|
||||
pub size: usize,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceKernelFplInfo {
|
||||
pub size: usize,
|
||||
pub name: [u8; 32usize],
|
||||
pub attr: u32,
|
||||
pub block_size: i32,
|
||||
pub num_blocks: i32,
|
||||
pub free_blocks: i32,
|
||||
pub num_wait_threads: i32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceKernelVTimerOptParam {
|
||||
pub size: usize,
|
||||
}
|
||||
|
||||
pub type SceKernelCallbackFunction = unsafe extern "C" fn(
|
||||
arg1: i32,
|
||||
arg2: i32,
|
||||
arg: *mut c_void,
|
||||
) -> i32;
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceKernelCallbackInfo {
|
||||
pub size: usize,
|
||||
pub name: [u8; 32usize],
|
||||
pub thread_id: SceUid,
|
||||
pub callback: SceKernelCallbackFunction,
|
||||
pub common: *mut c_void,
|
||||
pub notify_count: i32,
|
||||
pub notify_arg: i32,
|
||||
}
|
||||
|
||||
extern {
|
||||
pub fn sceKernelGetThreadmanIdType(uid: SceUid) -> SceKernelIdListType;
|
||||
pub fn sceKernelCreateThread(
|
||||
name: *const u8,
|
||||
entry: SceKernelThreadEntry,
|
||||
init_priority: i32,
|
||||
stack_size: i32,
|
||||
attr: i32,
|
||||
option: *mut SceKernelThreadOptParam,
|
||||
) -> SceUid;
|
||||
pub fn sceKernelDeleteThread(thid: SceUid) -> i32;
|
||||
pub fn sceKernelStartThread(
|
||||
id: SceUid,
|
||||
arg_len: usize,
|
||||
arg_p: *mut c_void,
|
||||
) -> i32;
|
||||
pub fn sceKernelExitThread(status: i32) -> i32;
|
||||
pub fn sceKernelExitDeleteThread(status: i32) -> i32;
|
||||
pub fn sceKernelTerminateThread(thid: SceUid) -> i32;
|
||||
pub fn sceKernelTerminateDeleteThread(thid: SceUid) -> i32;
|
||||
pub fn sceKernelSuspendDispatchThread() -> i32;
|
||||
pub fn sceKernelResumeDispatchThread(state: i32) -> i32;
|
||||
pub fn sceKernelSleepThread() -> i32;
|
||||
pub fn sceKernelSleepThreadCB() -> i32;
|
||||
pub fn sceKernelWakeupThread(thid: SceUid) -> i32;
|
||||
pub fn sceKernelCancelWakeupThread(thid: SceUid) -> i32;
|
||||
pub fn sceKernelSuspendThread(thid: SceUid) -> i32;
|
||||
pub fn sceKernelResumeThread(thid: SceUid) -> i32;
|
||||
pub fn sceKernelWaitThreadEnd(thid: SceUid, timeout: *mut u32) -> i32;
|
||||
pub fn sceKernelWaitThreadEndCB(thid: SceUid, timeout: *mut u32) -> i32;
|
||||
pub fn sceKernelDelayThread(delay: u32) -> i32;
|
||||
pub fn sceKernelDelayThreadCB(delay: u32) -> i32;
|
||||
pub fn sceKernelDelaySysClockThread(delay: *mut SceKernelSysClock) -> i32;
|
||||
pub fn sceKernelDelaySysClockThreadCB(delay: *mut SceKernelSysClock) -> i32;
|
||||
pub fn sceKernelChangeCurrentThreadAttr(
|
||||
unknown: i32,
|
||||
attr: i32,
|
||||
) -> i32;
|
||||
pub fn sceKernelChangeThreadPriority(
|
||||
thid: SceUid,
|
||||
priority: i32,
|
||||
) -> i32;
|
||||
pub fn sceKernelRotateThreadReadyQueue(
|
||||
priority: i32,
|
||||
) -> i32;
|
||||
pub fn sceKernelReleaseWaitThread(thid: SceUid) -> i32;
|
||||
pub fn sceKernelGetThreadId() -> i32;
|
||||
pub fn sceKernelGetThreadCurrentPriority() -> i32;
|
||||
pub fn sceKernelGetThreadExitStatus(thid: SceUid) -> i32;
|
||||
pub fn sceKernelCheckThreadStack() -> i32;
|
||||
pub fn sceKernelGetThreadStackFreeSize(thid: SceUid) -> i32;
|
||||
pub fn sceKernelReferThreadStatus(
|
||||
thid: SceUid,
|
||||
info: *mut SceKernelThreadInfo,
|
||||
) -> i32;
|
||||
pub fn sceKernelReferThreadRunStatus(
|
||||
thid: SceUid,
|
||||
status: *mut SceKernelThreadRunStatus,
|
||||
) -> i32;
|
||||
pub fn sceKernelCreateSema(
|
||||
name: *const u8,
|
||||
attr: u32,
|
||||
init_val: i32,
|
||||
max_val: i32,
|
||||
option: *mut SceKernelSemaOptParam,
|
||||
) -> SceUid;
|
||||
pub fn sceKernelDeleteSema(sema_id: SceUid) -> i32;
|
||||
pub fn sceKernelSignalSema(
|
||||
sema_id: SceUid,
|
||||
signal: i32,
|
||||
) -> i32;
|
||||
pub fn sceKernelWaitSema(
|
||||
sema_id: SceUid,
|
||||
signal: i32,
|
||||
timeout: *mut u32,
|
||||
) -> i32;
|
||||
pub fn sceKernelWaitSemaCB(
|
||||
sema_id: SceUid,
|
||||
signal: i32,
|
||||
timeout: *mut u32,
|
||||
) -> i32;
|
||||
pub fn sceKernelPollSema(
|
||||
sema_id: SceUid,
|
||||
signal: i32,
|
||||
) -> i32;
|
||||
pub fn sceKernelReferSemaStatus(
|
||||
sema_id: SceUid,
|
||||
info: *mut SceKernelSemaInfo,
|
||||
) -> i32;
|
||||
pub fn sceKernelCreateEventFlag(
|
||||
name: *const u8,
|
||||
attr: i32,
|
||||
bits: i32,
|
||||
opt: *mut SceKernelEventFlagOptParam,
|
||||
) -> SceUid;
|
||||
pub fn sceKernelSetEventFlag(ev_id: SceUid, bits: u32) -> i32;
|
||||
pub fn sceKernelClearEventFlag(ev_id: SceUid, bits: u32) -> i32;
|
||||
pub fn sceKernelPollEventFlag(
|
||||
ev_id: SceUid,
|
||||
bits: u32,
|
||||
wait: i32,
|
||||
out_bits: *mut u32,
|
||||
) -> i32;
|
||||
pub fn sceKernelWaitEventFlag(
|
||||
ev_id: SceUid,
|
||||
bits: u32,
|
||||
wait: i32,
|
||||
out_bits: *mut u32,
|
||||
timeout: *mut u32,
|
||||
) -> i32;
|
||||
pub fn sceKernelWaitEventFlagCB(
|
||||
ev_id: SceUid,
|
||||
bits: u32,
|
||||
wait: i32,
|
||||
out_bits: *mut u32,
|
||||
timeout: *mut u32,
|
||||
) -> i32;
|
||||
pub fn sceKernelDeleteEventFlag(ev_id: SceUid) -> i32;
|
||||
pub fn sceKernelReferEventFlagStatus(
|
||||
event: SceUid,
|
||||
status: *mut SceKernelEventFlagInfo,
|
||||
) -> i32;
|
||||
pub fn sceKernelCreateMbx(
|
||||
name: *const u8,
|
||||
attr: u32,
|
||||
option: *mut SceKernelMbxOptParam,
|
||||
) -> SceUid;
|
||||
pub fn sceKernelDeleteMbx(mbx_id: SceUid) -> i32;
|
||||
pub fn sceKernelSendMbx(
|
||||
mbx_id: SceUid,
|
||||
message: *mut c_void,
|
||||
) -> i32;
|
||||
pub fn sceKernelReceiveMbx(
|
||||
mbx_id: SceUid,
|
||||
message: *mut *mut c_void,
|
||||
timeout: *mut u32,
|
||||
) -> i32;
|
||||
pub fn sceKernelReceiveMbxCB(
|
||||
mbx_id: SceUid,
|
||||
message: *mut *mut c_void,
|
||||
timeout: *mut u32,
|
||||
) -> i32;
|
||||
pub fn sceKernelPollMbx(
|
||||
mbx_id: SceUid,
|
||||
pmessage: *mut *mut c_void,
|
||||
) -> i32;
|
||||
pub fn sceKernelCancelReceiveMbx(
|
||||
mbx_id: SceUid,
|
||||
num: *mut i32,
|
||||
) -> i32;
|
||||
pub fn sceKernelReferMbxStatus(
|
||||
mbx_id: SceUid,
|
||||
info: *mut SceKernelMbxInfo,
|
||||
) -> i32;
|
||||
pub fn sceKernelSetAlarm(
|
||||
clock: u32,
|
||||
handler: SceKernelAlarmHandler,
|
||||
common: *mut c_void,
|
||||
) -> SceUid;
|
||||
pub fn sceKernelSetSysClockAlarm(
|
||||
clock: *mut SceKernelSysClock,
|
||||
handler: *mut SceKernelAlarmHandler,
|
||||
common: *mut c_void,
|
||||
) -> SceUid;
|
||||
pub fn sceKernelCancelAlarm(alarm_id: SceUid) -> i32;
|
||||
pub fn sceKernelReferAlarmStatus(
|
||||
alarm_id: SceUid,
|
||||
info: *mut SceKernelAlarmInfo,
|
||||
) -> i32;
|
||||
pub fn sceKernelCreateCallback(
|
||||
name: *const u8,
|
||||
func: SceKernelCallbackFunction,
|
||||
arg: *mut c_void,
|
||||
) -> SceUid;
|
||||
pub fn sceKernelReferCallbackStatus(
|
||||
cb: SceUid,
|
||||
status: *mut SceKernelCallbackInfo,
|
||||
) -> i32;
|
||||
pub fn sceKernelDeleteCallback(cb: SceUid) -> i32;
|
||||
pub fn sceKernelNotifyCallback(
|
||||
cb: SceUid,
|
||||
arg2: i32,
|
||||
) -> i32;
|
||||
pub fn sceKernelCancelCallback(cb: SceUid) -> i32;
|
||||
pub fn sceKernelGetCallbackCount(cb: SceUid) -> i32;
|
||||
pub fn sceKernelCheckCallback() -> i32;
|
||||
pub fn sceKernelGetThreadmanIdList(
|
||||
type_: SceKernelIdListType,
|
||||
read_buf: *mut SceUid,
|
||||
read_buf_size: i32,
|
||||
id_count: *mut i32,
|
||||
) -> i32;
|
||||
pub fn sceKernelReferSystemStatus(status: *mut SceKernelSystemStatus) -> i32;
|
||||
pub fn sceKernelCreateMsgPipe(
|
||||
name: *const u8,
|
||||
part: i32,
|
||||
attr: i32,
|
||||
unk1: *mut c_void,
|
||||
opt: *mut c_void,
|
||||
) -> SceUid;
|
||||
pub fn sceKernelDeleteMsgPipe(uid: SceUid) -> i32;
|
||||
pub fn sceKernelSendMsgPipe(
|
||||
uid: SceUid,
|
||||
message: *mut c_void,
|
||||
size: u32,
|
||||
unk1: i32,
|
||||
unk2: *mut c_void,
|
||||
timeout: *mut u32,
|
||||
) -> i32;
|
||||
pub fn sceKernelSendMsgPipeCB(
|
||||
uid: SceUid,
|
||||
message: *mut c_void,
|
||||
size: u32,
|
||||
unk1: i32,
|
||||
unk2: *mut c_void,
|
||||
timeout: *mut u32,
|
||||
) -> i32;
|
||||
pub fn sceKernelTrySendMsgPipe(
|
||||
uid: SceUid,
|
||||
message: *mut c_void,
|
||||
size: u32,
|
||||
unk1: i32,
|
||||
unk2: *mut c_void,
|
||||
) -> i32;
|
||||
pub fn sceKernelReceiveMsgPipe(
|
||||
uid: SceUid,
|
||||
message: *mut c_void,
|
||||
size: u32,
|
||||
unk1: i32,
|
||||
unk2: *mut c_void,
|
||||
timeout: *mut u32,
|
||||
) -> i32;
|
||||
pub fn sceKernelReceiveMsgPipeCB(
|
||||
uid: SceUid,
|
||||
message: *mut c_void,
|
||||
size: u32,
|
||||
unk1: i32,
|
||||
unk2: *mut c_void,
|
||||
timeout: *mut u32,
|
||||
) -> i32;
|
||||
pub fn sceKernelTryReceiveMsgPipe(
|
||||
uid: SceUid,
|
||||
message: *mut c_void,
|
||||
size: u32,
|
||||
unk1: i32,
|
||||
unk2: *mut c_void,
|
||||
) -> i32;
|
||||
pub fn sceKernelCancelMsgPipe(
|
||||
uid: SceUid,
|
||||
send: *mut i32,
|
||||
recv: *mut i32,
|
||||
) -> i32;
|
||||
pub fn sceKernelReferMsgPipeStatus(
|
||||
uid: SceUid,
|
||||
info: *mut SceKernelMppInfo,
|
||||
) -> i32;
|
||||
pub fn sceKernelCreateVpl(
|
||||
name: *const u8,
|
||||
part: i32,
|
||||
attr: i32,
|
||||
size: u32,
|
||||
opt: *mut SceKernelVplOptParam,
|
||||
) -> SceUid;
|
||||
pub fn sceKernelDeleteVpl(uid: SceUid) -> i32;
|
||||
pub fn sceKernelAllocateVpl(
|
||||
uid: SceUid,
|
||||
size: u32,
|
||||
data: *mut *mut c_void,
|
||||
timeout: *mut u32,
|
||||
) -> i32;
|
||||
pub fn sceKernelAllocateVplCB(
|
||||
uid: SceUid,
|
||||
size: u32,
|
||||
data: *mut *mut c_void,
|
||||
timeout: *mut u32,
|
||||
) -> i32;
|
||||
pub fn sceKernelTryAllocateVpl(
|
||||
uid: SceUid,
|
||||
size: u32,
|
||||
data: *mut *mut c_void,
|
||||
) -> i32;
|
||||
pub fn sceKernelFreeVpl(
|
||||
uid: SceUid,
|
||||
data: *mut c_void,
|
||||
) -> i32;
|
||||
pub fn sceKernelCancelVpl(
|
||||
uid: SceUid,
|
||||
num: *mut i32,
|
||||
) -> i32;
|
||||
pub fn sceKernelReferVplStatus(
|
||||
uid: SceUid,
|
||||
info: *mut SceKernelVplInfo,
|
||||
) -> i32;
|
||||
pub fn sceKernelCreateFpl(
|
||||
name: *const u8,
|
||||
part: i32,
|
||||
attr: i32,
|
||||
size: u32,
|
||||
blocks: u32,
|
||||
opt: *mut SceKernelFplOptParam,
|
||||
) -> i32;
|
||||
pub fn sceKernelDeleteFpl(uid: SceUid) -> i32;
|
||||
pub fn sceKernelAllocateFpl(
|
||||
uid: SceUid,
|
||||
data: *mut *mut c_void,
|
||||
timeout: *mut u32,
|
||||
) -> i32;
|
||||
pub fn sceKernelAllocateFplCB(
|
||||
uid: SceUid,
|
||||
data: *mut *mut c_void,
|
||||
timeout: *mut u32,
|
||||
) -> i32;
|
||||
pub fn sceKernelTryAllocateFpl(
|
||||
uid: SceUid,
|
||||
data: *mut *mut c_void,
|
||||
) -> i32;
|
||||
pub fn sceKernelFreeFpl(
|
||||
uid: SceUid,
|
||||
data: *mut c_void,
|
||||
) -> i32;
|
||||
pub fn sceKernelCancelFpl(
|
||||
uid: SceUid,
|
||||
pnum: *mut i32,
|
||||
) -> i32;
|
||||
pub fn sceKernelReferFplStatus(
|
||||
uid: SceUid,
|
||||
info: *mut SceKernelFplInfo,
|
||||
) -> i32;
|
||||
pub fn sceKernelUSec2SysClock(
|
||||
usec: u32,
|
||||
clock: *mut SceKernelSysClock,
|
||||
) -> i32;
|
||||
pub fn sceKernelUSec2SysClockWide(usec: u32) -> i64;
|
||||
pub fn sceKernelSysClock2USec(
|
||||
clock: *mut SceKernelSysClock,
|
||||
low: *mut u32,
|
||||
high: *mut u32,
|
||||
) -> i32;
|
||||
pub fn sceKernelSysClock2USecWide(
|
||||
clock: i64,
|
||||
low: *mut u32,
|
||||
high: *mut u32,
|
||||
) -> i32;
|
||||
pub fn sceKernelGetSystemTime(time: *mut SceKernelSysClock) -> i32;
|
||||
pub fn sceKernelGetSystemTimeWide() -> i64;
|
||||
pub fn sceKernelGetSystemTimeLow() -> u32;
|
||||
pub fn sceKernelCreateVTimer(
|
||||
name: *const u8,
|
||||
opt: *mut SceKernelVTimerOptParam,
|
||||
) -> SceUid;
|
||||
pub fn sceKernelDeleteVTimer(uid: SceUid) -> i32;
|
||||
pub fn sceKernelGetVTimerBase(
|
||||
uid: SceUid,
|
||||
base: *mut SceKernelSysClock,
|
||||
) -> i32;
|
||||
pub fn sceKernelGetVTimerBaseWide(uid: SceUid) -> i64;
|
||||
pub fn sceKernelGetVTimerTime(
|
||||
uid: SceUid,
|
||||
time: *mut SceKernelSysClock,
|
||||
) -> i32;
|
||||
pub fn sceKernelGetVTimerTimeWide(uid: SceUid) -> i64;
|
||||
pub fn sceKernelSetVTimerTime(
|
||||
uid: SceUid,
|
||||
time: *mut SceKernelSysClock,
|
||||
) -> i32;
|
||||
pub fn sceKernelSetVTimerTimeWide(uid: SceUid, time: i64) -> i64;
|
||||
pub fn sceKernelStartVTimer(uid: SceUid) -> i32;
|
||||
pub fn sceKernelStopVTimer(uid: SceUid) -> i32;
|
||||
pub fn sceKernelSetVTimerHandler(
|
||||
uid: SceUid,
|
||||
time: *mut SceKernelSysClock,
|
||||
handler: SceKernelVTimerHandler,
|
||||
common: *mut c_void,
|
||||
) -> i32;
|
||||
pub fn sceKernelSetVTimerHandlerWide(
|
||||
uid: SceUid,
|
||||
time: i64,
|
||||
handler: SceKernelVTimerHandlerWide,
|
||||
common: *mut c_void,
|
||||
) -> i32;
|
||||
pub fn sceKernelCancelVTimerHandler(uid: SceUid) -> i32;
|
||||
pub fn sceKernelReferVTimerStatus(
|
||||
uid: SceUid,
|
||||
info: *mut SceKernelVTimerInfo,
|
||||
) -> i32;
|
||||
pub fn sceKernelRegisterThreadEventHandler(
|
||||
name: *const u8,
|
||||
thread_id: SceUid,
|
||||
mask: i32,
|
||||
handler: SceKernelThreadEventHandler,
|
||||
common: *mut c_void,
|
||||
) -> SceUid;
|
||||
pub fn sceKernelReleaseThreadEventHandler(uid: SceUid) -> i32;
|
||||
pub fn sceKernelReferThreadEventHandlerStatus(
|
||||
uid: SceUid,
|
||||
info: *mut SceKernelThreadEventHandlerInfo,
|
||||
) -> i32;
|
||||
pub fn sceKernelReferThreadProfiler() -> *mut DebugProfilerRegs;
|
||||
pub fn sceKernelReferGlobalProfiler() -> *mut DebugProfilerRegs;
|
||||
}
|
|
@ -1,4 +1,8 @@
|
|||
//! PSP C type definitions
|
||||
//!
|
||||
//! These type declarations are not enough, as they must be ultimately resolved
|
||||
//! by the linker. Crates that use these definitions must, somewhere in the
|
||||
//! crate graph, include a stub provider crate such as the `psp` crate.
|
||||
|
||||
pub type c_schar = i8;
|
||||
pub type c_uchar = u8;
|
||||
|
@ -45,3 +49,72 @@ cfg_if! {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
mod audio;
|
||||
pub use self::audio::*;
|
||||
|
||||
mod atrac;
|
||||
pub use self::atrac::*;
|
||||
|
||||
mod ctrl;
|
||||
pub use self::ctrl::*;
|
||||
|
||||
mod display;
|
||||
pub use self::display::*;
|
||||
|
||||
mod ge;
|
||||
pub use self::ge::*;
|
||||
|
||||
mod kernel;
|
||||
pub use self::kernel::*;
|
||||
|
||||
mod usb;
|
||||
pub use self::usb::*;
|
||||
|
||||
mod power;
|
||||
pub use self::power::*;
|
||||
|
||||
mod wlan;
|
||||
pub use self::wlan::*;
|
||||
|
||||
mod rtc;
|
||||
pub use self::rtc::*;
|
||||
|
||||
mod io;
|
||||
pub use self::io::*;
|
||||
|
||||
mod jpeg;
|
||||
pub use self::jpeg::*;
|
||||
|
||||
mod umd;
|
||||
pub use self::umd::*;
|
||||
|
||||
mod mpeg;
|
||||
pub use self::mpeg::*;
|
||||
|
||||
mod hprm;
|
||||
pub use self::hprm::*;
|
||||
|
||||
mod gu;
|
||||
pub use self::gu::*;
|
||||
|
||||
mod gum;
|
||||
pub use self::gum::*;
|
||||
|
||||
mod types;
|
||||
pub use self::types::*;
|
||||
|
||||
mod mp3;
|
||||
pub use self::mp3::*;
|
||||
|
||||
mod registry;
|
||||
pub use self::registry::*;
|
||||
|
||||
mod openpsid;
|
||||
pub use self::openpsid::*;
|
||||
|
||||
mod utility;
|
||||
pub use self::utility::*;
|
||||
|
||||
mod net;
|
||||
pub use self::net::*;
|
|
@ -0,0 +1,43 @@
|
|||
use super::c_void;
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceMp3InitArg {
|
||||
pub mp3_stream_start: u32,
|
||||
pub unk1: u32,
|
||||
pub mp3_stream_end: u32,
|
||||
pub unk2: u32,
|
||||
pub mp3_buf: *mut c_void,
|
||||
pub mp3_buf_size: i32,
|
||||
pub pcm_buf: *mut c_void,
|
||||
pub pcm_buf_size: i32,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(transparent)]
|
||||
pub struct Handle(pub i32);
|
||||
|
||||
extern {
|
||||
pub fn sceMp3ReserveMp3Handle(args: *mut SceMp3InitArg) -> i32;
|
||||
pub fn sceMp3ReleaseMp3Handle(handle: Handle) -> i32;
|
||||
pub fn sceMp3InitResource() -> i32;
|
||||
pub fn sceMp3TermResource() -> i32;
|
||||
pub fn sceMp3Init(handle: Handle) -> i32;
|
||||
pub fn sceMp3Decode(handle: Handle, dst: *mut *mut i16) -> i32;
|
||||
pub fn sceMp3GetInfoToAddStreamData(
|
||||
handle: Handle,
|
||||
dst: *mut *mut u8,
|
||||
to_write: *mut i32,
|
||||
src_pos: *mut i32,
|
||||
) -> i32;
|
||||
pub fn sceMp3NotifyAddStreamData(handle: Handle, size: i32) -> i32;
|
||||
pub fn sceMp3CheckStreamDataNeeded(handle: Handle) -> i32;
|
||||
pub fn sceMp3SetLoopNum(handle: Handle, loop_: i32) -> i32;
|
||||
pub fn sceMp3GetLoopNum(handle: Handle) -> i32;
|
||||
pub fn sceMp3GetSumDecodedSample(handle: Handle) -> i32;
|
||||
pub fn sceMp3GetMaxOutputSample(handle: Handle) -> i32;
|
||||
pub fn sceMp3GetSamplingRate(handle: Handle) -> i32;
|
||||
pub fn sceMp3GetBitRate(handle: Handle) -> i32;
|
||||
pub fn sceMp3GetMp3ChannelNum(handle: Handle) -> i32;
|
||||
pub fn sceMp3ResetPlayPosition(handle: Handle) -> i32;
|
||||
}
|
|
@ -0,0 +1,178 @@
|
|||
use super::c_void;
|
||||
|
||||
#[repr(transparent)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceMpeg(*mut *mut c_void);
|
||||
|
||||
#[repr(transparent)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceMpegStream(*mut c_void);
|
||||
pub type SceMpegRingbufferCb = Option<
|
||||
unsafe extern "C" fn(data: *mut c_void, num_packets: i32, param: *mut c_void) -> i32,
|
||||
>;
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceMpegRingbuffer {
|
||||
pub packets: i32,
|
||||
pub unk0: u32,
|
||||
pub unk1: u32,
|
||||
pub unk2: u32,
|
||||
pub unk3: u32,
|
||||
pub data: *mut c_void,
|
||||
pub callback: SceMpegRingbufferCb,
|
||||
pub cb_param: *mut c_void,
|
||||
pub unk4: u32,
|
||||
pub unk5: u32,
|
||||
pub sce_mpeg: *mut c_void,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceMpegAu {
|
||||
pub pts_msb: u32,
|
||||
pub pts: u32,
|
||||
pub dts_msb: u32,
|
||||
pub dts: u32,
|
||||
pub es_buffer: u32,
|
||||
pub au_size: u32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceMpegAvcMode {
|
||||
pub unk0: i32,
|
||||
pub pixel_format: super::DisplayPixelFormat,
|
||||
}
|
||||
|
||||
extern {
|
||||
pub fn sceMpegInit() -> i32;
|
||||
pub fn sceMpegFinish();
|
||||
pub fn sceMpegRingbufferQueryMemSize(packets: i32) -> i32;
|
||||
pub fn sceMpegRingbufferConstruct(
|
||||
ringbuffer: *mut SceMpegRingbuffer,
|
||||
packets: i32,
|
||||
data: *mut c_void,
|
||||
size: i32,
|
||||
callback: SceMpegRingbufferCb,
|
||||
cb_param: *mut c_void,
|
||||
) -> i32;
|
||||
pub fn sceMpegRingbufferDestruct(ringbuffer: *mut SceMpegRingbuffer);
|
||||
pub fn sceMpegRingbufferAvailableSize(ringbuffer: *mut SceMpegRingbuffer) -> i32;
|
||||
pub fn sceMpegRingbufferPut(
|
||||
ringbuffer: *mut SceMpegRingbuffer,
|
||||
num_packets: i32,
|
||||
available: i32,
|
||||
) -> i32;
|
||||
pub fn sceMpegQueryMemSize(unk: i32) -> i32;
|
||||
pub fn sceMpegCreate(
|
||||
handle: SceMpeg,
|
||||
data: *mut c_void,
|
||||
size: i32,
|
||||
ringbuffer: *mut SceMpegRingbuffer,
|
||||
frame_width: i32,
|
||||
unk1: i32,
|
||||
unk2: i32,
|
||||
) -> i32;
|
||||
pub fn sceMpegDelete(handle: SceMpeg);
|
||||
pub fn sceMpegQueryStreamOffset(
|
||||
handle: SceMpeg,
|
||||
buffer: *mut c_void,
|
||||
offset: *mut i32,
|
||||
) -> i32;
|
||||
pub fn sceMpegQueryStreamSize(buffer: *mut c_void, size: *mut i32) -> i32;
|
||||
pub fn sceMpegRegistStream(
|
||||
handle: SceMpeg,
|
||||
stream_id: i32,
|
||||
unk: i32,
|
||||
) -> SceMpegStream;
|
||||
pub fn sceMpegUnRegistStream(handle: SceMpeg, stream: SceMpegStream);
|
||||
pub fn sceMpegFlushAllStream(handle: SceMpeg) -> i32;
|
||||
pub fn sceMpegMallocAvcEsBuf(handle: SceMpeg) -> *mut c_void;
|
||||
pub fn sceMpegFreeAvcEsBuf(handle: SceMpeg, buf: *mut c_void);
|
||||
pub fn sceMpegQueryAtracEsSize(
|
||||
handle: SceMpeg,
|
||||
es_size: *mut i32,
|
||||
out_size: *mut i32,
|
||||
) -> i32;
|
||||
pub fn sceMpegInitAu(handle: SceMpeg, es_buffer: *mut c_void, au: *mut SceMpegAu) -> i32;
|
||||
pub fn sceMpegGetAvcAu(
|
||||
handle: SceMpeg,
|
||||
stream: SceMpegStream,
|
||||
au: *mut SceMpegAu,
|
||||
unk: *mut i32,
|
||||
) -> i32;
|
||||
pub fn sceMpegAvcDecodeMode(handle: SceMpeg, mode: *mut SceMpegAvcMode) -> i32;
|
||||
pub fn sceMpegAvcDecode(
|
||||
handle: SceMpeg,
|
||||
au: *mut SceMpegAu,
|
||||
iframe_width: i32,
|
||||
buffer: *mut c_void,
|
||||
init: *mut i32,
|
||||
) -> i32;
|
||||
pub fn sceMpegAvcDecodeStop(
|
||||
handle: SceMpeg,
|
||||
frame_width: i32,
|
||||
buffer: *mut c_void,
|
||||
status: *mut i32,
|
||||
) -> i32;
|
||||
pub fn sceMpegGetAtracAu(
|
||||
handle: SceMpeg,
|
||||
stream: SceMpegStream,
|
||||
au: *mut SceMpegAu,
|
||||
unk: *mut c_void,
|
||||
) -> i32;
|
||||
pub fn sceMpegAtracDecode(
|
||||
handle: SceMpeg,
|
||||
au: *mut SceMpegAu,
|
||||
buffer: *mut c_void,
|
||||
init: i32,
|
||||
) -> i32;
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[repr(align(64))]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceMpegLLI {
|
||||
pub src: *mut c_void,
|
||||
pub dst: *mut c_void,
|
||||
pub next: *mut c_void,
|
||||
pub size: i32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[repr(align(64))]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceMpegYCrCbBuffer {
|
||||
pub frame_buffer_height16: i32,
|
||||
pub frame_buffer_width16: i32,
|
||||
pub unknown: i32,
|
||||
pub unknown2: i32,
|
||||
pub y_buffer: *mut c_void,
|
||||
pub y_buffer2: *mut c_void,
|
||||
pub cr_buffer: *mut c_void,
|
||||
pub cb_buffer: *mut c_void,
|
||||
pub cr_buffer2: *mut c_void,
|
||||
pub cb_buffer2: *mut c_void,
|
||||
|
||||
pub frame_height: i32,
|
||||
pub frame_width: i32,
|
||||
pub frame_buffer_width: i32,
|
||||
pub unknown3: [i32; 11usize],
|
||||
}
|
||||
|
||||
extern {
|
||||
pub fn sceMpegBaseYCrCbCopyVme(
|
||||
yuv_buffer: *mut c_void,
|
||||
buffer: *mut i32,
|
||||
type_: i32,
|
||||
) -> i32;
|
||||
pub fn sceMpegBaseCscInit(width: i32) -> i32;
|
||||
pub fn sceMpegBaseCscVme(
|
||||
rgb_buffer: *mut c_void,
|
||||
rgb_buffer2: *mut c_void,
|
||||
width: i32,
|
||||
y_cr_cb_buffer: *mut SceMpegYCrCbBuffer,
|
||||
) -> i32;
|
||||
pub fn sceMpegbase_BEA18F91(lli: *mut SceMpegLLI) -> i32;
|
||||
}
|
|
@ -0,0 +1,24 @@
|
|||
use super::c_void;
|
||||
extern {
|
||||
pub fn sceNandSetWriteProtect(protect_flag: i32) -> i32;
|
||||
pub fn sceNandLock(write_flag: i32) -> i32;
|
||||
pub fn sceNandUnlock();
|
||||
pub fn sceNandReadStatus() -> i32;
|
||||
pub fn sceNandReset(flag: i32) -> i32;
|
||||
pub fn sceNandReadId(buf: *mut c_void, size: usize) -> i32;
|
||||
pub fn sceNandReadPages(
|
||||
ppn: u32,
|
||||
buf: *mut c_void,
|
||||
buf2: *mut c_void,
|
||||
count: u32,
|
||||
) -> i32;
|
||||
pub fn sceNandGetPageSize() -> i32;
|
||||
pub fn sceNandGetPagesPerBlock() -> i32;
|
||||
pub fn sceNandGetTotalBlocks() -> i32;
|
||||
pub fn sceNandReadBlockWithRetry(
|
||||
ppn: u32,
|
||||
buf: *mut c_void,
|
||||
buf2: *mut c_void,
|
||||
) -> i32;
|
||||
pub fn sceNandIsBadBlock(ppn: u32) -> i32;
|
||||
}
|
|
@ -0,0 +1,789 @@
|
|||
use super::c_void;
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceNetMallocStat {
|
||||
pub pool: i32,
|
||||
pub maximum: i32,
|
||||
pub free: i32,
|
||||
}
|
||||
|
||||
extern {
|
||||
pub fn sceNetInit(
|
||||
poolsize: i32,
|
||||
calloutprio: i32,
|
||||
calloutstack: i32,
|
||||
netintrprio: i32,
|
||||
netintrstack: i32,
|
||||
) -> i32;
|
||||
pub fn sceNetTerm() -> i32;
|
||||
pub fn sceNetFreeThreadinfo(thid: i32) -> i32;
|
||||
pub fn sceNetThreadAbort(thid: i32) -> i32;
|
||||
pub fn sceNetEtherStrton(name: *mut u8, mac: *mut u8);
|
||||
pub fn sceNetEtherNtostr(mac: *mut u8, name: *mut u8);
|
||||
pub fn sceNetGetLocalEtherAddr(mac: *mut u8) -> i32;
|
||||
pub fn sceNetGetMallocStat(stat: *mut SceNetMallocStat) -> i32;
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceNetAdhocctlAdhocId {
|
||||
pub unknown: i32,
|
||||
pub adhoc_id: [u8; 9usize],
|
||||
pub unk: [u8; 3usize],
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceNetAdhocctlPeerInfo {
|
||||
pub next: *mut SceNetAdhocctlPeerInfo,
|
||||
pub nickname: [u8; 128usize],
|
||||
pub mac: [u8; 6usize],
|
||||
pub unknown: [u8; 6usize],
|
||||
pub timestamp: u32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceNetAdhocctlScanInfo {
|
||||
pub next: *mut SceNetAdhocctlScanInfo,
|
||||
pub channel: i32,
|
||||
pub name: [u8; 8usize],
|
||||
pub bssid: [u8; 6usize],
|
||||
pub unknown: [u8; 2usize],
|
||||
pub unknown2: i32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceNetAdhocctlGameModeInfo {
|
||||
pub count: i32,
|
||||
pub macs: [[u8; 6usize]; 16usize],
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceNetAdhocctlParams {
|
||||
pub channel: i32,
|
||||
pub name: [u8; 8usize],
|
||||
pub bssid: [u8; 6usize],
|
||||
pub nickname: [u8; 128usize],
|
||||
}
|
||||
|
||||
pub type SceNetAdhocctlHandler =
|
||||
Option<unsafe extern "C" fn(flag: i32, error: i32, unknown: *mut c_void)>;
|
||||
|
||||
extern {
|
||||
pub fn sceNetAdhocctlInit(
|
||||
stacksize: i32,
|
||||
priority: i32,
|
||||
adhoc_id: *mut SceNetAdhocctlAdhocId,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocctlTerm() -> i32;
|
||||
pub fn sceNetAdhocctlConnect(name: *const u8) -> i32;
|
||||
pub fn sceNetAdhocctlDisconnect() -> i32;
|
||||
pub fn sceNetAdhocctlGetState(event: *mut i32) -> i32;
|
||||
pub fn sceNetAdhocctlCreate(name: *const u8) -> i32;
|
||||
pub fn sceNetAdhocctlJoin(scaninfo: *mut SceNetAdhocctlScanInfo) -> i32;
|
||||
pub fn sceNetAdhocctlGetAdhocId(id: *mut SceNetAdhocctlAdhocId) -> i32;
|
||||
pub fn sceNetAdhocctlCreateEnterGameMode(
|
||||
name: *const u8,
|
||||
unknown: i32,
|
||||
num: i32,
|
||||
macs: *mut u8,
|
||||
timeout: u32,
|
||||
unknown2: i32,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocctlJoinEnterGameMode(
|
||||
name: *const u8,
|
||||
hostmac: *mut u8,
|
||||
timeout: u32,
|
||||
unknown: i32,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocctlGetGameModeInfo(
|
||||
gamemodeinfo: *mut SceNetAdhocctlGameModeInfo,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocctlExitGameMode() -> i32;
|
||||
pub fn sceNetAdhocctlGetPeerList(
|
||||
length: *mut i32,
|
||||
buf: *mut c_void,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocctlGetPeerInfo(
|
||||
mac: *mut u8,
|
||||
size: i32,
|
||||
peerinfo: *mut SceNetAdhocctlPeerInfo,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocctlScan() -> i32;
|
||||
pub fn sceNetAdhocctlGetScanInfo(
|
||||
length: *mut i32,
|
||||
buf: *mut c_void,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocctlAddHandler(
|
||||
handler: SceNetAdhocctlHandler,
|
||||
unknown: *mut c_void,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocctlDelHandler(id: i32) -> i32;
|
||||
pub fn sceNetAdhocctlGetNameByAddr(
|
||||
mac: *mut u8,
|
||||
nickname: *mut u8,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocctlGetAddrByName(
|
||||
nickname: *mut u8,
|
||||
length: *mut i32,
|
||||
buf: *mut c_void,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocctlGetParameter(params: *mut SceNetAdhocctlParams) -> i32;
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceNetAdhocPtpStat {
|
||||
pub next: *mut SceNetAdhocPtpStat,
|
||||
pub ptp_id: i32,
|
||||
pub mac: [u8; 6usize],
|
||||
pub peermac: [u8; 6usize],
|
||||
pub port: u16,
|
||||
pub peerport: u16,
|
||||
pub sent_data: u32,
|
||||
pub rcvd_data: u32,
|
||||
pub state: ScePspnetAdhocPtpState,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum ScePspnetAdhocPtpState {
|
||||
Closed,
|
||||
Listen,
|
||||
SynSent,
|
||||
SynReceived,
|
||||
Established,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceNetAdhocPdpStat {
|
||||
pub next: *mut SceNetAdhocPdpStat,
|
||||
pub pdp_id: i32,
|
||||
pub mac: [u8; 6usize],
|
||||
pub port: u16,
|
||||
pub rcvd_data: u32,
|
||||
}
|
||||
|
||||
extern {
|
||||
pub fn sceNetAdhocInit() -> i32;
|
||||
pub fn sceNetAdhocTerm() -> i32;
|
||||
pub fn sceNetAdhocPdpCreate(
|
||||
mac: *mut u8,
|
||||
port: u16,
|
||||
buf_size: u32,
|
||||
unk1: i32,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocPdpDelete(
|
||||
id: i32,
|
||||
unk1: i32,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocPdpSend(
|
||||
id: i32,
|
||||
dest_mac_addr: *mut u8,
|
||||
port: u16,
|
||||
data: *mut c_void,
|
||||
len: u32,
|
||||
timeout: u32,
|
||||
nonblock: i32,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocPdpRecv(
|
||||
id: i32,
|
||||
src_mac_addr: *mut u8,
|
||||
port: *mut u16,
|
||||
data: *mut c_void,
|
||||
data_length: *mut c_void,
|
||||
timeout: u32,
|
||||
nonblock: i32,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocGetPdpStat(
|
||||
size: *mut i32,
|
||||
stat: *mut SceNetAdhocPdpStat,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocGameModeCreateMaster(
|
||||
data: *mut c_void,
|
||||
size: i32,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocGameModeCreateReplica(
|
||||
mac: *mut u8,
|
||||
data: *mut c_void,
|
||||
size: i32,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocGameModeUpdateMaster() -> i32;
|
||||
pub fn sceNetAdhocGameModeUpdateReplica(
|
||||
id: i32,
|
||||
unk1: i32,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocGameModeDeleteMaster() -> i32;
|
||||
pub fn sceNetAdhocGameModeDeleteReplica(id: i32) -> i32;
|
||||
pub fn sceNetAdhocPtpOpen(
|
||||
srcmac: *mut u8,
|
||||
srcport: u16,
|
||||
destmac: *mut u8,
|
||||
destport: u16,
|
||||
buf_size: u32,
|
||||
delay: u32,
|
||||
count: i32,
|
||||
unk1: i32,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocPtpConnect(
|
||||
id: i32,
|
||||
timeout: u32,
|
||||
nonblock: i32,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocPtpListen(
|
||||
srcmac: *mut u8,
|
||||
srcport: u16,
|
||||
buf_size: u32,
|
||||
delay: u32,
|
||||
count: i32,
|
||||
queue: i32,
|
||||
unk1: i32,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocPtpAccept(
|
||||
id: i32,
|
||||
mac: *mut u8,
|
||||
port: *mut u16,
|
||||
timeout: u32,
|
||||
nonblock: i32,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocPtpSend(
|
||||
id: i32,
|
||||
data: *mut c_void,
|
||||
data_size: *mut i32,
|
||||
timeout: u32,
|
||||
nonblock: i32,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocPtpRecv(
|
||||
id: i32,
|
||||
data: *mut c_void,
|
||||
data_size: *mut i32,
|
||||
timeout: u32,
|
||||
nonblock: i32,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocPtpFlush(
|
||||
id: i32,
|
||||
timeout: u32,
|
||||
nonblock: i32,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocPtpClose(
|
||||
id: i32,
|
||||
unk1: i32,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocGetPtpStat(
|
||||
size: *mut i32,
|
||||
stat: *mut SceNetAdhocPtpStat,
|
||||
) -> i32;
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct AdhocPoolStat {
|
||||
pub size: i32,
|
||||
pub maxsize: i32,
|
||||
pub freesize: i32,
|
||||
}
|
||||
|
||||
pub type AdhocMatchingCallback = Option<
|
||||
unsafe extern "C" fn(
|
||||
matching_id: i32,
|
||||
event: i32,
|
||||
mac: *mut u8,
|
||||
opt_len: i32,
|
||||
opt_data: *mut c_void,
|
||||
),
|
||||
>;
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub enum AdhocMatchingMode {
|
||||
Host = 1,
|
||||
Client,
|
||||
Ptp,
|
||||
}
|
||||
|
||||
extern {
|
||||
pub fn sceNetAdhocMatchingInit(memsize: i32) -> i32;
|
||||
pub fn sceNetAdhocMatchingTerm() -> i32;
|
||||
pub fn sceNetAdhocMatchingCreate(
|
||||
mode: AdhocMatchingMode,
|
||||
max_peers: i32,
|
||||
port: u16,
|
||||
buf_size: i32,
|
||||
hello_delay: u32,
|
||||
ping_delay: u32,
|
||||
init_count: i32,
|
||||
msg_delay: u32,
|
||||
callback: AdhocMatchingCallback,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocMatchingDelete(matching_id: i32) -> i32;
|
||||
pub fn sceNetAdhocMatchingStart(
|
||||
matching_id: i32,
|
||||
evth_pri: i32,
|
||||
evth_stack: i32,
|
||||
inth_pri: i32,
|
||||
inth_stack: i32,
|
||||
opt_len: i32,
|
||||
opt_data: *mut c_void,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocMatchingStop(matching_id: i32) -> i32;
|
||||
pub fn sceNetAdhocMatchingSelectTarget(
|
||||
matching_id: i32,
|
||||
mac: *mut u8,
|
||||
opt_len: i32,
|
||||
opt_data: *mut c_void,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocMatchingCancelTarget(
|
||||
matching_id: i32,
|
||||
mac: *mut u8,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocMatchingCancelTargetWithOpt(
|
||||
matching_id: i32,
|
||||
mac: *mut u8,
|
||||
opt_len: i32,
|
||||
opt_data: *mut c_void,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocMatchingSendData(
|
||||
matching_id: i32,
|
||||
mac: *mut u8,
|
||||
data_len: i32,
|
||||
data: *mut c_void,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocMatchingAbortSendData(
|
||||
matching_id: i32,
|
||||
mac: *mut u8,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocMatchingSetHelloOpt(
|
||||
matching_id: i32,
|
||||
opt_len: i32,
|
||||
opt_data: *mut c_void,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocMatchingGetHelloOpt(
|
||||
matching_id: i32,
|
||||
opt_len: *mut i32,
|
||||
opt_data: *mut c_void,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocMatchingGetMembers(
|
||||
matching_id: i32,
|
||||
length: *mut i32,
|
||||
buf: *mut c_void,
|
||||
) -> i32;
|
||||
pub fn sceNetAdhocMatchingGetPoolMaxAlloc() -> i32;
|
||||
pub fn sceNetAdhocMatchingGetPoolStat(poolstat: *mut AdhocPoolStat) -> i32;
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum ApctlState {
|
||||
Disconnected,
|
||||
Scanning,
|
||||
Joining,
|
||||
GettingIp,
|
||||
GotIp,
|
||||
EapAuth,
|
||||
KeyExchange,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum ApctlEvent {
|
||||
ConnectRequest,
|
||||
ScanRequest,
|
||||
ScanComplete,
|
||||
Established,
|
||||
GetIp,
|
||||
DisconnectRequest,
|
||||
Error,
|
||||
Info,
|
||||
EapAuth,
|
||||
KeyExchange,
|
||||
Reconnect,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum ApctlInfo {
|
||||
ProfileName,
|
||||
Bssid,
|
||||
Ssid,
|
||||
SsidLength,
|
||||
SecurityType,
|
||||
Strength,
|
||||
Channel,
|
||||
PowerSave,
|
||||
Ip,
|
||||
SubnetMask,
|
||||
Gateway,
|
||||
PrimaryDns,
|
||||
SecondaryDns,
|
||||
UseProxy,
|
||||
ProxyUrl,
|
||||
ProxyPort,
|
||||
EapType,
|
||||
StartBrowser,
|
||||
Wifisp,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum ApctlInfoSecurityType {
|
||||
None,
|
||||
Wep,
|
||||
Wpa,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub union SceNetApctlInfo {
|
||||
pub name: [u8; 64usize],
|
||||
pub bssid: [u8; 6usize],
|
||||
pub ssid: [u8; 32usize],
|
||||
pub ssid_length: u32,
|
||||
pub security_type: u32,
|
||||
pub strength: u8,
|
||||
pub channel: u8,
|
||||
pub power_save: u8,
|
||||
pub ip: [u8; 16usize],
|
||||
pub sub_net_mask: [u8; 16usize],
|
||||
pub gateway: [u8; 16usize],
|
||||
pub primary_dns: [u8; 16usize],
|
||||
pub secondary_dns: [u8; 16usize],
|
||||
pub use_proxy: u32,
|
||||
pub proxy_url: [u8; 128usize],
|
||||
pub proxy_port: u16,
|
||||
pub eap_type: u32,
|
||||
pub start_browser: u32,
|
||||
pub wifisp: u32,
|
||||
}
|
||||
|
||||
pub type SceNetApctlHandler = Option<
|
||||
unsafe extern "C" fn(oldState: i32, newState: i32, event: i32, error: i32, pArg: *mut c_void),
|
||||
>;
|
||||
|
||||
extern {
|
||||
pub fn sceNetApctlInit(
|
||||
stack_size: i32,
|
||||
init_priority: i32,
|
||||
) -> i32;
|
||||
pub fn sceNetApctlTerm() -> i32;
|
||||
pub fn sceNetApctlGetInfo(
|
||||
code: ApctlInfo,
|
||||
pinfo: *mut SceNetApctlInfo,
|
||||
) -> i32;
|
||||
pub fn sceNetApctlAddHandler(
|
||||
handler: SceNetApctlHandler,
|
||||
parg: *mut c_void,
|
||||
) -> i32;
|
||||
pub fn sceNetApctlDelHandler(handler_id: i32) -> i32;
|
||||
pub fn sceNetApctlConnect(conn_index: i32) -> i32;
|
||||
pub fn sceNetApctlDisconnect() -> i32;
|
||||
pub fn sceNetApctlGetState(pstate: *mut ApctlState) -> i32;
|
||||
}
|
||||
|
||||
#[allow(non_camel_case_types)]
|
||||
pub type socklen_t = u32;
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct sockaddr(pub u32);
|
||||
|
||||
extern {
|
||||
pub fn sceNetInetInit() -> i32;
|
||||
pub fn sceNetInetTerm() -> i32;
|
||||
pub fn sceNetInetAccept(
|
||||
s: i32,
|
||||
addr: *mut sockaddr,
|
||||
addr_len: *mut socklen_t,
|
||||
) -> i32;
|
||||
pub fn sceNetInetBind(
|
||||
s: i32,
|
||||
my_addr: *const sockaddr,
|
||||
addr_len: socklen_t,
|
||||
) -> i32;
|
||||
pub fn sceNetInetConnect(
|
||||
s: i32,
|
||||
serv_addr: *const sockaddr,
|
||||
addr_len: socklen_t,
|
||||
) -> i32;
|
||||
pub fn sceNetInetGetsockopt(
|
||||
s: i32,
|
||||
level: i32,
|
||||
opt_name: i32,
|
||||
opt_val: *mut c_void,
|
||||
optl_en: *mut socklen_t,
|
||||
) -> i32;
|
||||
pub fn sceNetInetListen(
|
||||
s: i32,
|
||||
backlog: i32,
|
||||
) -> i32;
|
||||
pub fn sceNetInetRecv(
|
||||
s: i32,
|
||||
buf: *mut c_void,
|
||||
len: usize,
|
||||
flags: i32,
|
||||
) -> usize;
|
||||
pub fn sceNetInetRecvfrom(
|
||||
s: i32,
|
||||
buf: *mut c_void,
|
||||
flags: usize,
|
||||
arg1: i32,
|
||||
from: *mut sockaddr,
|
||||
from_len: *mut socklen_t,
|
||||
) -> usize;
|
||||
pub fn sceNetInetSend(
|
||||
s: i32,
|
||||
buf: *const c_void,
|
||||
len: usize,
|
||||
flags: i32,
|
||||
) -> usize;
|
||||
pub fn sceNetInetSendto(
|
||||
s: i32,
|
||||
buf: *const c_void,
|
||||
len: usize,
|
||||
flags: i32,
|
||||
to: *const sockaddr,
|
||||
to_len: socklen_t,
|
||||
) -> usize;
|
||||
pub fn sceNetInetSetsockopt(
|
||||
s: i32,
|
||||
level: i32,
|
||||
opt_name: i32,
|
||||
opt_val: *const c_void,
|
||||
opt_len: socklen_t,
|
||||
) -> i32;
|
||||
pub fn sceNetInetShutdown(
|
||||
s: i32,
|
||||
how: i32,
|
||||
) -> i32;
|
||||
pub fn sceNetInetSocket(
|
||||
domain: i32,
|
||||
type_: i32,
|
||||
protocol: i32,
|
||||
) -> i32;
|
||||
pub fn sceNetInetClose(s: i32) -> i32;
|
||||
pub fn sceNetInetGetErrno() -> i32;
|
||||
}
|
||||
|
||||
extern {
|
||||
pub fn sceSslInit(unknown1: i32) -> i32;
|
||||
pub fn sceSslEnd() -> i32;
|
||||
pub fn sceSslGetUsedMemoryMax(memory: *mut u32) -> i32;
|
||||
pub fn sceSslGetUsedMemoryCurrent(memory: *mut u32) -> i32;
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub enum HttpMethod {
|
||||
Get,
|
||||
Post,
|
||||
Head,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub enum HttpAuthType {
|
||||
Basic,
|
||||
Digest,
|
||||
}
|
||||
|
||||
pub type HttpMallocFunction = Option<unsafe extern "C" fn(size: usize) -> *mut c_void>;
|
||||
pub type HttpReallocFunction =
|
||||
Option<unsafe extern "C" fn(p: *mut c_void, size: usize) -> *mut c_void>;
|
||||
|
||||
pub type HttpFreeFunction = Option<unsafe extern "C" fn(p: *mut c_void)>;
|
||||
pub type HttpPasswordCB = Option<
|
||||
unsafe extern "C" fn(
|
||||
request: i32,
|
||||
auth_type: HttpAuthType,
|
||||
realm: *const u8,
|
||||
username: *mut u8,
|
||||
password: *mut u8,
|
||||
need_entity: i32,
|
||||
entity_body: *mut *mut u8,
|
||||
entity_size: *mut usize,
|
||||
save: *mut i32,
|
||||
) -> i32,
|
||||
>;
|
||||
|
||||
extern {
|
||||
pub fn sceHttpInit(unknown1: u32) -> i32;
|
||||
pub fn sceHttpEnd() -> i32;
|
||||
pub fn sceHttpCreateTemplate(
|
||||
agent: *mut u8,
|
||||
unknown1: i32,
|
||||
unknown2: i32,
|
||||
) -> i32;
|
||||
pub fn sceHttpDeleteTemplate(templateid: i32) -> i32;
|
||||
pub fn sceHttpCreateConnection(
|
||||
templateid: i32,
|
||||
host: *mut u8,
|
||||
unknown1: *mut u8,
|
||||
port: u16,
|
||||
unknown2: i32,
|
||||
) -> i32;
|
||||
pub fn sceHttpCreateConnectionWithURL(
|
||||
templateid: i32,
|
||||
url: *const u8,
|
||||
unknown1: i32,
|
||||
) -> i32;
|
||||
pub fn sceHttpDeleteConnection(connection_id: i32) -> i32;
|
||||
pub fn sceHttpCreateRequest(
|
||||
connection_id: i32,
|
||||
method: HttpMethod,
|
||||
path: *mut u8,
|
||||
content_length: u64,
|
||||
) -> i32;
|
||||
pub fn sceHttpCreateRequestWithURL(
|
||||
connection_id: i32,
|
||||
method: HttpMethod,
|
||||
url: *mut u8,
|
||||
content_length: u64,
|
||||
) -> i32;
|
||||
pub fn sceHttpDeleteRequest(request_id: i32) -> i32;
|
||||
pub fn sceHttpSendRequest(
|
||||
request_id: i32,
|
||||
data: *mut c_void,
|
||||
data_size: u32,
|
||||
) -> i32;
|
||||
pub fn sceHttpAbortRequest(request_id: i32) -> i32;
|
||||
pub fn sceHttpReadData(
|
||||
request_id: i32,
|
||||
data: *mut c_void,
|
||||
data_size: u32,
|
||||
) -> i32;
|
||||
pub fn sceHttpGetContentLength(
|
||||
request_id: i32,
|
||||
content_length: *mut u64,
|
||||
) -> i32;
|
||||
pub fn sceHttpGetStatusCode(
|
||||
request_id: i32,
|
||||
status_code: *mut i32,
|
||||
) -> i32;
|
||||
pub fn sceHttpSetResolveTimeOut(
|
||||
id: i32,
|
||||
timeout: u32,
|
||||
) -> i32;
|
||||
pub fn sceHttpSetResolveRetry(
|
||||
id: i32,
|
||||
count: i32,
|
||||
) -> i32;
|
||||
pub fn sceHttpSetConnectTimeOut(
|
||||
id: i32,
|
||||
timeout: u32,
|
||||
) -> i32;
|
||||
pub fn sceHttpSetSendTimeOut(
|
||||
id: i32,
|
||||
timeout: u32,
|
||||
) -> i32;
|
||||
pub fn sceHttpSetRecvTimeOut(
|
||||
id: i32,
|
||||
timeout: u32,
|
||||
) -> i32;
|
||||
pub fn sceHttpEnableKeepAlive(id: i32) -> i32;
|
||||
pub fn sceHttpDisableKeepAlive(id: i32) -> i32;
|
||||
pub fn sceHttpEnableRedirect(id: i32) -> i32;
|
||||
pub fn sceHttpDisableRedirect(id: i32) -> i32;
|
||||
pub fn sceHttpEnableCookie(id: i32) -> i32;
|
||||
pub fn sceHttpDisableCookie(id: i32) -> i32;
|
||||
pub fn sceHttpSaveSystemCookie() -> i32;
|
||||
pub fn sceHttpLoadSystemCookie() -> i32;
|
||||
pub fn sceHttpAddExtraHeader(
|
||||
id: i32,
|
||||
name: *mut u8,
|
||||
value: *mut u8,
|
||||
unknown1: i32,
|
||||
) -> i32;
|
||||
pub fn sceHttpDeleteHeader(
|
||||
id: i32,
|
||||
name: *const u8,
|
||||
) -> i32;
|
||||
pub fn sceHttpsInit(
|
||||
unknown1: i32,
|
||||
unknown2: i32,
|
||||
unknown3: i32,
|
||||
unknown4: i32,
|
||||
) -> i32;
|
||||
pub fn sceHttpsEnd() -> i32;
|
||||
pub fn sceHttpsLoadDefaultCert(
|
||||
unknown1: i32,
|
||||
unknown2: i32,
|
||||
) -> i32;
|
||||
pub fn sceHttpDisableAuth(id: i32) -> i32;
|
||||
pub fn sceHttpDisableCache(id: i32) -> i32;
|
||||
pub fn sceHttpEnableAuth(id: i32) -> i32;
|
||||
pub fn sceHttpEnableCache(id: i32) -> i32;
|
||||
pub fn sceHttpEndCache() -> i32;
|
||||
pub fn sceHttpGetAllHeader(
|
||||
request: i32,
|
||||
header: *mut *mut u8,
|
||||
header_size: *mut u32,
|
||||
) -> i32;
|
||||
pub fn sceHttpGetNetworkErrno(
|
||||
request: i32,
|
||||
err_num: *mut i32,
|
||||
) -> i32;
|
||||
pub fn sceHttpGetProxy(
|
||||
id: i32,
|
||||
activate_flag: *mut i32,
|
||||
mode: *mut i32,
|
||||
proxy_host: *mut u8,
|
||||
len: usize,
|
||||
proxy_port: *mut u16,
|
||||
) -> i32;
|
||||
pub fn sceHttpInitCache(max_size: usize) -> i32;
|
||||
pub fn sceHttpSetAuthInfoCB(
|
||||
id: i32,
|
||||
cbfunc: HttpPasswordCB,
|
||||
) -> i32;
|
||||
pub fn sceHttpSetProxy(
|
||||
id: i32,
|
||||
activate_flag: i32,
|
||||
mode: i32,
|
||||
new_proxy_host: *const u8,
|
||||
new_proxy_port: u16,
|
||||
) -> i32;
|
||||
pub fn sceHttpSetResHeaderMaxSize(
|
||||
id: i32,
|
||||
header_size: u32,
|
||||
) -> i32;
|
||||
pub fn sceHttpSetMallocFunction(
|
||||
malloc_func: HttpMallocFunction,
|
||||
free_func: HttpFreeFunction,
|
||||
realloc_func: HttpReallocFunction,
|
||||
) -> i32;
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct in_addr(pub u32);
|
||||
|
||||
extern {
|
||||
pub fn sceNetResolverInit() -> i32;
|
||||
pub fn sceNetResolverCreate(
|
||||
rid: *mut i32,
|
||||
buf: *mut c_void,
|
||||
buf_length: u32,
|
||||
) -> i32;
|
||||
pub fn sceNetResolverDelete(rid: i32) -> i32;
|
||||
pub fn sceNetResolverStartNtoA(
|
||||
rid: i32,
|
||||
hostname: *const u8,
|
||||
addr: *mut in_addr,
|
||||
timeout: u32,
|
||||
retry: i32,
|
||||
) -> i32;
|
||||
pub fn sceNetResolverStartAtoN(
|
||||
rid: i32,
|
||||
addr: *const in_addr,
|
||||
hostname: *mut u8,
|
||||
hostname_len: u32,
|
||||
timeout: u32,
|
||||
retry: i32,
|
||||
) -> i32;
|
||||
pub fn sceNetResolverStop(rid: i32) -> i32;
|
||||
pub fn sceNetResolverTerm() -> i32;
|
||||
}
|
|
@ -0,0 +1,9 @@
|
|||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct OpenPSID {
|
||||
pub data: [u8; 16usize],
|
||||
}
|
||||
|
||||
extern {
|
||||
pub fn sceOpenPSIDGetOpenPSID(openpsid: *mut OpenPSID) -> i32;
|
||||
}
|
|
@ -0,0 +1,54 @@
|
|||
use super::SceUid;
|
||||
|
||||
pub const POWER_INFO_POWER_SWITCH: i32 = 0x80000000;
|
||||
pub const POWER_INFO_HOLD_SWITCH: i32 = 0x40000000;
|
||||
pub const POWER_INFO_STANDBY: i32 = 0x00080000;
|
||||
pub const POWER_INFO_RESUME_COMPLETE: i32 = 0x00040000;
|
||||
pub const POWER_INFO_RESUMING: i32 = 0x00020000;
|
||||
pub const POWER_INFO_SUSPENDING: i32 = 0x00010000;
|
||||
pub const POWER_INFO_AC_POWER: i32 = 0x00001000;
|
||||
pub const POWER_INFO_BATTERY_LOW: i32 = 0x00000100;
|
||||
pub const POWER_INFO_BATTERY_EXIST: i32 = 0x00000080;
|
||||
pub const POWER_INFO_BATTERY_POWER: i32 = 0x0000007;
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(u32)]
|
||||
pub enum PowerTick {
|
||||
All = 0,
|
||||
Suspend = 1,
|
||||
Display = 6,
|
||||
}
|
||||
|
||||
pub type PowerCallback = extern fn (unknown: i32, power_info: i32);
|
||||
|
||||
extern {
|
||||
pub fn scePowerRegisterCallback(slot: i32, cbid: SceUid) -> i32;
|
||||
pub fn scePowerUnregisterCallback(slot: i32) -> i32;
|
||||
pub fn scePowerIsPowerOnline() -> i32;
|
||||
pub fn scePowerIsBatteryExist() -> i32;
|
||||
pub fn scePowerIsBatteryCharging() -> i32;
|
||||
pub fn scePowerGetBatteryChargingStatus() -> i32;
|
||||
pub fn scePowerIsLowBattery() -> i32;
|
||||
pub fn scePowerGetBatteryLifePercent() -> i32;
|
||||
pub fn scePowerGetBatteryLifeTime() -> i32;
|
||||
pub fn scePowerGetBatteryTemp() -> i32;
|
||||
pub fn scePowerGetBatteryElec() -> i32;
|
||||
pub fn scePowerGetBatteryVolt() -> i32;
|
||||
pub fn scePowerSetCpuClockFrequency(cpufreq: i32) -> i32;
|
||||
pub fn scePowerSetBusClockFrequency(busfreq: i32) -> i32;
|
||||
pub fn scePowerGetCpuClockFrequency() -> i32;
|
||||
pub fn scePowerGetCpuClockFrequencyInt() -> i32;
|
||||
pub fn scePowerGetCpuClockFrequencyFloat() -> f32;
|
||||
pub fn scePowerGetBusClockFrequency() -> i32;
|
||||
pub fn scePowerGetBusClockFrequencyInt() -> i32;
|
||||
pub fn scePowerGetBusClockFrequencyFloat() -> f32;
|
||||
pub fn scePowerSetClockFrequency(pllfreq: i32, cpufreq: i32, busfreq: i32) -> i32;
|
||||
pub fn scePowerLock(unknown: i32) -> i32;
|
||||
pub fn scePowerUnlock(unknown: i32) -> i32;
|
||||
pub fn scePowerTick(t: PowerTick) -> i32;
|
||||
pub fn scePowerGetIdleTimer() -> i32;
|
||||
pub fn scePowerIdleTimerEnable(unknown: i32) -> i32;
|
||||
pub fn scePowerIdleTimerDisable(unknown: i32) -> i32;
|
||||
pub fn scePowerRequestStandby() -> i32;
|
||||
pub fn scePowerRequestSuspend() -> i32;
|
||||
}
|
|
@ -0,0 +1,96 @@
|
|||
use super::c_void;
|
||||
|
||||
pub const SYSTEM_REGISTRY: [u8; 7] = *b"/system";
|
||||
pub const REG_KEYNAME_SIZE: u32 = 27;
|
||||
|
||||
#[repr(transparent)]
|
||||
#[allow(missing_copy_implementations)]
|
||||
pub struct Handle(u32);
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct Key {
|
||||
pub key_type: KeyType,
|
||||
pub name: [u8; 256usize],
|
||||
pub name_len: u32,
|
||||
pub unk2: u32,
|
||||
pub unk3: u32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub enum KeyType {
|
||||
Directory = 1,
|
||||
Integer = 2,
|
||||
String = 3,
|
||||
Bytes = 4,
|
||||
}
|
||||
|
||||
extern {
|
||||
pub fn sceRegOpenRegistry(
|
||||
reg: *mut Key,
|
||||
mode: i32,
|
||||
handle: *mut Handle,
|
||||
) -> i32;
|
||||
pub fn sceRegFlushRegistry(handle: Handle) -> i32;
|
||||
pub fn sceRegCloseRegistry(handle: Handle) -> i32;
|
||||
pub fn sceRegOpenCategory(
|
||||
handle: Handle,
|
||||
name: *const u8,
|
||||
mode: i32,
|
||||
dir_handle: *mut Handle,
|
||||
) -> i32;
|
||||
pub fn sceRegRemoveCategory(
|
||||
handle: Handle,
|
||||
name: *const u8,
|
||||
) -> i32;
|
||||
pub fn sceRegCloseCategory(dir_handle: Handle) -> i32;
|
||||
pub fn sceRegFlushCategory(dir_handle: Handle) -> i32;
|
||||
pub fn sceRegGetKeyInfo(
|
||||
dir_handle: Handle,
|
||||
name: *const u8,
|
||||
key_handle: *mut Handle,
|
||||
type_: *mut KeyType,
|
||||
size: *mut usize,
|
||||
) -> i32;
|
||||
pub fn sceRegGetKeyInfoByName(
|
||||
dir_handle: Handle,
|
||||
name: *const u8,
|
||||
type_: *mut KeyType,
|
||||
size: *mut usize,
|
||||
) -> i32;
|
||||
pub fn sceRegGetKeyValue(
|
||||
dir_handle: Handle,
|
||||
key_handle: Handle,
|
||||
buf: *mut c_void,
|
||||
size: usize,
|
||||
) -> i32;
|
||||
pub fn sceRegGetKeyValueByName(
|
||||
dir_handle: Handle,
|
||||
name: *const u8,
|
||||
buf: *mut c_void,
|
||||
size: usize,
|
||||
) -> i32;
|
||||
pub fn sceRegSetKeyValue(
|
||||
dir_handle: Handle,
|
||||
name: *const u8,
|
||||
buf: *const c_void,
|
||||
size: usize,
|
||||
) -> i32;
|
||||
pub fn sceRegGetKeysNum(
|
||||
dir_handle: Handle,
|
||||
num: *mut i32,
|
||||
) -> i32;
|
||||
pub fn sceRegGetKeys(
|
||||
dir_handle: Handle,
|
||||
buf: *mut u8,
|
||||
num: i32,
|
||||
) -> i32;
|
||||
pub fn sceRegCreateKey(
|
||||
dir_handle: Handle,
|
||||
name: *const u8,
|
||||
type_: i32,
|
||||
size: usize,
|
||||
) -> i32;
|
||||
pub fn sceRegRemoveRegistry(key: *mut Key) -> i32;
|
||||
}
|
|
@ -0,0 +1,60 @@
|
|||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct ScePspDateTime {
|
||||
pub year: u16,
|
||||
pub month: u16,
|
||||
pub day: u16,
|
||||
pub hour: u16,
|
||||
pub minutes: u16,
|
||||
pub seconds: u16,
|
||||
pub microseconds: u32,
|
||||
}
|
||||
|
||||
#[repr(i32)]
|
||||
#[derive(Eq, PartialEq, Copy, Clone)]
|
||||
pub enum RtcCheckValidError {
|
||||
InvalidYear = -1,
|
||||
InvalidMonth = -2,
|
||||
InvalidDay = -3,
|
||||
InvalidHour = -4,
|
||||
InvalidMinutes = -5,
|
||||
InvalidSeconds = -6,
|
||||
InvalidMicroseconds = -7,
|
||||
}
|
||||
|
||||
extern {
|
||||
pub fn sceRtcGetTickResolution() -> u32;
|
||||
pub fn sceRtcGetCurrentTick(tick: *mut u64) -> i32;
|
||||
pub fn sceRtcGetCurrentClock(tm: *mut ScePspDateTime, tz: i32) -> i32;
|
||||
pub fn sceRtcGetCurrentClockLocalTime(tm: *mut ScePspDateTime) -> i32;
|
||||
pub fn sceRtcConvertUtcToLocalTime(tick_utc: *const u64, tick_local: *mut u64) -> i32;
|
||||
pub fn sceRtcConvertLocalTimeToUTC(tick_local: *const u64, tick_utc: *mut u64) -> i32;
|
||||
pub fn sceRtcIsLeapYear(year: i32) -> i32;
|
||||
pub fn sceRtcGetDaysInMonth(year: i32, month: i32) -> i32;
|
||||
pub fn sceRtcGetDayOfWeek(year: i32, month: i32, day: i32) -> i32;
|
||||
pub fn sceRtcCheckValid(date: *const ScePspDateTime) -> i32;
|
||||
pub fn sceRtcSetTick(date: *mut ScePspDateTime, tick: *const u64) -> i32;
|
||||
pub fn sceRtcGetTick(date: *const ScePspDateTime, tick: *mut u64) -> i32;
|
||||
pub fn sceRtcCompareTick(tick1: *const u64, tick2: *const u64) -> i32;
|
||||
pub fn sceRtcTickAddTicks(dest_tick: *mut u64, src_tick: *const u64, num_ticks: u64) -> i32;
|
||||
pub fn sceRtcTickAddMicroseconds(dest_tick: *mut u64, src_tick: *const u64, num_ms: u64) -> i32;
|
||||
pub fn sceRtcTickAddSeconds(dest_tick: *mut u64, src_tick: *const u64, num_seconds: u64) -> i32;
|
||||
pub fn sceRtcTickAddMinutes(dest_tick: *mut u64, src_tick: *const u64, num_minutes: u64) -> i32;
|
||||
pub fn sceRtcTickAddHours(dest_tick: *mut u64, src_tick: *const u64, num_hours: u64) -> i32;
|
||||
pub fn sceRtcTickAddDays(dest_tick: *mut u64, src_tick: *const u64, num_days: u64) -> i32;
|
||||
pub fn sceRtcTickAddWeeks(dest_tick: *mut u64, src_tick: *const u64, num_weeks: u64) -> i32;
|
||||
pub fn sceRtcTickAddMonths(dest_tick: *mut u64, src_tick: *const u64, num_months: u64) -> i32;
|
||||
pub fn sceRtcTickAddYears(dest_tick: *mut u64, src_tick: *const u64, num_years: u64) -> i32;
|
||||
pub fn sceRtcSetTime_t(date: *mut ScePspDateTime, time: i64) -> i32;
|
||||
pub fn sceRtcGetTime_t(date: *const ScePspDateTime, time: *mut i64) -> i32;
|
||||
pub fn sceRtcSetDosTime(date: *mut ScePspDateTime, dos_time: u32) -> i32;
|
||||
pub fn sceRtcGetDosTime(date: *mut ScePspDateTime, dos_time: u32) -> i32;
|
||||
pub fn sceRtcSetWin32FileTime(date: *mut ScePspDateTime, time: *mut u64) -> i32;
|
||||
pub fn sceRtcGetWin32FileTime(date: *mut ScePspDateTime, time: *mut u64) -> i32;
|
||||
pub fn sceRtcParseDateTime(dest_tick: *mut u64, date_string: *const u8) -> i32;
|
||||
pub fn sceRtcFormatRFC3339(psz_date_time: *mut char, p_utc: *const u64, time_zone_minutes: i32) -> i32;
|
||||
pub fn sceRtcFormatRFC3339LocalTime(psz_date_time: *mut char, p_utc: *const u64) -> i32;
|
||||
pub fn sceRtcParseRFC3339(p_utc: *mut u64, psz_date_time: *const u8) -> i32;
|
||||
pub fn sceRtcFormatRFC2822(psz_date_time: *mut char, p_utc: *const u64, time_zone_minutes: i32) -> i32;
|
||||
pub fn sceRtcFormatRFC2822LocalTime(psz_date_time: *mut char, p_utc: *const u64) -> i32;
|
||||
}
|
|
@ -0,0 +1,13 @@
|
|||
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SircsData {
|
||||
pub type_: u8,
|
||||
pub cmd: u8,
|
||||
pub dev: u16,
|
||||
}
|
||||
|
||||
extern {
|
||||
pub fn sceSircsSend(sd: *mut SircsData, count: i32) -> i32;
|
||||
}
|
|
@ -0,0 +1,269 @@
|
|||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct ScePspSRect {
|
||||
pub x: i16,
|
||||
pub y: i16,
|
||||
pub w: i16,
|
||||
pub h: i16,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct ScePspIRect {
|
||||
pub x: i32,
|
||||
pub y: i32,
|
||||
pub w: i32,
|
||||
pub h: i32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct ScePspL64Rect {
|
||||
pub x: u64,
|
||||
pub y: u64,
|
||||
pub w: u64,
|
||||
pub h: u64,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct ScePspFRect {
|
||||
pub x: f32,
|
||||
pub y: f32,
|
||||
pub w: f32,
|
||||
pub h: f32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct ScePspSVector2 {
|
||||
pub x: i16,
|
||||
pub y: i16,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct ScePspIVector2 {
|
||||
pub x: i32,
|
||||
pub y: i32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct ScePspL64Vector2 {
|
||||
pub x: u64,
|
||||
pub y: u64,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct ScePspFVector2 {
|
||||
pub x: f32,
|
||||
pub y: f32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub union ScePspVector2 {
|
||||
pub fv: ScePspFVector2,
|
||||
pub iv: ScePspIVector2,
|
||||
pub f: [f32; 2usize],
|
||||
pub i: [i32; 2usize],
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct ScePspSVector3 {
|
||||
pub x: i16,
|
||||
pub y: i16,
|
||||
pub z: i16,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct ScePspIVector3 {
|
||||
pub x: i32,
|
||||
pub y: i32,
|
||||
pub z: i32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct ScePspL64Vector3 {
|
||||
pub x: u64,
|
||||
pub y: u64,
|
||||
pub z: u64,
|
||||
}
|
||||
#[repr(C, align(16))]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct ScePspFVector3 {
|
||||
pub x: f32,
|
||||
pub y: f32,
|
||||
pub z: f32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub union ScePspVector3 {
|
||||
pub fv: ScePspFVector3,
|
||||
pub iv: ScePspIVector3,
|
||||
pub f: [f32; 3usize],
|
||||
pub i: [i32; 3usize],
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct ScePspSVector4 {
|
||||
pub x: i16,
|
||||
pub y: i16,
|
||||
pub z: i16,
|
||||
pub w: i16,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct ScePspIVector4 {
|
||||
pub x: i32,
|
||||
pub y: i32,
|
||||
pub z: i32,
|
||||
pub w: i32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct ScePspL64Vector4 {
|
||||
pub x: u64,
|
||||
pub y: u64,
|
||||
pub z: u64,
|
||||
pub w: u64,
|
||||
}
|
||||
|
||||
#[repr(C, align(16))]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct ScePspFVector4 {
|
||||
pub x: f32,
|
||||
pub y: f32,
|
||||
pub z: f32,
|
||||
pub w: f32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct ScePspFVector4Unaligned {
|
||||
pub x: f32,
|
||||
pub y: f32,
|
||||
pub z: f32,
|
||||
pub w: f32,
|
||||
}
|
||||
|
||||
#[repr(C, align(16))]
|
||||
#[derive(Copy, Clone)]
|
||||
pub union ScePspVector4 {
|
||||
pub fv: ScePspFVector4,
|
||||
pub iv: ScePspIVector4,
|
||||
pub qw: u128,
|
||||
pub f: [f32; 4usize],
|
||||
pub i: [i32; 4usize],
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct ScePspIMatrix2 {
|
||||
pub x: ScePspIVector2,
|
||||
pub y: ScePspIVector2,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct ScePspFMatrix2 {
|
||||
pub x: ScePspFVector2,
|
||||
pub y: ScePspFVector2,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub union ScePspMatrix2 {
|
||||
pub fm: ScePspFMatrix2,
|
||||
pub im: ScePspIMatrix2,
|
||||
pub fv: [ScePspFVector2; 2usize],
|
||||
pub iv: [ScePspIVector2; 2usize],
|
||||
pub v: [ScePspVector2; 2usize],
|
||||
pub f: [[f32; 2usize]; 2usize],
|
||||
pub i: [[i32; 2usize]; 2usize],
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct ScePspIMatrix3 {
|
||||
pub x: ScePspIVector3,
|
||||
pub y: ScePspIVector3,
|
||||
pub z: ScePspIVector3,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct ScePspFMatrix3 {
|
||||
pub x: ScePspFVector3,
|
||||
pub y: ScePspFVector3,
|
||||
pub z: ScePspFVector3,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub union ScePspMatrix3 {
|
||||
pub fm: ScePspFMatrix3,
|
||||
pub im: ScePspIMatrix3,
|
||||
pub fv: [ScePspFVector3; 3usize],
|
||||
pub iv: [ScePspIVector3; 3usize],
|
||||
pub v: [ScePspVector3; 3usize],
|
||||
pub f: [[f32; 3usize]; 3usize],
|
||||
pub i: [[i32; 3usize]; 3usize],
|
||||
}
|
||||
|
||||
#[repr(C, align(16))]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct ScePspIMatrix4 {
|
||||
pub x: ScePspIVector4,
|
||||
pub y: ScePspIVector4,
|
||||
pub z: ScePspIVector4,
|
||||
pub w: ScePspIVector4,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct ScePspIMatrix4Unaligned {
|
||||
pub x: ScePspIVector4,
|
||||
pub y: ScePspIVector4,
|
||||
pub z: ScePspIVector4,
|
||||
pub w: ScePspIVector4,
|
||||
}
|
||||
|
||||
#[repr(C, align(16))]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct ScePspFMatrix4 {
|
||||
pub x: ScePspFVector4,
|
||||
pub y: ScePspFVector4,
|
||||
pub z: ScePspFVector4,
|
||||
pub w: ScePspFVector4,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct ScePspFMatrix4Unaligned {
|
||||
pub x: ScePspFVector4,
|
||||
pub y: ScePspFVector4,
|
||||
pub z: ScePspFVector4,
|
||||
pub w: ScePspFVector4,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub union ScePspMatrix4 {
|
||||
pub fm: ScePspFMatrix4,
|
||||
pub im: ScePspIMatrix4,
|
||||
pub fv: [ScePspFVector4; 4usize],
|
||||
pub iv: [ScePspIVector4; 4usize],
|
||||
pub v: [ScePspVector4; 4usize],
|
||||
pub f: [[f32; 4usize]; 4usize],
|
||||
pub i: [[i32; 4usize]; 4usize],
|
||||
}
|
|
@ -0,0 +1,46 @@
|
|||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct UmdInfo {
|
||||
pub size: u32,
|
||||
pub type_: UmdType,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub enum UmdType {
|
||||
Game = 0x10,
|
||||
Video = 0x20,
|
||||
Audio = 0x40,
|
||||
}
|
||||
|
||||
pub const UMD_NOT_PRESENT: i32 = 0x01;
|
||||
pub const UMD_PRESENT: i32 = 0x02;
|
||||
pub const UMD_CHANGED: i32 = 0x04;
|
||||
pub const UMD_INITING: i32 = 0x08;
|
||||
pub const UMD_INITED: i32 = 0x10;
|
||||
pub const UMD_READY: i32 = 0x20;
|
||||
|
||||
pub type UmdCallback = fn(unknown: i32, event: i32) -> i32;
|
||||
|
||||
extern {
|
||||
pub fn sceUmdCheckMedium() -> i32;
|
||||
pub fn sceUmdGetDiscInfo(info: *mut UmdInfo) -> i32;
|
||||
pub fn sceUmdActivate(unit: i32, drive: *const u8) -> i32;
|
||||
pub fn sceUmdDeactivate(unit: i32, drive: *const u8) -> i32;
|
||||
pub fn sceUmdWaitDriveStat(state: i32) -> i32;
|
||||
pub fn sceUmdWaitDriveStatWithTimer(
|
||||
state: i32,
|
||||
timeout: u32,
|
||||
) -> i32;
|
||||
pub fn sceUmdWaitDriveStatCB(
|
||||
state: i32,
|
||||
timeout: u32,
|
||||
) -> i32;
|
||||
pub fn sceUmdCancelWaitDriveStat() -> i32;
|
||||
pub fn sceUmdGetDriveStat() -> i32;
|
||||
pub fn sceUmdGetErrorStat() -> i32;
|
||||
pub fn sceUmdRegisterUMDCallBack(cbid: i32) -> i32;
|
||||
pub fn sceUmdUnRegisterUMDCallBack(cbid: i32) -> i32;
|
||||
pub fn sceUmdReplacePermit() -> i32;
|
||||
pub fn sceUmdReplaceProhibit() -> i32;
|
||||
}
|
|
@ -0,0 +1,254 @@
|
|||
use super::c_void;
|
||||
use super::SceUid;
|
||||
|
||||
pub const USB_CAM_PID: i32 = 0x282;
|
||||
pub const USB_BUS_DRIVER_NAME: &str = "USBBusDriver";
|
||||
pub const USB_CAM_DRIVER_NAME: &str = "USBCamDriver";
|
||||
pub const USB_CAM_MIC_DRIVER_NAME: &str = "USBCamMicDriver";
|
||||
pub const USB_STOR_DRIVER_NAME: &str = "USBStor_Driver";
|
||||
|
||||
pub const ACTIVATED: i32 = 0x200;
|
||||
pub const CONNECTED: i32 = 0x020;
|
||||
pub const ESTABLISHED: i32 = 0x002;
|
||||
|
||||
extern {
|
||||
pub fn sceUsbStart(
|
||||
driver_name: *const u8,
|
||||
size: i32,
|
||||
args: *mut c_void,
|
||||
) -> i32;
|
||||
pub fn sceUsbStop(
|
||||
driver_name: *const u8,
|
||||
size: i32,
|
||||
args: *mut c_void,
|
||||
) -> i32;
|
||||
pub fn sceUsbActivate(pid: u32) -> i32;
|
||||
pub fn sceUsbDeactivate(pid: u32) -> i32;
|
||||
pub fn sceUsbGetState() -> i32;
|
||||
pub fn sceUsbGetDrvState(driver_name: *const u8) -> i32;
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct UsbCamSetupStillParam {
|
||||
pub size: i32,
|
||||
pub resolution: UsbCamResolution,
|
||||
pub jpeg_size: i32,
|
||||
pub reverse_flags: i32,
|
||||
pub delay: UsbCamDelay,
|
||||
pub comp_level: i32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct UsbCamSetupStillExParam {
|
||||
pub size: i32,
|
||||
pub unk: u32,
|
||||
pub resolution: UsbCamResolutionEx,
|
||||
pub jpeg_size: i32,
|
||||
pub comp_level: i32,
|
||||
pub unk2: u32,
|
||||
pub unk3: u32,
|
||||
pub flip: i32,
|
||||
pub mirror: i32,
|
||||
pub delay: UsbCamDelay,
|
||||
pub unk4: [u32; 5usize],
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct UsbCamSetupVideoParam {
|
||||
pub size: i32,
|
||||
pub resolution: UsbCamResolution,
|
||||
pub framerate: UsbCamFrameRate,
|
||||
pub white_balance: UsbCamWb,
|
||||
pub saturation: i32,
|
||||
pub brightness: i32,
|
||||
pub contrast: i32,
|
||||
pub sharpness: i32,
|
||||
pub effect_mode: UsbCamEffectMode,
|
||||
pub frame_size: i32,
|
||||
pub unk: u32,
|
||||
pub evl_evel: UsbCamEvLevel,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct UsbCamSetupVideoExParam {
|
||||
pub size: i32,
|
||||
pub unk: u32,
|
||||
pub resolution: UsbCamResolutionEx,
|
||||
pub framerate: UsbCamFrameRate,
|
||||
pub unk2: u32,
|
||||
pub unk3: u32,
|
||||
pub white_balance: UsbCamWb,
|
||||
pub saturation: i32,
|
||||
pub brightness: i32,
|
||||
pub contrast: i32,
|
||||
pub sharpness: i32,
|
||||
pub unk4: u32,
|
||||
pub unk5: u32,
|
||||
pub unk6: [u32; 3usize],
|
||||
pub effect_mode: UsbCamEffectMode,
|
||||
pub unk7: u32,
|
||||
pub unk8: u32,
|
||||
pub unk9: u32,
|
||||
pub unk10: u32,
|
||||
pub unk11: u32,
|
||||
pub frame_size: i32,
|
||||
pub unk12: u32,
|
||||
pub ev_level: UsbCamEvLevel,
|
||||
}
|
||||
|
||||
#[repr(i32)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub enum UsbCamResolution {
|
||||
Px160_120 = 0,
|
||||
Px176_144 = 1,
|
||||
Px320_240 = 2,
|
||||
Px352_288 = 3,
|
||||
Px640_480 = 4,
|
||||
Px1024_768 = 5,
|
||||
Px1280_960 = 6,
|
||||
Px480_272 = 7,
|
||||
Px360_272 = 8,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(i32)]
|
||||
pub enum UsbCamResolutionEx {
|
||||
Px160_120 = 0,
|
||||
Px176_144 = 1,
|
||||
Px320_240 = 2,
|
||||
Px352_288 = 3,
|
||||
Px360_272 = 4,
|
||||
Px480_272 = 5,
|
||||
Px640_480 = 6,
|
||||
Px1024_768 = 7,
|
||||
Px1280_960 = 8,
|
||||
}
|
||||
|
||||
pub const USB_CAM_FLIP: i32 = 1;
|
||||
pub const USB_CAM_MIRROR: i32 = 0x100;
|
||||
|
||||
#[repr(i32)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub enum UsbCamDelay {
|
||||
NoDelay = 0,
|
||||
Delay10Sec = 1,
|
||||
Delay20Sec = 2,
|
||||
Delay30Sec = 3,
|
||||
}
|
||||
|
||||
#[repr(i32)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub enum UsbCamFrameRate {
|
||||
Fps3_75 = 0,
|
||||
Fps5 = 1,
|
||||
Fps7_5 = 2,
|
||||
Fps10 = 3,
|
||||
Fps15 = 4,
|
||||
Fps20 = 5,
|
||||
Fps30 = 6,
|
||||
Fps60 = 7,
|
||||
}
|
||||
|
||||
#[repr(i32)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub enum UsbCamWb {
|
||||
Auto = 0,
|
||||
Daylight = 1,
|
||||
Fluorescent = 2,
|
||||
Incadescent = 3,
|
||||
}
|
||||
|
||||
#[repr(i32)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub enum UsbCamEffectMode {
|
||||
Normal = 0,
|
||||
Negative = 1,
|
||||
Blackwhite = 2,
|
||||
Sepia = 3,
|
||||
Blue = 4,
|
||||
Red = 5,
|
||||
Green = 6,
|
||||
}
|
||||
|
||||
#[repr(i32)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub enum UsbCamEvLevel {
|
||||
Pos2_0 = 0,
|
||||
Pos1_7 = 1,
|
||||
Pos1_5 = 2,
|
||||
Pos1_3 = 3,
|
||||
Pos1_0 = 4,
|
||||
Pos0_7 = 5,
|
||||
Pos0_5 = 6,
|
||||
Pos0_3 = 7,
|
||||
Zero = 8,
|
||||
Neg0_3,
|
||||
Neg0_5,
|
||||
Neg0_7,
|
||||
Neg1_0,
|
||||
Neg1_3,
|
||||
Neg1_5,
|
||||
Neg1_7,
|
||||
Neg2_0,
|
||||
}
|
||||
|
||||
extern {
|
||||
pub fn sceUsbCamSetupStill(param: *mut UsbCamSetupStillParam) -> i32;
|
||||
pub fn sceUsbCamSetupStillEx(param: *mut UsbCamSetupStillExParam) -> i32;
|
||||
pub fn sceUsbCamStillInputBlocking(buf: *mut u8, size: usize) -> i32;
|
||||
pub fn sceUsbCamStillInput(buf: *mut u8, size: usize) -> i32;
|
||||
pub fn sceUsbCamStillWaitInputEnd() -> i32;
|
||||
pub fn sceUsbCamStillPollInputEnd() -> i32;
|
||||
pub fn sceUsbCamStillCancelInput() -> i32;
|
||||
pub fn sceUsbCamStillGetInputLength() -> i32;
|
||||
pub fn sceUsbCamSetupVideo(
|
||||
param: *mut UsbCamSetupVideoParam,
|
||||
work_area: *mut c_void,
|
||||
work_area_size: i32,
|
||||
) -> i32;
|
||||
pub fn sceUsbCamSetupVideoEx(
|
||||
param: *mut UsbCamSetupVideoExParam,
|
||||
work_area: *mut c_void,
|
||||
work_area_size: i32,
|
||||
) -> i32;
|
||||
pub fn sceUsbCamStartVideo() -> i32;
|
||||
pub fn sceUsbCamStopVideo() -> i32;
|
||||
pub fn sceUsbCamReadVideoFrameBlocking(buf: *mut u8, size: usize) -> i32;
|
||||
pub fn sceUsbCamReadVideoFrame(buf: *mut u8, size: usize) -> i32;
|
||||
pub fn sceUsbCamWaitReadVideoFrameEnd() -> i32;
|
||||
pub fn sceUsbCamPollReadVideoFrameEnd() -> i32;
|
||||
pub fn sceUsbCamGetReadVideoFrameSize() -> i32;
|
||||
pub fn sceUsbCamSetSaturation(saturation: i32) -> i32;
|
||||
pub fn sceUsbCamSetBrightness(brightness: i32) -> i32;
|
||||
pub fn sceUsbCamSetContrast(contrast: i32) -> i32;
|
||||
pub fn sceUsbCamSetSharpness(sharpness: i32) -> i32;
|
||||
pub fn sceUsbCamSetImageEffectMode(effect_mode: UsbCamEffectMode) -> i32;
|
||||
pub fn sceUsbCamSetEvLevel(exposure_level: UsbCamEvLevel) -> i32;
|
||||
pub fn sceUsbCamSetReverseMode(reverse_flags: i32) -> i32;
|
||||
pub fn sceUsbCamSetZoom(zoom: i32) -> i32;
|
||||
pub fn sceUsbCamGetSaturation(saturation: *mut i32) -> i32;
|
||||
pub fn sceUsbCamGetBrightness(brightness: *mut i32) -> i32;
|
||||
pub fn sceUsbCamGetContrast(contrast: *mut i32) -> i32;
|
||||
pub fn sceUsbCamGetSharpness(sharpness: *mut i32) -> i32;
|
||||
pub fn sceUsbCamGetImageEffectMode(
|
||||
effect_mode: *mut UsbCamEffectMode,
|
||||
) -> i32;
|
||||
pub fn sceUsbCamGetEvLevel(exposure_level: *mut UsbCamEvLevel) -> i32;
|
||||
pub fn sceUsbCamGetReverseMode(
|
||||
reverse_flags: *mut i32,
|
||||
) -> i32;
|
||||
pub fn sceUsbCamGetZoom(zoom: *mut i32) -> i32;
|
||||
pub fn sceUsbCamAutoImageReverseSW(on: i32) -> i32;
|
||||
pub fn sceUsbCamGetAutoImageReverseState() -> i32;
|
||||
pub fn sceUsbCamGetLensDirection() -> i32;
|
||||
}
|
||||
|
||||
extern {
|
||||
pub fn sceUsbstorBootRegisterNotify(event_flag: SceUid) -> i32;
|
||||
pub fn sceUsbstorBootUnregisterNotify(event_flag: u32) -> i32;
|
||||
pub fn sceUsbstorBootSetCapacity(size: u32) -> i32;
|
||||
}
|
|
@ -0,0 +1,608 @@
|
|||
use super::c_void;
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct UtilityDialogCommon {
|
||||
pub size: u32,
|
||||
pub language: SystemParamLanguage,
|
||||
pub button_accept: UtilityDialogButtonAccept,
|
||||
pub graphics_thread: i32,
|
||||
pub access_thread: i32,
|
||||
pub font_thread: i32,
|
||||
pub sound_thread: i32,
|
||||
pub result: i32,
|
||||
pub reserved: [i32; 4usize],
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum UtilityMsgDialogMode {
|
||||
Error,
|
||||
Text,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum UtilityMsgDialogPressed {
|
||||
Unknown1,
|
||||
Yes,
|
||||
No,
|
||||
Back,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum UtilityDialogButtonAccept {
|
||||
Circle,
|
||||
Cross,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum SceUtilityOskInputLanguage {
|
||||
Default,
|
||||
Japanese,
|
||||
English,
|
||||
French,
|
||||
Spanish,
|
||||
German,
|
||||
Italian,
|
||||
Dutch,
|
||||
Portugese,
|
||||
Russian,
|
||||
Korean,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum SceUtilityOskInputType {
|
||||
All,
|
||||
LatinDigit,
|
||||
LatinSymbol,
|
||||
LatinLowercase = 4,
|
||||
LatinUppercase = 8,
|
||||
JapaneseDigit = 0x100,
|
||||
JapaneseSymbol = 0x200,
|
||||
JapaneseLowercase = 0x400,
|
||||
JapaneseUppercase = 0x800,
|
||||
JapaneseHiragana = 0x1000,
|
||||
JapaneseHalfWidthKatakana = 0x2000,
|
||||
JapaneseKatakana = 0x4000,
|
||||
JapaneseKanji = 0x8000,
|
||||
RussianLowercase = 0x10000,
|
||||
RussianUppercase = 0x20000,
|
||||
Korean = 0x40000,
|
||||
Url = 0x80000,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum SceUtilityOskState {
|
||||
None,
|
||||
Initializing,
|
||||
Initialized,
|
||||
Visible,
|
||||
Quit,
|
||||
Finished,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum SceUtilityOskResult {
|
||||
Unchanged,
|
||||
Cancelled,
|
||||
Changed,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum SystemParamLanguage {
|
||||
Japanese,
|
||||
English,
|
||||
French,
|
||||
Spanish,
|
||||
German,
|
||||
Italian,
|
||||
Dutch,
|
||||
Portugese,
|
||||
Russian,
|
||||
Korean,
|
||||
ChineseTraditional,
|
||||
ChineseSimplified,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum SystemParamId {
|
||||
StringNickname = 1,
|
||||
AdhocChannel,
|
||||
WlanPowerSave,
|
||||
DateFormat,
|
||||
TimeFormat,
|
||||
Timezone,
|
||||
DaylightSavings,
|
||||
Language,
|
||||
Unknown,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum SystemParamAdhocChannel {
|
||||
ChannelAutomatic = 0,
|
||||
Channel1 = 1,
|
||||
Channel6 = 6,
|
||||
Channel11 = 11,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum SystemParamWlanPowerSaveState {
|
||||
Off,
|
||||
On,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum SystemParamDateFormat {
|
||||
YYYYMMDD,
|
||||
MMDDYYYY,
|
||||
DDMMYYYY,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum SystemParamTimeFormat {
|
||||
Hour24,
|
||||
Hour12,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum SystemParamDaylightSavings {
|
||||
Std,
|
||||
Dst,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum AvModule {
|
||||
AvCodec,
|
||||
SasCore,
|
||||
Atrac3Plus,
|
||||
MpegBase,
|
||||
Mp3,
|
||||
Vaudio,
|
||||
Aac,
|
||||
G729,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum Module {
|
||||
NetCommon = 0x100,
|
||||
NetAdhoc,
|
||||
NetInet,
|
||||
NetParseUri,
|
||||
NetHttp,
|
||||
NetSsl,
|
||||
|
||||
UsbPspCm = 0x200,
|
||||
UsbMic,
|
||||
UsbCam,
|
||||
UsbGps,
|
||||
|
||||
AvCodec = 0x300,
|
||||
AvSascore,
|
||||
AvAtrac3Plus,
|
||||
AvMpegBase,
|
||||
AvMp3,
|
||||
AvVaudio,
|
||||
AvAac,
|
||||
AvG729,
|
||||
|
||||
NpCommon = 0x400,
|
||||
NpService,
|
||||
NpMatching2,
|
||||
NpDrm = 0x500,
|
||||
|
||||
Irda = 0x600,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum NetModule {
|
||||
NetCommon = 1,
|
||||
NetAdhoc,
|
||||
NetInet,
|
||||
NetParseUri,
|
||||
NetHttp,
|
||||
NetSsl,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum UsbModule {
|
||||
UsbPspCm = 1,
|
||||
UsbAcc,
|
||||
UsbMic,
|
||||
UsbCam,
|
||||
UsbGps,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum NetParam {
|
||||
Name,
|
||||
Ssid,
|
||||
Secure,
|
||||
WepKey,
|
||||
IsStaticIp,
|
||||
Ip,
|
||||
NetMask,
|
||||
Route,
|
||||
ManualDns,
|
||||
PrimaryDns,
|
||||
SecondaryDns,
|
||||
ProxyUser,
|
||||
ProxyPass,
|
||||
UseProxy,
|
||||
ProxyServer,
|
||||
ProxyPort,
|
||||
Unknown1,
|
||||
Unknown2,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
pub enum UtilityNetconfAction {
|
||||
ConnectAP,
|
||||
DisplayStatus,
|
||||
ConnectAdhoc,
|
||||
}
|
||||
|
||||
pub const UTILITY_MSGDIALOG_ERROR: i32 = 0;
|
||||
pub const UTILITY_MSGDIALOG_TEXT: i32 = 1;
|
||||
pub const UTILITY_MSGDIALOG_YES_NO_BUTTONS: i32 = 0x10;
|
||||
pub const UTILITY_MSGDIALOG_DEFAULT_NO: i32 = 0x100;
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct UtilityMsgDialogParams {
|
||||
pub base: UtilityDialogCommon,
|
||||
pub unknown: i32,
|
||||
pub mode: UtilityMsgDialogMode,
|
||||
pub error_value: u32,
|
||||
pub message: [u8; 512usize],
|
||||
pub options: i32,
|
||||
pub button_pressed: UtilityMsgDialogPressed,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct UtilityNetconfAdhoc {
|
||||
pub name: [u8; 8usize],
|
||||
pub timeout: u32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct UtilityNetconfData {
|
||||
pub base: UtilityDialogCommon,
|
||||
pub action: UtilityNetconfAction,
|
||||
pub adhocparam: *mut UtilityNetconfAdhoc,
|
||||
pub hotspot: i32,
|
||||
pub hotspot_connected: i32,
|
||||
pub wifisp: i32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub union UtilityNetData {
|
||||
pub as_uint: u32,
|
||||
pub as_string: [u8; 128usize],
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub enum UtilitySavedataMode {
|
||||
AutoLoad,
|
||||
AutoSave,
|
||||
Load,
|
||||
Save,
|
||||
ListLoad,
|
||||
ListSave,
|
||||
ListDelete,
|
||||
Delete,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub enum UtilitySavedataFocus {
|
||||
Unknown1,
|
||||
FirstList,
|
||||
LastList,
|
||||
Latest,
|
||||
Oldest,
|
||||
Unknown2,
|
||||
Unknown3,
|
||||
FirstEmpty,
|
||||
LastEmpty,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct UtilitySavedataSFOParam {
|
||||
pub title: [u8; 128usize],
|
||||
pub savedata_title: [u8; 128usize],
|
||||
pub detail: [u8; 1024usize],
|
||||
pub parental_level: u8,
|
||||
pub unknown: [u8; 3usize],
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct UtilitySavedataFileData {
|
||||
pub buf: *mut c_void,
|
||||
pub buf_size: usize,
|
||||
pub size: usize,
|
||||
pub unknown: i32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct UtilitySavedataListSaveNewData {
|
||||
pub icon0: UtilitySavedataFileData,
|
||||
pub title: *mut u8,
|
||||
}
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceUtilitySavedataParam {
|
||||
pub base: UtilityDialogCommon,
|
||||
pub mode: UtilitySavedataMode,
|
||||
pub unknown1: i32,
|
||||
pub overwrite: i32,
|
||||
pub game_name: [u8; 13usize],
|
||||
pub reserved: [u8; 3usize],
|
||||
pub save_name: [u8; 20usize],
|
||||
pub save_name_list: *mut [u8; 20usize],
|
||||
pub file_name: [u8; 13usize],
|
||||
pub reserved1: [u8; 3usize],
|
||||
pub data_buf: *mut c_void,
|
||||
pub data_buf_size: usize,
|
||||
pub data_size: usize,
|
||||
pub sfo_param: UtilitySavedataSFOParam,
|
||||
pub icon0_file_data: UtilitySavedataFileData,
|
||||
pub icon1_file_data: UtilitySavedataFileData,
|
||||
pub pic1_file_data: UtilitySavedataFileData,
|
||||
pub snd0_file_data: UtilitySavedataFileData,
|
||||
pub new_data: *mut UtilitySavedataListSaveNewData,
|
||||
pub focus: UtilitySavedataFocus,
|
||||
pub unknown2: [i32; 4usize],
|
||||
pub key: [u8; 16],
|
||||
pub unknown3: [u8; 20],
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub enum UtilityGameSharingMode {
|
||||
Single = 1,
|
||||
Multiple,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub enum UtilityGameSharingDataType {
|
||||
File = 1,
|
||||
Memory,
|
||||
}
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct UtilityGameSharingParams {
|
||||
pub base: UtilityDialogCommon,
|
||||
pub unknown1: i32,
|
||||
pub unknown2: i32,
|
||||
pub name: [u8; 8usize],
|
||||
pub unknown3: i32,
|
||||
pub unknown4: i32,
|
||||
pub unknown5: i32,
|
||||
pub result: i32,
|
||||
pub filepath: *mut u8,
|
||||
pub mode: UtilityGameSharingMode,
|
||||
pub datatype: UtilityGameSharingDataType,
|
||||
pub data: *mut c_void,
|
||||
pub datasize: u32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct UtilityHtmlViewerParam {
|
||||
pub base: UtilityDialogCommon,
|
||||
pub memaddr: *mut c_void,
|
||||
pub memsize: u32,
|
||||
pub unknown1: i32,
|
||||
pub unknown2: i32,
|
||||
pub initialurl: *mut u8,
|
||||
pub numtabs: u32,
|
||||
pub interfacemode: UtilityHtmlViewerInterfaceMode,
|
||||
pub options: i32,
|
||||
pub dldirname: *mut u8,
|
||||
pub dlfilename: *mut u8,
|
||||
pub uldirname: *mut u8,
|
||||
pub ulfilename: *mut u8,
|
||||
pub cookiemode: UtilityHtmlViewerCookieMode,
|
||||
pub unknown3: u32,
|
||||
pub homeurl: *mut u8,
|
||||
pub textsize: UtilityHtmlViewerTextSize,
|
||||
pub displaymode: UtilityHtmlViewerDisplayMode,
|
||||
pub connectmode: UtilityHtmlViewerConnectMode,
|
||||
pub disconnectmode: UtilityHtmlViewerDisconnectMode,
|
||||
pub memused: u32,
|
||||
pub unknown4: [i32; 10usize],
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum UtilityHtmlViewerInterfaceMode {
|
||||
Full,
|
||||
Limited,
|
||||
None,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum UtilityHtmlViewerCookieMode {
|
||||
Disabled = 0,
|
||||
Enabled,
|
||||
Confirm,
|
||||
Default,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum UtilityHtmlViewerTextSize {
|
||||
Large,
|
||||
Normal,
|
||||
Small,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum UtilityHtmlViewerDisplayMode {
|
||||
Normal,
|
||||
Fit,
|
||||
SmartFit,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum UtilityHtmlViewerConnectMode {
|
||||
Last,
|
||||
ManualOnce,
|
||||
ManualAll,
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum UtilityHtmlViewerDisconnectMode {
|
||||
Enable,
|
||||
Disable,
|
||||
Confirm,
|
||||
}
|
||||
|
||||
pub const UTILITY_HTMLVIEWER_OPEN_SCE_START_PAGE: i32 = 0x000001;
|
||||
pub const UTILITY_HTMLVIEWER_DISABLE_STARTUP_LIMITS: i32 = 0x000002;
|
||||
pub const UTILITY_HTMLVIEWER_DISABLE_EXIT_DIALOG: i32 = 0x000004;
|
||||
pub const UTILITY_HTMLVIEWER_DISABLE_CURSOR: i32 = 0x000008;
|
||||
pub const UTILITY_HTMLVIEWER_DISABLE_DOWNLOAD_COMPLETE_DIALOG: i32 = 0x000010;
|
||||
pub const UTILITY_HTMLVIEWER_DISABLE_DOWNLOAD_START_DIALOG: i32 = 0x000020;
|
||||
pub const UTILITY_HTMLVIEWER_DISABLE_DOWNLOAD_DESTINATION_DIALOG: i32 = 0x000040;
|
||||
pub const UTILITY_HTMLVIEWER_LOCK_DOWNLOAD_DESTINATION_DIALOG: i32 = 0x000080;
|
||||
pub const UTILITY_HTMLVIEWER_DISABLE_TAB_DISPLAY: i32 = 0x000100;
|
||||
pub const UTILITY_HTMLVIEWER_ENABLE_ANALOG_HOLD: i32 = 0x000200;
|
||||
pub const UTILITY_HTMLVIEWER_ENABLE_FLASH: i32 = 0x000400;
|
||||
pub const UTILITY_HTMLVIEWER_DISABLE_LRTRIGGER: i32 = 0x000800;
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceUtilityOskData {
|
||||
pub unk_00: i32,
|
||||
pub unk_04: i32,
|
||||
pub language: SceUtilityOskInputLanguage,
|
||||
pub unk_12: i32,
|
||||
pub inputtype: SceUtilityOskInputType,
|
||||
pub lines: i32,
|
||||
pub unk_24: i32,
|
||||
pub desc: *mut u16,
|
||||
pub intext: *mut u16,
|
||||
pub outtextlength: i32,
|
||||
pub outtext: *mut u16,
|
||||
pub result: SceUtilityOskResult,
|
||||
pub outtextlimit: i32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct SceUtilityOskParams {
|
||||
pub base: UtilityDialogCommon,
|
||||
pub datacount: i32,
|
||||
pub data: *mut SceUtilityOskData,
|
||||
pub state: SceUtilityOskState,
|
||||
pub unk_60: i32,
|
||||
}
|
||||
|
||||
extern {
|
||||
pub fn sceUtilityMsgDialogInitStart(
|
||||
params: *mut UtilityMsgDialogParams,
|
||||
) -> i32;
|
||||
pub fn sceUtilityMsgDialogShutdownStart();
|
||||
pub fn sceUtilityMsgDialogGetStatus() -> i32;
|
||||
pub fn sceUtilityMsgDialogUpdate(n: i32);
|
||||
pub fn sceUtilityMsgDialogAbort() -> i32;
|
||||
pub fn sceUtilityNetconfInitStart(data: *mut UtilityNetconfData) -> i32;
|
||||
pub fn sceUtilityNetconfShutdownStart() -> i32;
|
||||
pub fn sceUtilityNetconfUpdate(unknown: i32) -> i32;
|
||||
pub fn sceUtilityNetconfGetStatus() -> i32;
|
||||
pub fn sceUtilityCheckNetParam(id: i32) -> i32;
|
||||
pub fn sceUtilityGetNetParam(
|
||||
conf: i32,
|
||||
param: NetParam,
|
||||
data: *mut UtilityNetData,
|
||||
) -> i32;
|
||||
pub fn sceUtilitySavedataInitStart(
|
||||
params: *mut SceUtilitySavedataParam,
|
||||
) -> i32;
|
||||
pub fn sceUtilitySavedataGetStatus() -> i32;
|
||||
pub fn sceUtilitySavedataShutdownStart() -> i32;
|
||||
pub fn sceUtilitySavedataUpdate(unknown: i32);
|
||||
pub fn sceUtilityGameSharingInitStart(
|
||||
params: *mut UtilityGameSharingParams,
|
||||
) -> i32;
|
||||
pub fn sceUtilityGameSharingShutdownStart();
|
||||
pub fn sceUtilityGameSharingGetStatus() -> i32;
|
||||
pub fn sceUtilityGameSharingUpdate(n: i32);
|
||||
pub fn sceUtilityHtmlViewerInitStart(
|
||||
params: *mut UtilityHtmlViewerParam,
|
||||
) -> i32;
|
||||
pub fn sceUtilityHtmlViewerShutdownStart() -> i32;
|
||||
pub fn sceUtilityHtmlViewerUpdate(n: i32) -> i32;
|
||||
pub fn sceUtilityHtmlViewerGetStatus() -> i32;
|
||||
pub fn sceUtilitySetSystemParamInt(
|
||||
id: SystemParamId,
|
||||
value: i32,
|
||||
) -> i32;
|
||||
pub fn sceUtilitySetSystemParamString(
|
||||
id: SystemParamId,
|
||||
str: *const u8,
|
||||
) -> i32;
|
||||
pub fn sceUtilityGetSystemParamInt(
|
||||
id: SystemParamId,
|
||||
value: *mut i32,
|
||||
) -> i32;
|
||||
pub fn sceUtilityGetSystemParamString(
|
||||
id: SystemParamId,
|
||||
str: *mut u8,
|
||||
len: i32,
|
||||
) -> i32;
|
||||
pub fn sceUtilityOskInitStart(params: *mut SceUtilityOskParams) -> i32;
|
||||
pub fn sceUtilityOskShutdownStart() -> i32;
|
||||
pub fn sceUtilityOskUpdate(n: i32) -> i32;
|
||||
pub fn sceUtilityOskGetStatus() -> i32;
|
||||
pub fn sceUtilityLoadNetModule(module: NetModule) -> i32;
|
||||
pub fn sceUtilityUnloadNetModule(module: NetModule) -> i32;
|
||||
pub fn sceUtilityLoadAvModule(module: AvModule) -> i32;
|
||||
pub fn sceUtilityUnloadAvModule(module: AvModule) -> i32;
|
||||
pub fn sceUtilityLoadUsbModule(module: UsbModule) -> i32;
|
||||
pub fn sceUtilityUnloadUsbModule(module: UsbModule) -> i32;
|
||||
pub fn sceUtilityLoadModule(module: Module) -> i32;
|
||||
pub fn sceUtilityUnloadModule(module: Module) -> i32;
|
||||
}
|
||||
|
||||
extern {
|
||||
pub fn sceUtilityCreateNetParam(conf: i32) -> i32;
|
||||
pub fn sceUtilitySetNetParam(
|
||||
param: NetParam,
|
||||
val: *const c_void,
|
||||
) -> i32;
|
||||
pub fn sceUtilityCopyNetParam(
|
||||
src: i32,
|
||||
dest: i32,
|
||||
) -> i32;
|
||||
pub fn sceUtilityDeleteNetParam(conf: i32) -> i32;
|
||||
}
|
|
@ -0,0 +1,10 @@
|
|||
extern {
|
||||
pub fn sceWlanDevIsPowerOn() -> i32;
|
||||
pub fn sceWlanGetSwitchState() -> i32;
|
||||
pub fn sceWlanGetEtherAddr(ether_addr: *mut u8) -> i32;
|
||||
}
|
||||
|
||||
extern {
|
||||
pub fn sceWlanDevAttach() -> i32;
|
||||
pub fn sceWlanDevDetach() -> i32;
|
||||
}
|
Loading…
Reference in New Issue