psp port runs, bad colors
authornotaz <notasas@gmail.com>
Mon, 15 Oct 2007 20:50:37 +0000 (20:50 +0000)
committernotaz <notasas@gmail.com>
Mon, 15 Oct 2007 20:50:37 +0000 (20:50 +0000)
git-svn-id: file:///home/notaz/opt/svn/PicoDrive@275 be3aeb3a-fb24-0410-a615-afba39da0efa

Pico/Pico.c
platform/common/lprintf.h
platform/common/menu.c
platform/common/readpng.c
platform/linux/940ctl_ym2612.c
platform/linux/Makefile
platform/psp/emu.c
platform/psp/main.c
platform/psp/menu.c
platform/psp/psp.c
platform/psp/psp.h

index 48899a0..5f90db3 100644 (file)
@@ -667,7 +667,7 @@ char *debugString(void)
   sprintf(dstrp, "sram range: %06x-%06x, reg: %02x\n", SRam.start, SRam.end, Pico.m.sram_reg); dstrp+=strlen(dstrp);\r
   sprintf(dstrp, "pend int: v:%i, h:%i, vdp status: %04x\n", bit(pv->pending_ints,5), bit(pv->pending_ints,4), pv->status);\r
   dstrp+=strlen(dstrp);\r
-#ifdef EMU_C68K\r
+#if defined(EMU_C68K)\r
   sprintf(dstrp, "M68k: PC: %06x, st_flg: %x, cycles: %u\n", SekPc, PicoCpu.state_flags, SekCyclesDoneT());\r
   dstrp+=strlen(dstrp);\r
   sprintf(dstrp, "d0=%08x, a0=%08x, osp=%08x, irql=%i\n", PicoCpu.d[0], PicoCpu.a[0], PicoCpu.osp, PicoCpu.irq); dstrp+=strlen(dstrp);\r
@@ -675,6 +675,8 @@ char *debugString(void)
   for(r=2; r < 8; r++) {\r
     sprintf(dstrp, "d%i=%08x, a%i=%08x\n", r, PicoCpu.d[r], r, PicoCpu.a[r]); dstrp+=strlen(dstrp);\r
   }\r
+#elif defined(EMU_M68K)\r
+  sprintf(dstrp, "M68k: PC: %06x, cycles: %u, irql: %i\n", SekPc, SekCyclesDoneT(), PicoM68kCPU.int_level>>8); dstrp+=strlen(dstrp);\r
 #endif\r
   sprintf(dstrp, "z80Run: %i, pal: %i, frame#: %i\n", Pico.m.z80Run, Pico.m.pal, Pico.m.frame_count); dstrp+=strlen(dstrp);\r
   z80_debug(dstrp); dstrp+=strlen(dstrp);\r
index d09a461..1d74323 100644 (file)
@@ -1,7 +1,15 @@
-#if defined(__GP2X__) || defined(PSP)
-#include <stdio.h>
-#define lprintf printf
+#if defined(__GP2X__)
+ #include <stdio.h>
+ #define lprintf printf
+#elif defined(PSP)
+ #if 0
+  #include <stdio.h>
+  #define lprintf printf
+ #else
+  extern void lprintf_f(const char *fmt, ...);
+  #define lprintf lprintf_f
+ #endif
 #else
-#include "giz.h"
+ #include "giz.h"
 #endif
 
index b6bd019..bb59510 100644 (file)
@@ -164,7 +164,12 @@ static int parse_hex_color(char *buff)
 {\r
        char *endp = buff;\r
        int t = (int) strtoul(buff, &endp, 16);\r
-       if (endp != buff) return ((t>>8)&0xf800) | ((t>>5)&0x07e0) | ((t>>3)&0x1f);\r
+       if (endp != buff)\r
+#ifdef PSP\r
+               return ((t<<8)&0xf800) | ((t>>5)&0x07e0) | ((t>>19)&0x1f);\r
+#else\r
+               return ((t>>8)&0xf800) | ((t>>5)&0x07e0) | ((t>>3)&0x1f);\r
+#endif\r
        return -1;\r
 }\r
 \r
index 1dd05a8..c93b36f 100644 (file)
@@ -80,7 +80,11 @@ void readpng(void *dest, const char *fname, readpng_what what)
                                int len = width;
                                while (len--)
                                {
-                                       *dst++ = ((src[0]&0xf8)<<8) | ((src[1]&0xf8)<<3) | (src[2] >> 3);
+#ifdef PSP
+                                       *dst++ = ((src[2]&0xf8)<<8) | ((src[1]&0xf8)<<3) | (src[0] >> 3); // BGR
+#else
+                                       *dst++ = ((src[0]&0xf8)<<8) | ((src[1]&0xf8)<<3) | (src[2] >> 3); // RGB
+#endif
                                        src += 3;
                                }
                                dst += BG_WIDTH - width;
index 451c942..403cca2 100644 (file)
@@ -13,7 +13,7 @@
 #include "../gp2x/emu.h"
 #include "../gp2x/menu.h"
 #include "../gp2x/code940/940shared.h"
-#include "../gp2x/helix/pub/mp3dec.h"
+#include "../common/helix/pub/mp3dec.h"
 #include "../../Pico/PicoInt.h"
 
 
index 12cb4a2..e3aac31 100644 (file)
@@ -28,7 +28,7 @@ OBJS += ../gp2x/main.o ../gp2x/menu.o ../gp2x/emu.o ../gp2x/usbjoy.o blit.o \
                gp2x.o 940ctl_ym2612.o log_io.o
 
 # common
-OBJS += ../common/menu.o ../common/fonts.o ../common/readpng.o
+OBJS += ../common/emu.o ../common/menu.o ../common/fonts.o ../common/readpng.o ../common/mp3_helix.o
 
 # Pico
 OBJS += ../../Pico/Area.o ../../Pico/Cart.o ../../Pico/Memory.o ../../Pico/Misc.o \
@@ -45,8 +45,6 @@ OBJS += ../../zlib/gzio.o ../../zlib/inffast.o ../../zlib/inflate.o ../../zlib/i
        ../../zlib/deflate.o ../../zlib/crc32.o ../../zlib/adler32.o ../../zlib/zutil.o ../../zlib/compress.o
 # unzip
 OBJS += ../../unzip/unzip.o ../../unzip/unzip_stream.o
