initial psp code, functional menu
authornotaz <notasas@gmail.com>
Thu, 11 Oct 2007 20:43:48 +0000 (20:43 +0000)
committernotaz <notasas@gmail.com>
Thu, 11 Oct 2007 20:43:48 +0000 (20:43 +0000)
git-svn-id: file:///home/notaz/opt/svn/PicoDrive@274 be3aeb3a-fb24-0410-a615-afba39da0efa

23 files changed:
Pico/Pico.c
Pico/sound/sound.c
cpu/mz80/driver.h [new file with mode: 0644]
platform/common/emu.c
platform/common/lprintf.h
platform/common/menu.c
platform/common/readpng.c
platform/psp/Makefile [new file with mode: 0644]
platform/psp/emu.c [new file with mode: 0644]
platform/psp/emu.h [new file with mode: 0644]
platform/psp/main.c [new file with mode: 0644]
platform/psp/menu.c [new file with mode: 0644]
platform/psp/menu.h [new file with mode: 0644]
platform/psp/mp3.c [new file with mode: 0644]
platform/psp/port_config.h [new file with mode: 0644]
platform/psp/psp.c [new file with mode: 0644]
platform/psp/psp.h [new file with mode: 0644]
platform/psp/skin/background.png [new file with mode: 0644]
platform/psp/skin/font.png [new file with mode: 0644]
platform/psp/skin/readme.txt [new file with mode: 0644]
platform/psp/skin/selector.png [new file with mode: 0644]
platform/psp/skin/skin.txt [new file with mode: 0644]
platform/psp/version.h [new file with mode: 0644]

index c6bf03e..48899a0 100644 (file)
@@ -638,7 +638,7 @@ void PicoFrameDrawOnly(void)
 // callback to output message from emu\r
 void (*PicoMessage)(const char *msg)=NULL;\r
 \r
-#if defined(__DEBUG_PRINT) || defined(__GP2X__) || defined(__GIZ__)\r
+#if 1 // defined(__DEBUG_PRINT)\r
 // tmp debug: dump some stuff\r
 #define bit(r, x) ((r>>x)&1)\r
 void z80_debug(char *dstr);\r
index 8bec0ba..ab56bb9 100644 (file)
@@ -463,7 +463,7 @@ PICO_INTERNAL void z80_exit(void)
 #endif\r
 }\r
 \r
-#if defined(__DEBUG_PRINT) || defined(__GP2X__) || defined(__GIZ__)\r
+#if 1 // defined(__DEBUG_PRINT) || defined(__GP2X__) || defined(__GIZ__)\r
 PICO_INTERNAL void z80_debug(char *dstr)\r
 {\r
 #if defined(_USE_DRZ80)\r
diff --git a/cpu/mz80/driver.h b/cpu/mz80/driver.h
new file mode 100644 (file)
index 0000000..0705ea9
--- /dev/null
@@ -0,0 +1,13 @@
+/* compiler dependence */
+#ifndef UINT8
+typedef unsigned char  UINT8;   /* unsigned  8bit */
+typedef unsigned short UINT16;  /* unsigned 16bit */
+typedef unsigned int   UINT32;  /* unsigned 32bit */
+#endif
+#ifndef INT8
+typedef signed char            INT8;    /* signed  8bit   */
+typedef signed short   INT16;   /* signed 16bit   */
+typedef signed int             INT32;   /* signed 32bit   */
+#endif
+
+
index 723dfb7..9e07260 100644 (file)
 #elif defined(__GIZ__)\r
  #include "../gizmondo/giz.h"\r
  #define SCREEN_WIDTH 321\r
- #define SCREEN_BUFFER giz_screen // ?\r
+ #define SCREEN_BUFFER giz_screen\r
+#elif defined(PSP)\r
+ #include "../psp/psp.h"\r
+ #define SCREEN_WIDTH 512\r
+ #define SCREEN_BUFFER psp_screen\r
 #endif\r
 \r
 char *PicoConfigFile = "picoconfig.bin";\r
index 5cd176f..d09a461 100644 (file)
@@ -1,4 +1,5 @@
-#if defined(__GP2X__)
+#if defined(__GP2X__) || defined(PSP)
+#include <stdio.h>
 #define lprintf printf
 #else
 #include "giz.h"
index d2957c2..b6bd019 100644 (file)
  #define SCREEN_WIDTH 321\r
  #define SCREEN_BUFFER menu_screen\r
  extern unsigned char *menu_screen;\r
+#elif defined(PSP)\r
+ #include "../psp/psp.h"\r
+ #define SCREEN_WIDTH 512\r
+ #define SCREEN_BUFFER psp_screen\r
 #endif\r
 \r
 char menuErrorMsg[64] = { 0, };\r
@@ -216,6 +220,7 @@ void menu_init(void)
                                int tmp = parse_hex_color(buff+16);\r
                                if (tmp >= 0) menu_sel_color = tmp;\r
                                else lprintf("skin.txt: parse error for selection_color\n");\r
+                               lprintf("sel color: %04x\n", menu_sel_color);\r
                        }\r
                        else\r
                                lprintf("skin.txt: parse error: %s\n", buff);\r
index 2a74668..1dd05a8 100644 (file)
@@ -4,6 +4,14 @@
 #include "readpng.h"
 #include "lprintf.h"
 
+#ifdef PSP
+#define BG_WIDTH  480
+#define BG_HEIGHT 272
+#else
+#define BG_WIDTH  320
+#define BG_HEIGHT 240
+#endif
+
 void readpng(void *dest, const char *fname, readpng_what what)
 {
        FILE *fp;
@@ -62,9 +70,9 @@ void readpng(void *dest, const char *fname, readpng_what what)
                                break;
                        }
                        height = info_ptr->height;
-                       if (height > 240) height = 240;
+                       if (height > BG_HEIGHT) height = BG_HEIGHT;
                        width = info_ptr->width;
-                       if (width > 320) width = 320;
+                       if (width > BG_WIDTH) width = BG_WIDTH;
 
                        for (h = 0; h < height; h++)
                        {
@@ -75,7 +83,7 @@ void readpng(void *dest, const char *fname, readpng_what what)
                                        *dst++ = ((src[0]&0xf8)<<8) | ((src[1]&0xf8)<<3) | (src[2] >> 3);
                                        src += 3;
                                }
-                               dst += 320 - width;
+                               dst += BG_WIDTH - width;
                        }
                        break;
                }
