frontend: update libpicofe, fix missed callbacks
[pcsx_rearmed.git] / frontend / menu.c
index ec3c5a2..b50f05a 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * (C) Gražvydas "notaz" Ignotas, 2010-2011
+ * (C) Gražvydas "notaz" Ignotas, 2010-2015
  *
  * This work is licensed under the terms of any of these licenses
  * (at your option):
@@ -8,14 +8,18 @@
  * See the COPYING file in the top-level directory.
  */
 
+#define _GNU_SOURCE 1
 #include <stdio.h>
 #include <string.h>
 #include <errno.h>
+#ifndef NO_DYLIB
 #include <dlfcn.h>
+#endif
 #include <zlib.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <unistd.h>
+#include <dirent.h>
 
 #include "main.h"
 #include "menu.h"
 #include "plugin_lib.h"
 #include "plat.h"
 #include "pcnt.h"
+#include "cspace.h"
 #include "libpicofe/plat.h"
 #include "libpicofe/input.h"
 #include "libpicofe/linux/in_evdev.h"
 #include "libpicofe/plat.h"
 #include "../libpcsxcore/misc.h"
 #include "../libpcsxcore/cdrom.h"
+#include "../libpcsxcore/cdrom-async.h"
 #include "../libpcsxcore/cdriso.h"
 #include "../libpcsxcore/cheat.h"
-#include "../libpcsxcore/psemu_plugin_defs.h"
+#include "../libpcsxcore/ppf.h"
 #include "../libpcsxcore/new_dynarec/new_dynarec.h"
-#include "../plugins/dfinput/main.h"
-#include "../plugins/gpulib/cspace.h"
+#include "../plugins/dfsound/spu_config.h"
+#include "psemu_plugin_defs.h"
+#include "compiler_features.h"
+#include "arm_features.h"
 #include "revision.h"
 
 #define REARMED_BIRTHDAY_TIME 1293306830       /* 25 Dec 2010 */
+#if defined(__linux__) && (!defined(__SIZEOF_POINTER__) || __SIZEOF_POINTER__ == 4)
+#define STAT stat64
+#else
+#define STAT stat
+#endif
 
 #define array_size(x) (sizeof(x) / sizeof(x[0]))
 
@@ -72,6 +85,7 @@ typedef enum
        MA_OPT_SAVECFG,
        MA_OPT_SAVECFG_GAME,
        MA_OPT_CPU_CLOCKS,
+       MA_OPT_SPU_THREAD,
        MA_OPT_DISP_OPTS,
        MA_OPT_VARSCALER,
        MA_OPT_VARSCALER_C,
@@ -79,65 +93,65 @@ typedef enum
        MA_OPT_HWFILTER,
        MA_OPT_SWFILTER,
        MA_OPT_GAMMA,
+       MA_OPT_VOUT_MODE,
+       MA_OPT_VOUT_FULL,
+       MA_OPT_SCANLINES,
+       MA_OPT_SCANLINE_LEVEL,
+       MA_OPT_CENTERING,
+       MA_OPT_OVERSCAN,
+       MA_OPT_VSYNC,
 } menu_id;
 
 static int last_vout_w, last_vout_h, last_vout_bpp;
-static int cpu_clock, cpu_clock_st, volume_boost, frameskip;
-static char rom_fname_reload[MAXPATHLEN];
+static int cpu_clock, cpu_clock_st, volume_boost;
+static int frameskip = 1; // 0 - auto, 1 - off
 static char last_selected_fname[MAXPATHLEN];
 static int config_save_counter, region, in_type_sel1, in_type_sel2;
 static int psx_clock;
-static int memcard1_sel, memcard2_sel;
+static int memcard1_sel = -1, memcard2_sel = -1;
+static int cd_buf_count;
+extern int g_autostateld_opt;
+static int menu_iopts[8];
 int g_opts, g_scaler, g_gamma = 100;
+int scanlines, scanline_level = 20;
 int soft_scaling, analog_deadzone; // for Caanoo
-int filter, soft_filter;
+int soft_filter;
+int in_evdev_allow_abs_only attr_weak; // FIXME
 
-#ifdef __ARM_ARCH_7A__
-#define DEFAULT_PSX_CLOCK 57
+#ifndef HAVE_PRE_ARMV7
+#define DEFAULT_PSX_CLOCK (10000 / CYCLE_MULT_DEFAULT)
 #define DEFAULT_PSX_CLOCK_S "57"
 #else
 #define DEFAULT_PSX_CLOCK 50
 #define DEFAULT_PSX_CLOCK_S "50"
 #endif
 
-// sound plugin
-extern int iUseReverb;
-extern int iUseInterpolation;
-extern int iXAPitch;
-extern int iVolume;
-
-static const char *bioses[24];
+static const char *bioses[32];
 static const char *gpu_plugins[16];
 static const char *spu_plugins[16];
 static const char *memcards[32];
 static int bios_sel, gpu_plugsel, spu_plugsel;
 
 #ifndef UI_FEATURES_H
-#define MENU_BIOS_PATH "bios/"
-#define MENU_SHOW_VARSCALER 0
+#define MENU_SHOW_VOUTMODE 1
 #define MENU_SHOW_SCALER2 0
 #define MENU_SHOW_NUBS_BTNS 0
 #define MENU_SHOW_VIBRATION 0
 #define MENU_SHOW_DEADZONE 0
 #define MENU_SHOW_MINIMIZE 0
+#define MENU_SHOW_FULLSCREEN 1
 #define MENU_SHOW_VOLUME 0
 #endif
+#ifndef MENU_SHOW_VARSCALER
+#define MENU_SHOW_VARSCALER 0
+#endif
+#ifndef MENU_SHOW_VARSCALER_C
+#define MENU_SHOW_VARSCALER_C 0
+#endif
 
 static int min(int x, int y) { return x < y ? x : y; }
 static int max(int x, int y) { return x > y ? x : y; }
 
-void emu_make_path(char *buff, const char *end, int size)
-{
-       int pos, end_len;
-
-       end_len = strlen(end);
-       pos = plat_get_root_dir(buff, size);
-       strncpy(buff + pos, end, size - pos);
-       buff[size - 1] = 0;
-       if (pos + end_len > size - 1)
-               printf("Warning: path truncated: %s\n", buff);
-}
-
 static int emu_check_save_file(int slot, int *time)
 {
        char fname[MAXPATHLEN];
@@ -184,6 +198,112 @@ static int emu_save_load_game(int load, int unused)
        return ret;
 }
 
+static void rm_namelist_entry(struct dirent **namelist,
+       int count, const char *name)
+{
+       int i;
+
+       for (i = 1; i < count; i++) {
+               if (namelist[i] == NULL || namelist[i]->d_type == DT_DIR)
+                       continue;
+
+               if (strcmp(name, namelist[i]->d_name) == 0) {
+                       free(namelist[i]);
+                       namelist[i] = NULL;
+                       break;
+               }
+       }
+}
+
+static int optional_cdimg_filter(struct dirent **namelist, int count,
+       const char *basedir)
+{
+       const char *ext, *p;
+       char buf[256], buf2[257];
+       int i, d, ret, good_cue;
+       struct STAT statf;
+       FILE *f;
+
+       if (count <= 1)
+               return count;
+
+       for (i = 1; i < count; i++) {
+               if (namelist[i] == NULL || namelist[i]->d_type == DT_DIR)
+                       continue;
+
+               ext = strrchr(namelist[i]->d_name, '.');
+               if (ext == NULL) {
+                       // should not happen but whatever
+                       free(namelist[i]);
+                       namelist[i] = NULL;
+                       continue;
+               }
+               ext++;
+
+               // first find .cue files and remove files they reference
+               if (strcasecmp(ext, "cue") == 0)
+               {
+                       snprintf(buf, sizeof(buf), "%s/%s", basedir,
+                               namelist[i]->d_name);
+
+                       f = fopen(buf, "r");
+                       if (f == NULL) {
+                               free(namelist[i]);
+                               namelist[i] = NULL;
+                               continue;
+                       }
+
+                       good_cue = 0;
+                       while (fgets(buf, sizeof(buf), f)) {
+                               ret = sscanf(buf, " FILE \"%256[^\"]\"", buf2);
+                               if (ret != 1)
+                                       ret = sscanf(buf, " FILE %256s", buf2);
+                               if (ret != 1)
+                                       continue;
+
+                               p = strrchr(buf2, '/');
+                               if (p == NULL)
+                                       p = strrchr(buf2, '\\');
+                               if (p != NULL)
+                                       p++;
+                               else
+                                       p = buf2;
+
+                               snprintf(buf, sizeof(buf), "%s/%s", basedir, p);
+                               ret = STAT(buf, &statf);
+                               if (ret == 0) {
+                                       rm_namelist_entry(namelist, count, p);
+                                       good_cue = 1;
+                               }
+                       }
+                       fclose(f);
+
+                       if (!good_cue) {
+                               free(namelist[i]);
+                               namelist[i] = NULL;
+                       }
+                       continue;
+               }
+
+               p = strcasestr(namelist[i]->d_name, "track");
+               if (p != NULL) {
+                       ret = strtoul(p + 5, NULL, 10);
+                       if (ret > 1) {
+                               free(namelist[i]);
+                               namelist[i] = NULL;
+                               continue;
+                       }
+               }
+       }
+
+       // compact namelist
+       for (i = d = 1; i < count; i++)
+               if (namelist[i] != NULL)
+                       namelist[d++] = namelist[i];
+
+       return d;
+}
+
 // propagate menu settings to the emu vars
 static void menu_sync_config(void)
 {
@@ -194,24 +314,28 @@ static void menu_sync_config(void)
                Config.PsxAuto = 0;
                Config.PsxType = region - 1;
        }