-# mp3
-OBJS += ../gp2x/mp3.o
 # CPU cores
 DEFINC += -DEMU_M68K
 OBJS += ../../cpu/musashi/m68kops.o ../../cpu/musashi/m68kcpu.o
@@ -65,9 +63,9 @@ clean: tidy
 tidy:
        @$(RM) $(OBJS)
        @make -C ../../cpu/mz80/ clean
-       @make -C ../gp2x/helix/ X86=1 clean
+       @make -C ../common/helix/ X86=1 clean
 
-PicoDrive : $(OBJS) ../gp2x/helix/helix_mp3_x86.a
+PicoDrive : $(OBJS) ../common/helix/helix_mp3_x86.a
        @echo $@
        @$(GCC) $(COPT) $^ $(LDFLAGS) -lm -lpng -Wl,-Map=PicoDrive.map -o $@
 
@@ -82,8 +80,8 @@ PicoDrive : $(OBJS) ../gp2x/helix/helix_mp3_x86.a
 ../../cpu/mz80/mz80.asm :
        @make -C ../../cpu/mz80/
 
-../gp2x/helix/helix_mp3_x86.a:
-       @make -C ../gp2x/helix/ X86=1 clean all
+../common/helix/helix_mp3_x86.a:
+       @make -C ../common/helix/ X86=1 clean all
 
 .c.o:
        @echo $<
@@ -97,8 +95,3 @@ PicoDrive : $(OBJS) ../gp2x/helix/helix_mp3_x86.a
        @echo $@
        @$(GCC) $(COPT_COMMON) $(DEFINC) -c $< -o $@ # -mtune=arm940t -DEXTERNAL_YM2612
 
-# faked asm
-#../../Pico/Draw.o : ../../Pico/Draw.c
-#      @echo $<
-#      @$(GCC) $(COPT) $(DEFINC) -D_ASM_DRAW_C -c $< -o $@
-
index 0d22e42..338ffa4 100644 (file)
@@ -2,33 +2,75 @@
 #include <sys/types.h>
 #include <sys/syslimits.h> // PATH_MAX
 
+#include <pspthreadman.h>
+
+#include "psp.h"
+#include "menu.h"
+#include "emu.h"
+#include "../common/emu.h"
+#include "../common/lprintf.h"
 #include "../../Pico/PicoInt.h"
 
+#ifdef BENCHMARK
+#define OSD_FPS_X 220
+#else
+#define OSD_FPS_X 260
+#endif
+
+// vram usage map:
+// 000000-044000 fb0
+// 044000-088000 fb1
+// 088000-0ae000 texture0
+// 0ae000-0d4000 texture1
+
 char romFileName[PATH_MAX];
-unsigned char *PicoDraw2FB;  // temporary buffer for alt renderer ( (8+320)*(8+240+8) )
+static unsigned char picoD2FB[(8+320)*(8+240+8)];
+unsigned char *PicoDraw2FB = picoD2FB;  // temporary buffer for alt renderer ( (8+320)*(8+240+8) )
 int engineState;
 
+static int combo_keys = 0, combo_acts = 0; // keys and actions which need button combos
+static unsigned int noticeMsgTime = 0;
+int reset_timing = 0; // do we need this?
+
+
+static void blit(const char *fps, const char *notice);
+static void clearArea(int full);
 
 void emu_noticeMsgUpdated(void)
 {
+       noticeMsgTime = sceKernelGetSystemTimeLow();
 }
 
 void emu_getMainDir(char *dst, int len)
 {
+       if (len > 0) *dst = 0;
 }
 
-void emu_stateCb(const char *str)
+static void emu_msg_cb(const char *msg)
 {
+       void *fb = psp_video_get_active_fb();
+
+       memset32((int *)((char *)fb + 512*264*2), 0, 512*8*2/4);
+       emu_textOut16(4, 264, msg);
+       noticeMsgTime = sceKernelGetSystemTimeLow() - 2000000;
+
+       /* assumption: emu_msg_cb gets called only when something slow is about to happen */
+       reset_timing = 1;
 }
 
-void emu_setDefaultConfig(void)
+void emu_stateCb(const char *str)
 {
+       clearArea(0);
+       blit("", str);
 }
 
-void emu_forcedFrame(void)
+static void emu_msg_tray_open(void)
 {
+       strcpy(noticeMsg, "CD tray opened");
+       noticeMsgTime = sceKernelGetSystemTimeLow();
 }
 
+
 void emu_Init(void)
 {
        // make dirs for saves, cfgs, etc.
@@ -38,15 +80,15 @@ void emu_Init(void)
        mkdir("cfg", 0777);
 
        PicoInit();
-//     PicoMessage = emu_msg_cb;
-//     PicoMCDopenTray = emu_msg_tray_open;
-//     PicoMCDcloseTray = menu_loop_tray;
+       PicoMessage = emu_msg_cb;
+       PicoMCDopenTray = emu_msg_tray_open;
+       PicoMCDcloseTray = menu_loop_tray;
 }
 
 void emu_Deinit(void)
 {
        // save SRAM
-/*     if ((currentConfig.EmuOpt & 1) && SRam.changed) {
+       if ((currentConfig.EmuOpt & 1) && SRam.changed) {
                emu_SaveLoadGame(0, 1);
                SRam.changed = 0;
        }
@@ -64,13 +106,595 @@ void emu_Deinit(void)
                        fclose(f);
                }
        }
-*/
+
        PicoExit();
 }
 
