frontend/menu.c

   1 /*
   2  * (C) Gražvydas "notaz" Ignotas, 2010-2015
   3  *
   4  * This work is licensed under the terms of any of these licenses
   5  * (at your option):
   6  *  - GNU GPL, version 2 or later.
   7  *  - GNU LGPL, version 2.1 or later.
   8  * See the COPYING file in the top-level directory.
   9  */
  10
  11 #define _GNU_SOURCE 1
  12 #include <stdio.h>
  13 #include <string.h>
  14 #include <errno.h>
  15 #include <dlfcn.h>
  16 #include <zlib.h>
  17 #include <sys/types.h>
  18 #include <sys/stat.h>
  19 #include <unistd.h>
  20 #include <dirent.h>
  21
  22 #include "main.h"
  23 #include "menu.h"
  24 #include "config.h"
  25 #include "plugin.h"
  26 #include "plugin_lib.h"
  27 #include "plat.h"
  28 #include "pcnt.h"
  29 #include "cspace.h"
  30 #include "libpicofe/plat.h"
  31 #include "libpicofe/input.h"
  32 #include "libpicofe/linux/in_evdev.h"
  33 #include "libpicofe/plat.h"
  34 #include "../libpcsxcore/misc.h"
  35 #include "../libpcsxcore/cdrom.h"
  36 #include "../libpcsxcore/cdriso.h"
  37 #include "../libpcsxcore/cheat.h"
  38 #include "../libpcsxcore/new_dynarec/new_dynarec.h"
  39 #include "../plugins/dfinput/externals.h"
  40 #include "../plugins/dfsound/spu_config.h"
  41 #include "psemu_plugin_defs.h"
  42 #include "arm_features.h"
  43 #include "revision.h"
  44
  45 #define REARMED_BIRTHDAY_TIME 1293306830        /* 25 Dec 2010 */
  46
  47 #define array_size(x) (sizeof(x) / sizeof(x[0]))
  48
  49 typedef enum
  50 {
  51         MA_NONE = 1,
  52         MA_MAIN_RESUME_GAME,
  53         MA_MAIN_SAVE_STATE,
  54         MA_MAIN_LOAD_STATE,
  55         MA_MAIN_RESET_GAME,
  56         MA_MAIN_LOAD_ROM,
  57         MA_MAIN_SWAP_CD,
  58         MA_MAIN_SWAP_CD_MULTI,
  59         MA_MAIN_RUN_BIOS,
  60         MA_MAIN_RUN_EXE,
  61         MA_MAIN_LOAD_CHEATS,
  62         MA_MAIN_CHEATS,
  63         MA_MAIN_CONTROLS,
  64         MA_MAIN_CREDITS,
  65         MA_MAIN_EXIT,
  66         MA_CTRL_PLAYER1,
  67         MA_CTRL_PLAYER2,
  68         MA_CTRL_ANALOG,
  69         MA_CTRL_EMU,
  70         MA_CTRL_DEV_FIRST,
  71         MA_CTRL_DEV_NEXT,
  72         MA_CTRL_NUBS_BTNS,
  73         MA_CTRL_DEADZONE,
  74         MA_CTRL_VIBRATION,
  75         MA_CTRL_DONE,
  76         MA_OPT_SAVECFG,
  77         MA_OPT_SAVECFG_GAME,
  78         MA_OPT_CPU_CLOCKS,
  79         MA_OPT_SPU_THREAD,
  80         MA_OPT_DISP_OPTS,
  81         MA_OPT_VARSCALER,
  82         MA_OPT_VARSCALER_C,
  83         MA_OPT_SCALER2,
  84         MA_OPT_HWFILTER,
  85         MA_OPT_SWFILTER,
  86         MA_OPT_GAMMA,
  87         MA_OPT_VOUT_MODE,
  88         MA_OPT_SCANLINES,
  89         MA_OPT_SCANLINE_LEVEL,
  90 } menu_id;
  91
  92 static int last_vout_w, last_vout_h, last_vout_bpp;
  93 static int cpu_clock, cpu_clock_st, volume_boost, frameskip;
  94 static char last_selected_fname[MAXPATHLEN];
  95 static int config_save_counter, region, in_type_sel1, in_type_sel2;
  96 static int psx_clock;
  97 static int memcard1_sel = -1, memcard2_sel = -1;
  98 extern int g_autostateld_opt;
  99 static int menu_iopts[8];
 100 int g_opts, g_scaler, g_gamma = 100;
 101 int scanlines, scanline_level = 20;
 102 int soft_scaling, analog_deadzone; // for Caanoo
 103 int soft_filter;
 104
 105 #ifndef HAVE_PRE_ARMV7
 106 #define DEFAULT_PSX_CLOCK (10000 / CYCLE_MULT_DEFAULT)
 107 #define DEFAULT_PSX_CLOCK_S "57"
 108 #else
 109 #define DEFAULT_PSX_CLOCK 50
 110 #define DEFAULT_PSX_CLOCK_S "50"
 111 #endif
 112
 113 static const char *bioses[24];
 114 static const char *gpu_plugins[16];
 115 static const char *spu_plugins[16];
 116 static const char *memcards[32];
 117 static int bios_sel, gpu_plugsel, spu_plugsel;
 118
 119 #ifndef UI_FEATURES_H
 120 #define MENU_BIOS_PATH "bios/"
 121 #define MENU_SHOW_VARSCALER 0
 122 #define MENU_SHOW_VOUTMODE 1
 123 #define MENU_SHOW_SCALER2 0
 124 #define MENU_SHOW_NUBS_BTNS 0
 125 #define MENU_SHOW_VIBRATION 0
 126 #define MENU_SHOW_DEADZONE 0
 127 #define MENU_SHOW_MINIMIZE 0
 128 #define MENU_SHOW_FULLSCREEN 1
 129 #define MENU_SHOW_VOLUME 0
 130 #endif
 131
 132 static int min(int x, int y) { return x < y ? x : y; }
 133 static int max(int x, int y) { return x > y ? x : y; }
 134
 135 void emu_make_path(char *buff, const char *end, int size)
 136 {
 137         int pos, end_len;
 138
 139         end_len = strlen(end);
 140         pos = plat_get_root_dir(buff, size);
 141         strncpy(buff + pos, end, size - pos);
 142         buff[size - 1] = 0;
 143         if (pos + end_len > size - 1)
 144                 printf("Warning: path truncated: %s\n", buff);
 145 }
 146
 147 static int emu_check_save_file(int slot, int *time)
 148 {
 149         char fname[MAXPATHLEN];
 150         struct stat status;
 151         int ret;
 152
 153         ret = emu_check_state(slot);
 154         if (ret != 0 || time == NULL)
 155                 return ret == 0 ? 1 : 0;
 156
 157         ret = get_state_filename(fname, sizeof(fname), slot);
 158         if (ret != 0)
 159                 return 1;
 160
 161         ret = stat(fname, &status);
 162         if (ret != 0)
 163                 return 1;
 164
 165         if (status.st_mtime < REARMED_BIRTHDAY_TIME)
 166                 return 1; // probably bad rtc like on some Caanoos
 167
 168         *time = status.st_mtime;
 169
 170         return 1;
 171 }
 172
 173 static int emu_save_load_game(int load, int unused)
 174 {
 175         int ret;
 176
 177         if (load) {
 178                 ret = emu_load_state(state_slot);
 179
 180                 // reflect hle/bios mode from savestate
 181                 if (Config.HLE)
 182                         bios_sel = 0;
 183                 else if (bios_sel == 0 && bioses[1] != NULL)
 184                         // XXX: maybe find the right bios instead
 185                         bios_sel = 1;
 186         }
 187         else
 188                 ret = emu_save_state(state_slot);
 189
 190         return ret;
 191 }
 192
 193 static void rm_namelist_entry(struct dirent **namelist,
 194         int count, const char *name)
 195 {
 196         int i;
 197
 198         for (i = 1; i < count; i++) {
 199                 if (namelist[i] == NULL || namelist[i]->d_type == DT_DIR)
 200                         continue;
 201
 202                 if (strcmp(name, namelist[i]->d_name) == 0) {
 203                         free(namelist[i]);
 204                         namelist[i] = NULL;
 205                         break;
 206                 }
 207         }
 208 }
 209
 210 static int optional_cdimg_filter(struct dirent **namelist, int count,
 211         const char *basedir)
 212 {
 213         const char *ext, *p;
 214         char buf[256], buf2[256];
 215         int i, d, ret, good_cue;
 216         struct stat64 statf;
 217         FILE *f;
 218
 219         if (count <= 1)
 220                 return count;
 221
 222         for (i = 1; i < count; i++) {
 223                 if (namelist[i] == NULL || namelist[i]->d_type == DT_DIR)
 224                         continue;
 225
 226                 ext = strrchr(namelist[i]->d_name, '.');
 227                 if (ext == NULL) {
 228                         // should not happen but whatever
 229                         free(namelist[i]);
 230                         namelist[i] = NULL;
 231                         continue;
 232                 }
 233                 ext++;
 234
 235                 // first find .cue files and remove files they reference
 236                 if (strcasecmp(ext, "cue") == 0)
 237                 {
 238                         snprintf(buf, sizeof(buf), "%s/%s", basedir,
 239                                 namelist[i]->d_name);
 240
 241                         f = fopen(buf, "r");
 242                         if (f == NULL) {
 243                                 free(namelist[i]);
 244                                 namelist[i] = NULL;
 245                                 continue;
 246                         }
 247
 248                         good_cue = 0;
 249                         while (fgets(buf, sizeof(buf), f)) {
 250                                 ret = sscanf(buf, " FILE \"%256[^\"]\"", buf2);
 251                                 if (ret != 1)
 252                                         ret = sscanf(buf, " FILE %256s", buf2);
 253                                 if (ret != 1)
 254                                         continue;
 255
 256                                 p = strrchr(buf2, '/');
 257                                 if (p == NULL)
 258                                         p = strrchr(buf2, '\\');
 259                                 if (p != NULL)
 260                                         p++;
 261                                 else
 262                                         p = buf2;
 263
 264                                 snprintf(buf, sizeof(buf), "%s/%s", basedir, p);
 265                                 ret = stat64(buf, &statf);
 266                                 if (ret == 0) {
 267                                         rm_namelist_entry(namelist, count, p);
 268                                         good_cue = 1;
 269                                 }
 270                         }
 271                         fclose(f);
 272
 273                         if (!good_cue) {
 274                                 free(namelist[i]);
 275                                 namelist[i] = NULL;
 276                         }
 277                         continue;
 278                 }
 279
 280                 p = strcasestr(namelist[i]->d_name, "track");
 281                 if (p != NULL) {
 282                         ret = strtoul(p + 5, NULL, 10);
 283                         if (ret > 1) {
 284                                 free(namelist[i]);
 285                                 namelist[i] = NULL;
 286                                 continue;
 287                         }
 288                 }
 289         }
 290
 291         // compact namelist
 292         for (i = d = 1; i < count; i++)
 293                 if (namelist[i] != NULL)
 294                         namelist[d++] = namelist[i];
 295
 296         return d;
 297 }
 298
 299 // propagate menu settings to the emu vars
 300 static void menu_sync_config(void)
 301 {
 302         static int allow_abs_only_old;
 303
 304         Config.PsxAuto = 1;
 305         if (region > 0) {
 306                 Config.PsxAuto = 0;
 307                 Config.PsxType = region - 1;
 308         }
 309         Config.cycle_multiplier = 10000 / psx_clock;
 310
 311         switch (in_type_sel1) {
 312         case 1:  in_type[0] = PSE_PAD_TYPE_ANALOGPAD; break;
 313         case 2:  in_type[0] = PSE_PAD_TYPE_NEGCON;    break;
 314         default: in_type[0] = PSE_PAD_TYPE_STANDARD;
 315         }
 316         switch (in_type_sel2) {
 317         case 1:  in_type[1] = PSE_PAD_TYPE_ANALOGPAD; break;
 318         case 2:  in_type[1] = PSE_PAD_TYPE_NEGCON;    break;
 319         default: in_type[1] = PSE_PAD_TYPE_STANDARD;
 320         }
 321         if (in_evdev_allow_abs_only != allow_abs_only_old) {
 322                 in_probe();
 323                 allow_abs_only_old = in_evdev_allow_abs_only;
 324         }
 325
 326         spu_config.iVolume = 768 + 128 * volume_boost;
 327         pl_rearmed_cbs.frameskip = frameskip - 1;
 328         pl_timing_prepare(Config.PsxType);
 329 }
 330
 331 static void menu_set_defconfig(void)
 332 {
 333         emu_set_default_config();
 334
 335         g_opts = 0;
 336         g_scaler = SCALE_4_3;
 337         g_gamma = 100;
 338         volume_boost = 0;
 339         frameskip = 0;
 340         analog_deadzone = 50;
 341         soft_scaling = 1;
 342         soft_filter = 0;
 343         scanlines = 0;
 344         scanline_level = 20;
 345         plat_target.vout_fullscreen = 0;
 346         psx_clock = DEFAULT_PSX_CLOCK;
 347
 348         region = 0;
 349         in_type_sel1 = in_type_sel2 = 0;
 350         in_evdev_allow_abs_only = 0;
 351
 352         menu_sync_config();
 353 }
 354
 355 #define CE_CONFIG_STR(val) \
 356         { #val, 0, Config.val }
 357
 358 #define CE_CONFIG_VAL(val) \
 359         { #val, sizeof(Config.val), &Config.val }
 360
 361 #define CE_STR(val) \
 362         { #val, 0, val }
 363
 364 #define CE_INTVAL(val) \
 365         { #val, sizeof(val), &val }
 366
 367 #define CE_INTVAL_N(name, val) \
 368         { name, sizeof(val), &val }
 369
 370 #define CE_INTVAL_P(val) \
 371         { #val, sizeof(pl_rearmed_cbs.val), &pl_rearmed_cbs.val }
 372
 373 // 'versioned' var, used when defaults change
 374 #define CE_CONFIG_STR_V(val, ver) \
 375         { #val #ver, 0, Config.val }
 376
 377 #define CE_INTVAL_V(val, ver) \
 378         { #val #ver, sizeof(val), &val }
 379
 380 #define CE_INTVAL_PV(val, ver) \
 381         { #val #ver, sizeof(pl_rearmed_cbs.val), &pl_rearmed_cbs.val }
 382
 383 static const struct {
 384         const char *name;
 385         size_t len;
 386         void *val;
 387 } config_data[] = {
 388         CE_CONFIG_STR(Bios),
 389         CE_CONFIG_STR_V(Gpu, 3),
 390         CE_CONFIG_STR(Spu),
 391 //      CE_CONFIG_STR(Cdr),
 392         CE_CONFIG_VAL(Xa),
 393         CE_CONFIG_VAL(Mdec),
 394         CE_CONFIG_VAL(Cdda),
 395         CE_CONFIG_VAL(Debug),
 396         CE_CONFIG_VAL(PsxOut),
 397         CE_CONFIG_VAL(icache_emulation),
 398         CE_CONFIG_VAL(DisableStalls),
 399         CE_CONFIG_VAL(Cpu),
 400         CE_CONFIG_VAL(GpuListWalking),
 401         CE_INTVAL(region),
 402         CE_INTVAL_V(g_scaler, 3),
 403         CE_INTVAL(g_gamma),
 404         CE_INTVAL(g_layer_x),
 405         CE_INTVAL(g_layer_y),
 406         CE_INTVAL(g_layer_w),
 407         CE_INTVAL(g_layer_h),
 408         CE_INTVAL(soft_filter),
 409         CE_INTVAL(scanlines),
 410         CE_INTVAL(scanline_level),
 411         CE_INTVAL(plat_target.vout_method),
 412         CE_INTVAL(plat_target.hwfilter),
 413         CE_INTVAL(plat_target.vout_fullscreen),
 414         CE_INTVAL(state_slot),
 415         CE_INTVAL(cpu_clock),
 416         CE_INTVAL(g_opts),
 417         CE_INTVAL(in_type_sel1),
 418         CE_INTVAL(in_type_sel2),
 419         CE_INTVAL(analog_deadzone),
 420         CE_INTVAL(memcard1_sel),
 421         CE_INTVAL(memcard2_sel),
 422         CE_INTVAL(g_autostateld_opt),
 423         CE_INTVAL_N("adev0_is_nublike", in_adev_is_nublike[0]),
 424         CE_INTVAL_N("adev1_is_nublike", in_adev_is_nublike[1]),
 425         CE_INTVAL_V(frameskip, 3),
 426         CE_INTVAL_P(gpu_peops.iUseDither),
 427         CE_INTVAL_P(gpu_peops.dwActFixes),
 428         CE_INTVAL_P(gpu_unai.lineskip),
 429         CE_INTVAL_P(gpu_unai.abe_hack),
 430         CE_INTVAL_P(gpu_unai.no_light),
 431         CE_INTVAL_P(gpu_unai.no_blend),
 432         CE_INTVAL_P(gpu_senquack.ilace_force),
 433         CE_INTVAL_P(gpu_senquack.pixel_skip),
 434         CE_INTVAL_P(gpu_senquack.lighting),
 435         CE_INTVAL_P(gpu_senquack.fast_lighting),
 436         CE_INTVAL_P(gpu_senquack.blending),
 437         CE_INTVAL_P(gpu_senquack.dithering),
 438         CE_INTVAL_P(gpu_senquack.scale_hires),
 439         CE_INTVAL_P(gpu_neon.allow_interlace),
 440         CE_INTVAL_P(gpu_neon.enhancement_enable),
 441         CE_INTVAL_P(gpu_neon.enhancement_no_main),
 442         CE_INTVAL_P(gpu_peopsgl.bDrawDither),
 443         CE_INTVAL_P(gpu_peopsgl.iFilterType),
 444         CE_INTVAL_P(gpu_peopsgl.iFrameTexType),
 445         CE_INTVAL_P(gpu_peopsgl.iUseMask),
 446         CE_INTVAL_P(gpu_peopsgl.bOpaquePass),
 447         CE_INTVAL_P(gpu_peopsgl.bAdvancedBlend),
 448         CE_INTVAL_P(gpu_peopsgl.bUseFastMdec),
 449         CE_INTVAL_P(gpu_peopsgl.iVRamSize),
 450         CE_INTVAL_P(gpu_peopsgl.iTexGarbageCollection),
 451         CE_INTVAL_P(gpu_peopsgl.dwActFixes),
 452         CE_INTVAL(spu_config.iUseReverb),
 453         CE_INTVAL(spu_config.iXAPitch),
 454         CE_INTVAL(spu_config.iUseInterpolation),
 455         CE_INTVAL(spu_config.iTempo),
 456         CE_INTVAL(spu_config.iUseThread),
 457         CE_INTVAL(config_save_counter),
 458         CE_INTVAL(in_evdev_allow_abs_only),
 459         CE_INTVAL(volume_boost),
 460         CE_INTVAL(psx_clock),
 461         CE_INTVAL(new_dynarec_hacks),
 462         CE_INTVAL(in_enable_vibration),
 463 };
 464
 465 static char *get_cd_label(void)
 466 {
 467         static char trimlabel[33];
 468         int j;
 469
 470         strncpy(trimlabel, CdromLabel, 32);
 471         trimlabel[32] = 0;
 472         for (j = 31; j >= 0; j--)
 473                 if (trimlabel[j] == ' ')
 474                         trimlabel[j] = 0;
 475
 476         return trimlabel;
 477 }
 478
 479 static void make_cfg_fname(char *buf, size_t size, int is_game)
 480 {
 481         if (is_game)
 482                 snprintf(buf, size, "." PCSX_DOT_DIR "cfg/%.32s-%.9s.cfg", get_cd_label(), CdromId);
 483         else
 484                 snprintf(buf, size, "." PCSX_DOT_DIR "%s", cfgfile_basename);
 485 }
 486
 487 static void keys_write_all(FILE *f);
 488 static char *mystrip(char *str);
 489
 490 static int menu_write_config(int is_game)
 491 {
 492         char cfgfile[MAXPATHLEN];
 493         FILE *f;
 494         int i;
 495
 496         config_save_counter++;
 497
 498         make_cfg_fname(cfgfile, sizeof(cfgfile), is_game);
 499         f = fopen(cfgfile, "w");
 500         if (f == NULL) {
 501                 printf("menu_write_config: failed to open: %s\n", cfgfile);
 502                 return -1;
 503         }
 504
 505         for (i = 0; i < ARRAY_SIZE(config_data); i++) {
 506                 fprintf(f, "%s = ", config_data[i].name);
 507                 switch (config_data[i].len) {
 508                 case 0:
 509                         fprintf(f, "%s\n", (char *)config_data[i].val);
 510                         break;
 511                 case 1:
 512                         fprintf(f, "%x\n", *(u8 *)config_data[i].val);
 513                         break;
 514                 case 2:
 515                         fprintf(f, "%x\n", *(u16 *)config_data[i].val);
 516                         break;
 517                 case 4:
 518                         fprintf(f, "%x\n", *(u32 *)config_data[i].val);
 519                         break;
 520                 default:
 521                         printf("menu_write_config: unhandled len %d for %s\n",
 522                                  (int)config_data[i].len, config_data[i].name);
 523                         break;
 524                 }
 525         }
 526
 527         keys_write_all(f);
 528         fclose(f);
 529
 530         return 0;
 531 }
 532
 533 static int menu_do_last_cd_img(int is_get)
 534 {
 535         static const char *defaults[] = { "/media", "/mnt/sd", "/mnt" };
 536         char path[256];
 537         struct stat64 st;
 538         FILE *f;
 539         int i, ret = -1;
 540
 541         snprintf(path, sizeof(path), "." PCSX_DOT_DIR "lastcdimg.txt");
 542         f = fopen(path, is_get ? "r" : "w");
 543         if (f == NULL) {
 544                 ret = -1;
 545                 goto out;
 546         }
 547
 548         if (is_get) {
 549                 ret = fread(last_selected_fname, 1, sizeof(last_selected_fname) - 1, f);
 550                 last_selected_fname[ret] = 0;
 551                 mystrip(last_selected_fname);
 552         }
 553         else
 554                 fprintf(f, "%s\n", last_selected_fname);
 555         fclose(f);
 556
 557 out:
 558         if (is_get) {
 559                 for (i = 0; last_selected_fname[0] == 0
 560                        || stat64(last_selected_fname, &st) != 0; i++)
 561                 {
 562                         if (i >= ARRAY_SIZE(defaults))
 563                                 break;
 564                         strcpy(last_selected_fname, defaults[i]);
 565                 }
 566         }
 567
 568         return 0;
 569 }
 570
 571 static void parse_str_val(char *cval, const char *src)
 572 {
 573         char *tmp;
 574         strncpy(cval, src, MAXPATHLEN);
 575         cval[MAXPATHLEN - 1] = 0;
 576         tmp = strchr(cval, '\n');
 577         if (tmp == NULL)
 578                 tmp = strchr(cval, '\r');
 579         if (tmp != NULL)
 580                 *tmp = 0;
 581 }
 582
 583 static void keys_load_all(const char *cfg);
 584
 585 static int menu_load_config(int is_game)
 586 {
 587         char cfgfile[MAXPATHLEN];
 588         int i, ret = -1;
 589         long size;
 590         char *cfg;
 591         FILE *f;
 592
 593         make_cfg_fname(cfgfile, sizeof(cfgfile), is_game);
 594         f = fopen(cfgfile, "r");
 595         if (f == NULL) {
 596                 printf("menu_load_config: failed to open: %s\n", cfgfile);
 597                 goto fail;
 598         }
 599
 600         fseek(f, 0, SEEK_END);
 601         size = ftell(f);
 602         if (size <= 0) {
 603                 printf("bad size %ld: %s\n", size, cfgfile);
 604                 goto fail;
 605         }
 606
 607         cfg = malloc(size + 1);
 608         if (cfg == NULL)
 609                 goto fail;
 610
 611         fseek(f, 0, SEEK_SET);
 612         if (fread(cfg, 1, size, f) != size) {
 613                 printf("failed to read: %s\n", cfgfile);
 614                 goto fail_read;
 615         }
 616         cfg[size] = 0;
 617
 618         for (i = 0; i < ARRAY_SIZE(config_data); i++) {
 619                 char *tmp, *tmp2;
 620                 u32 val;
 621
 622                 tmp = strstr(cfg, config_data[i].name);
 623                 if (tmp == NULL)
 624                         continue;
 625                 tmp += strlen(config_data[i].name);
 626                 if (strncmp(tmp, " = ", 3) != 0)
 627                         continue;
 628                 tmp += 3;
 629
 630                 if (config_data[i].len == 0) {
 631                         parse_str_val(config_data[i].val, tmp);
 632                         continue;
 633                 }
 634
 635                 tmp2 = NULL;
 636                 val = strtoul(tmp, &tmp2, 16);
 637                 if (tmp2 == NULL || tmp == tmp2)
 638                         continue; // parse failed
 639
 640                 switch (config_data[i].len) {
 641                 case 1:
 642                         *(u8 *)config_data[i].val = val;
 643                         break;
 644                 case 2:
 645                         *(u16 *)config_data[i].val = val;
 646                         break;
 647                 case 4:
 648                         *(u32 *)config_data[i].val = val;
 649                         break;
 650                 default:
 651                         printf("menu_load_config: unhandled len %d for %s\n",
 652                                  (int)config_data[i].len, config_data[i].name);
 653                         break;
 654                 }
 655         }
 656
 657         if (!is_game) {
 658                 char *tmp = strstr(cfg, "lastcdimg = ");
 659                 if (tmp != NULL) {
 660                         tmp += 12;
 661                         parse_str_val(last_selected_fname, tmp);
 662                 }
 663         }
 664
 665         keys_load_all(cfg);
 666         ret = 0;
 667 fail_read:
 668         free(cfg);
 669 fail:
 670         if (f != NULL)
 671                 fclose(f);
 672
 673         menu_sync_config();
 674
 675         // sync plugins
 676         for (i = bios_sel = 0; bioses[i] != NULL; i++)
 677                 if (strcmp(Config.Bios, bioses[i]) == 0)
 678                         { bios_sel = i; break; }
 679
 680         for (i = gpu_plugsel = 0; gpu_plugins[i] != NULL; i++)
 681                 if (strcmp(Config.Gpu, gpu_plugins[i]) == 0)
 682                         { gpu_plugsel = i; break; }
 683
 684         for (i = spu_plugsel = 0; spu_plugins[i] != NULL; i++)
 685                 if (strcmp(Config.Spu, spu_plugins[i]) == 0)
 686                         { spu_plugsel = i; break; }
 687
 688         // memcard selections
 689         char mcd1_old[sizeof(Config.Mcd1)];
 690         char mcd2_old[sizeof(Config.Mcd2)];
 691         strcpy(mcd1_old, Config.Mcd1);
 692         strcpy(mcd2_old, Config.Mcd2);
 693
 694         if ((unsigned int)memcard1_sel < ARRAY_SIZE(memcards)) {
 695                 if (memcard1_sel == 0)
 696                         strcpy(Config.Mcd1, "none");
 697                 else if (memcards[memcard1_sel] != NULL)
 698                         snprintf(Config.Mcd1, sizeof(Config.Mcd1), ".%s%s",
 699                                 MEMCARD_DIR, memcards[memcard1_sel]);
 700         }
 701         if ((unsigned int)memcard2_sel < ARRAY_SIZE(memcards)) {
 702                 if (memcard2_sel == 0)
 703                         strcpy(Config.Mcd2, "none");
 704                 else if (memcards[memcard2_sel] != NULL)
 705                         snprintf(Config.Mcd2, sizeof(Config.Mcd2), ".%s%s",
 706                                 MEMCARD_DIR, memcards[memcard2_sel]);
 707         }
 708         if (strcmp(mcd1_old, Config.Mcd1) || strcmp(mcd2_old, Config.Mcd2))
 709                 LoadMcds(Config.Mcd1, Config.Mcd2);
 710
 711         return ret;
 712 }
 713
 714 static const char *filter_exts[] = {
 715         "bin", "img", "mdf", "iso", "cue", "z",
 716         #ifdef HAVE_CHD
 717         "chd",
 718         #endif
 719         "bz",  "znx", "pbp", "cbn", NULL
 720 };
 721
 722 // rrrr rggg gggb bbbb
 723 static unsigned short fname2color(const char *fname)
 724 {
 725         static const char *other_exts[] = {
 726                 "ccd", "toc", "mds", "sub", "table", "index", "sbi"
 727         };
 728         const char *ext = strrchr(fname, '.');
 729         int i;
 730
 731         if (ext == NULL)
 732                 return 0xffff;
 733         ext++;
 734         for (i = 0; filter_exts[i] != NULL; i++)
 735                 if (strcasecmp(ext, filter_exts[i]) == 0)
 736                         return 0x7bff;
 737         for (i = 0; i < array_size(other_exts); i++)
 738                 if (strcasecmp(ext, other_exts[i]) == 0)
 739                         return 0xa514;
 740         return 0xffff;
 741 }
 742
 743 static void draw_savestate_bg(int slot);
 744
 745 #define MENU_ALIGN_LEFT
 746 #ifndef HAVE_PRE_ARMV7 // assume hires device
 747 #define MENU_X2 1
 748 #else
 749 #define MENU_X2 0
 750 #endif
 751
 752 #include "libpicofe/menu.c"
 753
 754 // a bit of black magic here
 755 static void draw_savestate_bg(int slot)
 756 {
 757         static const int psx_widths[8]  = { 256, 368, 320, 384, 512, 512, 640, 640 };
 758         int x, y, w, h;
 759         char fname[MAXPATHLEN];
 760         GPUFreeze_t *gpu;
 761         u16 *s, *d;
 762         gzFile f;
 763         int ret;
 764         u32 tmp;
 765
 766         ret = get_state_filename(fname, sizeof(fname), slot);
 767         if (ret != 0)
 768                 return;
 769
 770         f = gzopen(fname, "rb");
 771         if (f == NULL)
 772                 return;
 773
 774         if ((ret = (int)gzseek(f, 0x29933d, SEEK_SET)) != 0x29933d) {
 775                 fprintf(stderr, "gzseek failed: %d\n", ret);
 776                 gzclose(f);
 777                 return;
 778         }
 779
 780         gpu = malloc(sizeof(*gpu));
 781         if (gpu == NULL) {
 782                 gzclose(f);
 783                 return;
 784         }
 785
 786         ret = gzread(f, gpu, sizeof(*gpu));
 787         gzclose(f);
 788         if (ret != sizeof(*gpu)) {
 789                 fprintf(stderr, "gzread failed\n");
 790                 goto out;
 791         }
 792
 793         memcpy(g_menubg_ptr, g_menubg_src_ptr, g_menuscreen_w * g_menuscreen_h * 2);
 794
 795         if (gpu->ulStatus & 0x800000)
 796                 goto out; // disabled
 797
 798         x = gpu->ulControl[5] & 0x3ff;
 799         y = (gpu->ulControl[5] >> 10) & 0x1ff;
 800         w = psx_widths[(gpu->ulStatus >> 16) & 7];
 801         tmp = gpu->ulControl[7];
 802         h = ((tmp >> 10) & 0x3ff) - (tmp & 0x3ff);
 803         if (gpu->ulStatus & 0x80000) // doubleheight
 804                 h *= 2;
 805         if (h <= 0 || h > 512)
 806                 goto out;
 807         if (y > 512 - 64)
 808                 y = 0;
 809         if (y + h > 512)
 810                 h = 512 - y;
 811         s = (u16 *)gpu->psxVRam + y * 1024 + x;
 812
 813         x = max(0, g_menuscreen_w - w) & ~3;
 814         y = max(0, g_menuscreen_h / 2 - h / 2);
 815         w = min(g_menuscreen_w, w);
 816         h = min(g_menuscreen_h, h);
 817         d = (u16 *)g_menubg_ptr + g_menuscreen_w * y + x;
 818
 819         for (; h > 0; h--, d += g_menuscreen_w, s += 1024) {
 820                 if (gpu->ulStatus & 0x200000)
 821                         bgr888_to_rgb565(d, s, w * 3);
 822                 else
 823                         bgr555_to_rgb565(d, s, w * 2);
 824
 825                 // darken this so that menu text is visible
 826                 if (g_menuscreen_w - w < 320)
 827                         menu_darken_bg(d, d, w, 0);
 828         }
 829
 830 out:
 831         free(gpu);
 832 }
 833
 834 // -------------- key config --------------
 835
 836 me_bind_action me_ctrl_actions[] =
 837 {
 838         { "UP      ", 1 << DKEY_UP},
 839         { "DOWN    ", 1 << DKEY_DOWN },
 840         { "LEFT    ", 1 << DKEY_LEFT },
 841         { "RIGHT   ", 1 << DKEY_RIGHT },
 842         { "TRIANGLE", 1 << DKEY_TRIANGLE },
 843         { "CIRCLE  ", 1 << DKEY_CIRCLE },
 844         { "CROSS   ", 1 << DKEY_CROSS },
 845         { "SQUARE  ", 1 << DKEY_SQUARE },
 846         { "L1      ", 1 << DKEY_L1 },
 847         { "R1      ", 1 << DKEY_R1 },
 848         { "L2      ", 1 << DKEY_L2 },
 849         { "R2      ", 1 << DKEY_R2 },
 850         { "L3      ", 1 << DKEY_L3 },
 851         { "R3      ", 1 << DKEY_R3 },
 852         { "START   ", 1 << DKEY_START },
 853         { "SELECT  ", 1 << DKEY_SELECT },
 854         { NULL,       0 }
 855 };
 856
 857 me_bind_action emuctrl_actions[] =
 858 {
 859         { "Save State       ", 1 << SACTION_SAVE_STATE },
 860         { "Load State       ", 1 << SACTION_LOAD_STATE },
 861         { "Prev Save Slot   ", 1 << SACTION_PREV_SSLOT },
 862         { "Next Save Slot   ", 1 << SACTION_NEXT_SSLOT },
 863         { "Toggle Frameskip ", 1 << SACTION_TOGGLE_FSKIP },
 864         { "Take Screenshot  ", 1 << SACTION_SCREENSHOT },
 865         { "Show/Hide FPS    ", 1 << SACTION_TOGGLE_FPS },
 866 #ifndef HAVE_PRE_ARMV7
 867         { "Switch Renderer  ", 1 << SACTION_SWITCH_DISPMODE },
 868 #endif
 869         { "Fast Forward     ", 1 << SACTION_FAST_FORWARD },
 870 #if MENU_SHOW_MINIMIZE
 871         { "Minimize         ", 1 << SACTION_MINIMIZE },
 872 #endif
 873 #if MENU_SHOW_FULLSCREEN
 874         { "Toggle fullscreen", 1 << SACTION_TOGGLE_FULLSCREEN },
 875 #endif
 876         { "Enter Menu       ", 1 << SACTION_ENTER_MENU },
 877         { "Gun Trigger      ", 1 << SACTION_GUN_TRIGGER },
 878         { "Gun A button     ", 1 << SACTION_GUN_A },
 879         { "Gun B button     ", 1 << SACTION_GUN_B },
 880         { "Gun Offscreen Trigger", 1 << SACTION_GUN_TRIGGER2 },
 881 #if MENU_SHOW_VOLUME
 882         { "Volume Up        ", 1 << SACTION_VOLUME_UP },
 883         { "Volume Down      ", 1 << SACTION_VOLUME_DOWN },
 884 #endif
 885         { NULL,                0 }
 886 };
 887
 888 static char *mystrip(char *str)
 889 {
 890         int i, len;
 891
 892         len = strlen(str);
 893         for (i = 0; i < len; i++)
 894                 if (str[i] != ' ') break;
 895         if (i > 0) memmove(str, str + i, len - i + 1);
 896
 897         len = strlen(str);
 898         for (i = len - 1; i >= 0; i--)
 899                 if (str[i] != ' ' && str[i] != '\r' && str[i] != '\n') break;
 900         str[i+1] = 0;
 901
 902         return str;
 903 }
 904
 905 static void get_line(char *d, size_t size, const char *s)
 906 {
 907         const char *pe;
 908         size_t len;
 909
 910         for (pe = s; *pe != '\r' && *pe != '\n' && *pe != 0; pe++)
 911                 ;
 912         len = pe - s;
 913         if (len > size - 1)
 914                 len = size - 1;
 915         strncpy(d, s, len);
 916         d[len] = 0;
 917 }
 918
 919 static void keys_write_all(FILE *f)
 920 {
 921         int d;
 922
 923         for (d = 0; d < IN_MAX_DEVS; d++)
 924         {
 925                 const int *binds = in_get_dev_binds(d);
 926                 const char *name = in_get_dev_name(d, 0, 0);
 927                 int k, count = 0;
 928
 929                 if (binds == NULL || name == NULL)
 930                         continue;
 931
 932                 fprintf(f, "binddev = %s\n", name);
 933                 in_get_config(d, IN_CFG_BIND_COUNT, &count);
 934
 935                 for (k = 0; k < count; k++)
 936                 {
 937                         int i, kbinds, mask;
 938                         char act[32];
 939
 940                         act[0] = act[31] = 0;
 941                         name = in_get_key_name(d, k);
 942
 943                         kbinds = binds[IN_BIND_OFFS(k, IN_BINDTYPE_PLAYER12)];
 944                         for (i = 0; kbinds && i < ARRAY_SIZE(me_ctrl_actions) - 1; i++) {
 945                                 mask = me_ctrl_actions[i].mask;
 946                                 if (mask & kbinds) {
 947                                         strncpy(act, me_ctrl_actions[i].name, 31);
 948                                         fprintf(f, "bind %s = player1 %s\n", name, mystrip(act));
 949                                         kbinds &= ~mask;
 950                                 }
 951                                 mask = me_ctrl_actions[i].mask << 16;
 952                                 if (mask & kbinds) {
 953                                         strncpy(act, me_ctrl_actions[i].name, 31);
 954                                         fprintf(f, "bind %s = player2 %s\n", name, mystrip(act));
 955                                         kbinds &= ~mask;
 956                                 }
 957                         }
 958
 959                         kbinds = binds[IN_BIND_OFFS(k, IN_BINDTYPE_EMU)];
 960                         for (i = 0; kbinds && emuctrl_actions[i].name != NULL; i++) {
 961                                 mask = emuctrl_actions[i].mask;
 962                                 if (mask & kbinds) {
 963                                         strncpy(act, emuctrl_actions[i].name, 31);
 964                                         fprintf(f, "bind %s = %s\n", name, mystrip(act));
 965                                         kbinds &= ~mask;
 966                                 }
 967                         }
 968                 }
 969
 970                 for (k = 0; k < array_size(in_adev); k++)
 971                 {
 972                         if (in_adev[k] == d)
 973                                 fprintf(f, "bind_analog = %d\n", k);
 974                 }
 975         }
 976 }
 977
 978 static int parse_bind_val(const char *val, int *type)
 979 {
 980         int i;
 981
 982         *type = IN_BINDTYPE_NONE;
 983         if (val[0] == 0)
 984                 return 0;
 985
 986         if (strncasecmp(val, "player", 6) == 0)
 987         {
 988                 int player, shift = 0;
 989                 player = atoi(val + 6) - 1;
 990
 991                 if ((unsigned int)player > 1)
 992                         return -1;
 993                 if (player == 1)
 994                         shift = 16;
 995
 996                 *type = IN_BINDTYPE_PLAYER12;
 997                 for (i = 0; me_ctrl_actions[i].name != NULL; i++) {
 998                         if (strncasecmp(me_ctrl_actions[i].name, val + 8, strlen(val + 8)) == 0)
 999                                 return me_ctrl_actions[i].mask << shift;
1000                 }
1001         }
1002         for (i = 0; emuctrl_actions[i].name != NULL; i++) {
1003                 if (strncasecmp(emuctrl_actions[i].name, val, strlen(val)) == 0) {
1004                         *type = IN_BINDTYPE_EMU;
1005                         return emuctrl_actions[i].mask;
1006                 }
1007         }
1008
1009         return -1;
1010 }
1011
1012 static void keys_load_all(const char *cfg)
1013 {
1014         char dev[256], key[128], *act;
1015         const char *p;
1016         int bind, bindtype;
1017         int ret, dev_id;
1018
1019         p = cfg;
1020         while (p != NULL && (p = strstr(p, "binddev = ")) != NULL) {
1021                 p += 10;
1022
1023                 // don't strip 'dev' because there are weird devices
1024                 // with names with space at the end
1025                 get_line(dev, sizeof(dev), p);
1026
1027                 dev_id = in_config_parse_dev(dev);
1028                 if (dev_id < 0) {
1029                         printf("input: can't handle dev: %s\n", dev);
1030                         continue;
1031                 }
1032
1033                 in_unbind_all(dev_id, -1, -1);
1034                 while ((p = strstr(p, "bind"))) {
1035                         if (strncmp(p, "binddev = ", 10) == 0)
1036                                 break;
1037
1038                         if (strncmp(p, "bind_analog", 11) == 0) {
1039                                 ret = sscanf(p, "bind_analog = %d", &bind);
1040                                 p += 11;
1041                                 if (ret != 1) {
1042                                         printf("input: parse error: %16s..\n", p);
1043                                         continue;
1044                                 }
1045                                 if ((unsigned int)bind >= array_size(in_adev)) {
1046                                         printf("input: analog id %d out of range\n", bind);
1047                                         continue;
1048                                 }
1049                                 in_adev[bind] = dev_id;
1050                                 continue;
1051                         }
1052
1053                         p += 4;
1054                         if (*p != ' ') {
1055                                 printf("input: parse error: %16s..\n", p);
1056                                 continue;
1057                         }
1058
1059                         get_line(key, sizeof(key), p);
1060                         act = strchr(key, '=');
1061                         if (act == NULL) {
1062                                 printf("parse failed: %16s..\n", p);
1063                                 continue;
1064                         }
1065                         *act = 0;
1066                         act++;
1067                         mystrip(key);
1068                         mystrip(act);
1069
1070                         bind = parse_bind_val(act, &bindtype);
1071                         if (bind != -1 && bind != 0) {
1072                                 //printf("bind #%d '%s' %08x (%s)\n", dev_id, key, bind, act);
1073                                 in_config_bind_key(dev_id, key, bind, bindtype);
1074                         }
1075                         else
1076                                 lprintf("config: unhandled action \"%s\"\n", act);
1077                 }
1078         }
1079         in_clean_binds();
1080 }
1081
1082 static int key_config_loop_wrap(int id, int keys)
1083 {
1084         switch (id) {
1085                 case MA_CTRL_PLAYER1:
1086                         key_config_loop(me_ctrl_actions, array_size(me_ctrl_actions) - 1, 0);
1087                         break;
1088                 case MA_CTRL_PLAYER2:
1089                         key_config_loop(me_ctrl_actions, array_size(me_ctrl_actions) - 1, 1);
1090                         break;
1091                 case MA_CTRL_EMU:
1092                         key_config_loop(emuctrl_actions, array_size(emuctrl_actions) - 1, -1);
1093                         break;
1094                 default:
1095                         break;
1096         }
1097         return 0;
1098 }
1099
1100 static const char h_nubmode[] = "Maps nub-like analog controls to PSX ones better\n"
1101                                 "Might cause problems with real analog sticks";
1102 static const char *adevnames[IN_MAX_DEVS + 2];
1103 static int stick_sel[2];
1104
1105 static menu_entry e_menu_keyconfig_analog[] =
1106 {
1107         mee_enum   ("Left stick (L3)",  0, stick_sel[0], adevnames),
1108         mee_range  ("  X axis",    0, in_adev_axis[0][0], 0, 7),
1109         mee_range  ("  Y axis",    0, in_adev_axis[0][1], 0, 7),
1110         mee_onoff_h("  nub mode",  0, in_adev_is_nublike[0], 1, h_nubmode),
1111         mee_enum   ("Right stick (R3)", 0, stick_sel[1], adevnames),
1112         mee_range  ("  X axis",    0, in_adev_axis[1][0], 0, 7),
1113         mee_range  ("  Y axis",    0, in_adev_axis[1][1], 0, 7),
1114         mee_onoff_h("  nub mode",  0, in_adev_is_nublike[1], 1, h_nubmode),
1115         mee_end,
1116 };
1117
1118 static int key_config_analog(int id, int keys)
1119 {
1120         int i, d, count, sel = 0;
1121         int sel2dev_map[IN_MAX_DEVS];
1122
1123         memset(adevnames, 0, sizeof(adevnames));
1124         memset(sel2dev_map, 0xff, sizeof(sel2dev_map));
1125         memset(stick_sel, 0, sizeof(stick_sel));
1126
1127         adevnames[0] = "None";
1128         i = 1;
1129         for (d = 0; d < IN_MAX_DEVS; d++)
1130         {
1131                 const char *name = in_get_dev_name(d, 0, 1);
1132                 if (name == NULL)
1133                         continue;
1134
1135                 count = 0;
1136                 in_get_config(d, IN_CFG_ABS_AXIS_COUNT, &count);
1137                 if (count == 0)
1138                         continue;
1139
1140                 if (in_adev[0] == d) stick_sel[0] = i;
1141                 if (in_adev[1] == d) stick_sel[1] = i;
1142                 sel2dev_map[i] = d;
1143                 adevnames[i++] = name;
1144         }
1145         adevnames[i] = NULL;
1146
1147         me_loop(e_menu_keyconfig_analog, &sel);
1148
1149         in_adev[0] = sel2dev_map[stick_sel[0]];
1150         in_adev[1] = sel2dev_map[stick_sel[1]];
1151
1152         return 0;
1153 }
1154
1155 static const char *mgn_dev_name(int id, int *offs)
1156 {
1157         const char *name = NULL;
1158         static int it = 0;
1159
1160         if (id == MA_CTRL_DEV_FIRST)
1161                 it = 0;
1162
1163         for (; it < IN_MAX_DEVS; it++) {
1164                 name = in_get_dev_name(it, 1, 1);
1165                 if (name != NULL)
1166                         break;
1167         }
1168
1169         it++;
1170         return name;
1171 }
1172
1173 static const char *mgn_saveloadcfg(int id, int *offs)
1174 {
1175         return "";
1176 }
1177
1178 static int mh_savecfg(int id, int keys)
1179 {
1180         if (menu_write_config(id == MA_OPT_SAVECFG_GAME ? 1 : 0) == 0)
1181                 menu_update_msg("config saved");
1182         else
1183                 menu_update_msg("failed to write config");
1184
1185         return 1;
1186 }
1187
1188 static int mh_input_rescan(int id, int keys)
1189 {
1190         //menu_sync_config();
1191         in_probe();
1192         menu_update_msg("rescan complete.");
1193
1194         return 0;
1195 }
1196
1197 static const char *men_in_type_sel[] = {
1198         "Standard (SCPH-1080)",
1199         "Analog (SCPH-1150)",
1200         "GunCon",
1201         NULL
1202 };
1203 static const char h_nub_btns[] = "Experimental, keep this OFF if unsure. Select rescan after change.";
1204 static const char h_notsgun[]  = "Don't trigger (shoot) when touching screen in gun games.";
1205 static const char h_vibration[]= "Must select analog above and enable this ingame too.";
1206
1207 static menu_entry e_menu_keyconfig[] =
1208 {
1209         mee_handler_id("Player 1",              MA_CTRL_PLAYER1,    key_config_loop_wrap),
1210         mee_handler_id("Player 2",              MA_CTRL_PLAYER2,    key_config_loop_wrap),
1211         mee_handler_id("Analog controls",       MA_CTRL_ANALOG,     key_config_analog),
1212         mee_handler_id("Emulator/Gun controls", MA_CTRL_EMU,        key_config_loop_wrap),
1213         mee_label     (""),
1214         mee_enum      ("Port 1 device",     0, in_type_sel1,    men_in_type_sel),
1215         mee_enum      ("Port 2 device",     0, in_type_sel2,    men_in_type_sel),
1216         mee_onoff_h   ("Nubs as buttons",   MA_CTRL_NUBS_BTNS,  in_evdev_allow_abs_only, 1, h_nub_btns),
1217         mee_onoff_h   ("Vibration",         MA_CTRL_VIBRATION,  in_enable_vibration, 1, h_vibration),
1218         mee_range     ("Analog deadzone",   MA_CTRL_DEADZONE,   analog_deadzone, 1, 99),
1219         mee_onoff_h   ("No TS Gun trigger", 0, g_opts, OPT_TSGUN_NOTRIGGER, h_notsgun),
1220         mee_cust_nosave("Save global config",       MA_OPT_SAVECFG,      mh_savecfg, mgn_saveloadcfg),
1221         mee_cust_nosave("Save cfg for loaded game", MA_OPT_SAVECFG_GAME, mh_savecfg, mgn_saveloadcfg),
1222         mee_handler   ("Rescan devices:",  mh_input_rescan),
1223         mee_label     (""),
1224         mee_label_mk  (MA_CTRL_DEV_FIRST, mgn_dev_name),
1225         mee_label_mk  (MA_CTRL_DEV_NEXT,  mgn_dev_name),
1226         mee_label_mk  (MA_CTRL_DEV_NEXT,  mgn_dev_name),
1227         mee_label_mk  (MA_CTRL_DEV_NEXT,  mgn_dev_name),
1228         mee_label_mk  (MA_CTRL_DEV_NEXT,  mgn_dev_name),
1229         mee_label_mk  (MA_CTRL_DEV_NEXT,  mgn_dev_name),
1230         mee_label_mk  (MA_CTRL_DEV_NEXT,  mgn_dev_name),
1231         mee_end,
1232 };
1233
1234 static int menu_loop_keyconfig(int id, int keys)
1235 {
1236         static int sel = 0;
1237
1238 //      me_enable(e_menu_keyconfig, MA_OPT_SAVECFG_GAME, ready_to_go && CdromId[0]);
1239         me_loop(e_menu_keyconfig, &sel);
1240         return 0;
1241 }
1242
1243 // ------------ gfx options menu ------------
1244
1245 static const char *men_scaler[] = {
1246         "1x1", "integer scaled 2x", "scaled 4:3", "integer scaled 4:3", "fullscreen", "custom", NULL
1247 };
1248 static const char *men_soft_filter[] = { "None",
1249 #ifdef __ARM_NEON__
1250         "scale2x", "eagle2x",
1251 #endif
1252         NULL };
1253 static const char *men_dummy[] = { NULL };
1254 static const char h_scaler[]    = "int. 2x  - scales w. or h. 2x if it fits on screen\n"
1255                                   "int. 4:3 - uses integer if possible, else fractional";
1256 static const char h_cscaler[]   = "Displays the scaler layer, you can resize it\n"
1257                                   "using d-pad or move it using R+d-pad";
1258 static const char h_soft_filter[] = "Works only if game uses low resolution modes";
1259 static const char h_gamma[]     = "Gamma/brightness adjustment (default 100)";
1260 #ifdef __ARM_NEON__
1261 static const char h_scanline_l[]  = "Scanline brightness, 0-100%";
1262 #endif
1263
1264 static int menu_loop_cscaler(int id, int keys)
1265 {
1266         unsigned int inp;
1267
1268         g_scaler = SCALE_CUSTOM;
1269
1270         plat_gvideo_open(Config.PsxType);
1271
1272         for (;;)
1273         {
1274                 menu_draw_begin(0, 1);
1275                 memset(g_menuscreen_ptr, 4, g_menuscreen_w * g_menuscreen_h * 2);
1276                 text_out16(2, 2, "%d,%d", g_layer_x, g_layer_y);
1277                 text_out16(2, 480 - 18, "%dx%d | d-pad: resize, R+d-pad: move", g_layer_w, g_layer_h);
1278                 menu_draw_end();
1279
1280                 inp = in_menu_wait(PBTN_UP|PBTN_DOWN|PBTN_LEFT|PBTN_RIGHT
1281                                 |PBTN_R|PBTN_MOK|PBTN_MBACK, NULL, 40);
1282                 if (inp & PBTN_UP)    g_layer_y--;
1283                 if (inp & PBTN_DOWN)  g_layer_y++;
1284                 if (inp & PBTN_LEFT)  g_layer_x--;
1285                 if (inp & PBTN_RIGHT) g_layer_x++;
1286                 if (!(inp & PBTN_R)) {
1287                         if (inp & PBTN_UP)    g_layer_h += 2;
1288                         if (inp & PBTN_DOWN)  g_layer_h -= 2;
1289                         if (inp & PBTN_LEFT)  g_layer_w += 2;
1290                         if (inp & PBTN_RIGHT) g_layer_w -= 2;
1291                 }
1292                 if (inp & (PBTN_MOK|PBTN_MBACK))
1293                         break;
1294
1295                 if (inp & (PBTN_UP|PBTN_DOWN|PBTN_LEFT|PBTN_RIGHT)) {
1296                         if (g_layer_x < 0)   g_layer_x = 0;
1297                         if (g_layer_x > 640) g_layer_x = 640;
1298                         if (g_layer_y < 0)   g_layer_y = 0;
1299                         if (g_layer_y > 420) g_layer_y = 420;
1300                         if (g_layer_w < 160) g_layer_w = 160;
1301                         if (g_layer_h < 60)  g_layer_h = 60;
1302                         if (g_layer_x + g_layer_w > 800)
1303                                 g_layer_w = 800 - g_layer_x;
1304                         if (g_layer_y + g_layer_h > 480)
1305                                 g_layer_h = 480 - g_layer_y;
1306                         // resize the layer
1307                         plat_gvideo_open(Config.PsxType);
1308                 }
1309         }
1310
1311         plat_gvideo_close();
1312
1313         return 0;
1314 }
1315
1316 static menu_entry e_menu_gfx_options[] =
1317 {
1318         mee_enum_h    ("Scaler",                   MA_OPT_VARSCALER, g_scaler, men_scaler, h_scaler),
1319         mee_enum      ("Video output mode",        MA_OPT_VOUT_MODE, plat_target.vout_method, men_dummy),
1320         mee_onoff     ("Software Scaling",         MA_OPT_SCALER2, soft_scaling, 1),
1321         mee_enum      ("Hardware Filter",          MA_OPT_HWFILTER, plat_target.hwfilter, men_dummy),
1322         mee_enum_h    ("Software Filter",          MA_OPT_SWFILTER, soft_filter, men_soft_filter, h_soft_filter),
1323 #ifdef __ARM_NEON__
1324         mee_onoff     ("Scanlines",                MA_OPT_SCANLINES, scanlines, 1),
1325         mee_range_h   ("Scanline brightness",      MA_OPT_SCANLINE_LEVEL, scanline_level, 0, 100, h_scanline_l),
1326 #endif
1327         mee_range_h   ("Gamma adjustment",         MA_OPT_GAMMA, g_gamma, 1, 200, h_gamma),
1328 //      mee_onoff     ("Vsync",                    0, vsync, 1),
1329         mee_cust_h    ("Setup custom scaler",      MA_OPT_VARSCALER_C, menu_loop_cscaler, NULL, h_cscaler),
1330         mee_end,
1331 };
1332
1333 static int menu_loop_gfx_options(int id, int keys)
1334 {
1335         static int sel = 0;
1336
1337         me_loop(e_menu_gfx_options, &sel);
1338
1339         return 0;
1340 }
1341
1342 // ------------ bios/plugins ------------
1343
1344 #ifdef BUILTIN_GPU_NEON
1345
1346 static const char h_gpu_neon[] =
1347         "Configure built-in NEON GPU plugin";
1348 static const char h_gpu_neon_enhanced[] =
1349         "Renders in double resolution at the cost of lower performance\n"
1350         "(not available for high resolution games)";
1351 static const char h_gpu_neon_enhanced_hack[] =
1352         "Speed hack for above option (glitches some games)";
1353 static const char *men_gpu_interlace[] = { "Off", "On", "Auto", NULL };
1354
1355 static menu_entry e_menu_plugin_gpu_neon[] =
1356 {
1357         mee_enum      ("Enable interlace mode",      0, pl_rearmed_cbs.gpu_neon.allow_interlace, men_gpu_interlace),
1358         mee_onoff_h   ("Enhanced resolution",        0, pl_rearmed_cbs.gpu_neon.enhancement_enable, 1, h_gpu_neon_enhanced),
1359         mee_onoff_h   ("Enhanced res. speed hack",   0, pl_rearmed_cbs.gpu_neon.enhancement_no_main, 1, h_gpu_neon_enhanced_hack),
1360         mee_end,
1361 };
1362
1363 static int menu_loop_plugin_gpu_neon(int id, int keys)
1364 {
1365         static int sel = 0;
1366         me_loop(e_menu_plugin_gpu_neon, &sel);
1367         return 0;
1368 }
1369
1370 #endif
1371
1372 static menu_entry e_menu_plugin_gpu_unai[] =
1373 {
1374         mee_onoff     ("Skip every 2nd line",        0, pl_rearmed_cbs.gpu_unai.lineskip, 1),
1375         mee_onoff     ("Abe's Odyssey hack",         0, pl_rearmed_cbs.gpu_unai.abe_hack, 1),
1376         mee_onoff     ("Disable lighting",           0, pl_rearmed_cbs.gpu_unai.no_light, 1),
1377         mee_onoff     ("Disable blending",           0, pl_rearmed_cbs.gpu_unai.no_blend, 1),
1378         mee_end,
1379 };
1380
1381 static int menu_loop_plugin_gpu_unai(int id, int keys)
1382 {
1383         int sel = 0;
1384         me_loop(e_menu_plugin_gpu_unai, &sel);
1385         return 0;
1386 }
1387
1388 static menu_entry e_menu_plugin_gpu_senquack[] =
1389 {
1390         mee_onoff     ("Interlace",                  0, pl_rearmed_cbs.gpu_senquack.ilace_force, 1),
1391         mee_onoff     ("Dithering",                  0, pl_rearmed_cbs.gpu_senquack.dithering, 1),
1392         mee_onoff     ("Lighting",                   0, pl_rearmed_cbs.gpu_senquack.lighting, 1),
1393         mee_onoff     ("Fast lighting",              0, pl_rearmed_cbs.gpu_senquack.fast_lighting, 1),
1394         mee_onoff     ("Blending",                   0, pl_rearmed_cbs.gpu_senquack.blending, 1),
1395         mee_onoff     ("Pixel skip",                 0, pl_rearmed_cbs.gpu_senquack.pixel_skip, 1),
1396         mee_end,
1397 };
1398
1399 static int menu_loop_plugin_gpu_senquack(int id, int keys)
1400 {
1401         int sel = 0;
1402         me_loop(e_menu_plugin_gpu_senquack, &sel);
1403         return 0;
1404 }
1405
1406
1407 static const char *men_gpu_dithering[] = { "None", "Game dependant", "Always", NULL };
1408 //static const char h_gpu_0[]            = "Needed for Chrono Cross";
1409 static const char h_gpu_1[]            = "Capcom fighting games";
1410 static const char h_gpu_2[]            = "Black screens in Lunar";
1411 static const char h_gpu_3[]            = "Compatibility mode";
1412 static const char h_gpu_6[]            = "Pandemonium 2";
1413 //static const char h_gpu_7[]            = "Skip every second frame";
1414 static const char h_gpu_8[]            = "Needed by Dark Forces";
1415 static const char h_gpu_9[]            = "better g-colors, worse textures";
1416 static const char h_gpu_10[]           = "Toggle busy flags after drawing";
1417
1418 static menu_entry e_menu_plugin_gpu_peops[] =
1419 {
1420         mee_enum      ("Dithering",                  0, pl_rearmed_cbs.gpu_peops.iUseDither, men_gpu_dithering),
1421 //      mee_onoff_h   ("Odd/even bit hack",          0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<0, h_gpu_0),
1422         mee_onoff_h   ("Expand screen width",        0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<1, h_gpu_1),
1423         mee_onoff_h   ("Ignore brightness color",    0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<2, h_gpu_2),
1424         mee_onoff_h   ("Disable coordinate check",   0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<3, h_gpu_3),
1425         mee_onoff_h   ("Lazy screen update",         0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<6, h_gpu_6),
1426 //      mee_onoff_h   ("Old frame skipping",         0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<7, h_gpu_7),
1427         mee_onoff_h   ("Repeated flat tex triangles ",0,pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<8, h_gpu_8),
1428         mee_onoff_h   ("Draw quads with triangles",  0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<9, h_gpu_9),
1429         mee_onoff_h   ("Fake 'gpu busy' states",     0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<10, h_gpu_10),
1430         mee_end,
1431 };
1432
1433 static int menu_loop_plugin_gpu_peops(int id, int keys)
1434 {
1435         static int sel = 0;
1436         me_loop(e_menu_plugin_gpu_peops, &sel);
1437         return 0;
1438 }
1439
1440 static const char *men_peopsgl_texfilter[] = { "None", "Standard", "Extended",
1441         "Standard-sprites", "Extended-sprites", "Standard+sprites", "Extended+sprites", NULL };
1442 static const char *men_peopsgl_fbtex[] = { "Emulated VRam", "Black", "Card", "Card+soft" };
1443
1444 static menu_entry e_menu_plugin_gpu_peopsgl[] =
1445 {
1446         mee_onoff     ("Dithering",                  0, pl_rearmed_cbs.gpu_peopsgl.bDrawDither, 1),
1447         mee_enum      ("Texture Filtering",          0, pl_rearmed_cbs.gpu_peopsgl.iFilterType, men_peopsgl_texfilter),
1448         mee_enum      ("Framebuffer Textures",       0, pl_rearmed_cbs.gpu_peopsgl.iFrameTexType, men_peopsgl_fbtex),
1449         mee_onoff     ("Mask Detect",                0, pl_rearmed_cbs.gpu_peopsgl.iUseMask, 1),
1450         mee_onoff     ("Opaque Pass",                0, pl_rearmed_cbs.gpu_peopsgl.bOpaquePass, 1),
1451         mee_onoff     ("Advanced Blend",             0, pl_rearmed_cbs.gpu_peopsgl.bAdvancedBlend, 1),
1452         mee_onoff     ("Use Fast Mdec",              0, pl_rearmed_cbs.gpu_peopsgl.bUseFastMdec, 1),
1453         mee_range     ("Texture RAM size (MB)",      0, pl_rearmed_cbs.gpu_peopsgl.iVRamSize, 4, 128),
1454         mee_onoff     ("Texture garbage collection", 0, pl_rearmed_cbs.gpu_peopsgl.iTexGarbageCollection, 1),
1455         mee_label     ("Fixes/hacks:"),
1456         mee_onoff     ("FF7 cursor",                 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<0),
1457         mee_onoff     ("Direct FB updates",          0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<1),
1458         mee_onoff     ("Black brightness",           0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<2),
1459         mee_onoff     ("Swap front detection",       0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<3),
1460         mee_onoff     ("Disable coord check",        0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<4),
1461         mee_onoff     ("No blue glitches (LoD)",     0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<5),
1462         mee_onoff     ("Soft FB access",             0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<6),
1463         mee_onoff     ("FF9 rect",                   0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<9),
1464         mee_onoff     ("No subtr. blending",         0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<10),
1465         mee_onoff     ("Lazy upload (DW7)",          0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<11),
1466         mee_onoff     ("Additional uploads",         0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<15),
1467         mee_end,
1468 };
1469
1470 static int menu_loop_plugin_gpu_peopsgl(int id, int keys)
1471 {
1472         static int sel = 0;
1473         me_loop(e_menu_plugin_gpu_peopsgl, &sel);
1474         return 0;
1475 }
1476
1477 static const char *men_spu_interp[] = { "None", "Simple", "Gaussian", "Cubic", NULL };
1478 static const char h_spu_volboost[]  = "Large values cause distortion";
1479 static const char h_spu_tempo[]     = "Slows down audio if emu is too slow\n"
1480                                       "This is inaccurate and breaks games";
1481
1482 static menu_entry e_menu_plugin_spu[] =
1483 {
1484         mee_range_h   ("Volume boost",              0, volume_boost, -5, 30, h_spu_volboost),
1485         mee_onoff     ("Reverb",                    0, spu_config.iUseReverb, 1),
1486         mee_enum      ("Interpolation",             0, spu_config.iUseInterpolation, men_spu_interp),
1487         //mee_onoff     ("Adjust XA pitch",           0, spu_config.iXAPitch, 1),
1488         mee_onoff_h   ("Adjust tempo",              0, spu_config.iTempo, 1, h_spu_tempo),
1489         mee_end,
1490 };
1491
1492 static int menu_loop_plugin_spu(int id, int keys)
1493 {
1494         static int sel = 0;
1495         me_loop(e_menu_plugin_spu, &sel);
1496         return 0;
1497 }
1498
1499 static const char h_bios[]       = "HLE is simulated BIOS. BIOS selection is saved in\n"
1500                                    "savestates and can't be changed there. Must save\n"
1501                                    "config and reload the game for change to take effect";
1502 static const char h_plugin_gpu[] =
1503 #ifdef BUILTIN_GPU_NEON
1504                                    "builtin_gpu is the NEON GPU, very fast and accurate\n"
1505 #endif
1506                                    "gpu_peops is Pete's soft GPU, slow but accurate\n"
1507                                    "gpu_unai is GPU from PCSX4ALL, fast but glitchy\n"
1508                                    "gpu_senquack is more accurate but slower\n"
1509                                    "gpu_gles Pete's hw GPU, uses 3D chip but is glitchy\n"
1510                                    "must save config and reload the game if changed";
1511 static const char h_plugin_spu[] = "spunull effectively disables sound\n"
1512                                    "must save config and reload the game if changed";
1513 static const char h_gpu_peops[]  = "Configure P.E.Op.S. SoftGL Driver V1.17";
1514 static const char h_gpu_peopsgl[]= "Configure P.E.Op.S. MesaGL Driver V1.78";
1515 static const char h_gpu_unai[]   = "Configure Unai/PCSX4ALL Team GPU plugin";
1516 static const char h_gpu_senquack[]   = "Configure Unai/PCSX4ALL Senquack plugin";
1517 static const char h_spu[]        = "Configure built-in P.E.Op.S. Sound Driver V1.7";
1518
1519 static menu_entry e_menu_plugin_options[] =
1520 {
1521         mee_enum_h    ("BIOS",                          0, bios_sel, bioses, h_bios),
1522         mee_enum_h    ("GPU plugin",                    0, gpu_plugsel, gpu_plugins, h_plugin_gpu),
1523         mee_enum_h    ("SPU plugin",                    0, spu_plugsel, spu_plugins, h_plugin_spu),
1524 #ifdef BUILTIN_GPU_NEON
1525         mee_handler_h ("Configure built-in GPU plugin", menu_loop_plugin_gpu_neon, h_gpu_neon),
1526 #endif
1527         mee_handler_h ("Configure gpu_peops plugin",    menu_loop_plugin_gpu_peops, h_gpu_peops),
1528         mee_handler_h ("Configure gpu_unai GPU plugin", menu_loop_plugin_gpu_unai, h_gpu_unai),
1529         mee_handler_h ("Configure gpu_senquack GPU plugin", menu_loop_plugin_gpu_senquack, h_gpu_senquack),
1530         mee_handler_h ("Configure gpu_gles GPU plugin", menu_loop_plugin_gpu_peopsgl, h_gpu_peopsgl),
1531         mee_handler_h ("Configure built-in SPU plugin", menu_loop_plugin_spu, h_spu),
1532         mee_end,
1533 };
1534
1535 static menu_entry e_menu_main2[];
1536
1537 static int menu_loop_plugin_options(int id, int keys)
1538 {
1539         static int sel = 0;
1540         me_loop(e_menu_plugin_options, &sel);
1541
1542         // sync BIOS/plugins
1543         snprintf(Config.Bios, sizeof(Config.Bios), "%s", bioses[bios_sel]);
1544         snprintf(Config.Gpu, sizeof(Config.Gpu), "%s", gpu_plugins[gpu_plugsel]);
1545         snprintf(Config.Spu, sizeof(Config.Spu), "%s", spu_plugins[spu_plugsel]);
1546         me_enable(e_menu_main2, MA_MAIN_RUN_BIOS, bios_sel != 0);
1547
1548         return 0;
1549 }
1550
1551 // ------------ adv options menu ------------
1552
1553 #ifndef DRC_DISABLE
1554 static const char h_cfg_noch[]    = "Disables game-specific compatibility hacks";
1555 static const char h_cfg_nosmc[]   = "Will cause crashes when loading, break memcards";
1556 static const char h_cfg_gteunn[]  = "May cause graphical glitches";
1557 static const char h_cfg_gteflgs[] = "Will cause graphical glitches";
1558 #endif
1559 static const char h_cfg_stalls[]  = "Will cause some games to run too fast";
1560
1561 static menu_entry e_menu_speed_hacks[] =
1562 {
1563 #ifndef DRC_DISABLE
1564         mee_onoff_h   ("Disable compat hacks",     0, new_dynarec_hacks, NDHACK_NO_COMPAT_HACKS, h_cfg_noch),
1565         mee_onoff_h   ("Disable SMC checks",       0, new_dynarec_hacks, NDHACK_NO_SMC_CHECK, h_cfg_nosmc),
1566         mee_onoff_h   ("Assume GTE regs unneeded", 0, new_dynarec_hacks, NDHACK_GTE_UNNEEDED, h_cfg_gteunn),
1567         mee_onoff_h   ("Disable GTE flags",        0, new_dynarec_hacks, NDHACK_GTE_NO_FLAGS, h_cfg_gteflgs),
1568 #endif
1569         mee_onoff_h   ("Disable CPU/GTE stalls",   0, menu_iopts[0], 1, h_cfg_stalls),
1570         mee_end,
1571 };
1572
1573 static int menu_loop_speed_hacks(int id, int keys)
1574 {
1575         static int sel = 0;
1576         menu_iopts[0] = Config.DisableStalls;
1577         me_loop(e_menu_speed_hacks, &sel);
1578         Config.DisableStalls = menu_iopts[0];
1579         return 0;
1580 }
1581
1582 static const char *men_gpul[]    = { "Auto", "Off", "On", NULL };
1583
1584 static const char h_cfg_cpul[]   = "Shows CPU usage in %";
1585 static const char h_cfg_spu[]    = "Shows active SPU channels\n"
1586                                    "(green: normal, red: fmod, blue: noise)";
1587 static const char h_cfg_fl[]     = "Frame Limiter keeps the game from running too fast";
1588 static const char h_cfg_xa[]     = "Disables XA sound, which can sometimes improve performance";
1589 static const char h_cfg_cdda[]   = "Disable CD Audio for a performance boost\n"
1590                                    "(proper .cue/.bin dump is needed otherwise)";
1591 #ifndef DRC_DISABLE
1592 static const char h_cfg_nodrc[]  = "Disable dynamic recompiler and use interpreter\n"
1593                                    "Might be useful to overcome some dynarec bugs";
1594 #endif
1595 static const char h_cfg_shacks[] = "Breaks games but may give better performance";
1596 static const char h_cfg_icache[] = "Support F1 games (only when dynarec is off)";
1597 static const char h_cfg_gpul[]   = "Try enabling this if the game is missing some graphics\n"
1598                                    "causes a performance hit";
1599 static const char h_cfg_psxclk[]  = "Over/under-clock the PSX, default is " DEFAULT_PSX_CLOCK_S "\n"
1600                                     "(adjust this if the game is too slow/too fast/hangs)";
1601
1602 enum { AMO_XA, AMO_CDDA, AMO_IC, AMO_CPU, AMO_GPUL };
1603
1604 static menu_entry e_menu_adv_options[] =
1605 {
1606         mee_onoff_h   ("Show CPU load",          0, g_opts, OPT_SHOWCPU, h_cfg_cpul),
1607         mee_onoff_h   ("Show SPU channels",      0, g_opts, OPT_SHOWSPU, h_cfg_spu),
1608         mee_onoff_h   ("Disable Frame Limiter",  0, g_opts, OPT_NO_FRAMELIM, h_cfg_fl),
1609         mee_onoff_h   ("Disable XA Decoding",    0, menu_iopts[AMO_XA],   1, h_cfg_xa),
1610         mee_onoff_h   ("Disable CD Audio",       0, menu_iopts[AMO_CDDA], 1, h_cfg_cdda),
1611         mee_onoff_h   ("ICache emulation",       0, menu_iopts[AMO_IC],   1, h_cfg_icache),
1612         mee_enum_h    ("GPU l-list slow walking",0, menu_iopts[AMO_GPUL], men_gpul, h_cfg_gpul),
1613 #if !defined(DRC_DISABLE) || defined(LIGHTREC)
1614         mee_onoff_h   ("Disable dynarec (slow!)",0, menu_iopts[AMO_CPU],  1, h_cfg_nodrc),
1615 #endif
1616         mee_range_h   ("PSX CPU clock, %",       0, psx_clock, 1, 500, h_cfg_psxclk),
1617         mee_handler_h ("[Speed hacks]",             menu_loop_speed_hacks, h_cfg_shacks),
1618         mee_end,
1619 };
1620
1621 static int menu_loop_adv_options(int id, int keys)
1622 {
1623         static int sel = 0;
1624         static struct {
1625                 boolean *opt;
1626                 int *mopt;
1627         } opts[] = {
1628                 { &Config.Xa,      &menu_iopts[AMO_XA] },
1629                 { &Config.Cdda,    &menu_iopts[AMO_CDDA] },
1630                 { &Config.icache_emulation, &menu_iopts[AMO_IC] },
1631                 { &Config.Cpu,     &menu_iopts[AMO_CPU] },
1632         };
1633         int i;
1634         for (i = 0; i < ARRAY_SIZE(opts); i++)
1635                 *opts[i].mopt = *opts[i].opt;
1636         menu_iopts[AMO_GPUL] = Config.GpuListWalking + 1;
1637
1638         me_loop(e_menu_adv_options, &sel);
1639
1640         for (i = 0; i < ARRAY_SIZE(opts); i++)
1641                 *opts[i].opt = *opts[i].mopt;
1642         Config.GpuListWalking = menu_iopts[AMO_GPUL] - 1;
1643
1644         return 0;
1645 }
1646
1647 // ------------ options menu ------------
1648
1649 static int mh_restore_defaults(int id, int keys)
1650 {
1651         menu_set_defconfig();
1652         menu_update_msg("defaults restored");
1653         return 1;
1654 }
1655
1656 static const char *men_region[]       = { "Auto", "NTSC", "PAL", NULL };
1657 static const char *men_frameskip[]    = { "Auto", "Off", "1", "2", "3", NULL };
1658 /*
1659 static const char *men_confirm_save[] = { "OFF", "writes", "loads", "both", NULL };
1660 static const char h_confirm_save[]    = "Ask for confirmation when overwriting save,\n"
1661                                         "loading state or both";
1662 */
1663 static const char h_restore_def[]     = "Switches back to default / recommended\n"
1664                                         "configuration";
1665 static const char h_frameskip[]       = "Warning: frameskip sometimes causes glitches\n";
1666
1667 static menu_entry e_menu_options[] =
1668 {
1669 //      mee_range     ("Save slot",                0, state_slot, 0, 9),
1670 //      mee_enum_h    ("Confirm savestate",        0, dummy, men_confirm_save, h_confirm_save),
1671         mee_enum_h    ("Frameskip",                0, frameskip, men_frameskip, h_frameskip),
1672         mee_onoff     ("Show FPS",                 0, g_opts, OPT_SHOWFPS),
1673         mee_enum      ("Region",                   0, region, men_region),
1674         mee_range     ("CPU clock",                MA_OPT_CPU_CLOCKS, cpu_clock, 20, 5000),
1675 #ifdef C64X_DSP
1676         mee_onoff     ("Use C64x DSP for sound",   MA_OPT_SPU_THREAD, spu_config.iUseThread, 1),
1677 #else
1678         mee_onoff     ("Threaded SPU",             MA_OPT_SPU_THREAD, spu_config.iUseThread, 1),
1679 #endif
1680         mee_handler_id("[Display]",                MA_OPT_DISP_OPTS, menu_loop_gfx_options),
1681         mee_handler   ("[BIOS/Plugins]",           menu_loop_plugin_options),
1682         mee_handler   ("[Advanced]",               menu_loop_adv_options),
1683         mee_cust_nosave("Save global config",      MA_OPT_SAVECFG,      mh_savecfg, mgn_saveloadcfg),
1684         mee_cust_nosave("Save cfg for loaded game",MA_OPT_SAVECFG_GAME, mh_savecfg, mgn_saveloadcfg),
1685         mee_handler_h ("Restore default config",   mh_restore_defaults, h_restore_def),
1686         mee_end,
1687 };
1688
1689 static int menu_loop_options(int id, int keys)
1690 {
1691         static int sel = 0;
1692
1693         me_enable(e_menu_options, MA_OPT_CPU_CLOCKS, cpu_clock_st > 0);
1694         me_enable(e_menu_options, MA_OPT_SPU_THREAD, spu_config.iThreadAvail);
1695         me_enable(e_menu_options, MA_OPT_SAVECFG_GAME, ready_to_go && CdromId[0]);
1696
1697         me_loop(e_menu_options, &sel);
1698
1699         return 0;
1700 }
1701
1702 // ------------ debug menu ------------
1703
1704 static void draw_frame_debug(GPUFreeze_t *gpuf, int x, int y)
1705 {
1706         int w = min(g_menuscreen_w, 1024);
1707         int h = min(g_menuscreen_h, 512);
1708         u16 *d = g_menuscreen_ptr;
1709         u16 *s = (u16 *)gpuf->psxVRam + y * 1024 + x;
1710         char buff[64];
1711         int ty = 1;
1712
1713         gpuf->ulFreezeVersion = 1;
1714         if (GPU_freeze != NULL)
1715                 GPU_freeze(1, gpuf);
1716
1717         for (; h > 0; h--, d += g_menuscreen_w, s += 1024)
1718                 bgr555_to_rgb565(d, s, w * 2);
1719
1720         smalltext_out16(4, 1, "build: "__DATE__ " " __TIME__ " " REV, 0xe7fc);
1721         snprintf(buff, sizeof(buff), "GPU sr: %08x", gpuf->ulStatus);
1722         smalltext_out16(4, (ty += me_sfont_h), buff, 0xe7fc);
1723         snprintf(buff, sizeof(buff), "PC/SP: %08x %08x", psxRegs.pc, psxRegs.GPR.n.sp);
1724         smalltext_out16(4, (ty += me_sfont_h), buff, 0xe7fc);
1725 }
1726
1727 static void debug_menu_loop(void)
1728 {
1729         int inp, df_x = 0, df_y = 0;
1730         GPUFreeze_t *gpuf;
1731
1732         gpuf = malloc(sizeof(*gpuf));
1733         if (gpuf == NULL)
1734                 return;
1735
1736         while (1)
1737         {
1738                 menu_draw_begin(0, 1);
1739                 draw_frame_debug(gpuf, df_x, df_y);
1740                 menu_draw_end();
1741
1742                 inp = in_menu_wait(PBTN_MOK|PBTN_MBACK|PBTN_MA2|PBTN_MA3|PBTN_L|PBTN_R |
1743                                         PBTN_UP|PBTN_DOWN|PBTN_LEFT|PBTN_RIGHT, NULL, 10);
1744                 if      (inp & PBTN_MBACK) break;
1745                 else if (inp & PBTN_UP)    { if (df_y > 0) df_y--; }
1746                 else if (inp & PBTN_DOWN)  { if (df_y < 512 - g_menuscreen_h) df_y++; }
1747                 else if (inp & PBTN_LEFT)  { if (df_x > 0) df_x -= 2; }
1748                 else if (inp & PBTN_RIGHT) { if (df_x < 1024 - g_menuscreen_w) df_x += 2; }
1749         }
1750
1751         free(gpuf);
1752 }
1753
1754 // --------- memcard manager ---------
1755
1756 static void draw_mc_icon(int dx, int dy, const u16 *s)
1757 {
1758         u16 *d;
1759         int x, y, l, p;
1760
1761         d = (u16 *)g_menuscreen_ptr + g_menuscreen_w * dy + dx;
1762
1763         for (y = 0; y < 16; y++, s += 16) {
1764                 for (l = 0; l < 2; l++, d += g_menuscreen_w) {
1765                         for (x = 0; x < 16; x++) {
1766                                 p = s[x];
1767                                 d[x*2] = d[x*2 + 1] = ((p & 0x7c00) >> 10)
1768                                         | ((p & 0x03e0) << 1) | ((p & 0x1f) << 11);
1769                         }
1770                 }
1771         }
1772 }
1773
1774 static void draw_mc_bg(void)
1775 {
1776         McdBlock *blocks1, *blocks2;
1777         int maxicons = 15;
1778         int i, y, row2;
1779
1780         blocks1 = malloc(15 * sizeof(blocks1[0]));
1781         blocks2 = malloc(15 * sizeof(blocks1[0]));
1782         if (blocks1 == NULL || blocks2 == NULL)
1783                 goto out;
1784
1785         for (i = 0; i < 15; i++) {
1786                 GetMcdBlockInfo(1, i + 1, &blocks1[i]);
1787                 GetMcdBlockInfo(2, i + 1, &blocks2[i]);
1788         }
1789
1790         menu_draw_begin(1, 1);
1791
1792         memcpy(g_menuscreen_ptr, g_menubg_src_ptr, g_menuscreen_w * g_menuscreen_h * 2);
1793
1794         y = g_menuscreen_h / 2 - 15 * 32 / 2;
1795         if (y < 0) {
1796                 // doesn't fit..
1797                 y = 0;
1798                 maxicons = g_menuscreen_h / 32;
1799         }
1800
1801         row2 = g_menuscreen_w / 2;
1802         for (i = 0; i < maxicons; i++) {
1803                 draw_mc_icon(8, y + i * 32, (u16 *)blocks1[i].Icon);
1804                 smalltext_out16(10+32, y + i * 32 + 8, blocks1[i].sTitle, 0xf71e);
1805
1806                 draw_mc_icon(row2 + 8, y + i * 32, (u16 *)blocks2[i].Icon);
1807                 smalltext_out16(row2 + 10+32, y + i * 32 + 8, blocks2[i].sTitle, 0xf71e);
1808         }
1809
1810         menu_darken_bg(g_menubg_ptr, g_menuscreen_ptr, g_menuscreen_w * g_menuscreen_h, 0);
1811
1812         menu_draw_end();
1813 out:
1814         free(blocks1);
1815         free(blocks2);
1816 }
1817
1818 static void handle_memcard_sel(void)
1819 {
1820         strcpy(Config.Mcd1, "none");
1821         if (memcard1_sel != 0)
1822                 snprintf(Config.Mcd1, sizeof(Config.Mcd1), ".%s%s", MEMCARD_DIR, memcards[memcard1_sel]);
1823         strcpy(Config.Mcd2, "none");
1824         if (memcard2_sel != 0)
1825                 snprintf(Config.Mcd2, sizeof(Config.Mcd2), ".%s%s", MEMCARD_DIR, memcards[memcard2_sel]);
1826         LoadMcds(Config.Mcd1, Config.Mcd2);
1827         draw_mc_bg();
1828 }
1829
1830 static menu_entry e_memcard_options[] =
1831 {
1832         mee_enum("Memory card 1", 0, memcard1_sel, memcards),
1833         mee_enum("Memory card 2", 0, memcard2_sel, memcards),
1834         mee_end,
1835 };
1836
1837 static int menu_loop_memcards(int id, int keys)
1838 {
1839         static int sel = 0;
1840         char *p;
1841         int i;
1842
1843         memcard1_sel = memcard2_sel = 0;
1844         p = strrchr(Config.Mcd1, '/');
1845         if (p != NULL)
1846                 for (i = 0; memcards[i] != NULL; i++)
1847                         if (strcmp(p + 1, memcards[i]) == 0)
1848                                 { memcard1_sel = i; break; }
1849         p = strrchr(Config.Mcd2, '/');
1850         if (p != NULL)
1851                 for (i = 0; memcards[i] != NULL; i++)
1852                         if (strcmp(p + 1, memcards[i]) == 0)
1853                                 { memcard2_sel = i; break; }
1854
1855         me_loop_d(e_memcard_options, &sel, handle_memcard_sel, NULL);
1856
1857         memcpy(g_menubg_ptr, g_menubg_src_ptr, g_menuscreen_w * g_menuscreen_h * 2);
1858
1859         return 0;
1860 }
1861
1862 // ------------ cheats menu ------------
1863
1864 static void draw_cheatlist(int sel)
1865 {
1866         int max_cnt, start, i, pos, active;
1867
1868         max_cnt = g_menuscreen_h / me_sfont_h;
1869         start = max_cnt / 2 - sel;
1870
1871         menu_draw_begin(1, 1);
1872
1873         for (i = 0; i < NumCheats; i++) {
1874                 pos = start + i;
1875                 if (pos < 0) continue;
1876                 if (pos >= max_cnt) break;
1877                 active = Cheats[i].Enabled;
1878                 smalltext_out16(14,                pos * me_sfont_h,
1879                         active ? "ON " : "OFF", active ? 0xfff6 : 0xffff);
1880                 smalltext_out16(14 + me_sfont_w*4, pos * me_sfont_h,
1881                         Cheats[i].Descr, active ? 0xfff6 : 0xffff);
1882         }
1883         pos = start + i;
1884         if (pos < max_cnt)
1885                 smalltext_out16(14, pos * me_sfont_h, "done", 0xffff);
1886
1887         text_out16(5, max_cnt / 2 * me_sfont_h, ">");
1888         menu_draw_end();
1889 }
1890
1891 static void menu_loop_cheats(void)
1892 {
1893         static int menu_sel = 0;
1894         int inp;
1895
1896         for (;;)
1897         {
1898                 draw_cheatlist(menu_sel);
1899                 inp = in_menu_wait(PBTN_UP|PBTN_DOWN|PBTN_LEFT|PBTN_RIGHT|PBTN_L|PBTN_R
1900                                 |PBTN_MOK|PBTN_MBACK, NULL, 33);
1901                 if (inp & PBTN_UP  ) { menu_sel--; if (menu_sel < 0) menu_sel = NumCheats; }
1902                 if (inp & PBTN_DOWN) { menu_sel++; if (menu_sel > NumCheats) menu_sel = 0; }
1903                 if (inp &(PBTN_LEFT|PBTN_L))  { menu_sel-=10; if (menu_sel < 0) menu_sel = 0; }
1904                 if (inp &(PBTN_RIGHT|PBTN_R)) { menu_sel+=10; if (menu_sel > NumCheats) menu_sel = NumCheats; }
1905                 if (inp & PBTN_MOK) { // action
1906                         if (menu_sel < NumCheats)
1907                                 Cheats[menu_sel].Enabled = !Cheats[menu_sel].Enabled;
1908                         else    break;
1909                 }
1910                 if (inp & PBTN_MBACK)
1911                         break;
1912         }
1913 }
1914
1915 // --------- main menu help ----------
1916
1917 static void menu_bios_warn(void)
1918 {
1919         int inp;
1920         static const char msg[] =
1921                 "You don't seem to have copied any BIOS\n"
1922                 "files to\n"
1923                 MENU_BIOS_PATH "\n\n"
1924
1925                 "While many games work fine with fake\n"
1926                 "(HLE) BIOS, others (like MGS and FF8)\n"
1927                 "require BIOS to work.\n"
1928                 "After copying the file, you'll also need\n"
1929                 "to select it in the emu's menu:\n"
1930                 "options->[BIOS/Plugins]\n\n"
1931                 "The file is usually named SCPH1001.BIN,\n"
1932                 "but other not compressed files can be\n"
1933                 "used too.\n\n"
1934                 "Press %s or %s to continue";
1935         char tmp_msg[sizeof(msg) + 64];
1936
1937         snprintf(tmp_msg, sizeof(tmp_msg), msg,
1938                 in_get_key_name(-1, -PBTN_MOK), in_get_key_name(-1, -PBTN_MBACK));
1939         while (1)
1940         {
1941                 draw_menu_message(tmp_msg, NULL);
1942
1943                 inp = in_menu_wait(PBTN_MOK|PBTN_MBACK, NULL, 70);
1944                 if (inp & (PBTN_MBACK|PBTN_MOK))
1945                         return;
1946         }
1947 }
1948
1949 // ------------ main menu ------------
1950
1951 static menu_entry e_menu_main[];
1952
1953 static void draw_frame_main(void)
1954 {
1955         struct tm *tmp;
1956         time_t ltime;
1957         int capacity;
1958         char ltime_s[16];
1959         char buff[64];
1960         char *out;
1961
1962         if (CdromId[0] != 0) {
1963                 snprintf(buff, sizeof(buff), "%.32s/%.9s (running as %s, with %s)",
1964                          get_cd_label(), CdromId, Config.PsxType ? "PAL" : "NTSC",
1965                          Config.HLE ? "HLE" : "BIOS");
1966                 smalltext_out16(4, 1, buff, 0x105f);
1967         }
1968
1969         if (ready_to_go) {
1970                 capacity = plat_target_bat_capacity_get();
1971                 ltime = time(NULL);
1972                 tmp = localtime(&ltime);
1973                 strftime(ltime_s, sizeof(ltime_s), "%H:%M", tmp);
1974                 if (capacity >= 0) {
1975                         snprintf(buff, sizeof(buff), "%s %3d%%", ltime_s, capacity);
1976                         out = buff;
1977                 }
1978                 else
1979                         out = ltime_s;
1980                 smalltext_out16(4, 1 + me_sfont_h, out, 0x105f);
1981         }
1982 }
1983
1984 static void draw_frame_credits(void)
1985 {
1986         smalltext_out16(4, 1, "build: " __DATE__ " " __TIME__ " " REV, 0xe7fc);
1987 }
1988
1989 static const char credits_text[] =
1990         "PCSX-ReARMed\n\n"
1991         "(C) 1999-2003 PCSX Team\n"
1992         "(C) 2005-2009 PCSX-df Team\n"
1993         "(C) 2009-2011 PCSX-Reloaded Team\n\n"
1994         "ARM recompiler (C) 2009-2011 Ari64\n"
1995 #ifdef BUILTIN_GPU_NEON
1996         "ARM NEON GPU (c) 2011-2012 Exophase\n"
1997 #endif
1998         "PEOpS GPU and SPU by Pete Bernert\n"
1999         "  and the P.E.Op.S. team\n"
2000         "PCSX4ALL plugin by PCSX4ALL team\n"
2001         "  Chui, Franxis, Unai\n\n"
2002         "integration, optimization and\n"
2003         "  frontend (C) 2010-2015 notaz\n";
2004
2005 static int reset_game(void)
2006 {
2007         // sanity check
2008         if (bios_sel == 0 && !Config.HLE)
2009                 return -1;
2010
2011         ClosePlugins();
2012         OpenPlugins();
2013         SysReset();
2014         return 0;
2015 }
2016
2017 static int reload_plugins(const char *cdimg)
2018 {
2019         pl_vout_buf = NULL;
2020
2021         ClosePlugins();
2022
2023         set_cd_image(cdimg);
2024         LoadPlugins();
2025         pcnt_hook_plugins();
2026         NetOpened = 0;
2027         if (OpenPlugins() == -1) {
2028                 menu_update_msg("failed to open plugins");
2029                 return -1;
2030         }
2031         plugin_call_rearmed_cbs();
2032
2033         cdrIsoMultidiskCount = 1;
2034         CdromId[0] = '\0';
2035         CdromLabel[0] = '\0';
2036
2037         return 0;
2038 }
2039
2040 static int run_bios(void)
2041 {
2042         boolean origSlowBoot = Config.SlowBoot;
2043
2044         if (bios_sel == 0)
2045                 return -1;
2046
2047         ready_to_go = 0;
2048         if (reload_plugins(NULL) != 0)
2049                 return -1;
2050         Config.SlowBoot = 1;
2051         SysReset();
2052         Config.SlowBoot = origSlowBoot;
2053
2054         ready_to_go = 1;
2055         return 0;
2056 }
2057
2058 static int run_exe(void)
2059 {
2060         const char *exts[] = { "exe", NULL };
2061         const char *fname;
2062
2063         fname = menu_loop_romsel(last_selected_fname,
2064                 sizeof(last_selected_fname), exts, NULL);
2065         if (fname == NULL)
2066                 return -1;
2067
2068         ready_to_go = 0;
2069         if (reload_plugins(NULL) != 0)
2070                 return -1;
2071
2072         SysReset();
2073         if (Load(fname) != 0) {
2074                 menu_update_msg("exe load failed, bad file?");
2075                 printf("meh\n");
2076                 return -1;
2077         }
2078
2079         ready_to_go = 1;
2080         return 0;
2081 }
2082
2083 static int run_cd_image(const char *fname)
2084 {
2085         int autoload_state = g_autostateld_opt;
2086
2087         ready_to_go = 0;
2088         reload_plugins(fname);
2089
2090         // always autodetect, menu_sync_config will override as needed
2091         Config.PsxAuto = 1;
2092
2093         if (CheckCdrom() == -1) {
2094                 // Only check the CD if we are starting the console with a CD
2095                 ClosePlugins();
2096                 menu_update_msg("unsupported/invalid CD image");
2097                 return -1;
2098         }
2099
2100         SysReset();
2101
2102         // Read main executable directly from CDRom and start it
2103         if (LoadCdrom() == -1) {
2104                 ClosePlugins();
2105                 menu_update_msg("failed to load CD image");
2106                 return -1;
2107         }
2108
2109         emu_on_new_cd(1);
2110         ready_to_go = 1;
2111
2112         if (autoload_state) {
2113                 unsigned int newest = 0;
2114                 int time, slot, newest_slot = -1;
2115
2116                 for (slot = 0; slot < 10; slot++) {
2117                         if (emu_check_save_file(slot, &time)) {
2118                                 if ((unsigned int)time > newest) {
2119                                         newest = time;
2120                                         newest_slot = slot;
2121                                 }
2122                         }
2123                 }
2124
2125                 if (newest_slot >= 0) {
2126                         lprintf("autoload slot %d\n", newest_slot);
2127                         emu_load_state(newest_slot);
2128                 }
2129                 else {
2130                         lprintf("no save to autoload.\n");
2131                 }
2132         }
2133
2134         return 0;
2135 }
2136
2137 static int romsel_run(void)
2138 {
2139         int prev_gpu, prev_spu;
2140         const char *fname;
2141
2142         fname = menu_loop_romsel(last_selected_fname,
2143                         sizeof(last_selected_fname), filter_exts,
2144                         optional_cdimg_filter);
2145         if (fname == NULL)
2146                 return -1;
2147
2148         printf("selected file: %s\n", fname);
2149
2150         new_dynarec_clear_full();
2151
2152         if (run_cd_image(fname) != 0)
2153                 return -1;
2154
2155         prev_gpu = gpu_plugsel;
2156         prev_spu = spu_plugsel;
2157         if (menu_load_config(1) != 0)
2158                 menu_load_config(0);
2159
2160         // check for plugin changes, have to repeat
2161         // loading if game config changed plugins to reload them
2162         if (prev_gpu != gpu_plugsel || prev_spu != spu_plugsel) {
2163                 printf("plugin change detected, reloading plugins..\n");
2164                 if (run_cd_image(fname) != 0)
2165                         return -1;
2166         }
2167
2168         strcpy(last_selected_fname, fname);
2169         menu_do_last_cd_img(0);
2170         return 0;
2171 }
2172
2173 static int swap_cd_image(void)
2174 {
2175         const char *fname;
2176
2177         fname = menu_loop_romsel(last_selected_fname,
2178                         sizeof(last_selected_fname), filter_exts,
2179                         optional_cdimg_filter);
2180         if (fname == NULL)
2181                 return -1;
2182
2183         printf("selected file: %s\n", fname);
2184
2185         CdromId[0] = '\0';
2186         CdromLabel[0] = '\0';
2187
2188         set_cd_image(fname);
2189         if (ReloadCdromPlugin() < 0) {
2190                 menu_update_msg("failed to load cdr plugin");
2191                 return -1;
2192         }
2193         if (CDR_open() < 0) {
2194                 menu_update_msg("failed to open cdr plugin");
2195                 return -1;
2196         }
2197
2198         SetCdOpenCaseTime(time(NULL) + 2);
2199         LidInterrupt();
2200
2201         strcpy(last_selected_fname, fname);
2202         return 0;
2203 }
2204
2205 static int swap_cd_multidisk(void)
2206 {
2207         cdrIsoMultidiskSelect++;
2208         CdromId[0] = '\0';
2209         CdromLabel[0] = '\0';
2210
2211         CDR_close();
2212         if (CDR_open() < 0) {
2213                 menu_update_msg("failed to open cdr plugin");
2214                 return -1;
2215         }
2216
2217         SetCdOpenCaseTime(time(NULL) + 2);
2218         LidInterrupt();
2219
2220         return 0;
2221 }
2222
2223 static void load_pcsx_cht(void)
2224 {
2225         static const char *exts[] = { "cht", NULL };
2226         const char *fname;
2227         char msg[64];
2228
2229         fname = menu_loop_romsel(last_selected_fname,
2230                         sizeof(last_selected_fname), exts, NULL);
2231         if (fname == NULL)
2232                 return;
2233
2234         printf("selected cheat file: %s\n", fname);
2235         LoadCheats(fname);
2236
2237         if (NumCheats == 0 && NumCodes == 0)
2238                 menu_update_msg("failed to load cheats");
2239         else {
2240                 snprintf(msg, sizeof(msg), "%d cheat(s) loaded", NumCheats + NumCodes);
2241                 menu_update_msg(msg);
2242         }
2243         me_enable(e_menu_main, MA_MAIN_CHEATS, ready_to_go && NumCheats);
2244 }
2245
2246 static int main_menu_handler(int id, int keys)
2247 {
2248         switch (id)
2249         {
2250         case MA_MAIN_RESUME_GAME:
2251                 if (ready_to_go)
2252                         return 1;
2253                 break;
2254         case MA_MAIN_SAVE_STATE:
2255                 if (ready_to_go)
2256                         return menu_loop_savestate(0);
2257                 break;
2258         case MA_MAIN_LOAD_STATE:
2259                 if (ready_to_go)
2260                         return menu_loop_savestate(1);
2261                 break;
2262         case MA_MAIN_RESET_GAME:
2263                 if (ready_to_go && reset_game() == 0)
2264                         return 1;
2265                 break;
2266         case MA_MAIN_LOAD_ROM:
2267                 if (romsel_run() == 0)
2268                         return 1;
2269                 break;
2270         case MA_MAIN_SWAP_CD:
2271                 if (swap_cd_image() == 0)
2272                         return 1;
2273                 break;
2274         case MA_MAIN_SWAP_CD_MULTI:
2275                 if (swap_cd_multidisk() == 0)
2276                         return 1;
2277                 break;
2278         case MA_MAIN_RUN_BIOS:
2279                 if (run_bios() == 0)
2280                         return 1;
2281                 break;
2282         case MA_MAIN_RUN_EXE:
2283                 if (run_exe() == 0)
2284                         return 1;
2285                 break;
2286         case MA_MAIN_CHEATS:
2287                 menu_loop_cheats();
2288                 break;
2289         case MA_MAIN_LOAD_CHEATS:
2290                 load_pcsx_cht();
2291                 break;
2292         case MA_MAIN_CREDITS:
2293                 draw_menu_message(credits_text, draw_frame_credits);
2294                 in_menu_wait(PBTN_MOK|PBTN_MBACK, NULL, 70);
2295                 break;
2296         case MA_MAIN_EXIT:
2297                 emu_core_ask_exit();
2298                 return 1;
2299         default:
2300                 lprintf("%s: something unknown selected\n", __FUNCTION__);
2301                 break;
2302         }
2303
2304         return 0;
2305 }
2306
2307 static menu_entry e_menu_main2[] =
2308 {
2309         mee_handler_id("Change CD image",    MA_MAIN_SWAP_CD,       main_menu_handler),
2310         mee_handler_id("Next multidisk CD",  MA_MAIN_SWAP_CD_MULTI, main_menu_handler),
2311         mee_handler_id("Run BIOS",           MA_MAIN_RUN_BIOS,      main_menu_handler),
2312         mee_handler_id("Run EXE",            MA_MAIN_RUN_EXE,       main_menu_handler),
2313         mee_handler   ("Memcard manager",    menu_loop_memcards),
2314         mee_handler_id("Load PCSX cheats..", MA_MAIN_LOAD_CHEATS,   main_menu_handler),
2315         mee_end,
2316 };
2317
2318 static int main_menu2_handler(int id, int keys)
2319 {
2320         static int sel = 0;
2321
2322         me_enable(e_menu_main2, MA_MAIN_SWAP_CD,  ready_to_go);
2323         me_enable(e_menu_main2, MA_MAIN_SWAP_CD_MULTI, ready_to_go && cdrIsoMultidiskCount > 1);
2324         me_enable(e_menu_main2, MA_MAIN_RUN_BIOS, bios_sel != 0);
2325         me_enable(e_menu_main2, MA_MAIN_LOAD_CHEATS, ready_to_go);
2326
2327         return me_loop_d(e_menu_main2, &sel, NULL, draw_frame_main);
2328 }
2329
2330 static const char h_extra[] = "Change CD, manage memcards..\n";
2331
2332 static menu_entry e_menu_main[] =
2333 {
2334         mee_label     (""),
2335         mee_label     (""),
2336         mee_handler_id("Resume game",        MA_MAIN_RESUME_GAME, main_menu_handler),
2337         mee_handler_id("Save State",         MA_MAIN_SAVE_STATE,  main_menu_handler),
2338         mee_handler_id("Load State",         MA_MAIN_LOAD_STATE,  main_menu_handler),
2339         mee_handler_id("Reset game",         MA_MAIN_RESET_GAME,  main_menu_handler),
2340         mee_handler_id("Load CD image",      MA_MAIN_LOAD_ROM,    main_menu_handler),
2341         mee_handler   ("Options",            menu_loop_options),
2342         mee_handler   ("Controls",           menu_loop_keyconfig),
2343         mee_handler_id("Cheats",             MA_MAIN_CHEATS,      main_menu_handler),
2344         mee_handler_h ("Extra stuff",        main_menu2_handler,  h_extra),
2345         mee_handler_id("Credits",            MA_MAIN_CREDITS,     main_menu_handler),
2346         mee_handler_id("Exit",               MA_MAIN_EXIT,        main_menu_handler),
2347         mee_end,
2348 };
2349
2350 // ----------------------------
2351
2352 static void menu_leave_emu(void);
2353
2354 void menu_loop(void)
2355 {
2356         static int warned_about_bios = 0;
2357         static int sel = 0;
2358
2359         menu_leave_emu();
2360
2361         if (config_save_counter == 0) {
2362                 // assume first run
2363                 if (bioses[1] != NULL) {
2364                         // autoselect BIOS to make user's life easier
2365                         snprintf(Config.Bios, sizeof(Config.Bios), "%s", bioses[1]);
2366                         bios_sel = 1;
2367                 }
2368                 else if (!warned_about_bios) {
2369                         menu_bios_warn();
2370                         warned_about_bios = 1;
2371                 }
2372         }
2373
2374         me_enable(e_menu_main, MA_MAIN_RESUME_GAME, ready_to_go);
2375         me_enable(e_menu_main, MA_MAIN_SAVE_STATE,  ready_to_go && CdromId[0]);
2376         me_enable(e_menu_main, MA_MAIN_LOAD_STATE,  ready_to_go && CdromId[0]);
2377         me_enable(e_menu_main, MA_MAIN_RESET_GAME,  ready_to_go);
2378         me_enable(e_menu_main, MA_MAIN_CHEATS,      ready_to_go && NumCheats);
2379
2380         in_set_config_int(0, IN_CFG_BLOCKING, 1);
2381
2382         do {
2383                 me_loop_d(e_menu_main, &sel, NULL, draw_frame_main);
2384         } while (!ready_to_go && !g_emu_want_quit);
2385
2386         /* wait until menu, ok, back is released */
2387         while (in_menu_wait_any(NULL, 50) & (PBTN_MENU|PBTN_MOK|PBTN_MBACK))
2388                 ;
2389
2390         in_set_config_int(0, IN_CFG_BLOCKING, 0);
2391
2392         menu_prepare_emu();
2393 }
2394
2395 static int qsort_strcmp(const void *p1, const void *p2)
2396 {
2397         char * const *s1 = (char * const *)p1;
2398         char * const *s2 = (char * const *)p2;
2399         return strcasecmp(*s1, *s2);
2400 }
2401
2402 static void scan_bios_plugins(void)
2403 {
2404         char fname[MAXPATHLEN];
2405         struct dirent *ent;
2406         int bios_i, gpu_i, spu_i, mc_i;
2407         char *p;
2408         DIR *dir;
2409
2410         bioses[0] = "HLE";
2411         gpu_plugins[0] = "builtin_gpu";
2412         spu_plugins[0] = "builtin_spu";
2413         memcards[0] = "(none)";
2414         bios_i = gpu_i = spu_i = mc_i = 1;
2415
2416         snprintf(fname, sizeof(fname), "%s/", Config.BiosDir);
2417         dir = opendir(fname);
2418         if (dir == NULL) {
2419                 perror("scan_bios_plugins bios opendir");
2420                 goto do_plugins;
2421         }
2422
2423         while (1) {
2424                 struct stat st;
2425
2426                 errno = 0;
2427                 ent = readdir(dir);
2428                 if (ent == NULL) {
2429                         if (errno != 0)
2430                                 perror("readdir");
2431                         break;
2432                 }
2433
2434                 if (ent->d_type != DT_REG && ent->d_type != DT_LNK)
2435                         continue;
2436
2437                 snprintf(fname, sizeof(fname), "%s/%s", Config.BiosDir, ent->d_name);
2438                 if (stat(fname, &st) != 0 || st.st_size != 512*1024) {
2439                         printf("bad BIOS file: %s\n", ent->d_name);
2440                         continue;
2441                 }
2442
2443                 if (bios_i < ARRAY_SIZE(bioses) - 1) {
2444                         bioses[bios_i++] = strdup(ent->d_name);
2445                         continue;
2446                 }
2447
2448                 printf("too many BIOSes, dropping \"%s\"\n", ent->d_name);
2449         }
2450
2451         closedir(dir);
2452
2453 do_plugins:
2454         snprintf(fname, sizeof(fname), "%s/", Config.PluginsDir);
2455         dir = opendir(fname);
2456         if (dir == NULL) {
2457                 perror("scan_bios_plugins plugins opendir");
2458                 goto do_memcards;
2459         }
2460
2461         while (1) {
2462                 void *h, *tmp;
2463
2464                 errno = 0;
2465                 ent = readdir(dir);
2466                 if (ent == NULL) {
2467                         if (errno != 0)
2468                                 perror("readdir");
2469                         break;
2470                 }
2471                 p = strstr(ent->d_name, ".so");
2472                 if (p == NULL)
2473                         continue;
2474
2475                 snprintf(fname, sizeof(fname), "%s/%s", Config.PluginsDir, ent->d_name);
2476                 h = dlopen(fname, RTLD_LAZY | RTLD_LOCAL);
2477                 if (h == NULL) {
2478                         fprintf(stderr, "%s\n", dlerror());
2479                         continue;
2480                 }
2481
2482                 // now what do we have here?
2483                 tmp = dlsym(h, "GPUinit");
2484                 if (tmp) {
2485                         dlclose(h);
2486                         if (gpu_i < ARRAY_SIZE(gpu_plugins) - 1)
2487                                 gpu_plugins[gpu_i++] = strdup(ent->d_name);
2488                         continue;
2489                 }
2490
2491                 tmp = dlsym(h, "SPUinit");
2492                 if (tmp) {
2493                         dlclose(h);
2494                         if (spu_i < ARRAY_SIZE(spu_plugins) - 1)
2495                                 spu_plugins[spu_i++] = strdup(ent->d_name);
2496                         continue;
2497                 }
2498
2499                 fprintf(stderr, "ignoring unidentified plugin: %s\n", fname);
2500                 dlclose(h);
2501         }
2502
2503         closedir(dir);
2504
2505 do_memcards:
2506         dir = opendir("." MEMCARD_DIR);
2507         if (dir == NULL) {
2508                 perror("scan_bios_plugins memcards opendir");
2509                 return;
2510         }
2511
2512         while (1) {
2513                 struct stat st;
2514
2515                 errno = 0;
2516                 ent = readdir(dir);
2517                 if (ent == NULL) {
2518                         if (errno != 0)
2519                                 perror("readdir");
2520                         break;
2521                 }
2522
2523                 if (ent->d_type != DT_REG && ent->d_type != DT_LNK)
2524                         continue;
2525
2526                 snprintf(fname, sizeof(fname), "." MEMCARD_DIR "%s", ent->d_name);
2527                 if (stat(fname, &st) != 0) {
2528                         printf("bad memcard file: %s\n", ent->d_name);
2529                         continue;
2530                 }
2531
2532                 if (mc_i < ARRAY_SIZE(memcards) - 1) {
2533                         memcards[mc_i++] = strdup(ent->d_name);
2534                         continue;
2535                 }
2536
2537                 printf("too many memcards, dropping \"%s\"\n", ent->d_name);
2538         }
2539
2540         if (mc_i > 2)
2541                 qsort(memcards + 1, mc_i - 1, sizeof(memcards[0]), qsort_strcmp);
2542
2543         closedir(dir);
2544 }
2545
2546 void menu_init(void)
2547 {
2548         char buff[MAXPATHLEN];
2549         int i;
2550
2551         cpu_clock_st = cpu_clock = plat_target_cpu_clock_get();
2552
2553         scan_bios_plugins();
2554         menu_init_base();
2555
2556         menu_set_defconfig();
2557         menu_load_config(0);
2558         menu_do_last_cd_img(1);
2559         last_vout_w = 320;
2560         last_vout_h = 240;
2561         last_vout_bpp = 16;
2562
2563         g_menubg_src_ptr = calloc(g_menuscreen_w * g_menuscreen_h * 2, 1);
2564         g_menubg_ptr = calloc(g_menuscreen_w * g_menuscreen_h * 2, 1);
2565         if (g_menubg_src_ptr == NULL || g_menubg_ptr == NULL) {
2566                 fprintf(stderr, "OOM\n");
2567                 exit(1);
2568         }
2569
2570         emu_make_path(buff, "skin/background.png", sizeof(buff));
2571         readpng(g_menubg_src_ptr, buff, READPNG_BG, g_menuscreen_w, g_menuscreen_h);
2572
2573         i = plat_target.cpu_clock_set != NULL
2574                 && plat_target.cpu_clock_get != NULL && cpu_clock_st > 0;
2575         me_enable(e_menu_gfx_options, MA_OPT_CPU_CLOCKS, i);
2576
2577         i = me_id2offset(e_menu_gfx_options, MA_OPT_VOUT_MODE);
2578         e_menu_gfx_options[i].data = plat_target.vout_methods;
2579         me_enable(e_menu_gfx_options, MA_OPT_VOUT_MODE,
2580                 plat_target.vout_methods != NULL);
2581
2582         i = me_id2offset(e_menu_gfx_options, MA_OPT_HWFILTER);
2583         e_menu_gfx_options[i].data = plat_target.hwfilters;
2584         me_enable(e_menu_gfx_options, MA_OPT_HWFILTER,
2585                 plat_target.hwfilters != NULL);
2586
2587         me_enable(e_menu_gfx_options, MA_OPT_GAMMA,
2588                 plat_target.gamma_set != NULL);
2589
2590 #ifdef HAVE_PRE_ARMV7
2591         me_enable(e_menu_gfx_options, MA_OPT_SWFILTER, 0);
2592 #endif
2593         me_enable(e_menu_gfx_options, MA_OPT_VARSCALER, MENU_SHOW_VARSCALER);
2594         me_enable(e_menu_gfx_options, MA_OPT_VOUT_MODE, MENU_SHOW_VOUTMODE);
2595         me_enable(e_menu_gfx_options, MA_OPT_VARSCALER_C, MENU_SHOW_VARSCALER);
2596         me_enable(e_menu_gfx_options, MA_OPT_SCALER2, MENU_SHOW_SCALER2);
2597         me_enable(e_menu_keyconfig, MA_CTRL_NUBS_BTNS, MENU_SHOW_NUBS_BTNS);
2598         me_enable(e_menu_keyconfig, MA_CTRL_VIBRATION, MENU_SHOW_VIBRATION);
2599         me_enable(e_menu_keyconfig, MA_CTRL_DEADZONE, MENU_SHOW_DEADZONE);
2600 }
2601
2602 void menu_notify_mode_change(int w, int h, int bpp)
2603 {
2604         last_vout_w = w;
2605         last_vout_h = h;
2606         last_vout_bpp = bpp;
2607 }
2608
2609 static void menu_leave_emu(void)
2610 {
2611         if (GPU_close != NULL) {
2612                 int ret = GPU_close();
2613                 if (ret)
2614                         fprintf(stderr, "Warning: GPU_close returned %d\n", ret);
2615         }
2616
2617         plat_video_menu_enter(ready_to_go);
2618
2619         memcpy(g_menubg_ptr, g_menubg_src_ptr, g_menuscreen_w * g_menuscreen_h * 2);
2620         if (pl_vout_buf != NULL && ready_to_go) {
2621                 int x = max(0, g_menuscreen_w - last_vout_w);
2622                 int y = max(0, g_menuscreen_h / 2 - last_vout_h / 2);
2623                 int w = min(g_menuscreen_w, last_vout_w);
2624                 int h = min(g_menuscreen_h, last_vout_h);
2625                 u16 *d = (u16 *)g_menubg_ptr + g_menuscreen_w * y + x;
2626                 char *s = pl_vout_buf;
2627
2628                 if (last_vout_bpp == 16) {
2629                         for (; h > 0; h--, d += g_menuscreen_w, s += last_vout_w * 2)
2630                                 menu_darken_bg(d, s, w, 0);
2631                 }
2632                 else {
2633                         for (; h > 0; h--, d += g_menuscreen_w, s += last_vout_w * 3) {
2634                                 rgb888_to_rgb565(d, s, w * 3);
2635                                 menu_darken_bg(d, d, w, 0);
2636                         }
2637                 }
2638         }
2639
2640         if (ready_to_go)
2641                 cpu_clock = plat_target_cpu_clock_get();
2642 }
2643
2644 void menu_prepare_emu(void)
2645 {
2646         R3000Acpu *prev_cpu = psxCpu;
2647
2648         plat_video_menu_leave();
2649
2650         #if !defined(DRC_DISABLE) || defined(LIGHTREC)
2651         psxCpu = (Config.Cpu == CPU_INTERPRETER) ? &psxInt : &psxRec;
2652         #else
2653         psxCpu = &psxInt;
2654         #endif
2655         if (psxCpu != prev_cpu) {
2656                 prev_cpu->Notify(R3000ACPU_NOTIFY_BEFORE_SAVE, NULL);
2657                 prev_cpu->Shutdown();
2658                 psxCpu->Init();
2659                 psxCpu->Reset();
2660                 psxCpu->Notify(R3000ACPU_NOTIFY_AFTER_LOAD, NULL);
2661         }
2662
2663         menu_sync_config();
2664         psxCpu->ApplyConfig();
2665
2666         // core doesn't care about Config.Cdda changes,
2667         // so handle them manually here
2668         if (Config.Cdda)
2669                 CDR_stop();
2670
2671         if (cpu_clock > 0)
2672                 plat_target_cpu_clock_set(cpu_clock);
2673
2674         // push config to GPU plugin
2675         plugin_call_rearmed_cbs();
2676
2677         if (GPU_open != NULL) {
2678                 int ret = GPU_open(&gpuDisp, "PCSX", NULL);
2679                 if (ret)
2680                         fprintf(stderr, "Warning: GPU_open returned %d\n", ret);
2681         }
2682
2683         dfinput_activate();
2684 }
2685
2686 void menu_update_msg(const char *msg)
2687 {
2688         strncpy(menu_error_msg, msg, sizeof(menu_error_msg));
2689         menu_error_msg[sizeof(menu_error_msg) - 1] = 0;
2690
2691         menu_error_time = plat_get_ticks_ms();
2692         lprintf("msg: %s\n", menu_error_msg);
2693 }
2694
2695 void menu_finish(void)
2696 {
2697         if (cpu_clock_st > 0)
2698                 plat_target_cpu_clock_set(cpu_clock_st);
2699 }