-       cycle_multiplier = 10000 / psx_clock;
+       Config.cycle_multiplier = 10000 / psx_clock;
 
        switch (in_type_sel1) {
-       case 1:  in_type1 = PSE_PAD_TYPE_ANALOGPAD; break;
-       case 2:  in_type1 = PSE_PAD_TYPE_GUNCON;    break;
-       default: in_type1 = PSE_PAD_TYPE_STANDARD;
+       case 1:  in_type[0] = PSE_PAD_TYPE_ANALOGPAD; break;
+       case 2:  in_type[0] = PSE_PAD_TYPE_GUNCON;    break;
+       case 3:  in_type[0] = PSE_PAD_TYPE_GUN;       break;
+       case 4:  in_type[0] = PSE_PAD_TYPE_NONE;      break;
+       default: in_type[0] = PSE_PAD_TYPE_STANDARD;
        }
        switch (in_type_sel2) {
-       case 1:  in_type2 = PSE_PAD_TYPE_ANALOGPAD; break;
-       case 2:  in_type2 = PSE_PAD_TYPE_GUNCON;    break;
-       default: in_type2 = PSE_PAD_TYPE_STANDARD;
+       case 1:  in_type[1] = PSE_PAD_TYPE_ANALOGPAD; break;
+       case 2:  in_type[1] = PSE_PAD_TYPE_GUNCON;    break;
+       case 3:  in_type[1] = PSE_PAD_TYPE_GUN;       break;
+       case 4:  in_type[1] = PSE_PAD_TYPE_NONE;      break;
+       default: in_type[1] = PSE_PAD_TYPE_STANDARD;
        }
        if (in_evdev_allow_abs_only != allow_abs_only_old) {
                in_probe();
                allow_abs_only_old = in_evdev_allow_abs_only;
        }
 
-       iVolume = 768 + 128 * volume_boost;
+       spu_config.iVolume = 768 + 128 * volume_boost;
        pl_rearmed_cbs.frameskip = frameskip - 1;
        pl_timing_prepare(Config.PsxType);
 }
@@ -222,11 +346,15 @@ static void menu_set_defconfig(void)
 
        g_opts = 0;
        g_scaler = SCALE_4_3;
+       g_gamma = 100;
        volume_boost = 0;
-       frameskip = 0;
+       frameskip = 1; // 1 - off
        analog_deadzone = 50;
        soft_scaling = 1;
        soft_filter = 0;
+       scanlines = 0;
+       scanline_level = 20;
+       plat_target.vout_fullscreen = 0;
        psx_clock = DEFAULT_PSX_CLOCK;
 
        region = 0;