+void emu_setDefaultConfig(void)
+{
+       memset(&currentConfig, 0, sizeof(currentConfig));
+       currentConfig.lastRomFile[0] = 0;
+       currentConfig.EmuOpt  = 0x1f | 0x680; // | confirm_save, cd_leds, 16bit rend
+       currentConfig.PicoOpt = 0x07 | 0xc00; // | cd_pcm, cd_cdda
+       currentConfig.PsndRate = 22050;
+       currentConfig.PicoRegion = 0; // auto
+       currentConfig.PicoAutoRgnOrder = 0x184; // US, EU, JP
+       currentConfig.Frameskip = -1; // auto
+       currentConfig.volume = 50;
+       currentConfig.KeyBinds[ 4] = 1<<0; // SACB RLDU
+       currentConfig.KeyBinds[ 6] = 1<<1;
+       currentConfig.KeyBinds[ 7] = 1<<2;
+       currentConfig.KeyBinds[ 5] = 1<<3;
+       currentConfig.KeyBinds[14] = 1<<4;
+       currentConfig.KeyBinds[13] = 1<<5;
+       currentConfig.KeyBinds[15] = 1<<6;
+       currentConfig.KeyBinds[ 3] = 1<<7;
+       currentConfig.KeyBinds[23] = 1<<26; // switch rend
+       currentConfig.KeyBinds[ 8] = 1<<27; // save state
+       currentConfig.KeyBinds[ 9] = 1<<28; // load state
+       currentConfig.PicoCDBuffers = 0;
+       currentConfig.scaling = 0;
+}
+
+
+static int EmuScan16(unsigned int num, void *sdata)
+{
+       if (!(Pico.video.reg[1]&8)) num += 8;
+       DrawLineDest = (unsigned short *) psp_screen + 512*(num+1);
+
+       return 0;
+}
+
+static int EmuScan8(unsigned int num, void *sdata)
+{
+       // draw like the fast renderer
+       // TODO?
+       //if (!(Pico.video.reg[1]&8)) num += 8;
+       //HighCol = gfx_buffer + 328*(num+1);
+
+       return 0;
+}
+
+static void osd_text(int x, const char *text)
+{
+       int len = strlen(text) * 8 / 2;
+       int *p, h;
+       for (h = 0; h < 8; h++) {
+               p = (int *) ((unsigned short *) psp_screen+x+512*(264+h));
+               p = (int *) ((int)p & ~3); // align
+               memset32(p, 0, len);
+       }
+       emu_textOut16(x, 264, text);
+}
+
+
+static void cd_leds(void)
+{
+       static int old_reg = 0;
+       unsigned int col_g, col_r, *p;
+
+       if (!((Pico_mcd->s68k_regs[0] ^ old_reg) & 3)) return; // no change
+       old_reg = Pico_mcd->s68k_regs[0];
+
+       p = (unsigned int *)((short *)psp_screen + 512*2+4+2);
+       col_g = (old_reg & 2) ? 0x06000600 : 0;
+       col_r = (old_reg & 1) ? 0xc000c000 : 0;
+       *p++ = col_g; *p++ = col_g; p+=2; *p++ = col_r; *p++ = col_r; p += 512/2 - 12/2;
+       *p++ = col_g; *p++ = col_g; p+=2; *p++ = col_r; *p++ = col_r; p += 512/2 - 12/2;
+       *p++ = col_g; *p++ = col_g; p+=2; *p++ = col_r; *p++ = col_r;
+}
+
+
+static short localPal[0x100];
+
+static void blit(const char *fps, const char *notice)
+{
+       int emu_opt = currentConfig.EmuOpt;
+
+#if 0
+       if (PicoOpt&0x10)
+       {
+               int lines_flags = 224;
+               // 8bit fast renderer
+               if (Pico.m.dirtyPal) {
+                       Pico.m.dirtyPal = 0;
+                       vidConvCpyRGB565(localPal, Pico.cram, 0x40);
+               }
+               if (!(Pico.video.reg[12]&1)) lines_flags|=0x10000;
+               if (currentConfig.EmuOpt&0x4000)
+                       lines_flags|=0x40000; // (Pico.m.frame_count&1)?0x20000:0x40000;
+               vidCpy8to16((unsigned short *)giz_screen+321*8, PicoDraw2FB+328*8, localPal, lines_flags);
+       }
+       else if (!(emu_opt&0x80))
+       {
+               int lines_flags;
+               // 8bit accurate renderer
+               if (Pico.m.dirtyPal) {
+                       Pico.m.dirtyPal = 0;
+                       vidConvCpyRGB565(localPal, Pico.cram, 0x40);
+                       if (Pico.video.reg[0xC]&8) { // shadow/hilight mode
+                               //vidConvCpyRGB32sh(localPal+0x40, Pico.cram, 0x40);
+                               //vidConvCpyRGB32hi(localPal+0x80, Pico.cram, 0x40); // TODO?
+                               blockcpy(localPal+0xc0, localPal+0x40, 0x40*2);
+                               localPal[0xc0] = 0x0600;
+                               localPal[0xd0] = 0xc000;
+                               localPal[0xe0] = 0x0000; // reserved pixels for OSD
+                               localPal[0xf0] = 0xffff;
+                       }
+                       /* no support
+                       else if (rendstatus & 0x20) { // mid-frame palette changes
+                               vidConvCpyRGB565(localPal+0x40, HighPal, 0x40);
+                               vidConvCpyRGB565(localPal+0x80, HighPal+0x40, 0x40);
+                       } */
+               }
+               lines_flags = (Pico.video.reg[1]&8) ? 240 : 224;
+               if (!(Pico.video.reg[12]&1)) lines_flags|=0x10000;
+               if (currentConfig.EmuOpt&0x4000)
+                       lines_flags|=0x40000; // (Pico.m.frame_count&1)?0x20000:0x40000;
+               vidCpy8to16((unsigned short *)giz_screen+321*8, PicoDraw2FB+328*8, localPal, lines_flags);
+       }
+#endif
+
+       if (notice || (emu_opt & 2)) {
+               if (notice)      osd_text(4, notice);
+               if (emu_opt & 2) osd_text(OSD_FPS_X, fps);
+       }
+
+       if ((emu_opt & 0x400) && (PicoMCD & 1))
+               cd_leds();
+
+       psp_video_flip(0);
+}
+
+// clears whole screen or just the notice area (in all buffers)
+static void clearArea(int full)
+{
+       if (full) {
+               memset32(psp_screen, 0, 512*272*2/4);
+               psp_video_flip(0);
+               memset32(psp_screen, 0, 512*272*2/4);
+       } else {
+               void *fb = psp_video_get_active_fb();
+               memset32((int *)((char *)psp_screen + 512*264*2), 0, 512*8*2/4);
+               memset32((int *)((char *)fb         + 512*264*2), 0, 512*8*2/4);
+       }
+}
+
+static void vidResetMode(void)
+{
+       if (PicoOpt&0x10) {
+       } else if (currentConfig.EmuOpt&0x80) {
+               PicoDrawSetColorFormat(1);
+               PicoScan = EmuScan16;
+       } else {
+               PicoDrawSetColorFormat(-1);
+               PicoScan = EmuScan8;
+       }
+       if ((PicoOpt&0x10) || !(currentConfig.EmuOpt&0x80)) {
+               // setup pal for 8-bit modes
+               localPal[0xc0] = 0x0600;
+               localPal[0xd0] = 0xc000;
+               localPal[0xe0] = 0x0000; // reserved pixels for OSD
+               localPal[0xf0] = 0xffff;
+       }
+       Pico.m.dirtyPal = 1;
+
+       clearArea(1);
+}
+
+static void updateSound(int len)
+{
+       if (PicoOpt&8) len<<=1;
+
+       // TODO..
+}
+
+
+static void SkipFrame(void)
+{
+       PicoSkipFrame=1;
+       PicoFrame();
+       PicoSkipFrame=0;
+}
+
+void emu_forcedFrame(void)
+{
+       int po_old = PicoOpt;
+       int eo_old = currentConfig.EmuOpt;
+
+       PicoOpt &= ~0x0010;
+       PicoOpt |=  0x4080; // soft_scale | acc_sprites
+       currentConfig.EmuOpt |= 0x80;
+
+       PicoDrawSetColorFormat(1);
+       PicoScan = EmuScan16;
+       PicoScan((unsigned) -1, NULL);
+       Pico.m.dirtyPal = 1;
+       PicoFrameDrawOnly();
+
+       PicoOpt = po_old;
+       currentConfig.EmuOpt = eo_old;
+}
+
+
+static void RunEvents(unsigned int which)
+{
+       if (which & 0x1800) // save or load (but not both)
+       {
+               int do_it = 1;
+
+               if ( emu_checkSaveFile(state_slot) &&
+                               (( (which & 0x1000) && (currentConfig.EmuOpt & 0x800)) || // load
+                                (!(which & 0x1000) && (currentConfig.EmuOpt & 0x200))) ) // save
+               {
+                       int keys;
+                       blit("", (which & 0x1000) ? "LOAD STATE? (X=yes, O=no)" : "OVERWRITE SAVE? (X=yes, O=no)");
+                       while( !((keys = psp_pad_read(1)) & (BTN_X|BTN_CIRCLE)) )
+                               psp_msleep(50);
+                       if (keys & BTN_CIRCLE) do_it = 0;
+                       while(  ((keys = psp_pad_read(1)) & (BTN_X|BTN_CIRCLE)) ) // wait for release
+                               psp_msleep(50);
+                       clearArea(0);
+               }
+
+               if (do_it)
+               {
+                       osd_text(4, (which & 0x1000) ? "LOADING GAME" : "SAVING GAME");
+                       PicoStateProgressCB = emu_stateCb;
+                       emu_SaveLoadGame((which & 0x1000) >> 12, 0);
+                       PicoStateProgressCB = NULL;
+                       psp_msleep(0);
+               }
+
+               reset_timing = 1;
+       }
+       if (which & 0x0400) // switch renderer
+       {
+               if (PicoOpt&0x10) { PicoOpt&=~0x10; currentConfig.EmuOpt |=  0x80; }
+               else              { PicoOpt|= 0x10; currentConfig.EmuOpt &= ~0x80; }
+
+               vidResetMode();
+
+               if (PicoOpt&0x10) {
+                       strcpy(noticeMsg, " 8bit fast renderer");
+               } else if (currentConfig.EmuOpt&0x80) {
+                       strcpy(noticeMsg, "16bit accurate renderer");
+               } else {
+                       strcpy(noticeMsg, " 8bit accurate renderer");
+               }
+
+               noticeMsgTime = sceKernelGetSystemTimeLow();
+       }
+       if (which & 0x0300)
+       {
+               if(which&0x0200) {
+                       state_slot -= 1;
+                       if(state_slot < 0) state_slot = 9;
+               } else {
+                       state_slot += 1;
+                       if(state_slot > 9) state_slot = 0;
+               }
+               sprintf(noticeMsg, "SAVE SLOT %i [%s]", state_slot, emu_checkSaveFile(state_slot) ? "USED" : "FREE");
+               noticeMsgTime = sceKernelGetSystemTimeLow();
+       }
+}
+
+static void updateKeys(void)
+{
+       unsigned int keys, allActions[2] = { 0, 0 }, events;
+       static unsigned int prevEvents = 0;
+       int i;
+
+       keys = psp_pad_read(0);
+       if (keys & BTN_SELECT)
+               engineState = PGS_Menu;
+
+       keys &= CONFIGURABLE_KEYS;
+
+       for (i = 0; i < 32; i++)
+       {
+               if (keys & (1 << i))
+               {
+                       int pl, acts = currentConfig.KeyBinds[i];
+                       if (!acts) continue;
+                       pl = (acts >> 16) & 1;
+                       if (combo_keys & (1 << i))
+                       {
+                               int u = i+1, acts_c = acts & combo_acts;
+                               // let's try to find the other one
+                               if (acts_c)
+                                       for (; u < 32; u++)
+                                               if ( (currentConfig.KeyBinds[u] & acts_c) && (keys & (1 << u)) ) {
+                                                       allActions[pl] |= acts_c;
+                                                       keys &= ~((1 << i) | (1 << u));
+                                                       break;
+                                               }
+                               // add non-combo actions if combo ones were not found
+                               if (!acts_c || u == 32)
+                                       allActions[pl] |= acts & ~combo_acts;
+                       } else {
+                               allActions[pl] |= acts;
+                       }
+               }
+       }
+
+       PicoPad[0] = (unsigned short) allActions[0];
+       PicoPad[1] = (unsigned short) allActions[1];
+
+       events = (allActions[0] | allActions[1]) >> 16;
+
+       // volume is treated in special way and triggered every frame
+       if ((events & 0x6000) && PsndOut != NULL)
+       {
+               int vol = currentConfig.volume;
+               if (events & 0x2000) {
+                       if (vol < 100) vol++;
+               } else {
+                       if (vol >   0) vol--;
+               }
+               // FrameworkAudio_SetVolume(vol, vol); // TODO
+               sprintf(noticeMsg, "VOL: %02i ", vol);
+               noticeMsgTime = sceKernelGetSystemTimeLow();
+               currentConfig.volume = vol;
+       }
+
+       events &= ~prevEvents;
+       if (events) RunEvents(events);
+       if (movie_data) emu_updateMovie();
+
+       prevEvents = (allActions[0] | allActions[1]) >> 16;
+}
+
+static void find_combos(void)
+{
+       int act, u;
+
+       // find out which keys and actions are combos
+       combo_keys = combo_acts = 0;
+       for (act = 0; act < 32; act++)
+       {
+               int keyc = 0;
+               if (act == 16 || act == 17) continue; // player2 flag
+               for (u = 0; u < 32; u++)
+               {
+                       if (currentConfig.KeyBinds[u] & (1 << act)) keyc++;
+               }
+               if (keyc > 1)
+               {
+                       // loop again and mark those keys and actions as combo
+                       for (u = 0; u < 32; u++)
+                       {
+                               if (currentConfig.KeyBinds[u] & (1 << act)) {
+                                       combo_keys |= 1 << u;
+                                       combo_acts |= 1 << act;
+                               }
+                       }
+               }
+       }
+}
+
+
+static void simpleWait(unsigned int until)
+{
+       unsigned int tval;
+       int diff;
+
+       tval = sceKernelGetSystemTimeLow();
+       diff = (int)until - (int)tval;
+       if (diff >= 512 && diff < 100*1024)
+               sceKernelDelayThread(diff);
+}
+
+void emu_Loop(void)
+{
+       //static int PsndRate_old = 0, PicoOpt_old = 0, pal_old = 0;
+       char fpsbuff[24]; // fps count c string
+       unsigned int tval, tval_prev = 0, tval_thissec = 0; // timing
+       int frames_done = 0, frames_shown = 0, oldmodes = 0;
+       int target_fps, target_frametime, lim_time, tval_diff, i;
+       char *notice = NULL;
+
+       lprintf("entered emu_Loop()\n");
+
+       fpsbuff[0] = 0;
+
+       // make sure we are in correct mode
+       vidResetMode();
+       Pico.m.dirtyPal = 1;
+       oldmodes = ((Pico.video.reg[12]&1)<<2) ^ 0xc;
+       find_combos();
+
+       // pal/ntsc might have changed, reset related stuff
+       target_fps = Pico.m.pal ? 50 : 60;
+       target_frametime = Pico.m.pal ? (1000000<<8)/50 : (1000000<<8)/60+1;
+       reset_timing = 1;
+
+       // prepare CD buffer
+       if (PicoMCD & 1) PicoCDBufferInit();
+
+       // prepare sound stuff
+       PsndOut = NULL;
+#if 0 // TODO
+       if (currentConfig.EmuOpt & 4)
+       {
+               int ret, snd_excess_add, stereo;
+               if (PsndRate != PsndRate_old || (PicoOpt&0x0b) != (PicoOpt_old&0x0b) || Pico.m.pal != pal_old) {
+                       sound_rerate(Pico.m.frame_count ? 1 : 0);
+               }
+               stereo=(PicoOpt&8)>>3;
+               snd_excess_add = ((PsndRate - PsndLen*target_fps)<<16) / target_fps;
+               snd_cbuf_samples = (PsndRate<<stereo) * 16 / target_fps;
+               lprintf("starting audio: %i len: %i (ex: %04x) stereo: %i, pal: %i\n",
+                       PsndRate, PsndLen, snd_excess_add, stereo, Pico.m.pal);
+               ret = FrameworkAudio_Init(PsndRate, snd_cbuf_samples, stereo);
+               if (ret != 0) {
+                       lprintf("FrameworkAudio_Init() failed: %i\n", ret);
+                       sprintf(noticeMsg, "sound init failed (%i), snd disabled", ret);
+                       noticeMsgTime = sceKernelGetSystemTimeLow();
+                       currentConfig.EmuOpt &= ~4;
+               } else {
+                       FrameworkAudio_SetVolume(currentConfig.volume, currentConfig.volume);
+                       PicoWriteSound = updateSound;
+                       snd_cbuff = FrameworkAudio_56448Buffer();
+                       PsndOut = snd_cbuff + snd_cbuf_samples / 2; // start writing at the middle
+                       snd_all_samples = 0;
+                       PsndRate_old = PsndRate;
+                       PicoOpt_old  = PicoOpt;
+                       pal_old = Pico.m.pal;
+               }
+       }
+#endif
+
+       // loop?
+       while (engineState == PGS_Running)
+       {
+               int modes;
+
+               tval = sceKernelGetSystemTimeLow();
+               if (reset_timing || tval < tval_prev) {
+                       //stdbg("timing reset");
+                       reset_timing = 0;
+                       tval_thissec = tval;
+                       frames_shown = frames_done = 0;
+               }
+
+               // show notice message?
+               if (noticeMsgTime) {
+                       static int noticeMsgSum;
+                       if (tval - noticeMsgTime > 2000000) { // > 2.0 sec
+                               noticeMsgTime = 0;
+                               clearArea(0);
+                               notice = 0;
+                       } else {
+                               int sum = noticeMsg[0]+noticeMsg[1]+noticeMsg[2];
+                               if (sum != noticeMsgSum) { clearArea(0); noticeMsgSum = sum; }
+                               notice = noticeMsg;
+                       }
+               }
+
+               // check for mode changes
+               modes = ((Pico.video.reg[12]&1)<<2)|(Pico.video.reg[1]&8);
+               if (modes != oldmodes) {
+                       oldmodes = modes;
+                       clearArea(1);
+               }
+
+               // second passed?
+               if (tval - tval_thissec >= 1000000)
+               {
+#ifdef BENCHMARK
+                       static int bench = 0, bench_fps = 0, bench_fps_s = 0, bfp = 0, bf[4];
+                       if(++bench == 10) {
+                               bench = 0;
+                               bench_fps_s = bench_fps;
+                               bf[bfp++ & 3] = bench_fps;
+                               bench_fps = 0;
+                       }
+                       bench_fps += frames_shown;
+                       sprintf(fpsbuff, "%02i/%02i/%02i", frames_shown, bench_fps_s, (bf[0]+bf[1]+bf[2]+bf[3])>>2);
+#else
+                       if(currentConfig.EmuOpt & 2)
+                               sprintf(fpsbuff, "%02i/%02i", frames_shown, frames_done);
+#endif
+                       tval_thissec += 1000000;
+
+                       if (currentConfig.Frameskip < 0) {
+                               frames_done  -= target_fps; if (frames_done  < 0) frames_done  = 0;
+                               frames_shown -= target_fps; if (frames_shown < 0) frames_shown = 0;
+                               if (frames_shown > frames_done) frames_shown = frames_done;
+                       } else {
+                               frames_done = frames_shown = 0;
+                       }
+               }
+#ifdef PFRAMES
+               sprintf(fpsbuff, "%i", Pico.m.frame_count);
+#endif
+
+               tval_prev = tval;
+               lim_time = (frames_done+1) * target_frametime;
+               if (currentConfig.Frameskip >= 0) // frameskip enabled
+               {
+                       for (i = 0; i < currentConfig.Frameskip; i++) {
+                               updateKeys();
+                               SkipFrame(); frames_done++;
+                               if (PsndOut) { // do framelimitting if sound is enabled
+                                       int tval_diff;
+                                       tval = sceKernelGetSystemTimeLow();
+                                       tval_diff = (int)(tval - tval_thissec) << 8;
+                                       if (tval_diff < lim_time) // we are too fast
+                                               simpleWait(tval + ((lim_time - tval_diff)>>8));
+                               }
+                               lim_time += target_frametime;
+                       }
+               }
+               else // auto frameskip
+               {
+                       int tval_diff;
+                       tval = sceKernelGetSystemTimeLow();
+                       tval_diff = (int)(tval - tval_thissec) << 8;
+                       if (tval_diff > lim_time)
+                       {
+                               // no time left for this frame - skip
+                               if (tval_diff - lim_time >= (300000<<8)) {
+                                       /* something caused a slowdown for us (disk access? cache flush?)
+                                        * try to recover by resetting timing... */
+                                       reset_timing = 1;
+                                       continue;
+                               }
+                               updateKeys();
+                               SkipFrame(); frames_done++;
+                               continue;
+                       }
+               }
+
+               updateKeys();
+
+               if (!(PicoOpt&0x10))
+                       PicoScan((unsigned) -1, NULL);
+
+               PicoFrame();
+
+               blit(fpsbuff, notice);
+
+               // check time
+               tval = sceKernelGetSystemTimeLow();
+               tval_diff = (int)(tval - tval_thissec) << 8;
+
+               if (currentConfig.Frameskip < 0 && tval_diff - lim_time >= (300000<<8)) // slowdown detection
+                       reset_timing = 1;
+               else if (PsndOut != NULL || currentConfig.Frameskip < 0)
+               {
+                       // sleep if we are still too fast
+                       if (tval_diff < lim_time)
+                       {
+                               // we are too fast
+                               simpleWait(tval + ((lim_time - tval_diff) >> 8));
+                       }
+               }
+
+               frames_done++; frames_shown++;
+       }
+
+
+       if (PicoMCD & 1) PicoCDBufferFree();
+/*
+       if (PsndOut != NULL) {
+               PsndOut = snd_cbuff = NULL;
+               FrameworkAudio_Close();
+       }
+*/
+       // save SRAM
+       if ((currentConfig.EmuOpt & 1) && SRam.changed) {
+               emu_stateCb("Writing SRAM/BRAM..");
+               emu_SaveLoadGame(0, 1);
+               SRam.changed = 0;
+       }
+}
+
+
 void emu_ResetGame(void)
 {
        PicoReset(0);
-       //reset_timing = 1;
+       reset_timing = 1;
 }
 