diff --git a/platform/psp/Makefile b/platform/psp/Makefile
new file mode 100644 (file)
index 0000000..769f3ed
--- /dev/null
@@ -0,0 +1,127 @@
+\r
+# pspdev is expected to be in path\r
+PSPSDK = $(shell psp-config --pspsdk-path)\r
+\r
+# settings\r
+use_musashi = 1\r
+use_mz80 = 1\r
+amalgamate = 0\r
+#profile = 1\r
+#up = 1\r
+\r
+\r
+CFLAGS += -I../.. -I. -D_UNZIP_SUPPORT -DNO_SYNC # -DBENCHMARK\r
+CFLAGS += -Wall -Winline\r
+ifeq ($(DEBUG),)\r
+CFLAGS += -O2 -G0 -ftracer -fstrength-reduce -fomit-frame-pointer -fstrict-aliasing -ffast-math\r
+else\r
+CFLAGS += -ggdb\r
+endif\r
+ifeq "$(profile)" "1"\r
+CFLAGS += -fprofile-generate\r
+endif\r
+ifeq "$(profile)" "2"\r
+CFLAGS += -fprofile-use\r
+endif\r
+\r
+\r
+# frontend\r
+OBJS += main.o emu.o mp3.o menu.o psp.o\r
+\r
+# common\r
+OBJS += ../common/emu.o ../common/menu.o ../common/fonts.o ../common/readpng.o\r
+\r
+# Pico\r
+ifeq "$(amalgamate)" "1"\r
+OBJS += ../../PicoAll.o\r
+else\r
+OBJS += ../../Pico/Area.o ../../Pico/Cart.o ../../Pico/Memory.o ../../Pico/Misc.o \\r
+               ../../Pico/Pico.o ../../Pico/Sek.o ../../Pico/VideoPort.o ../../Pico/Draw2.o ../../Pico/Draw.o \\r
+               ../../Pico/Patch.o\r
+# Pico - CD\r
+OBJS += ../../Pico/cd/Pico.o ../../Pico/cd/Memory.o ../../Pico/cd/Sek.o ../../Pico/cd/LC89510.o \\r
+               ../../Pico/cd/cd_sys.o ../../Pico/cd/cd_file.o ../../Pico/cd/gfx_cd.o \\r
+               ../../Pico/cd/Area.o ../../Pico/cd/Misc.o ../../Pico/cd/pcm.o ../../Pico/cd/buffering.o\r
+endif\r
+\r
+# Pico - sound\r
+ifneq "$(amalgamate)" "1"\r
+OBJS += ../../Pico/sound/sound.o\r
+endif\r
+OBJS += ../../Pico/sound/mix.o\r
+OBJS += ../../Pico/sound/sn76496.o ../../Pico/sound/ym2612.o\r
+# zlib (hacked)\r
+OBJS += ../../zlib/gzio.o ../../zlib/inffast.o ../../zlib/inflate.o ../../zlib/inftrees.o ../../zlib/trees.o \\r
+       ../../zlib/deflate.o ../../zlib/crc32.o ../../zlib/adler32.o ../../zlib/zutil.o ../../zlib/compress.o\r
+# unzip\r
+OBJS += ../../unzip/unzip.o ../../unzip/unzip_stream.o\r
+# CPU cores\r
+ifeq "$(use_musashi)" "1"\r
+CFLAGS += -DEMU_M68K\r
+OBJS += ../../cpu/musashi/m68kops.o ../../cpu/musashi/m68kcpu.o\r
+endif\r
+# z80\r
+ifeq "$(use_mz80)" "1"\r
+CFLAGS += -D_USE_MZ80\r
+OBJS += ../../cpu/mz80/mz80.o\r
+else\r
+$(error nothing here!)\r
+endif\r
+\r
+\r
+LIBS += -lpng -lm -lpspgu # -lpspaudio -lpspgu -lpsppower -lpsphprm -lz -lm -lstdc++\r
+\r
+# target\r
+TARGET = PicoDrive\r
+EXTRA_TARGETS = EBOOT.PBP\r
+PSP_EBOOT_TITLE = PICODRIVE\r
+#PSP_EBOOT_ICON = .png\r
+#PSP_EBOOT_PIC1 = .png\r
+\r
+CUSTOM_CLEAN = myclean\r
+\r
+include $(PSPSDK)/lib/build.mak\r
+\r
+\r
+# some additional rules\r
+.c.o:\r
+       @echo ">>>" $<\r
+       $(CC) $(CFLAGS) -c $< -o $@\r
+\r
+../../cpu/musashi/m68kops.c :\r
+       make -C ../../cpu/musashi\r
+\r
+readme.txt: ../../tools/textfilter ../base_readme.txt\r
+       ../../tools/textfilter ../base_readme.txt $@ PSP\r
+\r
+../../tools/textfilter: ../../tools/textfilter.c\r
+       make -C ../../tools/ textfilter\r
+\r
+\r
+# ?\r
+up: EBOOT.PBP\r
+       @cp -v $^ /media/disk/PSP/GAME/PicoDrive/\r
+\r
+\r
+# cleanup\r
+\r
+myclean:\r
+       make -C ../../cpu/musashi clean\r
+\r
+\r
+clean_prof:\r
+       find ../.. -name '*.gcno' -delete\r
+       find ../.. -name '*.gcda' -delete\r
+\r
+# ----------- release -----------\r
+ifneq ($(findstring rel,$(MAKECMDGOALS)),)\r
+ifeq ($(VER),)\r
+$(error need VER)\r
+endif\r
+endif\r
+\r
+# ?\r
+rel: EBOOT.PBP readme.txt\r
+       zip -9 -j ../../PicoDrive_$(VER).zip $^\r
+#      zip -9 -r ../../PicoDrive_$(VER).zip skin -i \*.png -i \*.txt\r
+\r
diff --git a/platform/psp/emu.c b/platform/psp/emu.c
new file mode 100644 (file)
index 0000000..0d22e42
--- /dev/null
@@ -0,0 +1,76 @@
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/syslimits.h> // PATH_MAX
+
+#include "../../Pico/PicoInt.h"
+
+char romFileName[PATH_MAX];
+unsigned char *PicoDraw2FB;  // temporary buffer for alt renderer ( (8+320)*(8+240+8) )
+int engineState;
+
+
+void emu_noticeMsgUpdated(void)
+{
+}
+
+void emu_getMainDir(char *dst, int len)
+{
+}
+
+void emu_stateCb(const char *str)
+{
+}
+
+void emu_setDefaultConfig(void)
+{
+}
+
+void emu_forcedFrame(void)
+{
+}
+
+void emu_Init(void)
+{
+       // make dirs for saves, cfgs, etc.
+       mkdir("mds", 0777);
+       mkdir("srm", 0777);
+       mkdir("brm", 0777);
+       mkdir("cfg", 0777);
+
+       PicoInit();
+//     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) {
+               emu_SaveLoadGame(0, 1);
+               SRam.changed = 0;
+       }
+
+       if (!(currentConfig.EmuOpt & 0x20)) {
+               FILE *f = fopen(PicoConfigFile, "r+b");
+               if (!f) emu_WriteConfig(0);
+               else {
+                       // if we already have config, reload it, except last ROM
+                       fseek(f, sizeof(currentConfig.lastRomFile), SEEK_SET);
+                       fread(&currentConfig.EmuOpt, 1, sizeof(currentConfig) - sizeof(currentConfig.lastRomFile), f);
+                       fseek(f, 0, SEEK_SET);
+                       fwrite(&currentConfig, 1, sizeof(currentConfig), f);
+                       fflush(f);
+                       fclose(f);
+               }
+       }
+*/
+       PicoExit();
+}
+
+void emu_ResetGame(void)
+{
+       PicoReset(0);
+       //reset_timing = 1;
+}
+
diff --git a/platform/psp/emu.h b/platform/psp/emu.h
new file mode 100644 (file)
index 0000000..48ce9a3
--- /dev/null
@@ -0,0 +1,31 @@
+// (c) Copyright 2006-2007 notaz, All rights reserved.
+// Free for non-commercial use.
+
+// For commercial use, separate licencing terms must be obtained.
+
+
+
+// engine states
+enum TPicoGameState {
+       PGS_Paused = 1,
+       PGS_Running,
+       PGS_Quit,
+       PGS_KeyConfig,
+       PGS_ReloadRom,
+       PGS_Menu,
+       PGS_RestartRun,
+};
+
+extern char romFileName[];
+extern int engineState;
+
+
+void emu_Init(void);
+void emu_Deinit(void);
+void emu_Loop(void);
+void emu_ResetGame(void);
+void emu_forcedFrame(void);
+
+void emu_stateCb(const char *str);
+
+
diff --git a/platform/psp/main.c b/platform/psp/main.c
new file mode 100644 (file)
index 0000000..8d5fbf4
--- /dev/null
@@ -0,0 +1,59 @@
+#include "psp.h"
+#include "emu.h"
+#include "menu.h"
+#include "../common/menu.h"
+#include "../common/lprintf.h"
+
+int main()
+{
+       psp_init();
+
+//     emu_ReadConfig(0, 0);
+       emu_Init();
+       menu_init();
+
+       engineState = PGS_Menu;
+
+       for (;;)
+       {
+               switch (engineState)
+               {
+                       case PGS_Menu:
+                               menu_loop();
+                               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();
+                               break;
+
+                       case PGS_Quit:
+                               goto endloop;
+
+                       default:
+                               lprintf("engine got into unknown state (%i), exitting\n", engineState);
+                               goto endloop;
+               }
+       }
+
+       endloop:
+
+       emu_Deinit();
+       psp_finish();
+
+       return 0;
+}
+
diff --git a/platform/psp/menu.c b/platform/psp/menu.c
new file mode 100644 (file)
index 0000000..18c8536
--- /dev/null
@@ -0,0 +1,1632 @@
+// (c) Copyright 2006,2007 notaz, All rights reserved.
+// Free for non-commercial use.
+
+// For commercial use, separate licencing terms must be obtained.
+
+// don't like to use loads of #ifdefs, so duplicating GP2X code
+// horribly instead
+
+//#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <wchar.h>
+#include <unistd.h>
+#include <dirent.h> // for opendir
+#include <sys/syslimits.h> // PATH_MAX
+
+#include <pspdisplay.h>
+#include <pspgu.h>
+#include <pspiofilemgr.h>
+
+#include "psp.h"
+#include "emu.h"
+#include "menu.h"
+#include "../common/menu.h"
+#include "../common/emu.h"
+#include "../common/readpng.h"
+#include "../common/lprintf.h"
+#include "version.h"
+
+#include <Pico/PicoInt.h>
+#include <Pico/Patch.h>
+#include <zlib/zlib.h>
+
+
+#define pspKeyUnkn "???"
+static const char * const pspKeyNames[] = {
+       "SELECT",   pspKeyUnkn, pspKeyUnkn, "START",    "UP",       "RIGHT",    "DOWN",     "LEFT",
+       "L",        "R",        pspKeyUnkn, pspKeyUnkn, "TRIANGLE", "CIRCLE",   "X",        "SQUARE",
+       "HOME",     "HOLD",     "WLAN_UP",  "REMOTE",   "VOLUP",    "VOLDOWN",  "SCREEN",   "NOTE",
+       pspKeyUnkn, pspKeyUnkn, pspKeyUnkn, pspKeyUnkn, pspKeyUnkn, pspKeyUnkn, pspKeyUnkn, pspKeyUnkn
+};
+
+unsigned int __attribute__((aligned(16))) guCmdList[1024]; // TODO: adjust, mv
+
+static unsigned char bg_buffer[480*272*2] __attribute__((aligned(16))); // TODO: move to vram?
+#define menu_screen psp_screen
+
+static void menu_darken_bg(void *dst, const void *src, int pixels, int darker);
+static void menu_prepare_bg(int use_game_bg);
+
+
+static unsigned int inp_prev = 0;
+
+static unsigned long wait_for_input(unsigned int interesting)
+{
+       unsigned int ret;
+       static int repeats = 0, wait = 50;
+       int release = 0, i;
+
+       if (repeats == 2 || repeats == 4) wait /= 2;
+       if (repeats == 6) wait = 15;
+
+       for (i = 0; i < 6 && inp_prev == psp_pad_read(); i++) {
+               if (i == 0) repeats++;
+               psp_msleep(wait);
+       }
+
+       while ( !((ret = psp_pad_read()) & interesting) ) {
+               psp_msleep(50);
+               release = 1;
+       }
+
+       if (release || ret != inp_prev) {
+               repeats = 0;
+               wait = 50;
+       }
+       inp_prev = ret;
+
+       // we don't need diagonals in menus
+       if ((ret&BTN_UP)   && (ret&BTN_LEFT))  ret &= ~BTN_LEFT;
+       if ((ret&BTN_UP)   && (ret&BTN_RIGHT)) ret &= ~BTN_RIGHT;
+       if ((ret&BTN_DOWN) && (ret&BTN_LEFT))  ret &= ~BTN_LEFT;
+       if ((ret&BTN_DOWN) && (ret&BTN_RIGHT)) ret &= ~BTN_RIGHT;
+
+       return ret;
+}
+
+static void menu_draw_begin(void)
+{
+       // short *src = (short *)bg_buffer, *dst = (short *)menu_screen;
+       // int i;
+
+       // for (i = 272; i >= 0; i--, dst += 512, src += 480)
+       //      memcpy32((int *)dst, (int *)src, 480*2/4);
+
+       sceGuStart(GU_DIRECT, guCmdList);
+       sceGuCopyImage(GU_PSM_5650, 0, 0, 480, 272, 480, bg_buffer, 0, 0, 512, menu_screen);
+       sceGuFinish();
+       sceGuSync(0, GU_SYNC_FINISH);
+}
+
+
+static void menu_draw_end(void)
+{
+       sceDisplayWaitVblankStart();
+       psp_video_flip();
+}
+
+
+// --------- loading ROM screen ----------
+
+static void load_progress_cb(int percent)
+{
+       int ln, len = percent * 480 / 100;
+       unsigned short *dst;
+
+       sceDisplayWaitVblankStart();
+
+       dst = (unsigned short *)menu_screen + 512*20;
+
+       if (len > 480) len = 480;
+       for (ln = 10; ln > 0; ln--, dst += 512)
+               memset(dst, 0xff, len*2);
+}
+
+void menu_romload_prepare(const char *rom_name)
+{
+       const char *p = rom_name + strlen(rom_name);
+       while (p > rom_name && *p != '/') p--;
+
+       psp_video_switch_to_single();
+       menu_draw_begin();
+
+       smalltext_out16(1, 1, "Loading", 0xffff);
+       smalltext_out16_lim(1, 10, p, 0xffff, 80);
+       PicoCartLoadProgressCB = load_progress_cb;
+}
+
+void menu_romload_end(void)
+{
+       PicoCartLoadProgressCB = NULL;
+       smalltext_out16(1, 30, "Starting emulation...", 0xffff);
+}
+
+// -------------- ROM selector --------------
+
+// SceIoDirent
+#define DT_DIR FIO_SO_IFDIR
+#define DT_REG FIO_SO_IFREG
+
+struct my_dirent
+{
+       unsigned char d_type;
+       char d_name[255];
+};
+
+// rrrr rggg gggb bbbb
+static unsigned short file2color(const char *fname)
+{
+       const char *ext = fname + strlen(fname) - 3;
+       static const char *rom_exts[]   = { "zip", "bin", "smd", "gen", "iso" };
+       static const char *other_exts[] = { "gmv", "pat" };
+       int i;
+
+       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;
+       for (i = 0; i < sizeof(other_exts)/sizeof(other_exts[0]); i++)
+               if (strcasecmp(ext, other_exts[i]) == 0) return 0xaff5;
+       return 0xffff;
+}
+
+static void draw_dirlist(char *curdir, struct my_dirent **namelist, int n, int sel)
+{
+       int start, i, pos;
+
+       start = 13 - sel;
+       n--; // exclude current dir (".")
+
+       menu_draw_begin();
+
+       if (rom_data == NULL) {
+//             menu_darken_bg(menu_screen, menu_screen, 321*240, 0);
+       }
+
+       menu_darken_bg((char *)menu_screen + 512*129*2, (char *)menu_screen + 512*129*2, 512*10, 0);
+
+       if (start - 2 >= 0)
+               smalltext_out16_lim(14, (start - 2)*10, curdir, 0xffff, 53-2);
+       for (i = 0; i < n; i++) {
+               pos = start + i;
+               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);
+               } else {
+                       unsigned short color = file2color(namelist[i+1]->d_name);
+                       smalltext_out16_lim(14,   pos*10, namelist[i+1]->d_name, color, 53-2);
+               }
+       }
+       text_out16(5, 130, ">");
+       menu_draw_end();
+}
+
+static int scandir_cmp(const void *p1, const void *p2)
+{
+       struct my_dirent **d1 = (struct my_dirent **)p1, **d2 = (struct my_dirent **)p2;
+       if ((*d1)->d_type == (*d2)->d_type) return strcasecmp((*d1)->d_name, (*d2)->d_name);
+       if ((*d1)->d_type & DT_DIR) return -1; // put before
+       if ((*d2)->d_type & DT_DIR) return  1;
+       return strcasecmp((*d1)->d_name, (*d2)->d_name);
+}
+
+static char *filter_exts[] = {
+       ".mp3", ".srm", ".brm", "s.gz", ".mds", "bcfg", ".txt", ".htm", "html",
+       ".jpg", ".cue", ".pbp"
+};
+
+static int scandir_filter(const struct my_dirent *ent)
+{
+       const char *p;
+       int i;
+
+       if (ent == NULL || ent->d_name == NULL) return 0;
+       if (strlen(ent->d_name) < 5) return 1;
+
+       p = ent->d_name + strlen(ent->d_name) - 4;
+
+       for (i = 0; i < sizeof(filter_exts)/sizeof(filter_exts[0]); i++)
+       {
+               if (strcasecmp(p, filter_exts[i]) == 0) return 0;
+       }
+
+       return 1;
+}
+
+static int my_scandir(const char *dir, struct my_dirent ***namelist_out,
+               int(*filter)(const struct my_dirent *),
+               int(*compar)(const void *, const void *))
+{
+       int ret = -1, dir_uid = -1, name_alloc = 4, name_count = 0;
+       struct my_dirent **namelist = NULL, *ent;
+       SceIoDirent sce_ent;
+
+       namelist = malloc(sizeof(*namelist) * name_alloc);
+       if (namelist == NULL) { lprintf("%s:%i: OOM\n", __FILE__, __LINE__); goto fail; }
+
+       // try to read first..
+       dir_uid = sceIoDopen(dir);
+       if (dir_uid >= 0)
+       {
+               ret = sceIoDread(dir_uid, &sce_ent);
+               if (ret < 0)
+               {
+                       lprintf("sceIoDread(\"%s\") failed with %i\n", dir, ret);
+                       goto fail;
+               }
+       }
+       else
+               lprintf("sceIoDopen(\"%s\") failed with %i\n", dir, dir_uid);
+
+       while (ret > 0)
+       {
+               ent = malloc(sizeof(*ent));
+               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;
+               if (filter == NULL || filter(ent))
+                    namelist[name_count++] = ent;
+               else free(ent);
+
+               if (name_count >= name_alloc)
+               {
+                       void *tmp;
+                       name_alloc *= 2;
+                       tmp = realloc(namelist, sizeof(*namelist) * name_alloc);
+                       if (tmp == NULL) { lprintf("%s:%i: OOM\n", __FILE__, __LINE__); goto fail; }
+                       namelist = tmp;
+               }
+
+               ret = sceIoDread(dir_uid, &sce_ent);
+       }
+
+       // sort
+       if (compar != NULL && name_count > 3) qsort(&namelist[2], name_count - 2, sizeof(namelist[0]), compar);
+
+       // all done.
+       ret = name_count;
+       *namelist_out = namelist;
+       goto end;
+
+fail:
+       if (namelist != NULL)
+       {
+               while (name_count--)
+                       free(namelist[name_count]);
+               free(namelist);
+       }
+end:
+       if (dir_uid >= 0) sceIoDclose(dir_uid);
+       return ret;
+}
+
+
+static char *romsel_loop(char *curr_path)
+{
+       struct my_dirent **namelist;
+       DIR *dir;
+       int n, sel = 0;
+       unsigned long inp = 0;
+       char *ret = NULL, *fname = NULL;
+
+       // is this a dir or a full path?
+       if ((dir = opendir(curr_path))) {
+               closedir(dir);
+       } else {
+               char *p;
+               for (p = curr_path + strlen(curr_path) - 1; p > curr_path && *p != '/'; p--);
+               *p = 0;
+               fname = p+1;
+       }
+
+       n = my_scandir(curr_path, &namelist, scandir_filter, scandir_cmp);
+       if (n < 0) {
+               // try root..
+               n = my_scandir("/", &namelist, scandir_filter, scandir_cmp);
+               if (n < 0) {
+                       // oops, we failed
+                       lprintf("scandir failed, dir: "); lprintf(curr_path); lprintf("\n");
+                       return NULL;
+               }
+       }
+
+       // try to find sel
+       if (fname != NULL) {
+               int i;
+               for (i = 1; i < n; i++) {
+                       if (strcmp(namelist[i]->d_name, fname) == 0) {
+                               sel = i - 1;
+                               break;
+                       }
+               }
+       }
+
+       for (;;)
+       {
+               draw_dirlist(curr_path, namelist, n, sel);
+               inp = wait_for_input(BTN_UP|BTN_DOWN|BTN_LEFT|BTN_RIGHT|BTN_L|BTN_R|BTN_X|BTN_CIRCLE);
+               if(inp & BTN_UP  )  { sel--;   if (sel < 0)   sel = n-2; }
+               if(inp & BTN_DOWN)  { sel++;   if (sel > n-2) sel = 0; }
+               if(inp & BTN_LEFT)  { sel-=10; if (sel < 0)   sel = 0; }
+               if(inp & BTN_L)     { sel-=24; if (sel < 0)   sel = 0; }
+               if(inp & BTN_RIGHT) { sel+=10; if (sel > n-2) sel = n-2; }
+               if(inp & BTN_R)     { sel+=24; if (sel > n-2) sel = n-2; }
+               if(inp & BTN_X)     { // enter dir/select
+                       if (namelist[sel+1]->d_type & DT_REG) {
+                               strcpy(romFileName, curr_path);
+                               strcat(romFileName, "/");
+                               strcat(romFileName, namelist[sel+1]->d_name);
+                               ret = romFileName;
+                               break;
+                       } else if (namelist[sel+1]->d_type & DT_DIR) {
+                               int newlen = strlen(curr_path) + strlen(namelist[sel+1]->d_name) + 2;
+                               char *p, *newdir = malloc(newlen);
+                               if (strcmp(namelist[sel+1]->d_name, "..") == 0) {
+                                       char *start = curr_path;
+                                       p = start + strlen(start) - 1;
+                                       while (*p == '/' && p > start) p--;
+                                       while (*p != '/' && p > start) p--;
+                                       if (p <= start) strcpy(newdir, "/");
+                                       else { strncpy(newdir, start, p-start); newdir[p-start] = 0; }
+                               } else {
+                                       strcpy(newdir, curr_path);
+                                       p = newdir + strlen(newdir) - 1;
+                                       while (*p == '/' && p >= newdir) *p-- = 0;
+                                       strcat(newdir, "/");
+                                       strcat(newdir, namelist[sel+1]->d_name);
+                               }
+                               ret = romsel_loop(newdir);
+                               free(newdir);
+                               break;
+                       }
+               }
+               if(inp & BTN_CIRCLE) break; // cancel
+       }
+
+       if (n > 0) {
+               while(n--) free(namelist[n]);
+               free(namelist);
+       }
+
+       return ret;
+}
+
+// ------------ debug menu ------------
+
+char *debugString(void);
+
+static void draw_debug(void)
+{
+       char *p, *str = debugString();
+       int len, line;
+
+       menu_draw_begin();
+
+       p = str;
+       for (line = 0; line < 24; line++)
+       {
+               while (*p && *p != '\n') p++;
+               len = p - str;
+               if (len > 55) len = 55;
+               smalltext_out16_lim(1, line*10, str, 0xffff, len);
+               if (*p == 0) break;
+               p++; str = p;
+       }
+       menu_draw_end();
+}
+
+static void debug_menu_loop(void)
+{
+       draw_debug();
+       wait_for_input(BTN_X|BTN_CIRCLE);
+}
+
+// ------------ patch/gg menu ------------
+
+static void draw_patchlist(int sel)
+{
+       int start, i, pos, active;
+
+       start = 13 - sel;
+
+       menu_draw_begin();
+
+       for (i = 0; i < PicoPatchCount; i++) {
+               pos = start + i;
+               if (pos < 0)  continue;
+               if (pos > 26) break;
+               active = PicoPatches[i].active;
+               smalltext_out16_lim(14,     pos*10, active ? "ON " : "OFF", active ? 0xfff6 : 0xffff, 3);
+               smalltext_out16_lim(14+6*4, pos*10, PicoPatches[i].name, active ? 0xfff6 : 0xffff, 53-6);
+       }
+       pos = start + i;
+       if (pos < 27) smalltext_out16_lim(14, pos*10, "done", 0xffff, 4);
+
+       text_out16(5, 130, ">");
+       menu_draw_end();
+}
+
+
+static void patches_menu_loop(void)
+{
+       int menu_sel = 0;
+       unsigned long inp = 0;
+
+       for(;;)
+       {
+               draw_patchlist(menu_sel);
+               inp = wait_for_input(BTN_UP|BTN_DOWN|BTN_LEFT|BTN_RIGHT|BTN_L|BTN_R|BTN_X|BTN_CIRCLE);
+               if(inp & BTN_UP  ) { menu_sel--; if (menu_sel < 0) menu_sel = PicoPatchCount; }
+               if(inp & BTN_DOWN) { menu_sel++; if (menu_sel > PicoPatchCount) menu_sel = 0; }
+               if(inp &(BTN_LEFT|BTN_L))  { menu_sel-=10; if (menu_sel < 0) menu_sel = 0; }
+               if(inp &(BTN_RIGHT|BTN_R)) { menu_sel+=10; if (menu_sel > PicoPatchCount) menu_sel = PicoPatchCount; }
+               if(inp & BTN_X) { // action
+                       if (menu_sel < PicoPatchCount)
+                               PicoPatches[menu_sel].active = !PicoPatches[menu_sel].active;
+                       else    return;
+               }
+               if(inp & BTN_CIRCLE) return;
+       }
+
+}
+
+// ------------ savestate loader ------------
+
+static int state_slot_flags = 0;
+
+static void state_check_slots(void)
+{
+       int slot;
+
+       state_slot_flags = 0;
+
+       for (slot = 0; slot < 10; slot++)
+       {
+               if (emu_checkSaveFile(slot))
+               {
+                       state_slot_flags |= 1 << slot;
+               }
+       }
+}
+
+static void draw_savestate_bg(int slot)
+{
+       struct PicoVideo tmp_pv;
+       unsigned short tmp_cram[0x40];
+       unsigned short tmp_vsram[0x40];
+       void *tmp_vram, *file;
+       char *fname;
+
+       fname = emu_GetSaveFName(1, 0, slot);
+       if (!fname) return;
+
+       tmp_vram = malloc(sizeof(Pico.vram));
+       if (tmp_vram == NULL) return;
+
+       memcpy(tmp_vram, Pico.vram, sizeof(Pico.vram));
+       memcpy(tmp_cram, Pico.cram, sizeof(Pico.cram));
+       memcpy(tmp_vsram, Pico.vsram, sizeof(Pico.vsram));
+       memcpy(&tmp_pv, &Pico.video, sizeof(Pico.video));
+
+       if (strcmp(fname + strlen(fname) - 3, ".gz") == 0) {
+               file = gzopen(fname, "rb");
+               emu_setSaveStateCbs(1);
+       } else {
+               file = fopen(fname, "rb");
+               emu_setSaveStateCbs(0);
+       }
+
+       if (file) {
+               if (PicoMCD & 1) {
+                       PicoCdLoadStateGfx(file);
+               } else {
+                       areaSeek(file, 0x10020, SEEK_SET);  // skip header and RAM in state file
+                       areaRead(Pico.vram, 1, sizeof(Pico.vram), file);
+                       areaSeek(file, 0x2000, SEEK_CUR);
+                       areaRead(Pico.cram, 1, sizeof(Pico.cram), file);
+                       areaRead(Pico.vsram, 1, sizeof(Pico.vsram), file);
+                       areaSeek(file, 0x221a0, SEEK_SET);
+                       areaRead(&Pico.video, 1, sizeof(Pico.video), file);
+               }
+               areaClose(file);
+       }
+
+       emu_forcedFrame();
+       menu_prepare_bg(1);
+
+       memcpy(Pico.vram, tmp_vram, sizeof(Pico.vram));
+       memcpy(Pico.cram, tmp_cram, sizeof(Pico.cram));
+       memcpy(Pico.vsram, tmp_vsram, sizeof(Pico.vsram));
+       memcpy(&Pico.video, &tmp_pv,  sizeof(Pico.video));
+       free(tmp_vram);
+}
+
+static void draw_savestate_menu(int menu_sel, int is_loading)
+{
+       int tl_x = 80+25, tl_y = 16+60, y, i;
+
+       if (state_slot_flags & (1 << menu_sel))
+               draw_savestate_bg(menu_sel);
+       menu_draw_begin();
+
+       text_out16(tl_x, 16+30, is_loading ? "Load state" : "Save state");
+
+       menu_draw_selection(tl_x - 16, tl_y + menu_sel*10, 108);
+
+       /* draw all 10 slots */
+       y = tl_y;
+       for (i = 0; i < 10; i++, y+=10)
+       {
+               text_out16(tl_x, y, "SLOT %i (%s)", i, (state_slot_flags & (1 << i)) ? "USED" : "free");
+       }
+       text_out16(tl_x, y, "back");
+
+       menu_draw_end();
+}
+
+static int savestate_menu_loop(int is_loading)
+{
+       static int menu_sel = 10;
+       int menu_sel_max = 10;
+       unsigned long inp = 0;
+
+       state_check_slots();
+
+       for(;;)
+       {
+               draw_savestate_menu(menu_sel, is_loading);
+               inp = wait_for_input(BTN_UP|BTN_DOWN|BTN_X|BTN_CIRCLE);
+               if(inp & BTN_UP  ) {
+                       do {
+                               menu_sel--; if (menu_sel < 0) menu_sel = menu_sel_max;
+                       } while (!(state_slot_flags & (1 << menu_sel)) && menu_sel != menu_sel_max && is_loading);
+               }
+               if(inp & BTN_DOWN) {
+                       do {
+                               menu_sel++; if (menu_sel > menu_sel_max) menu_sel = 0;
+                       } while (!(state_slot_flags & (1 << menu_sel)) && menu_sel != menu_sel_max && is_loading);
+               }
+               if(inp & BTN_X) { // save/load
+                       if (menu_sel < 10) {
+                               state_slot = menu_sel;
+                               PicoStateProgressCB = emu_stateCb; /* also suitable for menu */
+                               if (emu_SaveLoadGame(is_loading, 0)) {
+                                       strcpy(menuErrorMsg, is_loading ? "Load failed" : "Save failed");
+                                       return 1;
+                               }
+                               return 0;
+                       } else  return 1;
+               }
+               if(inp & BTN_CIRCLE) return 1;
+       }
+}
+
+// -------------- key config --------------
+
+static char *action_binds(int player_idx, int action_mask)
+{
+       static char strkeys[32*5];
+       int i;
+
+       strkeys[0] = 0;
+       for (i = 0; i < 32; i++) // i is key index
+       {
+               if (currentConfig.KeyBinds[i] & action_mask)
+               {
+                       if (player_idx >= 0 && ((currentConfig.KeyBinds[i] >> 16) & 3) != player_idx) continue;
+                       if (strkeys[0]) { strcat(strkeys, " + "); strcat(strkeys, pspKeyNames[i]); break; }
+                       else strcpy(strkeys, pspKeyNames[i]);
+               }
+       }
+
+       return strkeys;
+}
+
+static void unbind_action(int action)
+{
+       int i;
+
+       for (i = 0; i < 32; i++)
+               currentConfig.KeyBinds[i] &= ~action;
+}
+
+static int count_bound_keys(int action, int pl_idx)
+{
+       int i, keys = 0;
+
+       for (i = 0; i < 32; i++)
+       {
+               if (pl_idx >= 0 && (currentConfig.KeyBinds[i]&0x30000) != (pl_idx<<16)) continue;
+               if (currentConfig.KeyBinds[i] & action) keys++;
+       }
+
+       return keys;
+}
+
+typedef struct { char *name; int mask; } bind_action_t;
+
+static void draw_key_config(const bind_action_t *opts, int opt_cnt, int player_idx, int sel)
+{
+       int x, y, tl_y = 16+40, i;
+
+       menu_draw_begin();
+       if (player_idx >= 0) {
+               text_out16(80+80, 16+20, "Player %i controls", player_idx + 1);
+               x = 80+80;
+       } else {
+               text_out16(80+80, 16+20, "Emulator controls");
+               x = 80+40;
+       }
+
+       menu_draw_selection(x - 16, tl_y + sel*10, (player_idx >= 0) ? 66 : 130);
+
+       y = tl_y;
+       for (i = 0; i < opt_cnt; i++, y+=10)
+               text_out16(x, y, "%s : %s", opts[i].name, action_binds(player_idx, opts[i].mask));
+
+       text_out16(x, y, "Done");
+
+       if (sel < opt_cnt) {
+               text_out16(80+30, 180, "Press a button to bind/unbind");
+               text_out16(80+30, 190, "Use SELECT to clear");
+               text_out16(80+30, 200, "To bind UP/DOWN, hold SELECT");
+               text_out16(80+30, 210, "Select \"Done\" to exit");
+       } else {
+               text_out16(80+30, 190, "Use Options -> Save cfg");
+               text_out16(80+30, 200, "to save controls");
+               text_out16(80+30, 210, "Press X or O to exit");
+       }
+       menu_draw_end();
+}
+
+static void key_config_loop(const bind_action_t *opts, int opt_cnt, int player_idx)
+{
+       int sel = 0, menu_sel_max = opt_cnt, prev_select = 0, i;
+       unsigned long inp = 0;
+
+       for (;;)
+       {
+               draw_key_config(opts, opt_cnt, player_idx, sel);
+               inp = wait_for_input(CONFIGURABLE_KEYS|BTN_SELECT);
+               if (!(inp & BTN_SELECT)) {
+                       prev_select = 0;
+                       if(inp & BTN_UP  ) { sel--; if (sel < 0) sel = menu_sel_max; continue; }
+                       if(inp & BTN_DOWN) { sel++; if (sel > menu_sel_max) sel = 0; continue; }
+               }
+               if (sel >= opt_cnt) {
+                       if (inp & (BTN_X|BTN_CIRCLE)) break;
+                       else continue;
+               }
+               // if we are here, we want to bind/unbind something
+               if ((inp & BTN_SELECT) && !prev_select)
+                       unbind_action(opts[sel].mask);
+               prev_select = inp & BTN_SELECT;
+               inp &= CONFIGURABLE_KEYS;
+               inp &= ~BTN_SELECT;
+               for (i = 0; i < 32; i++)
+                       if (inp & (1 << i)) {
+                               if (count_bound_keys(opts[sel].mask, player_idx) >= 2)
+                                    currentConfig.KeyBinds[i] &= ~opts[sel].mask; // allow to unbind only
+                               else currentConfig.KeyBinds[i] ^=  opts[sel].mask;
+                               if (player_idx >= 0 && (currentConfig.KeyBinds[i] & opts[sel].mask)) {
+                                       currentConfig.KeyBinds[i] &= ~(3 << 16);
+                                       currentConfig.KeyBinds[i] |= player_idx << 16;
+                               }
+                       }
+       }
+}
+
+static void draw_kc_sel(int menu_sel)
+{
+       int tl_x = 80+25+40, tl_y = 16+60, y;
+
+       y = tl_y;
+       menu_draw_begin();
+       menu_draw_selection(tl_x - 16, tl_y + menu_sel*10, 138);
+
+       text_out16(tl_x, y,       "Player 1");
+       text_out16(tl_x, (y+=10), "Player 2");
+       text_out16(tl_x, (y+=10), "Emulator controls");
+       text_out16(tl_x, (y+=10), "Done");
+
+       menu_draw_end();
+}
+
+
+// PicoPad[] format: MXYZ SACB RLDU
+static bind_action_t ctrl_actions[] =
+{
+       { "UP     ", 0x001 },
+       { "DOWN   ", 0x002 },
+       { "LEFT   ", 0x004 },
+       { "RIGHT  ", 0x008 },
+       { "A      ", 0x040 },
+       { "B      ", 0x010 },
+       { "C      ", 0x020 },
+       { "START  ", 0x080 },
+       { "MODE   ", 0x800 },
+       { "X      ", 0x400 },
+       { "Y      ", 0x200 },
+       { "Z      ", 0x100 },
+};
+
+// player2_flag, ?, ?, ?, ?, ?, ?, menu
+// "NEXT SAVE SLOT", "PREV SAVE SLOT", "SWITCH RENDERER", "SAVE STATE",
+// "LOAD STATE", "VOLUME UP", "VOLUME DOWN", "DONE"
+static bind_action_t emuctrl_actions[] =
+{
+       { "Load State     ", 1<<28 },
+       { "Save State     ", 1<<27 },
+       { "Prev Save Slot ", 1<<25 },
+       { "Next Save Slot ", 1<<24 },
+       { "Switch Renderer", 1<<26 },
+       { "Volume Down    ", 1<<30 },
+       { "Volume Up      ", 1<<29 },
+};
+
+static void kc_sel_loop(void)
+{
+       int menu_sel = 3, menu_sel_max = 3;
+       unsigned long inp = 0;
+       int is_6button = currentConfig.PicoOpt & 0x020;
+
+       while (1)
+       {
+               draw_kc_sel(menu_sel);
+               inp = wait_for_input(BTN_UP|BTN_DOWN|BTN_X|BTN_CIRCLE);
+               if (inp & BTN_UP  ) { menu_sel--; if (menu_sel < 0) menu_sel = menu_sel_max; }
+               if (inp & BTN_DOWN) { menu_sel++; if (menu_sel > menu_sel_max) menu_sel = 0; }
+               if (inp & BTN_X) {
+                       switch (menu_sel) {
+                               case 0: key_config_loop(ctrl_actions, is_6button ? 12 : 8, 0); return;
+                               case 1: key_config_loop(ctrl_actions, is_6button ? 12 : 8, 1); return;
+                               case 2: key_config_loop(emuctrl_actions,
+                                               sizeof(emuctrl_actions)/sizeof(emuctrl_actions[0]), -1); return;
+                               case 3: if (rom_data == NULL) emu_WriteConfig(0); return;
+                               default: return;
+                       }
+               }
+               if (inp & BTN_CIRCLE) return;
+       }
+}
+
+
+// --------- sega/mega cd options ----------
+
+menu_entry cdopt_entries[] =
+{
+       { NULL,                        MB_NONE,  MA_CDOPT_TESTBIOS_USA, NULL, 0, 0, 0, 1 },
+       { NULL,                        MB_NONE,  MA_CDOPT_TESTBIOS_EUR, NULL, 0, 0, 0, 1 },
+       { NULL,                        MB_NONE,  MA_CDOPT_TESTBIOS_JAP, NULL, 0, 0, 0, 1 },
+       { "CD LEDs",                   MB_ONOFF, MA_CDOPT_LEDS,         &currentConfig.EmuOpt,  0x0400, 0, 0, 1 },
+       { "CDDA audio (using mp3s)",   MB_ONOFF, MA_CDOPT_CDDA,         &currentConfig.PicoOpt, 0x0800, 0, 0, 1 },
+       { "PCM audio",                 MB_ONOFF, MA_CDOPT_PCM,          &currentConfig.PicoOpt, 0x0400, 0, 0, 1 },
+       { NULL,                        MB_NONE,  MA_CDOPT_READAHEAD,    NULL, 0, 0, 0, 1 },
+       { "SaveRAM cart",              MB_ONOFF, MA_CDOPT_SAVERAM,      &currentConfig.PicoOpt, 0x8000, 0, 0, 1 },
+       { "Scale/Rot. fx (slow)",      MB_ONOFF, MA_CDOPT_SCALEROT_CHIP,&currentConfig.PicoOpt, 0x1000, 0, 0, 1 },
+       { "Better sync (slow)",        MB_ONOFF, MA_CDOPT_BETTER_SYNC,  &currentConfig.PicoOpt, 0x2000, 0, 0, 1 },
+       { "done",                      MB_NONE,  MA_CDOPT_DONE,         NULL, 0, 0, 0, 1 },
+};
+
+#define CDOPT_ENTRY_COUNT (sizeof(cdopt_entries) / sizeof(cdopt_entries[0]))
+
+
+struct bios_names_t
+{
+       char us[32], eu[32], jp[32];
+};
+
+static void menu_cdopt_cust_draw(const menu_entry *entry, int x, int y, void *param)
+{
+       struct bios_names_t *bios_names = param;
+       char ra_buff[16];
+
+       switch (entry->id)
+       {
+               case MA_CDOPT_TESTBIOS_USA: text_out16(x, y, "USA BIOS:     %s", bios_names->us); break;
+               case MA_CDOPT_TESTBIOS_EUR: text_out16(x, y, "EUR BIOS:     %s", bios_names->eu); break;
+               case MA_CDOPT_TESTBIOS_JAP: text_out16(x, y, "JAP BIOS:     %s", bios_names->jp); break;
+               case MA_CDOPT_READAHEAD:
+                       if (PicoCDBuffers > 1) sprintf(ra_buff, "%5iK", PicoCDBuffers * 2);
+                       else strcpy(ra_buff, "     OFF");
+                       text_out16(x, y, "ReadAhead buffer      %s", ra_buff);
+                       break;
+               default:break;
+       }
+}
+
+static void draw_cd_menu_options(int menu_sel, struct bios_names_t *bios_names)
+{
+       int tl_x = 80+25, tl_y = 16+60;
+       menu_id selected_id;
+       char ra_buff[16];
+
+       if (PicoCDBuffers > 1) sprintf(ra_buff, "%5iK", PicoCDBuffers * 2);
+       else strcpy(ra_buff, "     OFF");
+
+       menu_draw_begin();
+
+       menu_draw_selection(tl_x - 16, tl_y + menu_sel*10, 246);
+
+       me_draw(cdopt_entries, CDOPT_ENTRY_COUNT, tl_x, tl_y, menu_cdopt_cust_draw, bios_names);
+
+       selected_id = me_index2id(cdopt_entries, CDOPT_ENTRY_COUNT, menu_sel);
+       if ((selected_id == MA_CDOPT_TESTBIOS_USA && strcmp(bios_names->us, "NOT FOUND")) ||
+               (selected_id == MA_CDOPT_TESTBIOS_EUR && strcmp(bios_names->eu, "NOT FOUND")) ||
+               (selected_id == MA_CDOPT_TESTBIOS_JAP && strcmp(bios_names->jp, "NOT FOUND")))
+                       text_out16(tl_x, 210, "Press start to test selected BIOS");
+
+       menu_draw_end();
+}
+
+static void cd_menu_loop_options(void)
+{
+       static int menu_sel = 0;
+       int menu_sel_max = 10;
+       unsigned long inp = 0;
+       struct bios_names_t bios_names;
+       menu_id selected_id;
+       char *bios, *p;
+
+       if (emu_findBios(4, &bios)) { // US
+               for (p = bios+strlen(bios)-1; p > bios && *p != '/'; p--); p++;
+               strncpy(bios_names.us, p, sizeof(bios_names.us)); bios_names.us[sizeof(bios_names.us)-1] = 0;
+       } else  strcpy(bios_names.us, "NOT FOUND");
+
+       if (emu_findBios(8, &bios)) { // EU
+               for (p = bios+strlen(bios)-1; p > bios && *p != '/'; p--); p++;
+               strncpy(bios_names.eu, p, sizeof(bios_names.eu)); bios_names.eu[sizeof(bios_names.eu)-1] = 0;
+       } else  strcpy(bios_names.eu, "NOT FOUND");
+
+       if (emu_findBios(1, &bios)) { // JP
+               for (p = bios+strlen(bios)-1; p > bios && *p != '/'; p--); p++;
+               strncpy(bios_names.jp, p, sizeof(bios_names.jp)); bios_names.jp[sizeof(bios_names.jp)-1] = 0;
+       } else  strcpy(bios_names.jp, "NOT FOUND");
+
+       for(;;)
+       {
+               draw_cd_menu_options(menu_sel, &bios_names);
+               inp = wait_for_input(BTN_UP|BTN_DOWN|BTN_LEFT|BTN_RIGHT|BTN_X|BTN_CIRCLE);
+               if (inp & BTN_UP  ) { menu_sel--; if (menu_sel < 0) menu_sel = menu_sel_max; }
+               if (inp & BTN_DOWN) { menu_sel++; if (menu_sel > menu_sel_max) menu_sel = 0; }
+               selected_id = me_index2id(cdopt_entries, CDOPT_ENTRY_COUNT, menu_sel);
+               if (inp & (BTN_LEFT|BTN_RIGHT)) { // multi choise
+                       if (!me_process(cdopt_entries, CDOPT_ENTRY_COUNT, selected_id, (inp&BTN_RIGHT) ? 1 : 0) &&
+                           selected_id == MA_CDOPT_READAHEAD) {
+                               if (inp & BTN_LEFT) {
+                                       PicoCDBuffers >>= 1;
+                                       if (PicoCDBuffers < 64) PicoCDBuffers = 0;
+                               } else {
+                                       if (PicoCDBuffers < 64) PicoCDBuffers = 64;
+                                       else PicoCDBuffers <<= 1;
+                                       if (PicoCDBuffers > 8*1024) PicoCDBuffers = 8*1024; // 16M
+                               }
+                       }
+               }
+               if (inp & BTN_X) { // toggleable options
+                       if (!me_process(cdopt_entries, CDOPT_ENTRY_COUNT, selected_id, 1) &&
+                           selected_id == MA_CDOPT_DONE) {
+                               return;
+                       }
+                       switch (selected_id) { // BIOS testers
+                               case MA_CDOPT_TESTBIOS_USA:
+                                       if (emu_findBios(4, &bios)) { // test US
+                                               strcpy(romFileName, bios);
+                                               engineState = PGS_ReloadRom;
+                                               return;
+                                       }
+                                       break;
+                               case MA_CDOPT_TESTBIOS_EUR:
+                                       if (emu_findBios(8, &bios)) { // test EU
+                                               strcpy(romFileName, bios);
+                                               engineState = PGS_ReloadRom;
+                                               return;
+                                       }
+                                       break;
+                               case MA_CDOPT_TESTBIOS_JAP:
+                                       if (emu_findBios(1, &bios)) { // test JP
+                                               strcpy(romFileName, bios);
+                                               engineState = PGS_ReloadRom;
+                                               return;
+                                       }
+                                       break;
+                               default:
+                                       break;
+                       }
+               }
+               if (inp & BTN_CIRCLE) return;
+       }
+}
+
+
+// --------- advanced options ----------
+
+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 },
+       { "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 },
+};
+
+#define OPT2_ENTRY_COUNT (sizeof(opt2_entries) / sizeof(opt2_entries[0]))
+
+
+static void draw_amenu_options(int menu_sel)
+{
+       int tl_x = 80+25, tl_y = 16+50;
+
+       menu_draw_begin();
+
+       menu_draw_selection(tl_x - 16, tl_y + menu_sel*10, 252);
+
+       me_draw(opt2_entries, OPT2_ENTRY_COUNT, tl_x, tl_y, NULL, NULL);
+
+       menu_draw_end();
+}
+
+static void amenu_loop_options(void)
+{
+       static int menu_sel = 0;
+       int menu_sel_max;
+       unsigned long inp = 0;
+       menu_id selected_id;
+
+       menu_sel_max = me_count_enabled(opt2_entries, OPT2_ENTRY_COUNT) - 1;
+
+       for(;;)
+       {
+               draw_amenu_options(menu_sel);
+               inp = wait_for_input(BTN_UP|BTN_DOWN|BTN_LEFT|BTN_RIGHT|BTN_X|BTN_CIRCLE);
+               if (inp & BTN_UP  ) { menu_sel--; if (menu_sel < 0) menu_sel = menu_sel_max; }
+               if (inp & BTN_DOWN) { menu_sel++; if (menu_sel > menu_sel_max) menu_sel = 0; }
+               selected_id = me_index2id(opt2_entries, OPT2_ENTRY_COUNT, menu_sel);
+               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)) {
+                                       currentConfig.gamma += (inp & BTN_LEFT) ? -1 : 1;
+                                       if (currentConfig.gamma <   1) currentConfig.gamma =   1;
+                                       if (currentConfig.gamma > 300) currentConfig.gamma = 300;
+                                       draw_amenu_options(menu_sel);
+                                       psp_msleep(18);
+                               }
+                       }
+               }
+               if (inp & BTN_X) { // toggleable options
+                       if (!me_process(opt2_entries, OPT2_ENTRY_COUNT, selected_id, 1) &&
+                           selected_id == MA_OPT2_DONE) {
+                               return;
+                       }
+               }
+               if (inp & BTN_CIRCLE) return;
+       }
+}
+
+// -------------- options --------------
+
+
+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 },
+       { "Show FPS",                  MB_ONOFF, MA_OPT_SHOW_FPS,      &currentConfig.EmuOpt,  0x0002, 0, 0, 1 },
+       { NULL,                        MB_RANGE, MA_OPT_FRAMESKIP,     &currentConfig.Frameskip, 0, -1, 16, 1 },
+       { "Enable sound",              MB_ONOFF, MA_OPT_ENABLE_SOUND,  &currentConfig.EmuOpt,  0x0004, 0, 0, 1 },
+       { NULL,                        MB_NONE,  MA_OPT_SOUND_QUALITY, NULL, 0, 0, 0, 1 },
+       { "6 button pad",              MB_ONOFF, MA_OPT_6BUTTON_PAD,   &currentConfig.PicoOpt, 0x0020, 0, 0, 1 },
+       { NULL,                        MB_NONE,  MA_OPT_REGION,        NULL, 0, 0, 0, 1 },
+       { "Use SRAM/BRAM savestates",  MB_ONOFF, MA_OPT_SRAM_STATES,   &currentConfig.EmuOpt,  0x0001, 0, 0, 1 },
+       { NULL,                        MB_NONE,  MA_OPT_CONFIRM_STATES,NULL, 0, 0, 0, 1 },
+       { "Save slot",                 MB_RANGE, MA_OPT_SAVE_SLOT,     &state_slot, 0, 0, 9, 1 },
+       { "[Sega/Mega CD options]",    MB_NONE,  MA_OPT_SCD_OPTS,      NULL, 0, 0, 0, 1 },
+       { "[advanced options]",        MB_NONE,  MA_OPT_ADV_OPTS,      NULL, 0, 0, 0, 1 },
+       { NULL,                        MB_NONE,  MA_OPT_SAVECFG,       NULL, 0, 0, 0, 1 },
+       { "Save cfg for current game only",MB_NONE,MA_OPT_SAVECFG_GAME,NULL, 0, 0, 0, 1 },
+       { NULL,                        MB_NONE,  MA_OPT_LOADCFG,       NULL, 0, 0, 0, 1 },
+};
+
+#define OPT_ENTRY_COUNT (sizeof(opt_entries) / sizeof(opt_entries[0]))
+
+
+static const char *region_name(unsigned int code)
+{
+       static const char *names[] = { "Auto", "      Japan NTSC", "      Japan PAL", "      USA", "      Europe" };
+       static const char *names_short[] = { "", " JP", " JP", " US", " EU" };
+       int u, i = 0;
+       if (code) {
+               code <<= 1;
+               while((code >>= 1)) i++;
+               if (i > 4) return "unknown";
+               return names[i];
+       } else {
+               static char name[24];
+               strcpy(name, "Auto:");
+               for (u = 0; u < 3; u++) {
+                       i = 0; code = ((PicoAutoRgnOrder >> u*4) & 0xf) << 1;
+                       while((code >>= 1)) i++;
+                       strcat(name, names_short[i]);
+               }
+               return name;
+       }
+}
+
+
+static void menu_opt_cust_draw(const menu_entry *entry, int x, int y, void *param)
+{
+       char *str, str24[24];
+
+       switch (entry->id)
+       {
+               case MA_OPT_RENDERER:
+                       if (currentConfig.PicoOpt&0x10)
+                               str = " 8bit fast";
+                       else if (currentConfig.EmuOpt&0x80)
+                               str = "16bit accurate";
+                       else
+                               str = " 8bit accurate";
+                       text_out16(x, y, "Renderer:            %s", str);
+                       break;
+               case MA_OPT_FRAMESKIP:
+                       if (currentConfig.Frameskip < 0)
+                            strcpy(str24, "Auto");
+                       else sprintf(str24, "%i", currentConfig.Frameskip);
+                       text_out16(x, y, "Frameskip                  %s", str24);
+                       break;
+               case MA_OPT_SOUND_QUALITY:
+                       str = (currentConfig.PicoOpt&0x08)?"stereo":"mono";
+                       text_out16(x, y, "Sound Quality:     %5iHz %s", currentConfig.PsndRate, str);
+                       break;
+               case MA_OPT_REGION:
+                       text_out16(x, y, "Region:              %s", region_name(currentConfig.PicoRegion));
+                       break;
+               case MA_OPT_CONFIRM_STATES:
+                       switch ((currentConfig.EmuOpt >> 9) & 5) {
+                               default: str = "OFF";    break;
+                               case 1:  str = "writes"; break;
+                               case 4:  str = "loads";  break;
+                               case 5:  str = "both";   break;
+                       }
+                       text_out16(x, y, "Confirm savestate          %s", str);
+                       break;
+               case MA_OPT_SAVECFG:
+                       str24[0] = 0;
+                       if (config_slot != 0) sprintf(str24, " (profile: %i)", config_slot);
+                       text_out16(x, y, "Save cfg as default%s", str24);
+                       break;
+               case MA_OPT_LOADCFG:
+                       text_out16(x, y, "Load cfg from profile %i", config_slot);
+                       break;
+               default:
+                       lprintf("%s: unimplemented (%i)\n", __FUNCTION__, entry->id);
+                       break;
+       }
+}
+
+
+
+static void draw_menu_options(int menu_sel)
+{
+       int tl_x = 80+25, tl_y = 16+24;
+
+       menu_draw_begin();
+
+       menu_draw_selection(tl_x - 16, tl_y + menu_sel*10, 284);
+
+       me_draw(opt_entries, OPT_ENTRY_COUNT, tl_x, tl_y, menu_opt_cust_draw, NULL);
+
+       menu_draw_end();
+}
+
+static int sndrate_prevnext(int rate, int dir)
+{
+       int i, rates[] = { 11025, 22050, 44100 };
+
+       for (i = 0; i < 5; i++)
+               if (rates[i] == rate) break;
+
+       i += dir ? 1 : -1;
+       if (i > 2) return dir ? 44100 : 22050;
+       if (i < 0) return dir ? 22050 : 11025;
+       return rates[i];
+}
+
+static void region_prevnext(int right)
+{
+       // jp_ntsc=1, jp_pal=2, usa=4, eu=8
+       static int rgn_orders[] = { 0x148, 0x184, 0x814, 0x418, 0x841, 0x481 };
+       int i;
+       if (right) {
+               if (!currentConfig.PicoRegion) {
+                       for (i = 0; i < 6; i++)
+                               if (rgn_orders[i] == PicoAutoRgnOrder) break;
+                       if (i < 5) PicoAutoRgnOrder = rgn_orders[i+1];
+                       else currentConfig.PicoRegion=1;
+               }
+               else currentConfig.PicoRegion<<=1;
+               if (currentConfig.PicoRegion > 8) currentConfig.PicoRegion = 8;
+       } else {
+               if (!currentConfig.PicoRegion) {
+                       for (i = 0; i < 6; i++)
+                               if (rgn_orders[i] == PicoAutoRgnOrder) break;
+                       if (i > 0) PicoAutoRgnOrder = rgn_orders[i-1];
+               }
+               else currentConfig.PicoRegion>>=1;
+       }
+}
+
+static void menu_options_save(void)
+{
+       PicoOpt = currentConfig.PicoOpt;
+       PsndRate = currentConfig.PsndRate;
+       PicoRegionOverride = currentConfig.PicoRegion;
+       if (!(PicoOpt & 0x20)) {
+               // unbind XYZ MODE, just in case
+               unbind_action(0xf00);
+       }
+}
+
+static int menu_loop_options(void)
+{
+       static int menu_sel = 0;
+       int menu_sel_max, ret;
+       unsigned long inp = 0;
+       menu_id selected_id;
+
+       currentConfig.PicoOpt = PicoOpt;
+       currentConfig.PsndRate = PsndRate;
+       currentConfig.PicoRegion = PicoRegionOverride;
+
+       me_enable(opt_entries, OPT_ENTRY_COUNT, MA_OPT_SAVECFG_GAME, rom_data != NULL);
+       me_enable(opt_entries, OPT_ENTRY_COUNT, MA_OPT_LOADCFG, config_slot != config_slot_current);
+       menu_sel_max = me_count_enabled(opt_entries, OPT_ENTRY_COUNT) - 1;
+       if (menu_sel > menu_sel_max) menu_sel = menu_sel_max;
+
+       while (1)
+       {
+               draw_menu_options(menu_sel);
+               inp = wait_for_input(BTN_UP|BTN_DOWN|BTN_LEFT|BTN_RIGHT|BTN_X|BTN_CIRCLE);
+               if (inp & BTN_UP  ) { menu_sel--; if (menu_sel < 0) menu_sel = menu_sel_max; }
+               if (inp & BTN_DOWN) { menu_sel++; if (menu_sel > menu_sel_max) menu_sel = 0; }
+               selected_id = me_index2id(opt_entries, OPT_ENTRY_COUNT, menu_sel);
+               if (inp & (BTN_LEFT|BTN_RIGHT)) { // multi choise
+                       if (!me_process(opt_entries, OPT_ENTRY_COUNT, selected_id, (inp&BTN_RIGHT) ? 1 : 0)) {
+                               switch (selected_id) {
+                                       case MA_OPT_RENDERER:
+                                               if (inp & BTN_LEFT) {
+                                                       if ((currentConfig.PicoOpt&0x10) || !(currentConfig.EmuOpt &0x80)) {
+                                                               currentConfig.PicoOpt&= ~0x10;
+                                                               currentConfig.EmuOpt |=  0x80;
+                                                       }
+                                               } else {
+                                                       if (!(currentConfig.PicoOpt&0x10) || (currentConfig.EmuOpt &0x80)) {
+                                                               currentConfig.PicoOpt|=  0x10;
+                                                               currentConfig.EmuOpt &= ~0x80;
+                                                       }
+                                               }
+                                               break;
+                                       case MA_OPT_SOUND_QUALITY:
+                                               if ((inp & BTN_RIGHT) && currentConfig.PsndRate == 44100 &&
+                                                               !(currentConfig.PicoOpt&0x08))
+                                               {
+                                                       currentConfig.PsndRate =  11025;
+                                                       currentConfig.PicoOpt |=  8;
+                                               } else if ((inp & BTN_LEFT) && currentConfig.PsndRate == 11025 &&
+                                                               (currentConfig.PicoOpt&0x08) && !(PicoMCD&1))
+                                               {
+                                                       currentConfig.PsndRate =  44100;
+                                                       currentConfig.PicoOpt &= ~8;
+                                               } else
+                                                       currentConfig.PsndRate = sndrate_prevnext(currentConfig.PsndRate, inp & BTN_RIGHT);
+                                               break;
+                                       case MA_OPT_REGION:
+                                               region_prevnext(inp & BTN_RIGHT);
+                                               break;
+                                       case MA_OPT_CONFIRM_STATES: {
+                                                        int n = ((currentConfig.EmuOpt>>9)&1) | ((currentConfig.EmuOpt>>10)&2);
+                                                        n += (inp & BTN_LEFT) ? -1 : 1;
+                                                        if (n < 0) n = 0; else if (n > 3) n = 3;
+                                                        n |= n << 1; n &= ~2;
+                                                        currentConfig.EmuOpt &= ~0xa00;
+                                                        currentConfig.EmuOpt |= n << 9;
+                                                        break;
+                                                }
+                                       case MA_OPT_SAVE_SLOT:
+                                                if (inp & BTN_RIGHT) {
+                                                        state_slot++; if (state_slot > 9) state_slot = 0;
+                                                } else {state_slot--; if (state_slot < 0) state_slot = 9;
+                                                }
+                                                break;
+                                       case MA_OPT_SAVECFG:
+                                       case MA_OPT_SAVECFG_GAME:
+                                       case MA_OPT_LOADCFG:
+                                                config_slot += (inp&BTN_RIGHT) ? 1 : -1;
+                                                if (config_slot > 9) config_slot = 0;
+                                                if (config_slot < 0) config_slot = 9;
+                                                me_enable(opt_entries, OPT_ENTRY_COUNT, MA_OPT_LOADCFG, config_slot != config_slot_current);
+                                                menu_sel_max = me_count_enabled(opt_entries, OPT_ENTRY_COUNT) - 1;
+                                                if (menu_sel > menu_sel_max) menu_sel = menu_sel_max;
+                                                break;
+                                       default:
+                                               //lprintf("%s: something unknown selected (%i)\n", __FUNCTION__, selected_id);
+                                               break;
+                               }
+                       }
+               }
+               if (inp & BTN_X) {
+                       if (!me_process(opt_entries, OPT_ENTRY_COUNT, selected_id, 1))
+                       {
+                               switch (selected_id)
+                               {
+                                       case MA_OPT_SCD_OPTS:
+                                               cd_menu_loop_options();
+                                               if (engineState == PGS_ReloadRom)
+                                                       return 0; // test BIOS
+                                               break;
+                                       case MA_OPT_ADV_OPTS:
+                                               amenu_loop_options();
+                                               break;
+                                       case MA_OPT_SAVECFG: // done (update and write)
+                                               menu_options_save();
+                                               if (emu_WriteConfig(0)) strcpy(menuErrorMsg, "config saved");
+                                               else strcpy(menuErrorMsg, "failed to write config");
+                                               return 1;
+                                       case MA_OPT_SAVECFG_GAME: // done (update and write for current game)
+                                               menu_options_save();
+                                               if (emu_WriteConfig(1)) strcpy(menuErrorMsg, "config saved");
+                                               else strcpy(menuErrorMsg, "failed to write config");
+                                               return 1;
+                                       case MA_OPT_LOADCFG:
+                                               ret = emu_ReadConfig(1, 1);
+                                               if (!ret) ret = emu_ReadConfig(0, 1);
+                                               if (ret)  strcpy(menuErrorMsg, "config loaded");
+                                               else      strcpy(menuErrorMsg, "failed to load config");
+                                               return 1;
+                                       default:
+                                               //lprintf("%s: something unknown selected (%i)\n", __FUNCTION__, selected_id);
+                                               break;
+                               }
+                       }
+               }
+               if(inp & BTN_CIRCLE) {
+                       menu_options_save();
+                       return 0;  // done (update, no write)
+               }
+       }
+}
+
+// -------------- credits --------------
+
+static void draw_menu_credits(void)
+{
+       int tl_x = 80+15, tl_y = 16+64, y;
+       menu_draw_begin();
+
+       text_out16(tl_x, 16+20, "PicoDrive v" VERSION " (c) notaz, 2006,2007");
+
+       y = tl_y;
+       text_out16(tl_x, y, "Credits:");
+       text_out16(tl_x, (y+=10), "Dave: base code of PicoDrive");
+       text_out16(tl_x, (y+=10), "MAME devs: YM2612 and SN76496 cores");
+       text_out16(tl_x, (y+=10), "Charles MacDonald: Genesis hw docs");
+       text_out16(tl_x, (y+=10), "Stephane Dallongeville:");
+       text_out16(tl_x, (y+=10), "      opensource Gens");
+       text_out16(tl_x, (y+=10), "Haze: Genesis hw info");
+       text_out16(tl_x, (y+=10), "ketchupgun: skin design");
+
+       menu_draw_end();
+}
+
+
+// -------------- root menu --------------
+
+menu_entry main_entries[] =
+{
+       { "Resume game",        MB_NONE, MA_MAIN_RESUME_GAME, NULL, 0, 0, 0, 0 },
+       { "Save State",         MB_NONE, MA_MAIN_SAVE_STATE,  NULL, 0, 0, 0, 0 },
+       { "Load State",         MB_NONE, MA_MAIN_LOAD_STATE,  NULL, 0, 0, 0, 0 },
+       { "Reset game",         MB_NONE, MA_MAIN_RESET_GAME,  NULL, 0, 0, 0, 0 },
+       { "Load new ROM/ISO",   MB_NONE, MA_MAIN_LOAD_ROM,    NULL, 0, 0, 0, 1 },
+       { "Change options",     MB_NONE, MA_MAIN_OPTIONS,     NULL, 0, 0, 0, 1 },
+       { "Configure controls", MB_NONE, MA_MAIN_CONTROLS,    NULL, 0, 0, 0, 1 },
+       { "Credits",            MB_NONE, MA_MAIN_CREDITS,     NULL, 0, 0, 0, 1 },
+       { "Patches / GameGenie",MB_NONE, MA_MAIN_PATCHES,     NULL, 0, 0, 0, 0 },
+       { "Exit",               MB_NONE, MA_MAIN_EXIT,        NULL, 0, 0, 0, 1 }
+};
+
+#define MAIN_ENTRY_COUNT (sizeof(main_entries) / sizeof(main_entries[0]))
+
+static void draw_menu_root(int menu_sel)
+{
+       const int tl_x = 80+70, tl_y = 16+70;
+
+       menu_draw_begin();
+
+       text_out16(tl_x, 16+20, "PicoDrive v" VERSION);
+
+       menu_draw_selection(tl_x - 16, tl_y + menu_sel*10, 146);
+
+       me_draw(main_entries, MAIN_ENTRY_COUNT, tl_x, tl_y, NULL, NULL);
+
+       // error
+       if (menuErrorMsg[0]) {
+               // memset((char *)menu_screen + 321*224*2, 0, 321*16*2);
+               text_out16(5, 258, menuErrorMsg);
+       }
+       menu_draw_end();
+}
+
+
+static void menu_loop_root(void)
+{
+       static int menu_sel = 0;
+       int ret, menu_sel_max;
+       unsigned long inp = 0;
+
+       me_enable(main_entries, MAIN_ENTRY_COUNT, MA_MAIN_RESUME_GAME, rom_data != NULL);
+       me_enable(main_entries, MAIN_ENTRY_COUNT, MA_MAIN_SAVE_STATE,  rom_data != NULL);
+       me_enable(main_entries, MAIN_ENTRY_COUNT, MA_MAIN_LOAD_STATE,  rom_data != NULL);
+       me_enable(main_entries, MAIN_ENTRY_COUNT, MA_MAIN_RESET_GAME,  rom_data != NULL);
+       me_enable(main_entries, MAIN_ENTRY_COUNT, MA_MAIN_PATCHES,     PicoPatches != NULL);
+
+       menu_sel_max = me_count_enabled(main_entries, MAIN_ENTRY_COUNT) - 1;
+       if (menu_sel > menu_sel_max) menu_sel = menu_sel_max;
+
+       /* 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);
+
+       for (;;)
+       {
+               draw_menu_root(menu_sel);
+               inp = wait_for_input(BTN_UP|BTN_DOWN|BTN_X|BTN_CIRCLE|BTN_SELECT|BTN_L|BTN_R);
+               if(inp & BTN_UP  )  { menu_sel--; if (menu_sel < 0) menu_sel = menu_sel_max; }
+               if(inp & BTN_DOWN)  { menu_sel++; if (menu_sel > menu_sel_max) menu_sel = 0; }
+               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
+                               engineState = PGS_Running;
+                               break;
+                       }
+               }
+               if(inp & BTN_X)  {
+                       switch (me_index2id(main_entries, MAIN_ENTRY_COUNT, menu_sel))
+                       {
+                               case MA_MAIN_RESUME_GAME:
+                                       if (rom_data) {
+                                               while (psp_pad_read() & BTN_X) psp_msleep(50);
+                                               engineState = PGS_Running;
+                                               return;
+                                       }
+                                       break;
+                               case MA_MAIN_SAVE_STATE:
+                                       if (rom_data) {
+                                               if(savestate_menu_loop(0))
+                                                       continue;
+                                               engineState = PGS_Running;
+                                               return;
+                                       }
+                                       break;
+                               case MA_MAIN_LOAD_STATE:
+                                       if (rom_data) {
+                                               if(savestate_menu_loop(1))
+                                                       continue;
+                                               engineState = PGS_Running;
+                                               return;
+                                       }
+                                       break;
+                               case MA_MAIN_RESET_GAME:
+                                       if (rom_data) {
+                                               emu_ResetGame();
+                                               engineState = PGS_Running;
+                                               return;
+                                       }
+                                       break;
+                               case MA_MAIN_LOAD_ROM:
+                               {
+                                       char curr_path[PATH_MAX], *selfname;
+                                       FILE *tstf;
+                                       if ( (tstf = fopen(currentConfig.lastRomFile, "rb")) )
+                                       {
+                                               fclose(tstf);
+                                               strcpy(curr_path, currentConfig.lastRomFile);
+                                       }
+                                       else
+                                               getcwd(curr_path, PATH_MAX);
+                                       selfname = romsel_loop(curr_path);
+                                       if (selfname) {
+                                               lprintf("selected file: %s\n", selfname);
+                                               engineState = PGS_ReloadRom;
+                                               return;
+                                       }
+                                       break;
+                               }
+                               case MA_MAIN_OPTIONS:
+                                       ret = menu_loop_options();
+                                       if (ret == 1) continue; // status update
+                                       if (engineState == PGS_ReloadRom)
+                                               return; // BIOS test
+                                       break;
+                               case MA_MAIN_CONTROLS:
+                                       kc_sel_loop();
+                                       break;
+                               case MA_MAIN_CREDITS:
+                                       draw_menu_credits();
+                                       psp_msleep(500);
+                                       inp = wait_for_input(BTN_X|BTN_CIRCLE);
+                                       break;
+                               case MA_MAIN_EXIT:
+                                       engineState = PGS_Quit;
+                                       return;
+                               case MA_MAIN_PATCHES:
+                                       if (rom_data && PicoPatches) {
+                                               patches_menu_loop();
+                                               PicoPatchApply();
+                                               strcpy(menuErrorMsg, "Patches applied");
+                                               continue;
+                                       }
+                                       break;
+                               default:
+                                       lprintf("%s: something unknown selected\n", __FUNCTION__);
+                                       break;
+                       }
+               }
+               menuErrorMsg[0] = 0; // clear error msg
+       }
+}
+
+// warning: alignment
+static void menu_darken_bg(void *dst, const void *src, int pixels, int darker)
+{
+       unsigned int *dest = dst;
+       const unsigned int *srce = src;
+       pixels /= 2;
+       if (darker)
+       {
+               while (pixels--)
+               {
+                       unsigned int p = *srce++;
+                       *dest++ = ((p&0xf79ef79e)>>1) - ((p&0xc618c618)>>3);
+               }
+       }
+       else
+       {
+               while (pixels--)
+               {
+                       unsigned int p = *srce++;
+                       *dest++ = (p&0xf79ef79e)>>1;
+               }
+       }
+}
+
+static void menu_prepare_bg(int use_game_bg)
+{
+       memset(bg_buffer, 0, sizeof(bg_buffer));
+
+       if (use_game_bg)
+       {
+               // darken the active framebuffer
+               /*
+               memset(bg_buffer, 0, 321*8*2);
+               menu_darken_bg(bg_buffer + 321*8*2, (char *)giz_screen + 321*8*2, 321*224, 1);
+               memset(bg_buffer + 321*232*2, 0, 321*8*2);
+               */
+       }
+       else
+       {
+               // should really only happen once, on startup..
+               readpng(bg_buffer, "skin/background.png", READPNG_BG);
+       }
+}
+
+static void menu_gfx_prepare(void)
+{
+       menu_prepare_bg(rom_data != NULL);
+
+       menu_draw_begin();
+       menu_draw_end();
+}
+
+
+void menu_loop(void)
+{
+       menu_gfx_prepare();
+
+       menu_loop_root();
+
+       menuErrorMsg[0] = 0;
+}
+
+
+// --------- CD tray close menu ----------
+
+static void draw_menu_tray(int menu_sel)
+{
+       int tl_x = 70, tl_y = 90, y;
+
+       menu_draw_begin();
+
+       text_out16(tl_x, 20, "The unit is about to");
+       text_out16(tl_x, 30, "close the CD tray.");
+
+       y = tl_y;
+       text_out16(tl_x, y,       "Load new CD image");
+       text_out16(tl_x, (y+=10), "Insert nothing");
+
+       // draw cursor
+       text_out16(tl_x - 16, tl_y + menu_sel*10, ">");
+       // error
+       if (menuErrorMsg[0]) text_out16(5, 226, menuErrorMsg);
+       menu_draw_end();
+}
+
+
+int menu_loop_tray(void)
+{
+       int menu_sel = 0, menu_sel_max = 1;
+       unsigned long inp = 0;
+       char curr_path[PATH_MAX], *selfname;
+       FILE *tstf;
+
+       menu_gfx_prepare();
+
+       if ( (tstf = fopen(currentConfig.lastRomFile, "rb")) )
+       {
+               fclose(tstf);
+               strcpy(curr_path, currentConfig.lastRomFile);
+       }
+       else
+       {
+               getcwd(curr_path, PATH_MAX);
+       }
+
+       /* make sure action buttons are not pressed on entering menu */
+       draw_menu_tray(menu_sel);
+       while (psp_pad_read() & BTN_X) psp_msleep(50);
+
+       for (;;)
+       {
+               draw_menu_tray(menu_sel);
+               inp = wait_for_input(BTN_UP|BTN_DOWN|BTN_X);
+               if(inp & BTN_UP  )  { menu_sel--; if (menu_sel < 0) menu_sel = menu_sel_max; }
+               if(inp & BTN_DOWN)  { menu_sel++; if (menu_sel > menu_sel_max) menu_sel = 0; }
+               if(inp & BTN_X   )  {
+                       switch (menu_sel) {
+                               case 0: // select image
+                                       selfname = romsel_loop(curr_path);
+                                       if (selfname) {
+                                               int ret = -1, cd_type;
+                                               cd_type = emu_cdCheck(NULL);
+                                               if (cd_type > 0)
+                                                       ret = Insert_CD(romFileName, cd_type == 2);
+                                               if (ret != 0) {
+                                                       sprintf(menuErrorMsg, "Load failed, invalid CD image?");
+                                                       lprintf("%s\n", menuErrorMsg);
+                                                       continue;
+                                               }
+                                               engineState = PGS_RestartRun;
+                                               return 1;
+                                       }
+                                       break;
+                               case 1: // insert nothing
+                                       engineState = PGS_RestartRun;
+                                       return 0;
+                       }
+               }
+               menuErrorMsg[0] = 0; // clear error msg
+       }
+}
+
+
diff --git a/platform/psp/menu.h b/platform/psp/menu.h
new file mode 100644 (file)
index 0000000..fa6c90c
--- /dev/null
@@ -0,0 +1,13 @@
+// (c) Copyright 2006,2007 notaz, All rights reserved.
+// Free for non-commercial use.
+
+// For commercial use, separate licencing terms must be obtained.
+
+void menu_loop(void);
+int  menu_loop_tray(void);
+void menu_romload_prepare(const char *rom_name);
+void menu_romload_end(void);
+
+
+#define CONFIGURABLE_KEYS (BTN_UP|BTN_LEFT|BTN_RIGHT|BTN_DOWN|BTN_L|BTN_R|BTN_TRIANGLE|BTN_CIRCLE|BTN_X|BTN_SQUARE|BTN_START|BTN_NOTE)
+
diff --git a/platform/psp/mp3.c b/platform/psp/mp3.c
new file mode 100644 (file)
index 0000000..ac00660
--- /dev/null
@@ -0,0 +1,20 @@
+#include <stdio.h>
+
+int mp3_get_bitrate(FILE *f, int size)
+{
+       return 0;
+}
+
+void mp3_start_play(FILE *f, int pos)
+{
+}
+
+int  mp3_get_offset(void) // 0-1023
+{
+       return 0;
+}
+
+void mp3_update(int *buffer, int length, int stereo)
+{
+}
+
diff --git a/platform/psp/port_config.h b/platform/psp/port_config.h
new file mode 100644 (file)
index 0000000..dcd5032
--- /dev/null
@@ -0,0 +1,24 @@
+// port specific settings\r
+\r
+#ifndef PORT_CONFIG_H\r
+#define PORT_CONFIG_H\r
+\r
+#define CPU_CALL\r
+\r
+// draw.c\r
+#define OVERRIDE_HIGHCOL 0\r
+\r
+// draw2.c\r
+#define START_ROW  0 // which row of tiles to start rendering at?\r
+#define END_ROW   28 // ..end\r
+\r
+// pico.c\r
+#define CAN_HANDLE_240_LINES   1\r
+\r
+// logging emu events\r
+#define EL_LOGMASK 0 // (EL_STATUS|EL_ANOMALY|EL_UIO|EL_SRAMIO) // xffff\r
+\r
+//#define dprintf(f,...) printf("%05i:%03i: " f "\n",Pico.m.frame_count,Pico.m.scanline,##__VA_ARGS__)\r
+#define dprintf(x...)\r
+\r
+#endif //PORT_CONFIG_H\r
diff --git a/platform/psp/psp.c b/platform/psp/psp.c
new file mode 100644 (file)
index 0000000..4bc1020
--- /dev/null
@@ -0,0 +1,96 @@
+#include <pspkernel.h>
+#include <pspdisplay.h>
+#include <pspgu.h>
+
+#include "psp.h"
+#include "../common/lprintf.h"
+
+PSP_MODULE_INFO("PicoDrive", 0, 1, 34);
+
+void *psp_screen = PSP_VRAM_BASE0;
+static int current_screen = 0; /* front bufer */
+
+
+/* Exit callback */
+static int exit_callback(int arg1, int arg2, void *common)
+{
+       sceKernelExitGame();
+       return 0;
+}
+
+/* Callback thread */
+static int callback_thread(SceSize args, void *argp)
+{
+       int cbid;
+
+       lprintf("callback_thread started with id %i\n", sceKernelGetThreadId());
+
+       cbid = sceKernelCreateCallback("Exit Callback", exit_callback, NULL);
+       sceKernelRegisterExitCallback(cbid);
+
+       sceKernelSleepThreadCB();
+
+       return 0;
+}
+
+void psp_init(void)
+{
+       int thid;
+
+       lprintf("entered psp_init, threadId %i\n", sceKernelGetThreadId());
+
+       thid = sceKernelCreateThread("update_thread", callback_thread, 0x11, 0xFA0, 0, 0);
+       if (thid >= 0)
+       {
+               sceKernelStartThread(thid, 0, 0);
+       }
+
+       /* video */
+       sceDisplaySetMode(0, 480, 272);
+       sceDisplaySetFrameBuf(PSP_VRAM_BASE1, 512, PSP_DISPLAY_PIXEL_FORMAT_565, PSP_DISPLAY_SETBUF_NEXTFRAME);
+       current_screen = 1;
+       psp_screen = PSP_VRAM_BASE0;
+
+       /* gu */
+       sceGuInit();
+
+       /* input */
+       sceCtrlSetSamplingCycle(0);
+       sceCtrlSetSamplingMode(0);
+}
+
+void psp_finish(void)
+{
+       sceGuTerm();
+
+       //sceKernelSleepThread();
+       sceKernelExitGame();
+}
+
+void psp_video_flip(void)
+{
+       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;
+}
+
+void psp_video_switch_to_single(void)
+{
+       psp_screen = PSP_VRAM_BASE0;
+       sceDisplaySetFrameBuf(psp_screen, 512, PSP_DISPLAY_PIXEL_FORMAT_565, PSP_DISPLAY_SETBUF_NEXTFRAME);
+       current_screen = 0;
+}
+
+void psp_msleep(int ms)
+{
+       sceKernelDelayThread(ms * 1000);
+}
+
+unsigned int psp_pad_read(void)
+{
+       SceCtrlData pad;
+       sceCtrlReadBufferPositive(&pad, 1);
+
+       return pad.Buttons;
+}
+
diff --git a/platform/psp/psp.h b/platform/psp/psp.h
new file mode 100644 (file)
index 0000000..cece8cf
--- /dev/null
@@ -0,0 +1,32 @@
+#include <pspctrl.h>
+
+void psp_init(void);
+void psp_finish(void);
+
+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);
+extern void *psp_screen;
+
+unsigned int psp_pad_read(void);
+
+
+/* shorter btn names */
+#define BTN_UP       PSP_CTRL_UP
+#define BTN_LEFT     PSP_CTRL_LEFT
+#define BTN_RIGHT    PSP_CTRL_RIGHT
+#define BTN_DOWN     PSP_CTRL_DOWN
+#define BTN_L        PSP_CTRL_LTRIGGER
+#define BTN_R        PSP_CTRL_RTRIGGER
+#define BTN_TRIANGLE PSP_CTRL_TRIANGLE
+#define BTN_CIRCLE   PSP_CTRL_CIRCLE
+#define BTN_X        PSP_CTRL_CROSS
+#define BTN_SQUARE   PSP_CTRL_SQUARE
+#define BTN_SELECT   PSP_CTRL_SELECT
+#define BTN_START    PSP_CTRL_START
+#define BTN_NOTE     PSP_CTRL_NOTE
+
diff --git a/platform/psp/skin/background.png b/platform/psp/skin/background.png
new file mode 100644 (file)
index 0000000..cb6a377
Binary files /dev/null and b/platform/psp/skin/background.png differ
diff --git a/platform/psp/skin/font.png b/platform/psp/skin/font.png
new file mode 100644 (file)
index 0000000..c526a08
Binary files /dev/null and b/platform/psp/skin/font.png differ
diff --git a/platform/psp/skin/readme.txt b/platform/psp/skin/readme.txt
new file mode 100644 (file)
index 0000000..dd83963
--- /dev/null
@@ -0,0 +1,8 @@
+The skin images can be customized, but there are several limitations:\r
+\r
+background.png - must be 320x240 image with 24bit RGB colors.\r
+font.png       - must be 128x160 8bit grayscale image.\r
+selector.png   - must be 8x10 8bit grayscale image.\r
+\r
+Font and selector colors can be changed by editing skin.txt.\r
+\r
diff --git a/platform/psp/skin/selector.png b/platform/psp/skin/selector.png
new file mode 100644 (file)
index 0000000..5062cc2
Binary files /dev/null and b/platform/psp/skin/selector.png differ
diff --git a/platform/psp/skin/skin.txt b/platform/psp/skin/skin.txt
new file mode 100644 (file)
index 0000000..c2baeb2
--- /dev/null
@@ -0,0 +1,4 @@
+// html-style hex color codes, ex. ff0000 is red, 0000ff is blue, etc.\r
+text_color=ffffff\r
+selection_color=c00000\r
+\r
diff --git a/platform/psp/version.h b/platform/psp/version.h
new file mode 100644 (file)
index 0000000..93ee956
--- /dev/null
@@ -0,0 +1,2 @@
+#define VERSION "1.34"\r
+\r