@@ -274,42 +402,60 @@ static const struct {
        CE_CONFIG_STR(Spu),
 //     CE_CONFIG_STR(Cdr),
        CE_CONFIG_VAL(Xa),
-       CE_CONFIG_VAL(Sio),
        CE_CONFIG_VAL(Mdec),
        CE_CONFIG_VAL(Cdda),
        CE_CONFIG_VAL(Debug),
        CE_CONFIG_VAL(PsxOut),
-       CE_CONFIG_VAL(SpuIrq),
-       CE_CONFIG_VAL(RCntFix),
-       CE_CONFIG_VAL(VSyncWA),
+       CE_CONFIG_VAL(icache_emulation),
+       CE_CONFIG_VAL(DisableStalls),
        CE_CONFIG_VAL(Cpu),
-       CE_CONFIG_VAL(CdrReschedule),
+       CE_CONFIG_VAL(GpuListWalking),
+       CE_CONFIG_VAL(FractionalFramerate),
+       CE_CONFIG_VAL(PreciseExceptions),
+       CE_CONFIG_VAL(TurboCD),
+       CE_CONFIG_VAL(SlowBoot),
        CE_INTVAL(region),
-       CE_INTVAL_V(g_scaler, 2),
+       CE_INTVAL_V(g_scaler, 3),
+       CE_INTVAL(g_gamma),
        CE_INTVAL(g_layer_x),
        CE_INTVAL(g_layer_y),
        CE_INTVAL(g_layer_w),
        CE_INTVAL(g_layer_h),
-       CE_INTVAL(filter),
        CE_INTVAL(soft_filter),
+       CE_INTVAL(scanlines),
+       CE_INTVAL(scanline_level),
+       CE_INTVAL(plat_target.vout_method),
+       CE_INTVAL(plat_target.hwfilter),
+       CE_INTVAL(plat_target.vout_fullscreen),
        CE_INTVAL(state_slot),
        CE_INTVAL(cpu_clock),
        CE_INTVAL(g_opts),
        CE_INTVAL(in_type_sel1),
        CE_INTVAL(in_type_sel2),
        CE_INTVAL(analog_deadzone),
+       CE_INTVAL(memcard1_sel),
+       CE_INTVAL(memcard2_sel),
+       CE_INTVAL(g_autostateld_opt),
+       CE_INTVAL(cd_buf_count),
+       CE_INTVAL_N("adev0_axis0", in_adev_axis[0][0]),
+       CE_INTVAL_N("adev0_axis1", in_adev_axis[0][1]),
+       CE_INTVAL_N("adev1_axis0", in_adev_axis[1][0]),
+       CE_INTVAL_N("adev1_axis1", in_adev_axis[1][1]),
        CE_INTVAL_N("adev0_is_nublike", in_adev_is_nublike[0]),
        CE_INTVAL_N("adev1_is_nublike", in_adev_is_nublike[1]),
-       CE_INTVAL_V(frameskip, 3),
-       CE_INTVAL_P(gpu_peops.iUseDither),
+       CE_INTVAL_V(frameskip, 4),
+       CE_INTVAL_PV(dithering, 2),
        CE_INTVAL_P(gpu_peops.dwActFixes),
-       CE_INTVAL_P(gpu_unai.lineskip),
-       CE_INTVAL_P(gpu_unai.abe_hack),
-       CE_INTVAL_P(gpu_unai.no_light),
-       CE_INTVAL_P(gpu_unai.no_blend),
+       CE_INTVAL_P(gpu_unai.old_renderer),
+       CE_INTVAL_P(gpu_unai.ilace_force),
+       CE_INTVAL_P(gpu_unai.lighting),
+       CE_INTVAL_P(gpu_unai.fast_lighting),
+       CE_INTVAL_P(gpu_unai.blending),
+       CE_INTVAL_P(gpu_unai.scale_hires),
        CE_INTVAL_P(gpu_neon.allow_interlace),
        CE_INTVAL_P(gpu_neon.enhancement_enable),
        CE_INTVAL_P(gpu_neon.enhancement_no_main),
+       CE_INTVAL_PV(gpu_neon.enhancement_tex_adj, 2),
        CE_INTVAL_P(gpu_peopsgl.bDrawDither),
        CE_INTVAL_P(gpu_peopsgl.iFilterType),
        CE_INTVAL_P(gpu_peopsgl.iFrameTexType),
@@ -320,14 +466,21 @@ static const struct {
        CE_INTVAL_P(gpu_peopsgl.iVRamSize),
        CE_INTVAL_P(gpu_peopsgl.iTexGarbageCollection),
        CE_INTVAL_P(gpu_peopsgl.dwActFixes),
-       CE_INTVAL_V(iUseReverb, 3),
-       CE_INTVAL_V(iXAPitch, 3),
-       CE_INTVAL_V(iUseInterpolation, 3),
+       CE_INTVAL_P(screen_centering_type),
+       CE_INTVAL_P(screen_centering_x),
+       CE_INTVAL_P(screen_centering_y),
+       CE_INTVAL_P(screen_centering_h_adj),
+       CE_INTVAL_P(show_overscan),
+       CE_INTVAL(spu_config.iUseReverb),
+       CE_INTVAL(spu_config.iXAPitch),
+       CE_INTVAL(spu_config.iUseInterpolation),
+       CE_INTVAL(spu_config.iTempo),
+       CE_INTVAL(spu_config.iUseThread),
        CE_INTVAL(config_save_counter),
        CE_INTVAL(in_evdev_allow_abs_only),
        CE_INTVAL(volume_boost),
        CE_INTVAL(psx_clock),
-       CE_INTVAL(new_dynarec_hacks),
+       CE_INTVAL(ndrc_g.hacks),
        CE_INTVAL(in_enable_vibration),
 };
 
@@ -347,15 +500,26 @@ static char *get_cd_label(void)
 
 static void make_cfg_fname(char *buf, size_t size, int is_game)
 {
-       if (is_game)
-               snprintf(buf, size, "." PCSX_DOT_DIR "cfg/%.32s-%.9s.cfg", get_cd_label(), CdromId);
+       char id_buf[64];
+       if (is_game) {
+               snprintf(id_buf, sizeof(id_buf), "%.32s-%.9s.cfg",
+                       get_cd_label(), CdromId);
+               emu_make_path(buf, size, CFG_DIR, id_buf);
+       }
        else
-               snprintf(buf, size, "." PCSX_DOT_DIR "%s", cfgfile_basename);
+               emu_make_path(buf, size, PCSX_DOT_DIR, cfgfile_basename);
 }
 
 static void keys_write_all(FILE *f);
 static char *mystrip(char *str);
 
+static void write_u32_value(FILE *f, u32 v)
+{
+       if (v > 7)
+               fprintf(f, "0x");
+       fprintf(f, "%x\n", v);
+}
+
 static int menu_write_config(int is_game)
 {
        char cfgfile[MAXPATHLEN];
@@ -371,6 +535,8 @@ static int menu_write_config(int is_game)
                return -1;
        }
 
+       cd_buf_count = cdra_get_buf_count();
+
        for (i = 0; i < ARRAY_SIZE(config_data); i++) {
                fprintf(f, "%s = ", config_data[i].name);
                switch (config_data[i].len) {
@@ -378,13 +544,13 @@ static int menu_write_config(int is_game)
                        fprintf(f, "%s\n", (char *)config_data[i].val);
                        break;
                case 1:
-                       fprintf(f, "%x\n", *(u8 *)config_data[i].val);
+                       write_u32_value(f, *(u8 *)config_data[i].val);
                        break;
                case 2:
-                       fprintf(f, "%x\n", *(u16 *)config_data[i].val);
+                       write_u32_value(f, *(u16 *)config_data[i].val);
                        break;
                case 4:
-                       fprintf(f, "%x\n", *(u32 *)config_data[i].val);
+                       write_u32_value(f, *(u32 *)config_data[i].val);
                        break;
                default:
                        printf("menu_write_config: unhandled len %d for %s\n",
@@ -401,14 +567,18 @@ static int menu_write_config(int is_game)
 
 static int menu_do_last_cd_img(int is_get)
 {
+       static const char *defaults[] = { "/media", "/mnt/sd", "/mnt" };
        char path[256];
+       struct STAT st;
        FILE *f;
-       int ret;
+       int i, ret = -1;
 
-       snprintf(path, sizeof(path), "." PCSX_DOT_DIR "lastcdimg.txt");
+       emu_make_path(path, sizeof(path), PCSX_DOT_DIR, "lastcdimg.txt");
        f = fopen(path, is_get ? "r" : "w");
-       if (f == NULL)
-               return -1;
+       if (f == NULL) {
+               ret = -1;
+               goto out;
+       }
 
        if (is_get) {
                ret = fread(last_selected_fname, 1, sizeof(last_selected_fname) - 1, f);
@@ -419,6 +589,17 @@ static int menu_do_last_cd_img(int is_get)
                fprintf(f, "%s\n", last_selected_fname);
        fclose(f);
 
+out:
+       if (is_get) {
+               for (i = 0; last_selected_fname[0] == 0
+                      || STAT(last_selected_fname, &st) != 0; i++)
+               {
+                       if (i >= ARRAY_SIZE(defaults))
+                               break;
+                       strcpy(last_selected_fname, defaults[i]);
+               }
+       }
+
        return 0;
 }
 
@@ -436,7 +617,7 @@ static void parse_str_val(char *cval, const char *src)
 
 static void keys_load_all(const char *cfg);
 
-static int menu_load_config(int is_game)
+int menu_load_config(int is_game)
 {
        char cfgfile[MAXPATHLEN];
        int i, ret = -1;
@@ -517,6 +698,7 @@ static int menu_load_config(int is_game)
        }
 
        keys_load_all(cfg);
+       cdra_set_buf_count(cd_buf_count);
        ret = 0;
 fail_read:
        free(cfg);
@@ -539,23 +721,54 @@ fail:
                if (strcmp(Config.Spu, spu_plugins[i]) == 0)
                        { spu_plugsel = i; break; }
 
+       // memcard selections
+       char mcd1_old[sizeof(Config.Mcd1)];
+       char mcd2_old[sizeof(Config.Mcd2)];
+       strcpy(mcd1_old, Config.Mcd1);
+       strcpy(mcd2_old, Config.Mcd2);
+
+       if ((unsigned int)memcard1_sel < ARRAY_SIZE(memcards)) {
+               if (memcard1_sel == 0)
+                       strcpy(Config.Mcd1, "none");
+               else if (memcards[memcard1_sel] != NULL)
+                       snprintf(Config.Mcd1, sizeof(Config.Mcd1), ".%s%s",
+                               MEMCARD_DIR, memcards[memcard1_sel]);
+       }
+       if ((unsigned int)memcard2_sel < ARRAY_SIZE(memcards)) {
+               if (memcard2_sel == 0)
+                       strcpy(Config.Mcd2, "none");
+               else if (memcards[memcard2_sel] != NULL)
+                       snprintf(Config.Mcd2, sizeof(Config.Mcd2), ".%s%s",
+                               MEMCARD_DIR, memcards[memcard2_sel]);
+       }
+       if (strcmp(mcd1_old, Config.Mcd1) || strcmp(mcd2_old, Config.Mcd2))
+               LoadMcds(Config.Mcd1, Config.Mcd2);
+
        return ret;
 }
 
+static const char *filter_exts[] = {
+       "bin", "img", "mdf", "iso", "cue", "z",
+       #ifdef HAVE_CHD
+       "chd",
+       #endif
+       "bz",  "znx", "pbp", "cbn", "ppf", NULL
+};
+
 // rrrr rggg gggb bbbb
 static unsigned short fname2color(const char *fname)
 {
-       static const char *cdimg_exts[] = { ".bin", ".img", ".mdf", ".iso", ".cue", ".z",
-                                           ".bz", ".znx", ".pbp", ".cbn" };
-       static const char *other_exts[] = { ".ccd", ".toc", ".mds", ".sub",
-                                           ".table", ".index", ".sbi" };
+       static const char *other_exts[] = {
+               "ccd", "toc", "mds", "sub", "table", "index", "sbi"
+       };
        const char *ext = strrchr(fname, '.');
        int i;
 
        if (ext == NULL)
                return 0xffff;
-       for (i = 0; i < array_size(cdimg_exts); i++)
-               if (strcasecmp(ext, cdimg_exts[i]) == 0)
+       ext++;
+       for (i = 0; filter_exts[i] != NULL; i++)
+               if (strcasecmp(ext, filter_exts[i]) == 0)
                        return 0x7bff;
        for (i = 0; i < array_size(other_exts); i++)
                if (strcasecmp(ext, other_exts[i]) == 0)
@@ -565,12 +778,8 @@ static unsigned short fname2color(const char *fname)
 
 static void draw_savestate_bg(int slot);
 
-static const char *filter_exts[] = {
-       ".mp3", ".MP3", ".txt", ".htm", "html", ".jpg", ".pnd"
-};
-
 #define MENU_ALIGN_LEFT
-#ifdef __ARM_ARCH_7A__ // assume hires device
+#ifndef HAVE_PRE_ARMV7 // assume hires device
 #define MENU_X2 1
 #else
 #define MENU_X2 0
@@ -598,8 +807,8 @@ static void draw_savestate_bg(int slot)
        if (f == NULL)
                return;
 
-       if (gzseek(f, 0x29933d, SEEK_SET) != 0x29933d) {
-               fprintf(stderr, "gzseek failed\n");
+       if ((ret = (int)gzseek(f, 0x29933d, SEEK_SET)) != 0x29933d) {
+               fprintf(stderr, "gzseek failed: %d\n", ret);
                gzclose(f);
                return;
        }
@@ -624,12 +833,18 @@ static void draw_savestate_bg(int slot)
 
        x = gpu->ulControl[5] & 0x3ff;
        y = (gpu->ulControl[5] >> 10) & 0x1ff;
-       s = (u16 *)gpu->psxVRam + y * 1024 + x;
        w = psx_widths[(gpu->ulStatus >> 16) & 7];
        tmp = gpu->ulControl[7];
        h = ((tmp >> 10) & 0x3ff) - (tmp & 0x3ff);
        if (gpu->ulStatus & 0x80000) // doubleheight
                h *= 2;
+       if (h <= 0 || h > 512)
+               goto out;
+       if (y > 512 - 64)
+               y = 0;
+       if (y + h > 512)
+               h = 512 - y;
+       s = (u16 *)gpu->psxVRam + y * 1024 + x;
 
        x = max(0, g_menuscreen_w - w) & ~3;
        y = max(0, g_menuscreen_h / 2 - h / 2);
@@ -645,7 +860,7 @@ static void draw_savestate_bg(int slot)
 
                // darken this so that menu text is visible
                if (g_menuscreen_w - w < 320)
-                       menu_darken_bg(d, d, w * 2, 0);
+                       menu_darken_bg(d, d, w, 0);
        }
 
 out:
@@ -684,12 +899,15 @@ me_bind_action emuctrl_actions[] =
        { "Toggle Frameskip ", 1 << SACTION_TOGGLE_FSKIP },
        { "Take Screenshot  ", 1 << SACTION_SCREENSHOT },
        { "Show/Hide FPS    ", 1 << SACTION_TOGGLE_FPS },
-#ifdef __ARM_ARCH_7A__
+#ifndef HAVE_PRE_ARMV7
        { "Switch Renderer  ", 1 << SACTION_SWITCH_DISPMODE },
 #endif
        { "Fast Forward     ", 1 << SACTION_FAST_FORWARD },
 #if MENU_SHOW_MINIMIZE
        { "Minimize         ", 1 << SACTION_MINIMIZE },
+#endif
+#if MENU_SHOW_FULLSCREEN
+       { "Toggle fullscreen", 1 << SACTION_TOGGLE_FULLSCREEN },
 #endif
        { "Enter Menu       ", 1 << SACTION_ENTER_MENU },
        { "Gun Trigger      ", 1 << SACTION_GUN_TRIGGER },
@@ -700,6 +918,7 @@ me_bind_action emuctrl_actions[] =
        { "Volume Up        ", 1 << SACTION_VOLUME_UP },
        { "Volume Down      ", 1 << SACTION_VOLUME_DOWN },
 #endif
+       { "Analog toggle    ", 1 << SACTION_ANALOG_TOGGLE },
        { NULL,                0 }
 };
 
@@ -732,8 +951,6 @@ static void get_line(char *d, size_t size, const char *s)
                len = size - 1;
        strncpy(d, s, len);
        d[len] = 0;
-
-       mystrip(d);
 }
 
 static void keys_write_all(FILE *f)
@@ -840,7 +1057,10 @@ static void keys_load_all(const char *cfg)
        while (p != NULL && (p = strstr(p, "binddev = ")) != NULL) {
                p += 10;
 
+               // don't strip 'dev' because there are weird devices
+               // with names with space at the end
                get_line(dev, sizeof(dev), p);
+
                dev_id = in_config_parse_dev(dev);
                if (dev_id < 0) {
                        printf("input: can't handle dev: %s\n", dev);
@@ -898,6 +1118,10 @@ static void keys_load_all(const char *cfg)
 
 static int key_config_loop_wrap(int id, int keys)
 {
+       int d;
+
+       for (d = 0; d < IN_MAX_DEVS; d++)
+               in_set_config_int(d, IN_CFG_ANALOG_MAP_ULDR, 0);
        switch (id) {
                case MA_CTRL_PLAYER1:
                        key_config_loop(me_ctrl_actions, array_size(me_ctrl_actions) - 1, 0);
@@ -911,6 +1135,9 @@ static int key_config_loop_wrap(int id, int keys)
                default:
                        break;
        }
+       for (d = 0; d < IN_MAX_DEVS; d++)
+               in_set_config_int(d, IN_CFG_ANALOG_MAP_ULDR, 1);
+
        return 0;
 }
 
@@ -1015,6 +1242,8 @@ static const char *men_in_type_sel[] = {
        "Standard (SCPH-1080)",
        "Analog (SCPH-1150)",
        "GunCon",
+       "Konami Gun",
+       "None",
        NULL
 };
 static const char h_nub_btns[] = "Experimental, keep this OFF if unsure. Select rescan after change.";
@@ -1059,33 +1288,69 @@ static int menu_loop_keyconfig(int id, int keys)
 
 // ------------ gfx options menu ------------
 
-static const char *men_scaler[] = { "1x1", "scaled 4:3", "integer scaled 4:3", "fullscreen", "custom", NULL };
+static const char *men_scaler[] = {
+       "1x1", "integer scaled 2x", "scaled 4:3", "integer scaled 4:3", "fullscreen",
+#if MENU_SHOW_VARSCALER_C
+       "custom",
+#endif
+       NULL
+};
 static const char *men_soft_filter[] = { "None",
-#ifdef __ARM_NEON__
+#ifdef HAVE_NEON32
        "scale2x", "eagle2x",
 #endif
        NULL };
 static const char *men_dummy[] = { NULL };
+static const char *men_centering[] = { "Auto", "Ingame", "Borderless", "Force", NULL };
+static const char *men_overscan[] = { "OFF", "Auto", "Hack", NULL };
+static const char h_scaler[]    = "int. 2x  - scales w. or h. 2x if it fits on screen\n"
+                                 "int. 4:3 - uses integer if possible, else fractional";
 static const char h_cscaler[]   = "Displays the scaler layer, you can resize it\n"
                                  "using d-pad or move it using R+d-pad";
 static const char h_soft_filter[] = "Works only if game uses low resolution modes";
 static const char h_gamma[]     = "Gamma/brightness adjustment (default 100)";
+#ifdef HAVE_NEON32
+static const char *men_scanlines[] = { "OFF", "1", "2", "3", NULL };
+static const char h_scanline_l[]  = "Scanline brightness, 0-100%";
+#endif
 
 static int menu_loop_cscaler(int id, int keys)
 {
+       void *saved_layer = NULL;
+       size_t saved_layer_size = 0;
+       int was_layer_clipped = 0;
        unsigned int inp;
 
+       if (!pl_vout_buf)
+               return -1;
+
        g_scaler = SCALE_CUSTOM;
+       saved_layer_size = last_vout_w * last_vout_h * last_vout_bpp / 8;
+       saved_layer = malloc(saved_layer_size);
+       if (saved_layer)
+               memcpy(saved_layer, pl_vout_buf, saved_layer_size);
 
        plat_gvideo_open(Config.PsxType);
 
+       menu_draw_begin(0, 1);
+       memset(g_menuscreen_ptr, 4, g_menuscreen_w * g_menuscreen_h * 2);
+       menu_draw_end();
+
        for (;;)
        {
-               menu_draw_begin(0, 1);
-               memset(g_menuscreen_ptr, 4, g_menuscreen_w * g_menuscreen_h * 2);
-               text_out16(2, 2, "%d,%d", g_layer_x, g_layer_y);
-               text_out16(2, 480 - 18, "%dx%d | d-pad: resize, R+d-pad: move", g_layer_w, g_layer_h);
-               menu_draw_end();
+               if (saved_layer && last_vout_bpp == 16) {
+                       int top_x = max(0, -g_layer_x * last_vout_w / 800) + 1;
+                       int top_y = max(0, -g_layer_y * last_vout_h / 480) + 1;
+                       char text[128];
+                       memcpy(pl_vout_buf, saved_layer, saved_layer_size);
+                       snprintf(text, sizeof(text), "%d,%d %dx%d",
+                               g_layer_x, g_layer_y, g_layer_w, g_layer_h);
+                       basic_text_out16_nf(pl_vout_buf, last_vout_w,
+                               top_x, top_y, text);
+                       basic_text_out16_nf(pl_vout_buf, last_vout_w, 2,
+                               last_vout_h - 20, "d-pad: resize, R+d-pad: move");
+                       pl_vout_buf = plat_gvideo_flip();
+               }
 
                inp = in_menu_wait(PBTN_UP|PBTN_DOWN|PBTN_LEFT|PBTN_RIGHT
                                |PBTN_R|PBTN_MOK|PBTN_MBACK, NULL, 40);
@@ -1103,34 +1368,50 @@ static int menu_loop_cscaler(int id, int keys)
                        break;
 
                if (inp & (PBTN_UP|PBTN_DOWN|PBTN_LEFT|PBTN_RIGHT)) {
-                       if (g_layer_x < 0)   g_layer_x = 0;
-                       if (g_layer_x > 640) g_layer_x = 640;
-                       if (g_layer_y < 0)   g_layer_y = 0;
-                       if (g_layer_y > 420) g_layer_y = 420;
-                       if (g_layer_w < 160) g_layer_w = 160;
-                       if (g_layer_h < 60)  g_layer_h = 60;
-                       if (g_layer_x + g_layer_w > 800)
-                               g_layer_w = 800 - g_layer_x;
-                       if (g_layer_y + g_layer_h > 480)
-                               g_layer_h = 480 - g_layer_y;
+                       int layer_clipped = 0;
+                       g_layer_x = max(-320, min(g_layer_x, 640));
+                       g_layer_y = max(-240, min(g_layer_y, 400));
+                       g_layer_w = max(160, g_layer_w);
+                       g_layer_h = max( 60, g_layer_h);
+                       if (g_layer_x < 0 || g_layer_x + g_layer_w > 800)
+                               layer_clipped = 1;
+                       if (g_layer_w > 800+400)
+                               g_layer_w = 800+400;
+                       if (g_layer_y < 0 || g_layer_y + g_layer_h > 480)
+                               layer_clipped = 1;
+                       if (g_layer_h > 480+360)
+                               g_layer_h = 480+360;
                        // resize the layer
                        plat_gvideo_open(Config.PsxType);
+                       if (layer_clipped || was_layer_clipped)
+                               pl_vout_buf = plat_gvideo_set_mode(&last_vout_w,
+                                       &last_vout_h, &last_vout_bpp);
+                       was_layer_clipped = layer_clipped;
                }
        }
 
        plat_gvideo_close();
+       free(saved_layer);
 
        return 0;
 }
 
 static menu_entry e_menu_gfx_options[] =
 {
-       mee_enum      ("Scaler",                   MA_OPT_VARSCALER, g_scaler, men_scaler),
+       mee_enum      ("PSX Screen centering",     MA_OPT_CENTERING, pl_rearmed_cbs.screen_centering_type, men_centering),
+       mee_enum      ("Show overscan",            MA_OPT_OVERSCAN, pl_rearmed_cbs.show_overscan, men_overscan),
+       mee_enum_h    ("Scaler",                   MA_OPT_VARSCALER, g_scaler, men_scaler, h_scaler),
+       mee_enum      ("Video output mode",        MA_OPT_VOUT_MODE, plat_target.vout_method, men_dummy),
+       mee_onoff     ("Fullscreen mode",          MA_OPT_VOUT_FULL, plat_target.vout_fullscreen, 1),
        mee_onoff     ("Software Scaling",         MA_OPT_SCALER2, soft_scaling, 1),
-       mee_enum      ("Hardware Filter",          MA_OPT_HWFILTER, filter, men_dummy),
        mee_enum_h    ("Software Filter",          MA_OPT_SWFILTER, soft_filter, men_soft_filter, h_soft_filter),
+       mee_enum      ("Hardware Filter",          MA_OPT_HWFILTER, plat_target.hwfilter, men_dummy),
+#ifdef HAVE_NEON32
+       mee_enum      ("Scanlines",                MA_OPT_SCANLINES, scanlines, men_scanlines),
+       mee_range_h   ("Scanline brightness",      MA_OPT_SCANLINE_LEVEL, scanline_level, 0, 100, h_scanline_l),
+#endif
        mee_range_h   ("Gamma adjustment",         MA_OPT_GAMMA, g_gamma, 1, 200, h_gamma),
-//     mee_onoff     ("Vsync",                    0, vsync, 1),
+       mee_onoff     ("OpenGL Vsync",             MA_OPT_VSYNC, g_opts, OPT_VSYNC),
        mee_cust_h    ("Setup custom scaler",      MA_OPT_VARSCALER_C, menu_loop_cscaler, NULL, h_cscaler),
        mee_end,
 };
@@ -1146,51 +1427,34 @@ static int menu_loop_gfx_options(int id, int keys)
 
 // ------------ bios/plugins ------------
 
-#ifdef __ARM_NEON__
-
-static const char h_gpu_neon[] =
-       "Configure built-in NEON GPU plugin";
 static const char h_gpu_neon_enhanced[] =
-       "Renders in double resolution at the cost of lower performance\n"
+       "Renders in double resolution at perf. cost\n"
        "(not available for high resolution games)";
 static const char h_gpu_neon_enhanced_hack[] =
        "Speed hack for above option (glitches some games)";
+static const char h_gpu_neon_enhanced_texadj[] =
+       "Solves some Enh. res. texture issues, some perf hit";
 static const char *men_gpu_interlace[] = { "Off", "On", "Auto", NULL };
 
 static menu_entry e_menu_plugin_gpu_neon[] =
 {
-       mee_enum      ("Enable interlace mode",      0, pl_rearmed_cbs.gpu_neon.allow_interlace, men_gpu_interlace),
-       mee_onoff_h   ("Enhanced resolution (slow)", 0, pl_rearmed_cbs.gpu_neon.enhancement_enable, 1, h_gpu_neon_enhanced),
+       mee_onoff_h   ("Enhanced resolution",        0, pl_rearmed_cbs.gpu_neon.enhancement_enable, 1, h_gpu_neon_enhanced),
        mee_onoff_h   ("Enhanced res. speed hack",   0, pl_rearmed_cbs.gpu_neon.enhancement_no_main, 1, h_gpu_neon_enhanced_hack),
+       mee_onoff_h   ("Enh. res. texture adjust",   0, pl_rearmed_cbs.gpu_neon.enhancement_tex_adj, 1, h_gpu_neon_enhanced_texadj),
+       mee_enum      ("Enable interlace mode",      0, pl_rearmed_cbs.gpu_neon.allow_interlace, men_gpu_interlace),
        mee_end,
 };
 
-static int menu_loop_plugin_gpu_neon(int id, int keys)
-{
-       static int sel = 0;
-       me_loop(e_menu_plugin_gpu_neon, &sel);
-       return 0;
-}
-
-#endif
-
 static menu_entry e_menu_plugin_gpu_unai[] =
 {
-       mee_onoff     ("Skip every 2nd line",        0, pl_rearmed_cbs.gpu_unai.lineskip, 1),
-       mee_onoff     ("Abe's Odyssey hack",         0, pl_rearmed_cbs.gpu_unai.abe_hack, 1),
-       mee_onoff     ("Disable lighting",           0, pl_rearmed_cbs.gpu_unai.no_light, 1),
-       mee_onoff     ("Disable blending",           0, pl_rearmed_cbs.gpu_unai.no_blend, 1),
+       mee_onoff     ("Old renderer",               0, pl_rearmed_cbs.gpu_unai.old_renderer, 1),
+       mee_onoff     ("Skip every 2nd line",        0, pl_rearmed_cbs.gpu_unai.ilace_force, 1),
+       mee_onoff     ("Lighting",                   0, pl_rearmed_cbs.gpu_unai.lighting, 1),
+       mee_onoff     ("Fast lighting",              0, pl_rearmed_cbs.gpu_unai.fast_lighting, 1),
+       mee_onoff     ("Blending",                   0, pl_rearmed_cbs.gpu_unai.blending, 1),
        mee_end,
 };
 
-static int menu_loop_plugin_gpu_unai(int id, int keys)
-{
-       int sel = 0;
-       me_loop(e_menu_plugin_gpu_unai, &sel);
-       return 0;
-}
-
-static const char *men_gpu_dithering[] = { "None", "Game dependant", "Always", NULL };
 //static const char h_gpu_0[]            = "Needed for Chrono Cross";
 static const char h_gpu_1[]            = "Capcom fighting games";
 static const char h_gpu_2[]            = "Black screens in Lunar";
@@ -1203,7 +1467,6 @@ static const char h_gpu_10[]           = "Toggle busy flags after drawing";
 
 static menu_entry e_menu_plugin_gpu_peops[] =
 {
-       mee_enum      ("Dithering",                  0, pl_rearmed_cbs.gpu_peops.iUseDither, men_gpu_dithering),
 //     mee_onoff_h   ("Odd/even bit hack",          0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<0, h_gpu_0),
        mee_onoff_h   ("Expand screen width",        0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<1, h_gpu_1),
        mee_onoff_h   ("Ignore brightness color",    0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<2, h_gpu_2),
@@ -1216,13 +1479,6 @@ static menu_entry e_menu_plugin_gpu_peops[] =
        mee_end,
 };
 
-static int menu_loop_plugin_gpu_peops(int id, int keys)
-{
-       static int sel = 0;
-       me_loop(e_menu_plugin_gpu_peops, &sel);
-       return 0;
-}
-
 static const char *men_peopsgl_texfilter[] = { "None", "Standard", "Extended",
        "Standard-sprites", "Extended-sprites", "Standard+sprites", "Extended+sprites", NULL };
 static const char *men_peopsgl_fbtex[] = { "Emulated VRam", "Black", "Card", "Card+soft" };
@@ -1253,22 +1509,18 @@ static menu_entry e_menu_plugin_gpu_peopsgl[] =
        mee_end,
 };
 
-static int menu_loop_plugin_gpu_peopsgl(int id, int keys)
-{
-       static int sel = 0;
-       me_loop(e_menu_plugin_gpu_peopsgl, &sel);
-       return 0;
-}
-
 static const char *men_spu_interp[] = { "None", "Simple", "Gaussian", "Cubic", NULL };
 static const char h_spu_volboost[]  = "Large values cause distortion";
+static const char h_spu_tempo[]     = "Slows down audio if emu is too slow\n"
+                                     "This is inaccurate and breaks games";
 
 static menu_entry e_menu_plugin_spu[] =
 {
        mee_range_h   ("Volume boost",              0, volume_boost, -5, 30, h_spu_volboost),
-       mee_onoff     ("Reverb",                    0, iUseReverb, 2),
-       mee_enum      ("Interpolation",             0, iUseInterpolation, men_spu_interp),
-       mee_onoff     ("Adjust XA pitch",           0, iXAPitch, 1),
+       mee_onoff     ("Reverb",                    0, spu_config.iUseReverb, 1),
+       mee_enum      ("Interpolation",             0, spu_config.iUseInterpolation, men_spu_interp),
+       //mee_onoff     ("Adjust XA pitch",           0, spu_config.iXAPitch, 1),
+       mee_onoff_h   ("Adjust tempo",              0, spu_config.iTempo, 1, h_spu_tempo),
        mee_end,
 };
 
@@ -1279,35 +1531,75 @@ static int menu_loop_plugin_spu(int id, int keys)
        return 0;
 }
 
+static const char *men_gpu_dithering[] = { "OFF", "ON", "Force", NULL };
+
 static const char h_bios[]       = "HLE is simulated BIOS. BIOS selection is saved in\n"
                                   "savestates and can't be changed there. Must save\n"
                                   "config and reload the game for change to take effect";
 static const char h_plugin_gpu[] = 
-#ifdef __ARM_NEON__
+#if defined(BUILTIN_GPU_NEON)
                                   "builtin_gpu is the NEON GPU, very fast and accurate\n"
+#elif defined(BUILTIN_GPU_PEOPS)
+                                  "builtin_gpu is the P.E.Op.S GPU, slow but accurate\n"
+#elif defined(BUILTIN_GPU_UNAI)
+                                  "builtin_gpu is the Unai GPU, very fast\n"
+#endif
+#ifndef NO_DYLIB
+#if !defined(BUILTIN_GPU_NEON) && defined(GPU_NEON)
+                                  "gpu_neon is Exophase's NEON GPU, fast and accurate\n"
 #endif
+#ifndef BUILTIN_GPU_PEOPS
                                   "gpu_peops is Pete's soft GPU, slow but accurate\n"
-                                  "gpu_unai is GPU from PCSX4ALL, fast but glitchy\n"
+#endif
+#ifndef BUILTIN_GPU_UNAI
+                                  "gpu_unai is the GPU renderer from PCSX4ALL\n"
+#endif
+#ifdef HAVE_GLES
                                   "gpu_gles Pete's hw GPU, uses 3D chip but is glitchy\n"
-                                  "must save config and reload the game if changed";
-static const char h_plugin_spu[] = "spunull effectively disables sound\n"
-                                  "must save config and reload the game if changed";
-static const char h_gpu_peops[]  = "Configure P.E.Op.S. SoftGL Driver V1.17";
-static const char h_gpu_peopsgl[]= "Configure P.E.Op.S. MesaGL Driver V1.78";
-static const char h_gpu_unai[]   = "Configure Unai/PCSX4ALL Team GPU plugin";
+#endif
+                                  "must save config and reload the game if changed"
+#endif
+                                  ;
+static const char h_plugin_spu[] = ""
+#ifndef NO_DYLIB
+                                  "spunull effectively disables sound\n"
+                                  "must save config and reload the game if changed"
+#endif
+;
+// static const char h_gpu_peops[]  = "Configure P.E.Op.S. SoftGL Driver V1.17";
+// static const char h_gpu_peopsgl[]= "Configure P.E.Op.S. MesaGL Driver V1.78";
+// static const char h_gpu_unai[]   = "Configure Unai/PCSX4ALL Team plugin (new)";
 static const char h_spu[]        = "Configure built-in P.E.Op.S. Sound Driver V1.7";
 
+static int menu_loop_pluginsel_options(int id, int keys)
+{
+       static int sel = 0;
+       if (strcmp(gpu_plugins[gpu_plugsel], "gpu_peops.so") == 0)
+               me_loop(e_menu_plugin_gpu_peops, &sel);
+       else if (strcmp(gpu_plugins[gpu_plugsel], "gpu_unai.so") == 0)
+               me_loop(e_menu_plugin_gpu_unai, &sel);
+       else if (strcmp(gpu_plugins[gpu_plugsel], "gpu_gles.so") == 0)
+               me_loop(e_menu_plugin_gpu_peopsgl, &sel);
+       else if (strcmp(gpu_plugins[gpu_plugsel], "gpu_neon.so") == 0)
+               me_loop(e_menu_plugin_gpu_neon, &sel);
+       else
+#if defined(BUILTIN_GPU_NEON)
+               me_loop(e_menu_plugin_gpu_neon, &sel);
+#elif defined(BUILTIN_GPU_PEOPS)
+               me_loop(e_menu_plugin_gpu_peops, &sel);
+#elif defined(BUILTIN_GPU_UNAI)
+               me_loop(e_menu_plugin_gpu_unai, &sel);
+#endif
+       return 0;
+}
+
 static menu_entry e_menu_plugin_options[] =
 {
        mee_enum_h    ("BIOS",                          0, bios_sel, bioses, h_bios),
+       mee_enum      ("GPU Dithering",                 0, pl_rearmed_cbs.dithering, men_gpu_dithering),
        mee_enum_h    ("GPU plugin",                    0, gpu_plugsel, gpu_plugins, h_plugin_gpu),
        mee_enum_h    ("SPU plugin",                    0, spu_plugsel, spu_plugins, h_plugin_spu),
-#ifdef __ARM_NEON__
-       mee_handler_h ("Configure built-in GPU plugin", menu_loop_plugin_gpu_neon, h_gpu_neon),
-#endif
-       mee_handler_h ("Configure gpu_peops plugin",    menu_loop_plugin_gpu_peops, h_gpu_peops),
-       mee_handler_h ("Configure gpu_unai GPU plugin", menu_loop_plugin_gpu_unai, h_gpu_unai),
-       mee_handler_h ("Configure gpu_gles GPU plugin", menu_loop_plugin_gpu_peopsgl, h_gpu_peopsgl),
+       mee_handler   ("Configure selected GPU plugin", menu_loop_pluginsel_options),
        mee_handler_h ("Configure built-in SPU plugin", menu_loop_plugin_spu, h_spu),
        mee_end,
 };
@@ -1330,29 +1622,37 @@ static int menu_loop_plugin_options(int id, int keys)
 
 // ------------ adv options menu ------------
 
-static const char h_cfg_psxclk[]  = "Over/under-clock the PSX, default is " DEFAULT_PSX_CLOCK_S "\n"
-                                   "(lower value - less work for the emu, may be faster)";
+#ifndef DRC_DISABLE
+static const char h_cfg_noch[]    = "Disables game-specific compatibility hacks";
 static const char h_cfg_nosmc[]   = "Will cause crashes when loading, break memcards";
 static const char h_cfg_gteunn[]  = "May cause graphical glitches";
 static const char h_cfg_gteflgs[] = "Will cause graphical glitches";
+#endif
+static const char h_cfg_stalls[]  = "Will cause some games to run too fast";
 
 static menu_entry e_menu_speed_hacks[] =
 {
-       mee_range_h   ("PSX CPU clock, %%",        0, psx_clock, 1, 500, h_cfg_psxclk),
-       mee_onoff_h   ("Disable SMC checks",       0, new_dynarec_hacks, NDHACK_NO_SMC_CHECK, h_cfg_nosmc),
-       mee_onoff_h   ("Assume GTE regs unneeded", 0, new_dynarec_hacks, NDHACK_GTE_UNNEEDED, h_cfg_gteunn),
-       mee_onoff_h   ("Disable GTE flags",        0, new_dynarec_hacks, NDHACK_GTE_NO_FLAGS, h_cfg_gteflgs),
+#ifndef DRC_DISABLE
+       mee_onoff_h   ("Disable compat hacks",     0, ndrc_g.hacks, NDHACK_NO_COMPAT_HACKS, h_cfg_noch),
+       mee_onoff_h   ("Disable SMC checks",       0, ndrc_g.hacks, NDHACK_NO_SMC_CHECK, h_cfg_nosmc),
+       mee_onoff_h   ("Assume GTE regs unneeded", 0, ndrc_g.hacks, NDHACK_GTE_UNNEEDED, h_cfg_gteunn),
+       mee_onoff_h   ("Disable GTE flags",        0, ndrc_g.hacks, NDHACK_GTE_NO_FLAGS, h_cfg_gteflgs),
+#endif
+       mee_onoff_h   ("Disable CPU/GTE stalls",   0, menu_iopts[0], 1, h_cfg_stalls),
        mee_end,
 };
 
 static int menu_loop_speed_hacks(int id, int keys)
 {
        static int sel = 0;
+       menu_iopts[0] = Config.DisableStalls;
        me_loop(e_menu_speed_hacks, &sel);
+       Config.DisableStalls = menu_iopts[0];
        return 0;
 }
 
-static const char *men_cfg_cdrr[] = { "Auto", "ON", "OFF", NULL };
+static const char *men_autooo[]  = { "Auto", "Off", "On", NULL };
+
 static const char h_cfg_cpul[]   = "Shows CPU usage in %";
 static const char h_cfg_spu[]    = "Shows active SPU channels\n"
                                   "(green: normal, red: fmod, blue: noise)";
@@ -1360,31 +1660,43 @@ static const char h_cfg_fl[]     = "Frame Limiter keeps the game from running to
 static const char h_cfg_xa[]     = "Disables XA sound, which can sometimes improve performance";
 static const char h_cfg_cdda[]   = "Disable CD Audio for a performance boost\n"
                                   "(proper .cue/.bin dump is needed otherwise)";
-static const char h_cfg_sio[]    = "You should not need this, breaks games";
-static const char h_cfg_spuirq[] = "Compatibility tweak; should be left off";
-static const char h_cfg_rcnt1[]  = "Parasite Eve 2, Vandal Hearts 1/2 Fix\n"
-                                  "(timing hack, breaks other games)";
-static const char h_cfg_rcnt2[]  = "InuYasha Sengoku Battle Fix\n"
-                                  "(timing hack, breaks other games)";
-static const char h_cfg_cdrr[]   = "Compatibility tweak (CD timing hack, breaks FMVs)";
+#ifndef DRC_DISABLE
 static const char h_cfg_nodrc[]  = "Disable dynamic recompiler and use interpreter\n"
                                   "Might be useful to overcome some dynarec bugs";
-static const char h_cfg_shacks[] = "Breaks games but may give better performance\n"
-                                  "must reload game for any change to take effect";
+#endif
+static const char h_cfg_shacks[] = "Breaks games but may give better performance";
+static const char h_cfg_icache[] = "Support F1 games (only when dynarec is off)";
+static const char h_cfg_exc[]    = "Emulate some PSX's debug hw like breakpoints\n"
+                                  "and exceptions (slow, interpreter only, keep off)";
+static const char h_cfg_gpul[]   = "Try enabling this if the game misses some graphics\n"
+                                  "causes a performance hit";
+static const char h_cfg_ffps[]   = "Instead of 50/60fps for PAL/NTSC use ~49.75/59.81\n"
+                                  "Closer to real hw but doesn't match modern displays.";
+static const char h_cfg_tcd[]    = "Greatly reduce CD load times. Breaks some games.";
+static const char h_cfg_psxclk[]  = "Over/under-clock the PSX, default is " DEFAULT_PSX_CLOCK_S "\n"
+                                   "(adjust this if the game is too slow/too fast/hangs)";
+
+enum { AMO_XA, AMO_CDDA, AMO_IC, AMO_BP, AMO_CPU, AMO_GPUL, AMO_FFPS, AMO_TCD };
 
 static menu_entry e_menu_adv_options[] =
 {
        mee_onoff_h   ("Show CPU load",          0, g_opts, OPT_SHOWCPU, h_cfg_cpul),
        mee_onoff_h   ("Show SPU channels",      0, g_opts, OPT_SHOWSPU, h_cfg_spu),
        mee_onoff_h   ("Disable Frame Limiter",  0, g_opts, OPT_NO_FRAMELIM, h_cfg_fl),
-       mee_onoff_h   ("Disable XA Decoding",    0, Config.Xa, 1, h_cfg_xa),
-       mee_onoff_h   ("Disable CD Audio",       0, Config.Cdda, 1, h_cfg_cdda),
-       mee_onoff_h   ("SIO IRQ Always Enabled", 0, Config.Sio, 1, h_cfg_sio),
-       mee_onoff_h   ("SPU IRQ Always Enabled", 0, Config.SpuIrq, 1, h_cfg_spuirq),
-       //mee_onoff_h   ("Rootcounter hack",       0, Config.RCntFix, 1, h_cfg_rcnt1),
-       mee_onoff_h   ("Rootcounter hack 2",     0, Config.VSyncWA, 1, h_cfg_rcnt2),
-       mee_enum_h    ("CD read reschedule hack",0, Config.CdrReschedule, men_cfg_cdrr, h_cfg_cdrr),
-       mee_onoff_h   ("Disable dynarec (slow!)",0, Config.Cpu, 1, h_cfg_nodrc),
+       mee_onoff_h   ("Disable XA Decoding",    0, menu_iopts[AMO_XA],   1, h_cfg_xa),
+       mee_onoff_h   ("Disable CD Audio",       0, menu_iopts[AMO_CDDA], 1, h_cfg_cdda),
+       mee_onoff_h   ("ICache emulation",       0, menu_iopts[AMO_IC],   1, h_cfg_icache),
+       mee_onoff_h   ("BP exception emulation", 0, menu_iopts[AMO_BP],   1, h_cfg_exc),
+       mee_enum_h    ("GPU l-list slow walking",0, menu_iopts[AMO_GPUL], men_autooo, h_cfg_gpul),
+       mee_enum_h    ("Fractional framerate",   0, menu_iopts[AMO_FFPS], men_autooo, h_cfg_ffps),
+       mee_onoff_h   ("Turbo CD-ROM ",          0, menu_iopts[AMO_TCD], 1, h_cfg_tcd),
+#ifdef USE_ASYNC_CDROM
+       mee_range     ("CD-ROM read-ahead",      0, cd_buf_count, 0, 1024),
+#endif
+#if !defined(DRC_DISABLE) || defined(LIGHTREC)
+       mee_onoff_h   ("Disable dynarec (slow!)",0, menu_iopts[AMO_CPU],  1, h_cfg_nodrc),
+#endif
+       mee_range_h   ("PSX CPU clock, %",       0, psx_clock, 1, 500, h_cfg_psxclk),
        mee_handler_h ("[Speed hacks]",             menu_loop_speed_hacks, h_cfg_shacks),
        mee_end,
 };
@@ -1392,7 +1704,31 @@ static menu_entry e_menu_adv_options[] =
 static int menu_loop_adv_options(int id, int keys)
 {
        static int sel = 0;
+       static struct {
+               boolean *opt;
+               int *mopt;
+       } opts[] = {
+               { &Config.Xa,      &menu_iopts[AMO_XA] },
+               { &Config.Cdda,    &menu_iopts[AMO_CDDA] },
+               { &Config.icache_emulation, &menu_iopts[AMO_IC] },
+               { &Config.PreciseExceptions, &menu_iopts[AMO_BP] },
+               { &Config.Cpu,     &menu_iopts[AMO_CPU] },
+               { &Config.TurboCD, &menu_iopts[AMO_TCD] },
+       };
+       int i;
+       for (i = 0; i < ARRAY_SIZE(opts); i++)
+               *opts[i].mopt = *opts[i].opt;
+       menu_iopts[AMO_GPUL] = Config.GpuListWalking + 1;
+       menu_iopts[AMO_FFPS] = Config.FractionalFramerate + 1;
+
        me_loop(e_menu_adv_options, &sel);
+
+       for (i = 0; i < ARRAY_SIZE(opts); i++)
+               *opts[i].opt = *opts[i].mopt;
+       Config.GpuListWalking = menu_iopts[AMO_GPUL] - 1;
+       Config.FractionalFramerate = menu_iopts[AMO_FFPS] - 1;
+       cdra_set_buf_count(cd_buf_count);
+
        return 0;
 }
 
@@ -1415,6 +1751,7 @@ static const char h_confirm_save[]    = "Ask for confirmation when overwriting s
 static const char h_restore_def[]     = "Switches back to default / recommended\n"
                                        "configuration";
 static const char h_frameskip[]       = "Warning: frameskip sometimes causes glitches\n";
+static const char h_sputhr[]          = "Warning: has some known bugs\n";
 
 static menu_entry e_menu_options[] =
 {
@@ -1424,6 +1761,11 @@ static menu_entry e_menu_options[] =
        mee_onoff     ("Show FPS",                 0, g_opts, OPT_SHOWFPS),
        mee_enum      ("Region",                   0, region, men_region),
        mee_range     ("CPU clock",                MA_OPT_CPU_CLOCKS, cpu_clock, 20, 5000),
+#ifdef C64X_DSP
+       mee_onoff_h   ("Use C64x DSP for sound",   MA_OPT_SPU_THREAD, spu_config.iUseThread, 1, h_sputhr),
+#else
+       mee_onoff_h   ("Threaded SPU",             MA_OPT_SPU_THREAD, spu_config.iUseThread, 1, h_sputhr),
+#endif
        mee_handler_id("[Display]",                MA_OPT_DISP_OPTS, menu_loop_gfx_options),
        mee_handler   ("[BIOS/Plugins]",           menu_loop_plugin_options),
        mee_handler   ("[Advanced]",               menu_loop_adv_options),
@@ -1436,10 +1778,9 @@ static menu_entry e_menu_options[] =
 static int menu_loop_options(int id, int keys)
 {
        static int sel = 0;
-       int i;
 
-       i = me_id2offset(e_menu_options, MA_OPT_CPU_CLOCKS);
-       e_menu_options[i].enabled = cpu_clock_st > 0 ? 1 : 0;
+       me_enable(e_menu_options, MA_OPT_CPU_CLOCKS, cpu_clock_st > 0);
+       me_enable(e_menu_options, MA_OPT_SPU_THREAD, spu_config.iThreadAvail);
        me_enable(e_menu_options, MA_OPT_SAVECFG_GAME, ready_to_go && CdromId[0]);
 
        me_loop(e_menu_options, &sel);
@@ -1565,12 +1906,12 @@ out:
 
 static void handle_memcard_sel(void)
 {
-       Config.Mcd1[0] = 0;
+       strcpy(Config.Mcd1, "none");
        if (memcard1_sel != 0)
-               snprintf(Config.Mcd1, sizeof(Config.Mcd1), ".%s%s", MEMCARD_DIR, memcards[memcard1_sel]);
-       Config.Mcd2[0] = 0;
+               emu_make_path(Config.Mcd1, sizeof(Config.Mcd1), MEMCARD_DIR, memcards[memcard1_sel]);
+       strcpy(Config.Mcd2, "none");
        if (memcard2_sel != 0)
-               snprintf(Config.Mcd2, sizeof(Config.Mcd2), ".%s%s", MEMCARD_DIR, memcards[memcard2_sel]);
+               emu_make_path(Config.Mcd2, sizeof(Config.Mcd2), MEMCARD_DIR, memcards[memcard2_sel]);
        LoadMcds(Config.Mcd1, Config.Mcd2);
        draw_mc_bg();
 }
@@ -1667,8 +2008,7 @@ static void menu_bios_warn(void)
        int inp;
        static const char msg[] =
                "You don't seem to have copied any BIOS\n"
-               "files to\n"
-               MENU_BIOS_PATH "\n\n"
+               "files to\n%s\n\n"
 
                "While many games work fine with fake\n"
                "(HLE) BIOS, others (like MGS and FF8)\n"
@@ -1682,7 +2022,7 @@ static void menu_bios_warn(void)
                "Press %s or %s to continue";
        char tmp_msg[sizeof(msg) + 64];
 
-       snprintf(tmp_msg, sizeof(tmp_msg), msg,
+       snprintf(tmp_msg, sizeof(tmp_msg), msg, Config.BiosDir,
                in_get_key_name(-1, -PBTN_MOK), in_get_key_name(-1, -PBTN_MBACK));
        while (1)
        {
@@ -1697,7 +2037,6 @@ static void menu_bios_warn(void)
 // ------------ main menu ------------
 
 static menu_entry e_menu_main[];
-void OnFile_Exit();
 
 static void draw_frame_main(void)
 {
@@ -1741,27 +2080,22 @@ static const char credits_text[] =
        "(C) 2005-2009 PCSX-df Team\n"
        "(C) 2009-2011 PCSX-Reloaded Team\n\n"
        "ARM recompiler (C) 2009-2011 Ari64\n"
-#ifdef __ARM_NEON__
        "ARM NEON GPU (c) 2011-2012 Exophase\n"
-#endif
        "PEOpS GPU and SPU by Pete Bernert\n"
        "  and the P.E.Op.S. team\n"
        "PCSX4ALL plugin by PCSX4ALL team\n"
        "  Chui, Franxis, Unai\n\n"
        "integration, optimization and\n"
-       "  frontend (C) 2010-2012 notaz\n";
+       "  frontend (C) 2010-2015 notaz\n";
 
 static int reset_game(void)
 {
-       // sanity check
-       if (bios_sel == 0 && !Config.HLE)
-               return -1;
-
        ClosePlugins();
        OpenPlugins();
        SysReset();
-       if (CheckCdrom() != -1) {
-               LoadCdrom();
+       if (Config.HLE) {
+               if (LoadCdrom() == -1)
+                       return -1;
        }
        return 0;
 }
@@ -1775,7 +2109,6 @@ static int reload_plugins(const char *cdimg)
        set_cd_image(cdimg);
        LoadPlugins();
        pcnt_hook_plugins();
-       NetOpened = 0;
        if (OpenPlugins() == -1) {
                menu_update_msg("failed to open plugins");
                return -1;
@@ -1791,13 +2124,17 @@ static int reload_plugins(const char *cdimg)
 
 static int run_bios(void)
 {
+       boolean origSlowBoot = Config.SlowBoot;
+
        if (bios_sel == 0)
                return -1;
 
        ready_to_go = 0;
        if (reload_plugins(NULL) != 0)
                return -1;
+       Config.SlowBoot = 1;
        SysReset();
+       Config.SlowBoot = origSlowBoot;
 
        ready_to_go = 1;
        return 0;
@@ -1805,9 +2142,11 @@ static int run_bios(void)
 
 static int run_exe(void)
 {
+       const char *exts[] = { "exe", NULL };
        const char *fname;
 
-       fname = menu_loop_romsel(last_selected_fname, sizeof(last_selected_fname));
+       fname = menu_loop_romsel(last_selected_fname,
+               sizeof(last_selected_fname), exts, NULL);
        if (fname == NULL)
                return -1;
 
@@ -1828,6 +2167,20 @@ static int run_exe(void)
 
 static int run_cd_image(const char *fname)
 {
+       int autoload_state = g_autostateld_opt;
+       size_t fname_len = strlen(fname);
+       const char *ppfname = NULL;
+       char fname2[256];
+
+       // simle ppf handling, like game.chd.ppf
+       if (4 < fname_len && fname_len < sizeof(fname2)
+           && strcasecmp(fname + fname_len - 4, ".ppf") == 0) {
+               memcpy(fname2, fname, fname_len - 4);
+               fname2[fname_len - 4] = 0;
+               ppfname = fname;
+               fname = fname2;
+       }
+
        ready_to_go = 0;
        reload_plugins(fname);
 
@@ -1840,6 +2193,8 @@ static int run_cd_image(const char *fname)
                menu_update_msg("unsupported/invalid CD image");
                return -1;
        }
+       if (ppfname)
+               BuildPPFCache(ppfname);
 
        SysReset();
 
@@ -1853,6 +2208,28 @@ static int run_cd_image(const char *fname)
        emu_on_new_cd(1);
        ready_to_go = 1;
 
+       if (autoload_state) {
+               unsigned int newest = 0;
+               int time = 0, slot, newest_slot = -1;
+
+               for (slot = 0; slot < 10; slot++) {
+                       if (emu_check_save_file(slot, &time)) {
+                               if ((unsigned int)time > newest) {
+                                       newest = time;
+                                       newest_slot = slot;
+                               }
+                       }
+               }
+
+               if (newest_slot >= 0) {
+                       lprintf("autoload slot %d\n", newest_slot);
+                       emu_load_state(newest_slot);
+               }
+               else {
+                       lprintf("no save to autoload.\n");
+               }
+       }
+
        return 0;
 }
 
@@ -1861,13 +2238,15 @@ static int romsel_run(void)
        int prev_gpu, prev_spu;
        const char *fname;
 
-       fname = menu_loop_romsel(last_selected_fname, sizeof(last_selected_fname));
+       fname = menu_loop_romsel(last_selected_fname,
+                       sizeof(last_selected_fname), filter_exts,
+                       optional_cdimg_filter);
        if (fname == NULL)
                return -1;
 
        printf("selected file: %s\n", fname);
 
-       new_dynarec_clear_full();
+       ndrc_clear_full();
 
        if (run_cd_image(fname) != 0)
                return -1;
@@ -1885,16 +2264,18 @@ static int romsel_run(void)
                        return -1;
        }
 
-       strcpy(last_selected_fname, rom_fname_reload);
+       strcpy(last_selected_fname, fname);
        menu_do_last_cd_img(0);
        return 0;
 }
 
 static int swap_cd_image(void)
 {
-       char *fname;
+       const char *fname;
 
-       fname = menu_loop_romsel(last_selected_fname, sizeof(last_selected_fname));
+       fname = menu_loop_romsel(last_selected_fname,
+                       sizeof(last_selected_fname), filter_exts,
+                       optional_cdimg_filter);
        if (fname == NULL)
                return -1;
 
@@ -1908,7 +2289,7 @@ static int swap_cd_image(void)
                menu_update_msg("failed to load cdr plugin");
                return -1;
        }
-       if (CDR_open() < 0) {
+       if (cdra_open() < 0) {
                menu_update_msg("failed to open cdr plugin");
                return -1;
        }
@@ -1916,7 +2297,7 @@ static int swap_cd_image(void)
        SetCdOpenCaseTime(time(NULL) + 2);
        LidInterrupt();
 
-       strcpy(last_selected_fname, rom_fname_reload);
+       strcpy(last_selected_fname, fname);
        return 0;
 }
 
@@ -1926,8 +2307,8 @@ static int swap_cd_multidisk(void)
        CdromId[0] = '\0';
        CdromLabel[0] = '\0';
 
-       CDR_close();
-       if (CDR_open() < 0) {
+       cdra_close();
+       if (cdra_open() < 0) {
                menu_update_msg("failed to open cdr plugin");
                return -1;
        }
@@ -1940,11 +2321,12 @@ static int swap_cd_multidisk(void)
 
 static void load_pcsx_cht(void)
 {
-       char path[256];
-       char *fname;
+       static const char *exts[] = { "cht", NULL };
+       const char *fname;
+       char msg[64];
 
-       path[0] = 0;
-       fname = menu_loop_romsel(path, sizeof(path));
+       fname = menu_loop_romsel(last_selected_fname,
+                       sizeof(last_selected_fname), exts, NULL);
        if (fname == NULL)
                return;
 
@@ -1954,8 +2336,8 @@ static void load_pcsx_cht(void)
        if (NumCheats == 0 && NumCodes == 0)
                menu_update_msg("failed to load cheats");
        else {
-               snprintf(path, sizeof(path), "%d cheat(s) loaded", NumCheats + NumCodes);
-               menu_update_msg(path);
+               snprintf(msg, sizeof(msg), "%d cheat(s) loaded", NumCheats + NumCodes);
+               menu_update_msg(msg);
        }
        me_enable(e_menu_main, MA_MAIN_CHEATS, ready_to_go && NumCheats);
 }
@@ -2011,8 +2393,8 @@ static int main_menu_handler(int id, int keys)
                in_menu_wait(PBTN_MOK|PBTN_MBACK, NULL, 70);
                break;
        case MA_MAIN_EXIT:
-               OnFile_Exit();
-               break;
+               emu_core_ask_exit();
+               return 1;
        default:
                lprintf("%s: something unknown selected\n", __FUNCTION__);
                break;
@@ -2098,7 +2480,7 @@ void menu_loop(void)
 
        do {
                me_loop_d(e_menu_main, &sel, NULL, draw_frame_main);
-       } while (!ready_to_go);
+       } while (!ready_to_go && !g_emu_want_quit);
 
        /* wait until menu, ok, back is released */
        while (in_menu_wait_any(NULL, 50) & (PBTN_MENU|PBTN_MOK|PBTN_MBACK))
@@ -2121,7 +2503,6 @@ static void scan_bios_plugins(void)
        char fname[MAXPATHLEN];
        struct dirent *ent;
        int bios_i, gpu_i, spu_i, mc_i;
-       char *p;
        DIR *dir;
 
        bioses[0] = "HLE";
@@ -2134,7 +2515,11 @@ static void scan_bios_plugins(void)
        dir = opendir(fname);
        if (dir == NULL) {
                perror("scan_bios_plugins bios opendir");
+#ifndef NO_DYLIB
                goto do_plugins;
+#else
+               goto do_memcards;
+#endif
        }
 
        while (1) {
@@ -2152,7 +2537,8 @@ static void scan_bios_plugins(void)
                        continue;
 
                snprintf(fname, sizeof(fname), "%s/%s", Config.BiosDir, ent->d_name);
-               if (stat(fname, &st) != 0 || st.st_size != 512*1024) {
+               if (stat(fname, &st) != 0
+                   || (st.st_size != 512*1024 && st.st_size != 4*1024*1024)) {
                        printf("bad BIOS file: %s\n", ent->d_name);
                        continue;
                }
@@ -2167,6 +2553,7 @@ static void scan_bios_plugins(void)
 
        closedir(dir);
 
+#ifndef NO_DYLIB
 do_plugins:
        snprintf(fname, sizeof(fname), "%s/", Config.PluginsDir);
        dir = opendir(fname);
@@ -2177,6 +2564,7 @@ do_plugins:
 
        while (1) {
                void *h, *tmp;
+               char *p;
 
                errno = 0;
                ent = readdir(dir);
@@ -2218,9 +2606,11 @@ do_plugins:
        }
 
        closedir(dir);
+#endif
 
 do_memcards:
-       dir = opendir("." MEMCARD_DIR);
+       emu_make_path(fname, sizeof(fname), MEMCARD_DIR, NULL);
+       dir = opendir(fname);
        if (dir == NULL) {
                perror("scan_bios_plugins memcards opendir");
                return;
@@ -2240,7 +2630,7 @@ do_memcards:
                if (ent->d_type != DT_REG && ent->d_type != DT_LNK)
                        continue;
 
-               snprintf(fname, sizeof(fname), "." MEMCARD_DIR "%s", ent->d_name);
+               emu_make_path(fname, sizeof(fname), MEMCARD_DIR, ent->d_name);
                if (stat(fname, &st) != 0) {
                        printf("bad memcard file: %s\n", ent->d_name);
                        continue;
@@ -2265,8 +2655,6 @@ void menu_init(void)
        char buff[MAXPATHLEN];
        int i;
 
-       strcpy(last_selected_fname, "/media");
-
        cpu_clock_st = cpu_clock = plat_target_cpu_clock_get();
 
        scan_bios_plugins();
@@ -2286,26 +2674,39 @@ void menu_init(void)
                exit(1);
        }
 
-       emu_make_path(buff, "skin/background.png", sizeof(buff));
+       emu_make_data_path(buff, "skin/background.png", sizeof(buff));
        readpng(g_menubg_src_ptr, buff, READPNG_BG, g_menuscreen_w, g_menuscreen_h);
 
        i = plat_target.cpu_clock_set != NULL
                && plat_target.cpu_clock_get != NULL && cpu_clock_st > 0;
-       me_enable(e_menu_gfx_options, MA_OPT_CPU_CLOCKS, i);
+       me_enable(e_menu_options, MA_OPT_CPU_CLOCKS, i);
+
+       i = me_id2offset(e_menu_gfx_options, MA_OPT_VOUT_MODE);
+       e_menu_gfx_options[i].data = plat_target.vout_methods;
+       me_enable(e_menu_gfx_options, MA_OPT_VOUT_MODE,
+               plat_target.vout_methods != NULL);
+
+#ifndef SDL_OVERLAY_2X
+       i = me_id2offset(e_menu_gfx_options, MA_OPT_VOUT_FULL);
+       e_menu_gfx_options[i].data = plat_target.vout_methods;
+       me_enable(e_menu_gfx_options, MA_OPT_VOUT_FULL, 0);
+#endif
 
        i = me_id2offset(e_menu_gfx_options, MA_OPT_HWFILTER);
        e_menu_gfx_options[i].data = plat_target.hwfilters;
-       me_enable(e_menu_gfx_options, MA_OPT_HWFILTER,
-               plat_target.hwfilters != NULL);
-
-       me_enable(e_menu_gfx_options, MA_OPT_GAMMA,
-               plat_target.gamma_set != NULL);
+       me_enable(e_menu_gfx_options, MA_OPT_HWFILTER, plat_target.hwfilters != NULL);
+       if (plat_target.hwfilters && !strcmp(plat_target.hwfilters[0], "linear"))
+               e_menu_gfx_options[i].name = "OpenGL filter";
+       else
+               me_enable(e_menu_gfx_options, MA_OPT_VSYNC, 0);
 
-#ifndef __ARM_ARCH_7A__
+       me_enable(e_menu_gfx_options, MA_OPT_GAMMA, plat_target.gamma_set != NULL);
+#ifndef HAVE_NEON32
        me_enable(e_menu_gfx_options, MA_OPT_SWFILTER, 0);
 #endif
        me_enable(e_menu_gfx_options, MA_OPT_VARSCALER, MENU_SHOW_VARSCALER);
-       me_enable(e_menu_gfx_options, MA_OPT_VARSCALER_C, MENU_SHOW_VARSCALER);
+       me_enable(e_menu_gfx_options, MA_OPT_VOUT_MODE, MENU_SHOW_VOUTMODE);
+       me_enable(e_menu_gfx_options, MA_OPT_VARSCALER_C, MENU_SHOW_VARSCALER_C);
        me_enable(e_menu_gfx_options, MA_OPT_SCALER2, MENU_SHOW_SCALER2);
        me_enable(e_menu_keyconfig, MA_CTRL_NUBS_BTNS, MENU_SHOW_NUBS_BTNS);
        me_enable(e_menu_keyconfig, MA_CTRL_VIBRATION, MENU_SHOW_VIBRATION);
@@ -2360,17 +2761,21 @@ void menu_prepare_emu(void)
 
        plat_video_menu_leave();
 
+       #if !defined(DRC_DISABLE) || defined(LIGHTREC)
        psxCpu = (Config.Cpu == CPU_INTERPRETER) ? &psxInt : &psxRec;
-       if (psxCpu != prev_cpu)
-               // note that this does not really reset, just clears drc caches
-               psxCpu->Reset();
-
-       // core doesn't care about Config.Cdda changes,
-       // so handle them manually here
-       if (Config.Cdda)
-               CDR_stop();
+       #else
+       psxCpu = &psxInt;
+       #endif
+       if (psxCpu != prev_cpu) {
+               prev_cpu->Notify(R3000ACPU_NOTIFY_BEFORE_SAVE, NULL);
+               prev_cpu->Shutdown();
+               psxCpu->Init();
+               psxCpu->Notify(R3000ACPU_NOTIFY_AFTER_LOAD, NULL);
+       }
 
        menu_sync_config();
+       psxCpu->ApplyConfig();
+
        if (cpu_clock > 0)
                plat_target_cpu_clock_set(cpu_clock);
 
@@ -2382,8 +2787,6 @@ void menu_prepare_emu(void)
                if (ret)
                        fprintf(stderr, "Warning: GPU_open returned %d\n", ret);
        }
-
-       dfinput_activate();
 }
 
 void menu_update_msg(const char *msg)