Add PSP user mode API

Author: overdrivenpotato

src/psp/atrac.rs

@@ -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;
+}

src/psp/audio.rs

@@ -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;
+}

src/psp/codec.rs

@@ -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;
+}

src/psp/ctrl.rs

@@ -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;
+}

src/psp/display.rs

@@ -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;
+}