index 8d5fbf4..606ca02 100644 (file)
@@ -2,13 +2,14 @@
 #include "emu.h"
 #include "menu.h"
 #include "../common/menu.h"
+#include "../common/emu.h"
 #include "../common/lprintf.h"
 
 int main()
 {
        psp_init();
 
-//     emu_ReadConfig(0, 0);
+       emu_ReadConfig(0, 0);
        emu_Init();
        menu_init();
 
@@ -23,21 +24,19 @@ int main()
                                break;
 
                        case PGS_ReloadRom:
-/*
                                if (emu_ReloadRom())
                                        engineState = PGS_Running;
                                else {
                                        lprintf("PGS_ReloadRom == 0\n");
                                        engineState = PGS_Menu;
                                }
-*/
                                break;
 
                        case PGS_RestartRun:
                                engineState = PGS_Running;
 
                        case PGS_Running:
-//                             emu_Loop();
+                               emu_Loop();
                                break;
 
                        case PGS_Quit:
index 18c8536..c878f40 100644 (file)
@@ -11,7 +11,6 @@
 #include <stdlib.h>
 #include <wchar.h>
 #include <unistd.h>
-#include <dirent.h> // for opendir
 #include <sys/syslimits.h> // PATH_MAX
 
 #include <pspdisplay.h>
@@ -60,12 +59,12 @@ static unsigned long wait_for_input(unsigned int interesting)
        if (repeats == 2 || repeats == 4) wait /= 2;
        if (repeats == 6) wait = 15;
 
-       for (i = 0; i < 6 && inp_prev == psp_pad_read(); i++) {
+       for (i = 0; i < 6 && inp_prev == psp_pad_read(1); i++) {
                if (i == 0) repeats++;
                psp_msleep(wait);
        }
 
-       while ( !((ret = psp_pad_read()) & interesting) ) {
+       while ( !((ret = psp_pad_read(1)) & interesting) ) {
                psp_msleep(50);
                release = 1;
        }
@@ -102,8 +101,7 @@ static void menu_draw_begin(void)
 
 static void menu_draw_end(void)
 {
-       sceDisplayWaitVblankStart();
-       psp_video_flip();
+       psp_video_flip(1);
 }
 
 
@@ -154,7 +152,7 @@ struct my_dirent
        char d_name[255];
 };
 
-// rrrr rggg gggb bbbb
+// bbbb bggg gggr rrrr
 static unsigned short file2color(const char *fname)
 {
        const char *ext = fname + strlen(fname) - 3;
@@ -164,7 +162,7 @@ static unsigned short file2color(const char *fname)
 
        if (ext < fname) ext = fname;
        for (i = 0; i < sizeof(rom_exts)/sizeof(rom_exts[0]); i++)
-               if (strcasecmp(ext, rom_exts[i]) == 0) return 0xbdff;
+               if (strcasecmp(ext, rom_exts[i]) == 0) return 0xfdf7;
        for (i = 0; i < sizeof(other_exts)/sizeof(other_exts[0]); i++)
                if (strcasecmp(ext, other_exts[i]) == 0) return 0xaff5;
        return 0xffff;
@@ -192,8 +190,8 @@ static void draw_dirlist(char *curdir, struct my_dirent **namelist, int n, int s
                if (pos < 0)  continue;
                if (pos > 26) break;
                if (namelist[i+1]->d_type & DT_DIR) {
-                       smalltext_out16_lim(14,   pos*10, "/", 0xfff6, 1);
-                       smalltext_out16_lim(14+6, pos*10, namelist[i+1]->d_name, 0xfff6, 53-3);
+                       smalltext_out16_lim(14,   pos*10, "/", 0xd7ff, 1);
+                       smalltext_out16_lim(14+6, pos*10, namelist[i+1]->d_name, 0xd7ff, 53-3);
                } else {
                        unsigned short color = file2color(namelist[i+1]->d_name);
                        smalltext_out16_lim(14,   pos*10, namelist[i+1]->d_name, color, 53-2);
@@ -250,6 +248,9 @@ static int my_scandir(const char *dir, struct my_dirent ***namelist_out,
        dir_uid = sceIoDopen(dir);
        if (dir_uid >= 0)
        {
+               /* it is very important to clear SceIoDirent to be passed to sceIoDread(), */
+               /* or else it may crash, probably misinterpreting something in it. */
+               memset(&sce_ent, 0, sizeof(sce_ent));
                ret = sceIoDread(dir_uid, &sce_ent);
                if (ret < 0)
                {
@@ -266,7 +267,7 @@ static int my_scandir(const char *dir, struct my_dirent ***namelist_out,
                if (ent == NULL) { lprintf("%s:%i: OOM\n", __FILE__, __LINE__); goto fail; }
                ent->d_type = sce_ent.d_stat.st_attr;
                strncpy(ent->d_name, sce_ent.d_name, sizeof(ent->d_name));
-               ent->d_name[sizeof(ent->d_name)] = 0;
+               ent->d_name[sizeof(ent->d_name)-1] = 0;
                if (filter == NULL || filter(ent))
                     namelist[name_count++] = ent;
                else free(ent);
@@ -280,6 +281,7 @@ static int my_scandir(const char *dir, struct my_dirent ***namelist_out,
                        namelist = tmp;
                }
 
+               memset(&sce_ent, 0, sizeof(sce_ent));
                ret = sceIoDread(dir_uid, &sce_ent);
        }
 
@@ -307,25 +309,27 @@ end:
 static char *romsel_loop(char *curr_path)
 {
        struct my_dirent **namelist;
-       DIR *dir;
-       int n, sel = 0;
+       int n, iret, sel = 0;
        unsigned long inp = 0;
        char *ret = NULL, *fname = NULL;
+       SceIoStat cpstat;
 
        // is this a dir or a full path?
-       if ((dir = opendir(curr_path))) {
-               closedir(dir);
-       } else {
+       memset(&cpstat, 0, sizeof(cpstat));
+       iret = sceIoGetstat(curr_path, &cpstat);
+       if (iret >= 0 && (cpstat.st_attr & FIO_SO_IFREG)) { // file
                char *p;
                for (p = curr_path + strlen(curr_path) - 1; p > curr_path && *p != '/'; p--);
                *p = 0;
                fname = p+1;
        }
+       else if (iret >= 0 && (cpstat.st_attr & FIO_SO_IFDIR)); // dir
+       else strcpy(curr_path, "ms0:/"); // something else
 
        n = my_scandir(curr_path, &namelist, scandir_filter, scandir_cmp);
        if (n < 0) {
                // try root..
-               n = my_scandir("/", &namelist, scandir_filter, scandir_cmp);
+               n = my_scandir("ms0:/", &namelist, scandir_filter, scandir_cmp);
                if (n < 0) {
                        // oops, we failed
                        lprintf("scandir failed, dir: "); lprintf(curr_path); lprintf("\n");
@@ -368,8 +372,8 @@ static char *romsel_loop(char *curr_path)
                                        char *start = curr_path;
                                        p = start + strlen(start) - 1;
                                        while (*p == '/' && p > start) p--;
-                                       while (*p != '/' && p > start) p--;
-                                       if (p <= start) strcpy(newdir, "/");
+                                       while (*p != '/' && *p != ':' && p > start) p--;
+                                       if (p <= start || *p == ':' || p[-1] == ':') strcpy(newdir, "ms0:/");
                                        else { strncpy(newdir, start, p-start); newdir[p-start] = 0; }
                                } else {
                                        strcpy(newdir, curr_path);
@@ -949,8 +953,8 @@ menu_entry opt2_entries[] =
        { "Emulate Z80",               MB_ONOFF, MA_OPT2_ENABLE_Z80,    &currentConfig.PicoOpt,0x0004, 0, 0, 1 },
        { "Emulate YM2612 (FM)",       MB_ONOFF, MA_OPT2_ENABLE_YM2612, &currentConfig.PicoOpt,0x0001, 0, 0, 1 },
        { "Emulate SN76496 (PSG)",     MB_ONOFF, MA_OPT2_ENABLE_SN76496,&currentConfig.PicoOpt,0x0002, 0, 0, 1 },
-       { "Double buffering",          MB_ONOFF, MA_OPT2_DBLBUFF,       &currentConfig.EmuOpt, 0x8000, 0, 0, 1 },
-       { "Wait for V-sync (slow)",    MB_ONOFF, MA_OPT2_VSYNC,         &currentConfig.EmuOpt, 0x2000, 0, 0, 1 },
+//     { "Double buffering",          MB_ONOFF, MA_OPT2_DBLBUFF,       &currentConfig.EmuOpt, 0x8000, 0, 0, 1 },
+//     { "Wait for V-sync (slow)",    MB_ONOFF, MA_OPT2_VSYNC,         &currentConfig.EmuOpt, 0x2000, 0, 0, 1 },
        { "gzip savestates",           MB_ONOFF, MA_OPT2_GZIP_STATES,   &currentConfig.EmuOpt, 0x0008, 0, 0, 1 },
        { "Don't save last used ROM",  MB_ONOFF, MA_OPT2_NO_LAST_ROM,   &currentConfig.EmuOpt, 0x0020, 0, 0, 1 },
        { "done",                      MB_NONE,  MA_OPT2_DONE,          NULL, 0, 0, 0, 1 },
@@ -991,7 +995,7 @@ static void amenu_loop_options(void)
                if (inp & (BTN_LEFT|BTN_RIGHT)) { // multi choise
                        if (!me_process(opt2_entries, OPT2_ENTRY_COUNT, selected_id, (inp&BTN_RIGHT) ? 1 : 0) &&
                            selected_id == MA_OPT2_GAMMA) {
-                               while ((inp = psp_pad_read()) & (BTN_LEFT|BTN_RIGHT)) {
+                               while ((inp = psp_pad_read(1)) & (BTN_LEFT|BTN_RIGHT)) {
                                        currentConfig.gamma += (inp & BTN_LEFT) ? -1 : 1;
                                        if (currentConfig.gamma <   1) currentConfig.gamma =   1;
                                        if (currentConfig.gamma > 300) currentConfig.gamma = 300;
@@ -1016,7 +1020,6 @@ static void amenu_loop_options(void)
 menu_entry opt_entries[] =
 {
        { NULL,                        MB_NONE,  MA_OPT_RENDERER,      NULL, 0, 0, 0, 1 },
-       { "Scanline mode (faster)",    MB_ONOFF, MA_OPT_INTERLACED,    &currentConfig.EmuOpt,  0x4000, 0, 0, 1 },
        { "Scale low res mode",        MB_ONOFF, MA_OPT_SCALING,       &currentConfig.scaling, 0x0001, 0, 3, 1 },
        { "Accurate timing (slower)",  MB_ONOFF, MA_OPT_ACC_TIMING,    &currentConfig.PicoOpt, 0x0040, 0, 0, 1 },
        { "Accurate sprites (slower)", MB_ONOFF, MA_OPT_ACC_SPRITES,   &currentConfig.PicoOpt, 0x0080, 0, 0, 1 },
@@ -1385,7 +1388,7 @@ static void menu_loop_root(void)
        /* make sure action buttons are not pressed on entering menu */
        draw_menu_root(menu_sel);
 
-       while (psp_pad_read() & (BTN_X|BTN_CIRCLE|BTN_SELECT)) psp_msleep(50);
+       while (psp_pad_read(1) & (BTN_X|BTN_CIRCLE|BTN_SELECT)) psp_msleep(50);
 
        for (;;)
        {
@@ -1396,7 +1399,7 @@ static void menu_loop_root(void)
                if((inp & (BTN_L|BTN_R)) == (BTN_L|BTN_R)) debug_menu_loop();
                if( inp & (BTN_SELECT|BTN_CIRCLE)) {
                        if (rom_data) {
-                               while (psp_pad_read() & (BTN_SELECT|BTN_CIRCLE)) psp_msleep(50); // wait until released
+                               while (psp_pad_read(1) & (BTN_SELECT|BTN_CIRCLE)) psp_msleep(50); // wait until released
                                engineState = PGS_Running;
                                break;
                        }
@@ -1406,7 +1409,7 @@ static void menu_loop_root(void)
                        {
                                case MA_MAIN_RESUME_GAME:
                                        if (rom_data) {
-                                               while (psp_pad_read() & BTN_X) psp_msleep(50);
+                                               while (psp_pad_read(1) & BTN_X) psp_msleep(50);
                                                engineState = PGS_Running;
                                                return;
                                        }
@@ -1594,7 +1597,7 @@ int menu_loop_tray(void)
 
        /* make sure action buttons are not pressed on entering menu */
        draw_menu_tray(menu_sel);
-       while (psp_pad_read() & BTN_X) psp_msleep(50);
+       while (psp_pad_read(1) & BTN_X) psp_msleep(50);
 
        for (;;)
        {
index 4bc1020..48e5e63 100644 (file)
@@ -1,4 +1,9 @@
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+
 #include <pspkernel.h>
+#include <pspiofilemgr.h>
 #include <pspdisplay.h>
 #include <pspgu.h>
 
@@ -10,6 +15,7 @@ PSP_MODULE_INFO("PicoDrive", 0, 1, 34);
 void *psp_screen = PSP_VRAM_BASE0;
 static int current_screen = 0; /* front bufer */
 
+static SceUID logfd = -1;
 
 /* Exit callback */
 static int exit_callback(int arg1, int arg2, void *common)
@@ -67,11 +73,17 @@ void psp_finish(void)
        sceKernelExitGame();
 }
 
-void psp_video_flip(void)
+void psp_video_flip(int wait_vsync)
 {
+       if (wait_vsync) sceDisplayWaitVblankStart();
        sceDisplaySetFrameBuf(psp_screen, 512, PSP_DISPLAY_PIXEL_FORMAT_565, PSP_DISPLAY_SETBUF_NEXTFRAME);
        current_screen ^= 1;
-       psp_screen = current_screen ? PSP_VRAM_BASE1 : PSP_VRAM_BASE0;
+       psp_screen = current_screen ? PSP_VRAM_BASE0 : PSP_VRAM_BASE1;
+}
+
+void *psp_video_get_active_fb(void)
+{
+       return current_screen ? PSP_VRAM_BASE1 : PSP_VRAM_BASE0;
 }
 
 void psp_video_switch_to_single(void)
@@ -86,11 +98,39 @@ void psp_msleep(int ms)
        sceKernelDelayThread(ms * 1000);
 }
 
-unsigned int psp_pad_read(void)
+unsigned int psp_pad_read(int blocking)
 {
        SceCtrlData pad;
-       sceCtrlReadBufferPositive(&pad, 1);
+       if (blocking)
+            sceCtrlReadBufferPositive(&pad, 1);
+       else sceCtrlPeekBufferPositive(&pad, 1);
 
        return pad.Buttons;
 }
 
+/* alt logging */
+#define LOG_FILE "log.log"
+
+void lprintf_f(const char *fmt, ...)
+{
+       va_list vl;
+       char buff[256];
+
+       if (logfd < 0)
+       {
+               logfd = sceIoOpen(LOG_FILE, PSP_O_WRONLY|PSP_O_APPEND, 0777);
+               if (logfd < 0)
+                       return;
+       }
+
+       va_start(vl, fmt);
+       vsnprintf(buff, sizeof(buff), fmt, vl);
+       va_end(vl);
+
+       sceIoWrite(logfd, buff, strlen(buff));
+//sceKernelDelayThread(200 * 1000);
+sceIoClose(logfd);
+logfd = -1;
+}
+
+
index cece8cf..e6d04ff 100644 (file)
@@ -8,11 +8,12 @@ void psp_msleep(int ms);
 #define PSP_VRAM_BASE0 ((void *) 0x44000000)
 #define PSP_VRAM_BASE1 ((void *) 0x44044000)
 
-void psp_video_switch_to_single(void);
-void psp_video_flip(void);
+void *psp_video_get_active_fb(void);
+void  psp_video_switch_to_single(void);
+void  psp_video_flip(int wait_vsync);
 extern void *psp_screen;
 
-unsigned int psp_pad_read(void);
+unsigned int psp_pad_read(int blocking);
 
 
 /* shorter btn names */