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_INTVAL(region),
 401         CE_INTVAL_V(g_scaler, 3),
 402         CE_INTVAL(g_gamma),
 403         CE_INTVAL(g_layer_x),
 404         CE_INTVAL(g_layer_y),
 405         CE_INTVAL(g_layer_w),
 406         CE_INTVAL(g_layer_h),
 407         CE_INTVAL(soft_filter),
 408         CE_INTVAL(scanlines),
 409         CE_INTVAL(scanline_level),
 410         CE_INTVAL(plat_target.vout_method),
 411         CE_INTVAL(plat_target.hwfilter),
 412         CE_INTVAL(plat_target.vout_fullscreen),
 413         CE_INTVAL(state_slot),
 414         CE_INTVAL(cpu_clock),
 415         CE_INTVAL(g_opts),
 416         CE_INTVAL(in_type_sel1),
 417         CE_INTVAL(in_type_sel2),
 418         CE_INTVAL(analog_deadzone),
 419         CE_INTVAL(memcard1_sel),
 420         CE_INTVAL(memcard2_sel),
 421         CE_INTVAL(g_autostateld_opt),
 422         CE_INTVAL_N("adev0_is_nublike", in_adev_is_nublike[0]),
 423         CE_INTVAL_N("adev1_is_nublike", in_adev_is_nublike[1]),
 424         CE_INTVAL_V(frameskip, 3),
 425         CE_INTVAL_P(thread_rendering),
 426         CE_INTVAL_P(gpu_peops.iUseDither),
 427         CE_INTVAL_P(gpu_peops.dwActFixes),
 428         CE_INTVAL_P(gpu_unai.ilace_force),
 429         CE_INTVAL_P(gpu_unai.pixel_skip),
 430         CE_INTVAL_P(gpu_unai.lighting),
 431         CE_INTVAL_P(gpu_unai.fast_lighting),
 432         CE_INTVAL_P(gpu_unai.blending),
 433         CE_INTVAL_P(gpu_unai.dithering),
 434         CE_INTVAL_P(gpu_unai.lineskip),
 435         CE_INTVAL_P(gpu_unai.abe_hack),
 436         CE_INTVAL_P(gpu_unai.no_light),
 437         CE_INTVAL_P(gpu_unai.no_blend),
 438         CE_INTVAL_P(gpu_unai.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 (slow)", 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_onoff     ("Interlace",                  0, pl_rearmed_cbs.gpu_unai.ilace_force, 1),
1379         mee_onoff     ("Dithering",                  0, pl_rearmed_cbs.gpu_unai.dithering, 1),
1380         mee_onoff     ("Lighting",                   0, pl_rearmed_cbs.gpu_unai.lighting, 1),
1381         mee_onoff     ("Fast lighting",              0, pl_rearmed_cbs.gpu_unai.fast_lighting, 1),
1382         mee_onoff     ("Blending",                   0, pl_rearmed_cbs.gpu_unai.blending, 1),
1383         mee_onoff     ("Pixel skip",                 0, pl_rearmed_cbs.gpu_unai.pixel_skip, 1),
1384         mee_end,
1385 };
1386
1387 static int menu_loop_plugin_gpu_unai(int id, int keys)
1388 {
1389         int sel = 0;
1390         me_loop(e_menu_plugin_gpu_unai, &sel);
1391         return 0;
1392 }
1393
1394 static const char *men_gpu_dithering[] = { "None", "Game dependant", "Always", NULL };
1395 //static const char h_gpu_0[]            = "Needed for Chrono Cross";
1396 static const char h_gpu_1[]            = "Capcom fighting games";
1397 static const char h_gpu_2[]            = "Black screens in Lunar";
1398 static const char h_gpu_3[]            = "Compatibility mode";
1399 static const char h_gpu_6[]            = "Pandemonium 2";
1400 //static const char h_gpu_7[]            = "Skip every second frame";
1401 static const char h_gpu_8[]            = "Needed by Dark Forces";
1402 static const char h_gpu_9[]            = "better g-colors, worse textures";
1403 static const char h_gpu_10[]           = "Toggle busy flags after drawing";
1404
1405 static menu_entry e_menu_plugin_gpu_peops[] =
1406 {
1407         mee_enum      ("Dithering",                  0, pl_rearmed_cbs.gpu_peops.iUseDither, men_gpu_dithering),
1408 //      mee_onoff_h   ("Odd/even bit hack",          0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<0, h_gpu_0),
1409         mee_onoff_h   ("Expand screen width",        0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<1, h_gpu_1),
1410         mee_onoff_h   ("Ignore brightness color",    0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<2, h_gpu_2),
1411         mee_onoff_h   ("Disable coordinate check",   0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<3, h_gpu_3),
1412         mee_onoff_h   ("Lazy screen update",         0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<6, h_gpu_6),
1413 //      mee_onoff_h   ("Old frame skipping",         0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<7, h_gpu_7),
1414         mee_onoff_h   ("Repeated flat tex triangles ",0,pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<8, h_gpu_8),
1415         mee_onoff_h   ("Draw quads with triangles",  0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<9, h_gpu_9),
1416         mee_onoff_h   ("Fake 'gpu busy' states",     0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<10, h_gpu_10),
1417         mee_end,
1418 };
1419
1420 static int menu_loop_plugin_gpu_peops(int id, int keys)
1421 {
1422         static int sel = 0;
1423         me_loop(e_menu_plugin_gpu_peops, &sel);
1424         return 0;
1425 }
1426
1427 static const char *men_peopsgl_texfilter[] = { "None", "Standard", "Extended",
1428         "Standard-sprites", "Extended-sprites", "Standard+sprites", "Extended+sprites", NULL };
1429 static const char *men_peopsgl_fbtex[] = { "Emulated VRam", "Black", "Card", "Card+soft" };
1430
1431 static menu_entry e_menu_plugin_gpu_peopsgl[] =
1432 {
1433         mee_onoff     ("Dithering",                  0, pl_rearmed_cbs.gpu_peopsgl.bDrawDither, 1),
1434         mee_enum      ("Texture Filtering",          0, pl_rearmed_cbs.gpu_peopsgl.iFilterType, men_peopsgl_texfilter),
1435         mee_enum      ("Framebuffer Textures",       0, pl_rearmed_cbs.gpu_peopsgl.iFrameTexType, men_peopsgl_fbtex),
1436         mee_onoff     ("Mask Detect",                0, pl_rearmed_cbs.gpu_peopsgl.iUseMask, 1),
1437         mee_onoff     ("Opaque Pass",                0, pl_rearmed_cbs.gpu_peopsgl.bOpaquePass, 1),
1438         mee_onoff     ("Advanced Blend",             0, pl_rearmed_cbs.gpu_peopsgl.bAdvancedBlend, 1),
1439         mee_onoff     ("Use Fast Mdec",              0, pl_rearmed_cbs.gpu_peopsgl.bUseFastMdec, 1),
1440         mee_range     ("Texture RAM size (MB)",      0, pl_rearmed_cbs.gpu_peopsgl.iVRamSize, 4, 128),
1441         mee_onoff     ("Texture garbage collection", 0, pl_rearmed_cbs.gpu_peopsgl.iTexGarbageCollection, 1),
1442         mee_label     ("Fixes/hacks:"),
1443         mee_onoff     ("FF7 cursor",                 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<0),
1444         mee_onoff     ("Direct FB updates",          0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<1),
1445         mee_onoff     ("Black brightness",           0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<2),
1446         mee_onoff     ("Swap front detection",       0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<3),
1447         mee_onoff     ("Disable coord check",        0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<4),
1448         mee_onoff     ("No blue glitches (LoD)",     0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<5),
1449         mee_onoff     ("Soft FB access",             0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<6),
1450         mee_onoff     ("FF9 rect",                   0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<9),
1451         mee_onoff     ("No subtr. blending",         0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<10),
1452         mee_onoff     ("Lazy upload (DW7)",          0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<11),
1453         mee_onoff     ("Additional uploads",         0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<15),
1454         mee_end,
1455 };
1456
1457 static int menu_loop_plugin_gpu_peopsgl(int id, int keys)
1458 {
1459         static int sel = 0;
1460         me_loop(e_menu_plugin_gpu_peopsgl, &sel);
1461         return 0;
1462 }
1463
1464 static const char *men_spu_interp[] = { "None", "Simple", "Gaussian", "Cubic", NULL };
1465 static const char h_spu_volboost[]  = "Large values cause distortion";
1466 static const char h_spu_tempo[]     = "Slows down audio if emu is too slow\n"
1467                                       "This is inaccurate and breaks games";
1468
1469 static menu_entry e_menu_plugin_spu[] =
1470 {
1471         mee_range_h   ("Volume boost",              0, volume_boost, -5, 30, h_spu_volboost),
1472         mee_onoff     ("Reverb",                    0, spu_config.iUseReverb, 1),
1473         mee_enum      ("Interpolation",             0, spu_config.iUseInterpolation, men_spu_interp),
1474         //mee_onoff     ("Adjust XA pitch",           0, spu_config.iXAPitch, 1),
1475         mee_onoff_h   ("Adjust tempo",              0, spu_config.iTempo, 1, h_spu_tempo),
1476         mee_end,
1477 };
1478
1479 static int menu_loop_plugin_spu(int id, int keys)
1480 {
1481         static int sel = 0;
1482         me_loop(e_menu_plugin_spu, &sel);
1483         return 0;
1484 }
1485
1486 static const char h_bios[]       = "HLE is simulated BIOS. BIOS selection is saved in\n"
1487                                    "savestates and can't be changed there. Must save\n"
1488                                    "config and reload the game for change to take effect";
1489 static const char h_plugin_gpu[] =
1490 #ifdef BUILTIN_GPU_NEON
1491                                    "builtin_gpu is the NEON GPU, very fast and accurate\n"
1492 #endif
1493                                    "gpu_peops is Pete's soft GPU, slow but accurate\n"
1494                                    "gpu_unai is GPU from PCSX4ALL, fast but glitchy\n"
1495                                    "gpu_gles Pete's hw GPU, uses 3D chip but is glitchy\n"
1496                                    "must save config and reload the game if changed";
1497 static const char h_plugin_spu[] = "spunull effectively disables sound\n"
1498                                    "must save config and reload the game if changed";
1499 static const char h_gpu_peops[]  = "Configure P.E.Op.S. SoftGL Driver V1.17";
1500 static const char h_gpu_peopsgl[]= "Configure P.E.Op.S. MesaGL Driver V1.78";
1501 static const char h_gpu_unai[]   = "Configure Unai/PCSX4ALL Team GPU plugin";
1502 static const char h_spu[]        = "Configure built-in P.E.Op.S. Sound Driver V1.7";
1503
1504 static menu_entry e_menu_plugin_options[] =
1505 {
1506         mee_enum_h    ("BIOS",                          0, bios_sel, bioses, h_bios),
1507         mee_enum_h    ("GPU plugin",                    0, gpu_plugsel, gpu_plugins, h_plugin_gpu),
1508         mee_enum_h    ("SPU plugin",                    0, spu_plugsel, spu_plugins, h_plugin_spu),
1509 #ifdef BUILTIN_GPU_NEON
1510         mee_handler_h ("Configure built-in GPU plugin", menu_loop_plugin_gpu_neon, h_gpu_neon),
1511 #endif
1512         mee_handler_h ("Configure gpu_peops plugin",    menu_loop_plugin_gpu_peops, h_gpu_peops),
1513         mee_handler_h ("Configure gpu_unai GPU plugin", menu_loop_plugin_gpu_unai, h_gpu_unai),
1514         mee_handler_h ("Configure gpu_gles GPU plugin", menu_loop_plugin_gpu_peopsgl, h_gpu_peopsgl),
1515         mee_handler_h ("Configure built-in SPU plugin", menu_loop_plugin_spu, h_spu),
1516         mee_end,
1517 };
1518
1519 static menu_entry e_menu_main2[];
1520
1521 static int menu_loop_plugin_options(int id, int keys)
1522 {
1523         static int sel = 0;
1524         me_loop(e_menu_plugin_options, &sel);
1525
1526         // sync BIOS/plugins
1527         snprintf(Config.Bios, sizeof(Config.Bios), "%s", bioses[bios_sel]);
1528         snprintf(Config.Gpu, sizeof(Config.Gpu), "%s", gpu_plugins[gpu_plugsel]);
1529         snprintf(Config.Spu, sizeof(Config.Spu), "%s", spu_plugins[spu_plugsel]);
1530         me_enable(e_menu_main2, MA_MAIN_RUN_BIOS, bios_sel != 0);
1531
1532         return 0;
1533 }
1534
1535 // ------------ adv options menu ------------
1536
1537 #ifndef DRC_DISABLE
1538 static const char h_cfg_noch[]    = "Disables game-specific compatibility hacks";
1539 static const char h_cfg_nosmc[]   = "Will cause crashes when loading, break memcards";
1540 static const char h_cfg_gteunn[]  = "May cause graphical glitches";
1541 static const char h_cfg_gteflgs[] = "Will cause graphical glitches";
1542 #endif
1543 static const char h_cfg_stalls[]  = "Will cause some games to run too fast";
1544
1545 static menu_entry e_menu_speed_hacks[] =
1546 {
1547 #ifndef DRC_DISABLE
1548         mee_onoff_h   ("Disable compat hacks",     0, new_dynarec_hacks, NDHACK_NO_COMPAT_HACKS, h_cfg_noch),
1549         mee_onoff_h   ("Disable SMC checks",       0, new_dynarec_hacks, NDHACK_NO_SMC_CHECK, h_cfg_nosmc),
1550         mee_onoff_h   ("Assume GTE regs unneeded", 0, new_dynarec_hacks, NDHACK_GTE_UNNEEDED, h_cfg_gteunn),
1551         mee_onoff_h   ("Disable GTE flags",        0, new_dynarec_hacks, NDHACK_GTE_NO_FLAGS, h_cfg_gteflgs),
1552 #endif
1553         mee_onoff_h   ("Disable CPU/GTE stalls",   0, menu_iopts[0], 1, h_cfg_stalls),
1554         mee_end,
1555 };
1556
1557 static int menu_loop_speed_hacks(int id, int keys)
1558 {
1559         static int sel = 0;
1560         menu_iopts[0] = Config.DisableStalls;
1561         me_loop(e_menu_speed_hacks, &sel);
1562         Config.DisableStalls = menu_iopts[0];
1563         return 0;
1564 }
1565
1566 static const char h_cfg_cpul[]   = "Shows CPU usage in %";
1567 static const char h_cfg_spu[]    = "Shows active SPU channels\n"
1568                                    "(green: normal, red: fmod, blue: noise)";
1569 static const char h_cfg_fl[]     = "Frame Limiter keeps the game from running too fast";
1570 static const char h_cfg_xa[]     = "Disables XA sound, which can sometimes improve performance";
1571 static const char h_cfg_cdda[]   = "Disable CD Audio for a performance boost\n"
1572                                    "(proper .cue/.bin dump is needed otherwise)";
1573 #ifndef DRC_DISABLE
1574 static const char h_cfg_nodrc[]  = "Disable dynamic recompiler and use interpreter\n"
1575                                    "Might be useful to overcome some dynarec bugs";
1576 #endif
1577 static const char h_cfg_shacks[] = "Breaks games but may give better performance";
1578 static const char h_cfg_icache[] = "Support F1 games (only when dynarec is off)";
1579 static const char h_cfg_psxclk[]  = "Over/under-clock the PSX, default is " DEFAULT_PSX_CLOCK_S "\n"
1580                                     "(adjust this if the game is too slow/too fast/hangs)";
1581
1582 enum { AMO_XA, AMO_CDDA, AMO_IC, AMO_CPU };
1583
1584 static menu_entry e_menu_adv_options[] =
1585 {
1586         mee_onoff_h   ("Show CPU load",          0, g_opts, OPT_SHOWCPU, h_cfg_cpul),
1587         mee_onoff_h   ("Show SPU channels",      0, g_opts, OPT_SHOWSPU, h_cfg_spu),
1588         mee_onoff_h   ("Disable Frame Limiter",  0, g_opts, OPT_NO_FRAMELIM, h_cfg_fl),
1589         mee_onoff_h   ("Disable XA Decoding",    0, menu_iopts[AMO_XA],   1, h_cfg_xa),
1590         mee_onoff_h   ("Disable CD Audio",       0, menu_iopts[AMO_CDDA], 1, h_cfg_cdda),
1591         mee_onoff_h   ("ICache emulation",       0, menu_iopts[AMO_IC],   1, h_cfg_icache),
1592 #if !defined(DRC_DISABLE) || defined(LIGHTREC)
1593         mee_onoff_h   ("Disable dynarec (slow!)",0, menu_iopts[AMO_CPU],  1, h_cfg_nodrc),
1594 #endif
1595         mee_range_h   ("PSX CPU clock, %",       0, psx_clock, 1, 500, h_cfg_psxclk),
1596         mee_handler_h ("[Speed hacks]",             menu_loop_speed_hacks, h_cfg_shacks),
1597         mee_end,
1598 };
1599
1600 static int menu_loop_adv_options(int id, int keys)
1601 {
1602         static int sel = 0;
1603         static struct {
1604                 boolean *opt;
1605                 int *mopt;
1606         } opts[] = {
1607                 { &Config.Xa,      &menu_iopts[AMO_XA] },
1608                 { &Config.Cdda,    &menu_iopts[AMO_CDDA] },
1609                 { &Config.icache_emulation, &menu_iopts[AMO_IC] },
1610                 { &Config.Cpu,     &menu_iopts[AMO_CPU] },
1611         };
1612         int i;
1613         for (i = 0; i < ARRAY_SIZE(opts); i++)
1614                 *opts[i].mopt = *opts[i].opt;
1615         me_loop(e_menu_adv_options, &sel);
1616         for (i = 0; i < ARRAY_SIZE(opts); i++)
1617                 *opts[i].opt = *opts[i].mopt;
1618         return 0;
1619 }
1620
1621 // ------------ options menu ------------
1622
1623 static int mh_restore_defaults(int id, int keys)
1624 {
1625         menu_set_defconfig();
1626         menu_update_msg("defaults restored");
1627         return 1;
1628 }
1629
1630 static const char *men_region[]       = { "Auto", "NTSC", "PAL", NULL };
1631 static const char *men_frameskip[]    = { "Auto", "Off", "1", "2", "3", NULL };
1632 /*
1633 static const char *men_confirm_save[] = { "OFF", "writes", "loads", "both", NULL };
1634 static const char h_confirm_save[]    = "Ask for confirmation when overwriting save,\n"
1635                                         "loading state or both";
1636 */
1637 static const char h_restore_def[]     = "Switches back to default / recommended\n"
1638                                         "configuration";
1639 static const char h_frameskip[]       = "Warning: frameskip sometimes causes glitches\n";
1640
1641 static menu_entry e_menu_options[] =
1642 {
1643 //      mee_range     ("Save slot",                0, state_slot, 0, 9),
1644 //      mee_enum_h    ("Confirm savestate",        0, dummy, men_confirm_save, h_confirm_save),
1645         mee_enum_h    ("Frameskip",                0, frameskip, men_frameskip, h_frameskip),
1646         mee_onoff     ("Show FPS",                 0, g_opts, OPT_SHOWFPS),
1647         mee_enum      ("Region",                   0, region, men_region),
1648         mee_range     ("CPU clock",                MA_OPT_CPU_CLOCKS, cpu_clock, 20, 5000),
1649 #ifdef C64X_DSP
1650         mee_onoff     ("Use C64x DSP for sound",   MA_OPT_SPU_THREAD, spu_config.iUseThread, 1),
1651 #else
1652         mee_onoff     ("Threaded SPU",             MA_OPT_SPU_THREAD, spu_config.iUseThread, 1),
1653 #endif
1654         mee_handler_id("[Display]",                MA_OPT_DISP_OPTS, menu_loop_gfx_options),
1655         mee_handler   ("[BIOS/Plugins]",           menu_loop_plugin_options),
1656         mee_handler   ("[Advanced]",               menu_loop_adv_options),
1657         mee_cust_nosave("Save global config",      MA_OPT_SAVECFG,      mh_savecfg, mgn_saveloadcfg),
1658         mee_cust_nosave("Save cfg for loaded game",MA_OPT_SAVECFG_GAME, mh_savecfg, mgn_saveloadcfg),
1659         mee_handler_h ("Restore default config",   mh_restore_defaults, h_restore_def),
1660         mee_end,
1661 };
1662
1663 static int menu_loop_options(int id, int keys)
1664 {
1665         static int sel = 0;
1666
1667         me_enable(e_menu_options, MA_OPT_CPU_CLOCKS, cpu_clock_st > 0);
1668         me_enable(e_menu_options, MA_OPT_SPU_THREAD, spu_config.iThreadAvail);
1669         me_enable(e_menu_options, MA_OPT_SAVECFG_GAME, ready_to_go && CdromId[0]);
1670
1671         me_loop(e_menu_options, &sel);
1672
1673         return 0;
1674 }
1675
1676 // ------------ debug menu ------------
1677
1678 static void draw_frame_debug(GPUFreeze_t *gpuf, int x, int y)
1679 {
1680         int w = min(g_menuscreen_w, 1024);
1681         int h = min(g_menuscreen_h, 512);
1682         u16 *d = g_menuscreen_ptr;
1683         u16 *s = (u16 *)gpuf->psxVRam + y * 1024 + x;
1684         char buff[64];
1685         int ty = 1;
1686
1687         gpuf->ulFreezeVersion = 1;
1688         if (GPU_freeze != NULL)
1689                 GPU_freeze(1, gpuf);
1690
1691         for (; h > 0; h--, d += g_menuscreen_w, s += 1024)
1692                 bgr555_to_rgb565(d, s, w * 2);
1693
1694         smalltext_out16(4, 1, "build: "__DATE__ " " __TIME__ " " REV, 0xe7fc);
1695         snprintf(buff, sizeof(buff), "GPU sr: %08x", gpuf->ulStatus);
1696         smalltext_out16(4, (ty += me_sfont_h), buff, 0xe7fc);
1697         snprintf(buff, sizeof(buff), "PC/SP: %08x %08x", psxRegs.pc, psxRegs.GPR.n.sp);
1698         smalltext_out16(4, (ty += me_sfont_h), buff, 0xe7fc);
1699 }
1700
1701 static void debug_menu_loop(void)
1702 {
1703         int inp, df_x = 0, df_y = 0;
1704         GPUFreeze_t *gpuf;
1705
1706         gpuf = malloc(sizeof(*gpuf));
1707         if (gpuf == NULL)
1708                 return;
1709
1710         while (1)
1711         {
1712                 menu_draw_begin(0, 1);
1713                 draw_frame_debug(gpuf, df_x, df_y);
1714                 menu_draw_end();
1715
1716                 inp = in_menu_wait(PBTN_MOK|PBTN_MBACK|PBTN_MA2|PBTN_MA3|PBTN_L|PBTN_R |
1717                                         PBTN_UP|PBTN_DOWN|PBTN_LEFT|PBTN_RIGHT, NULL, 10);
1718                 if      (inp & PBTN_MBACK) break;
1719                 else if (inp & PBTN_UP)    { if (df_y > 0) df_y--; }
1720                 else if (inp & PBTN_DOWN)  { if (df_y < 512 - g_menuscreen_h) df_y++; }
1721                 else if (inp & PBTN_LEFT)  { if (df_x > 0) df_x -= 2; }
1722                 else if (inp & PBTN_RIGHT) { if (df_x < 1024 - g_menuscreen_w) df_x += 2; }
1723         }
1724
1725         free(gpuf);
1726 }
1727
1728 // --------- memcard manager ---------
1729
1730 static void draw_mc_icon(int dx, int dy, const u16 *s)
1731 {
1732         u16 *d;
1733         int x, y, l, p;
1734
1735         d = (u16 *)g_menuscreen_ptr + g_menuscreen_w * dy + dx;
1736
1737         for (y = 0; y < 16; y++, s += 16) {
1738                 for (l = 0; l < 2; l++, d += g_menuscreen_w) {
1739                         for (x = 0; x < 16; x++) {
1740                                 p = s[x];
1741                                 d[x*2] = d[x*2 + 1] = ((p & 0x7c00) >> 10)
1742                                         | ((p & 0x03e0) << 1) | ((p & 0x1f) << 11);
1743                         }
1744                 }
1745         }
1746 }
1747
1748 static void draw_mc_bg(void)
1749 {
1750         McdBlock *blocks1, *blocks2;
1751         int maxicons = 15;
1752         int i, y, row2;
1753
1754         blocks1 = malloc(15 * sizeof(blocks1[0]));
1755         blocks2 = malloc(15 * sizeof(blocks1[0]));
1756         if (blocks1 == NULL || blocks2 == NULL)
1757                 goto out;
1758
1759         for (i = 0; i < 15; i++) {
1760                 GetMcdBlockInfo(1, i + 1, &blocks1[i]);
1761                 GetMcdBlockInfo(2, i + 1, &blocks2[i]);
1762         }
1763
1764         menu_draw_begin(1, 1);
1765
1766         memcpy(g_menuscreen_ptr, g_menubg_src_ptr, g_menuscreen_w * g_menuscreen_h * 2);
1767
1768         y = g_menuscreen_h / 2 - 15 * 32 / 2;
1769         if (y < 0) {
1770                 // doesn't fit..
1771                 y = 0;
1772                 maxicons = g_menuscreen_h / 32;
1773         }
1774
1775         row2 = g_menuscreen_w / 2;
1776         for (i = 0; i < maxicons; i++) {
1777                 draw_mc_icon(8, y + i * 32, (u16 *)blocks1[i].Icon);
1778                 smalltext_out16(10+32, y + i * 32 + 8, blocks1[i].sTitle, 0xf71e);
1779
1780                 draw_mc_icon(row2 + 8, y + i * 32, (u16 *)blocks2[i].Icon);
1781                 smalltext_out16(row2 + 10+32, y + i * 32 + 8, blocks2[i].sTitle, 0xf71e);
1782         }
1783
1784         menu_darken_bg(g_menubg_ptr, g_menuscreen_ptr, g_menuscreen_w * g_menuscreen_h, 0);
1785
1786         menu_draw_end();
1787 out:
1788         free(blocks1);
1789         free(blocks2);
1790 }
1791
1792 static void handle_memcard_sel(void)
1793 {
1794         strcpy(Config.Mcd1, "none");
1795         if (memcard1_sel != 0)
1796                 snprintf(Config.Mcd1, sizeof(Config.Mcd1), ".%s%s", MEMCARD_DIR, memcards[memcard1_sel]);
1797         strcpy(Config.Mcd2, "none");
1798         if (memcard2_sel != 0)
1799                 snprintf(Config.Mcd2, sizeof(Config.Mcd2), ".%s%s", MEMCARD_DIR, memcards[memcard2_sel]);
1800         LoadMcds(Config.Mcd1, Config.Mcd2);
1801         draw_mc_bg();
1802 }
1803
1804 static menu_entry e_memcard_options[] =
1805 {
1806         mee_enum("Memory card 1", 0, memcard1_sel, memcards),
1807         mee_enum("Memory card 2", 0, memcard2_sel, memcards),
1808         mee_end,
1809 };
1810
1811 static int menu_loop_memcards(int id, int keys)
1812 {
1813         static int sel = 0;
1814         char *p;
1815         int i;
1816
1817         memcard1_sel = memcard2_sel = 0;
1818         p = strrchr(Config.Mcd1, '/');
1819         if (p != NULL)
1820                 for (i = 0; memcards[i] != NULL; i++)
1821                         if (strcmp(p + 1, memcards[i]) == 0)
1822                                 { memcard1_sel = i; break; }
1823         p = strrchr(Config.Mcd2, '/');
1824         if (p != NULL)
1825                 for (i = 0; memcards[i] != NULL; i++)
1826                         if (strcmp(p + 1, memcards[i]) == 0)
1827                                 { memcard2_sel = i; break; }
1828
1829         me_loop_d(e_memcard_options, &sel, handle_memcard_sel, NULL);
1830
1831         memcpy(g_menubg_ptr, g_menubg_src_ptr, g_menuscreen_w * g_menuscreen_h * 2);
1832
1833         return 0;
1834 }
1835
1836 // ------------ cheats menu ------------
1837
1838 static void draw_cheatlist(int sel)
1839 {
1840         int max_cnt, start, i, pos, active;
1841
1842         max_cnt = g_menuscreen_h / me_sfont_h;
1843         start = max_cnt / 2 - sel;
1844
1845         menu_draw_begin(1, 1);
1846
1847         for (i = 0; i < NumCheats; i++) {
1848                 pos = start + i;
1849                 if (pos < 0) continue;
1850                 if (pos >= max_cnt) break;
1851                 active = Cheats[i].Enabled;
1852                 smalltext_out16(14,                pos * me_sfont_h,
1853                         active ? "ON " : "OFF", active ? 0xfff6 : 0xffff);
1854                 smalltext_out16(14 + me_sfont_w*4, pos * me_sfont_h,
1855                         Cheats[i].Descr, active ? 0xfff6 : 0xffff);
1856         }
1857         pos = start + i;
1858         if (pos < max_cnt)
1859                 smalltext_out16(14, pos * me_sfont_h, "done", 0xffff);
1860
1861         text_out16(5, max_cnt / 2 * me_sfont_h, ">");
1862         menu_draw_end();
1863 }
1864
1865 static void menu_loop_cheats(void)
1866 {
1867         static int menu_sel = 0;
1868         int inp;
1869
1870         for (;;)
1871         {
1872                 draw_cheatlist(menu_sel);
1873                 inp = in_menu_wait(PBTN_UP|PBTN_DOWN|PBTN_LEFT|PBTN_RIGHT|PBTN_L|PBTN_R
1874                                 |PBTN_MOK|PBTN_MBACK, NULL, 33);
1875                 if (inp & PBTN_UP  ) { menu_sel--; if (menu_sel < 0) menu_sel = NumCheats; }
1876                 if (inp & PBTN_DOWN) { menu_sel++; if (menu_sel > NumCheats) menu_sel = 0; }
1877                 if (inp &(PBTN_LEFT|PBTN_L))  { menu_sel-=10; if (menu_sel < 0) menu_sel = 0; }
1878                 if (inp &(PBTN_RIGHT|PBTN_R)) { menu_sel+=10; if (menu_sel > NumCheats) menu_sel = NumCheats; }
1879                 if (inp & PBTN_MOK) { // action
1880                         if (menu_sel < NumCheats)
1881                                 Cheats[menu_sel].Enabled = !Cheats[menu_sel].Enabled;
1882                         else    break;
1883                 }
1884                 if (inp & PBTN_MBACK)
1885                         break;
1886         }
1887 }
1888
1889 // --------- main menu help ----------
1890
1891 static void menu_bios_warn(void)
1892 {
1893         int inp;
1894         static const char msg[] =
1895                 "You don't seem to have copied any BIOS\n"
1896                 "files to\n"
1897                 MENU_BIOS_PATH "\n\n"
1898
1899                 "While many games work fine with fake\n"
1900                 "(HLE) BIOS, others (like MGS and FF8)\n"
1901                 "require BIOS to work.\n"
1902                 "After copying the file, you'll also need\n"
1903                 "to select it in the emu's menu:\n"
1904                 "options->[BIOS/Plugins]\n\n"
1905                 "The file is usually named SCPH1001.BIN,\n"
1906                 "but other not compressed files can be\n"
1907                 "used too.\n\n"
1908                 "Press %s or %s to continue";
1909         char tmp_msg[sizeof(msg) + 64];
1910
1911         snprintf(tmp_msg, sizeof(tmp_msg), msg,
1912                 in_get_key_name(-1, -PBTN_MOK), in_get_key_name(-1, -PBTN_MBACK));
1913         while (1)
1914         {
1915                 draw_menu_message(tmp_msg, NULL);
1916
1917                 inp = in_menu_wait(PBTN_MOK|PBTN_MBACK, NULL, 70);
1918                 if (inp & (PBTN_MBACK|PBTN_MOK))
1919                         return;
1920         }
1921 }
1922
1923 // ------------ main menu ------------
1924
1925 static menu_entry e_menu_main[];
1926
1927 static void draw_frame_main(void)
1928 {
1929         struct tm *tmp;
1930         time_t ltime;
1931         int capacity;
1932         char ltime_s[16];
1933         char buff[64];
1934         char *out;
1935
1936         if (CdromId[0] != 0) {
1937                 snprintf(buff, sizeof(buff), "%.32s/%.9s (running as %s, with %s)",
1938                          get_cd_label(), CdromId, Config.PsxType ? "PAL" : "NTSC",
1939                          Config.HLE ? "HLE" : "BIOS");
1940                 smalltext_out16(4, 1, buff, 0x105f);
1941         }
1942
1943         if (ready_to_go) {
1944                 capacity = plat_target_bat_capacity_get();
1945                 ltime = time(NULL);
1946                 tmp = localtime(&ltime);
1947                 strftime(ltime_s, sizeof(ltime_s), "%H:%M", tmp);
1948                 if (capacity >= 0) {
1949                         snprintf(buff, sizeof(buff), "%s %3d%%", ltime_s, capacity);
1950                         out = buff;
1951                 }
1952                 else
1953                         out = ltime_s;
1954                 smalltext_out16(4, 1 + me_sfont_h, out, 0x105f);
1955         }
1956 }
1957
1958 static void draw_frame_credits(void)
1959 {
1960         smalltext_out16(4, 1, "build: " __DATE__ " " __TIME__ " " REV, 0xe7fc);
1961 }
1962
1963 static const char credits_text[] =
1964         "PCSX-ReARMed\n\n"
1965         "(C) 1999-2003 PCSX Team\n"
1966         "(C) 2005-2009 PCSX-df Team\n"
1967         "(C) 2009-2011 PCSX-Reloaded Team\n\n"
1968         "ARM recompiler (C) 2009-2011 Ari64\n"
1969 #ifdef BUILTIN_GPU_NEON
1970         "ARM NEON GPU (c) 2011-2012 Exophase\n"
1971 #endif
1972         "PEOpS GPU and SPU by Pete Bernert\n"
1973         "  and the P.E.Op.S. team\n"
1974         "PCSX4ALL plugin by PCSX4ALL team\n"
1975         "  Chui, Franxis, Unai\n\n"
1976         "integration, optimization and\n"
1977         "  frontend (C) 2010-2015 notaz\n";
1978
1979 static int reset_game(void)
1980 {
1981         // sanity check
1982         if (bios_sel == 0 && !Config.HLE)
1983                 return -1;
1984
1985         ClosePlugins();
1986         OpenPlugins();
1987         SysReset();
1988         if (CheckCdrom() != -1) {
1989                 LoadCdrom();
1990         }
1991         return 0;
1992 }
1993
1994 static int reload_plugins(const char *cdimg)
1995 {
1996         pl_vout_buf = NULL;
1997
1998         ClosePlugins();
1999
2000         set_cd_image(cdimg);
2001         LoadPlugins();
2002         pcnt_hook_plugins();
2003         NetOpened = 0;
2004         if (OpenPlugins() == -1) {
2005                 menu_update_msg("failed to open plugins");
2006                 return -1;
2007         }
2008         plugin_call_rearmed_cbs();
2009
2010         cdrIsoMultidiskCount = 1;
2011         CdromId[0] = '\0';
2012         CdromLabel[0] = '\0';
2013
2014         return 0;
2015 }
2016
2017 static int run_bios(void)
2018 {
2019         if (bios_sel == 0)
2020                 return -1;
2021
2022         ready_to_go = 0;
2023         if (reload_plugins(NULL) != 0)
2024                 return -1;
2025         SysReset();
2026
2027         ready_to_go = 1;
2028         return 0;
2029 }
2030
2031 static int run_exe(void)
2032 {
2033         const char *exts[] = { "exe", NULL };
2034         const char *fname;
2035
2036         fname = menu_loop_romsel(last_selected_fname,
2037                 sizeof(last_selected_fname), exts, NULL);
2038         if (fname == NULL)
2039                 return -1;
2040
2041         ready_to_go = 0;
2042         if (reload_plugins(NULL) != 0)
2043                 return -1;
2044
2045         SysReset();
2046         if (Load(fname) != 0) {
2047                 menu_update_msg("exe load failed, bad file?");
2048                 printf("meh\n");
2049                 return -1;
2050         }
2051
2052         ready_to_go = 1;
2053         return 0;
2054 }
2055
2056 static int run_cd_image(const char *fname)
2057 {
2058         int autoload_state = g_autostateld_opt;
2059
2060         ready_to_go = 0;
2061         reload_plugins(fname);
2062
2063         // always autodetect, menu_sync_config will override as needed
2064         Config.PsxAuto = 1;
2065
2066         if (CheckCdrom() == -1) {
2067                 // Only check the CD if we are starting the console with a CD
2068                 ClosePlugins();
2069                 menu_update_msg("unsupported/invalid CD image");
2070                 return -1;
2071         }
2072
2073         SysReset();
2074
2075         // Read main executable directly from CDRom and start it
2076         if (LoadCdrom() == -1) {
2077                 ClosePlugins();
2078                 menu_update_msg("failed to load CD image");
2079                 return -1;
2080         }
2081
2082         emu_on_new_cd(1);
2083         ready_to_go = 1;
2084
2085         if (autoload_state) {
2086                 unsigned int newest = 0;
2087                 int time, slot, newest_slot = -1;
2088
2089                 for (slot = 0; slot < 10; slot++) {
2090                         if (emu_check_save_file(slot, &time)) {
2091                                 if ((unsigned int)time > newest) {
2092                                         newest = time;
2093                                         newest_slot = slot;
2094                                 }
2095                         }
2096                 }
2097
2098                 if (newest_slot >= 0) {
2099                         lprintf("autoload slot %d\n", newest_slot);
2100                         emu_load_state(newest_slot);
2101                 }
2102                 else {
2103                         lprintf("no save to autoload.\n");
2104                 }
2105         }
2106
2107         return 0;
2108 }
2109
2110 static int romsel_run(void)
2111 {
2112         int prev_gpu, prev_spu;
2113         const char *fname;
2114
2115         fname = menu_loop_romsel(last_selected_fname,
2116                         sizeof(last_selected_fname), filter_exts,
2117                         optional_cdimg_filter);
2118         if (fname == NULL)
2119                 return -1;
2120
2121         printf("selected file: %s\n", fname);
2122
2123         new_dynarec_clear_full();
2124
2125         if (run_cd_image(fname) != 0)
2126                 return -1;
2127
2128         prev_gpu = gpu_plugsel;
2129         prev_spu = spu_plugsel;
2130         if (menu_load_config(1) != 0)
2131                 menu_load_config(0);
2132
2133         // check for plugin changes, have to repeat
2134         // loading if game config changed plugins to reload them
2135         if (prev_gpu != gpu_plugsel || prev_spu != spu_plugsel) {
2136                 printf("plugin change detected, reloading plugins..\n");
2137                 if (run_cd_image(fname) != 0)
2138                         return -1;
2139         }
2140
2141         strcpy(last_selected_fname, fname);
2142         menu_do_last_cd_img(0);
2143         return 0;
2144 }
2145
2146 static int swap_cd_image(void)
2147 {
2148         const char *fname;
2149
2150         fname = menu_loop_romsel(last_selected_fname,
2151                         sizeof(last_selected_fname), filter_exts,
2152                         optional_cdimg_filter);
2153         if (fname == NULL)
2154                 return -1;
2155
2156         printf("selected file: %s\n", fname);
2157
2158         CdromId[0] = '\0';
2159         CdromLabel[0] = '\0';
2160
2161         set_cd_image(fname);
2162         if (ReloadCdromPlugin() < 0) {
2163                 menu_update_msg("failed to load cdr plugin");
2164                 return -1;
2165         }
2166         if (CDR_open() < 0) {
2167                 menu_update_msg("failed to open cdr plugin");
2168                 return -1;
2169         }
2170
2171         SetCdOpenCaseTime(time(NULL) + 2);
2172         LidInterrupt();
2173
2174         strcpy(last_selected_fname, fname);
2175         return 0;
2176 }
2177
2178 static int swap_cd_multidisk(void)
2179 {
2180         cdrIsoMultidiskSelect++;
2181         CdromId[0] = '\0';
2182         CdromLabel[0] = '\0';
2183
2184         CDR_close();
2185         if (CDR_open() < 0) {
2186                 menu_update_msg("failed to open cdr plugin");
2187                 return -1;
2188         }
2189
2190         SetCdOpenCaseTime(time(NULL) + 2);
2191         LidInterrupt();
2192
2193         return 0;
2194 }
2195
2196 static void load_pcsx_cht(void)
2197 {
2198         static const char *exts[] = { "cht", NULL };
2199         const char *fname;
2200         char msg[64];
2201
2202         fname = menu_loop_romsel(last_selected_fname,
2203                         sizeof(last_selected_fname), exts, NULL);
2204         if (fname == NULL)
2205                 return;
2206
2207         printf("selected cheat file: %s\n", fname);
2208         LoadCheats(fname);
2209
2210         if (NumCheats == 0 && NumCodes == 0)
2211                 menu_update_msg("failed to load cheats");
2212         else {
2213                 snprintf(msg, sizeof(msg), "%d cheat(s) loaded", NumCheats + NumCodes);
2214                 menu_update_msg(msg);
2215         }
2216         me_enable(e_menu_main, MA_MAIN_CHEATS, ready_to_go && NumCheats);
2217 }
2218
2219 static int main_menu_handler(int id, int keys)
2220 {
2221         switch (id)
2222         {
2223         case MA_MAIN_RESUME_GAME:
2224                 if (ready_to_go)
2225                         return 1;
2226                 break;
2227         case MA_MAIN_SAVE_STATE:
2228                 if (ready_to_go)
2229                         return menu_loop_savestate(0);
2230                 break;
2231         case MA_MAIN_LOAD_STATE:
2232                 if (ready_to_go)
2233                         return menu_loop_savestate(1);
2234                 break;
2235         case MA_MAIN_RESET_GAME:
2236                 if (ready_to_go && reset_game() == 0)
2237                         return 1;
2238                 break;
2239         case MA_MAIN_LOAD_ROM:
2240                 if (romsel_run() == 0)
2241                         return 1;
2242                 break;
2243         case MA_MAIN_SWAP_CD:
2244                 if (swap_cd_image() == 0)
2245                         return 1;
2246                 break;
2247         case MA_MAIN_SWAP_CD_MULTI:
2248                 if (swap_cd_multidisk() == 0)
2249                         return 1;
2250                 break;
2251         case MA_MAIN_RUN_BIOS:
2252                 if (run_bios() == 0)
2253                         return 1;
2254                 break;
2255         case MA_MAIN_RUN_EXE:
2256                 if (run_exe() == 0)
2257                         return 1;
2258                 break;
2259         case MA_MAIN_CHEATS:
2260                 menu_loop_cheats();
2261                 break;
2262         case MA_MAIN_LOAD_CHEATS:
2263                 load_pcsx_cht();
2264                 break;
2265         case MA_MAIN_CREDITS:
2266                 draw_menu_message(credits_text, draw_frame_credits);
2267                 in_menu_wait(PBTN_MOK|PBTN_MBACK, NULL, 70);
2268                 break;
2269         case MA_MAIN_EXIT:
2270                 emu_core_ask_exit();
2271                 return 1;
2272         default:
2273                 lprintf("%s: something unknown selected\n", __FUNCTION__);
2274                 break;
2275         }
2276
2277         return 0;
2278 }
2279
2280 static menu_entry e_menu_main2[] =
2281 {
2282         mee_handler_id("Change CD image",    MA_MAIN_SWAP_CD,       main_menu_handler),
2283         mee_handler_id("Next multidisk CD",  MA_MAIN_SWAP_CD_MULTI, main_menu_handler),
2284         mee_handler_id("Run BIOS",           MA_MAIN_RUN_BIOS,      main_menu_handler),
2285         mee_handler_id("Run EXE",            MA_MAIN_RUN_EXE,       main_menu_handler),
2286         mee_handler   ("Memcard manager",    menu_loop_memcards),
2287         mee_handler_id("Load PCSX cheats..", MA_MAIN_LOAD_CHEATS,   main_menu_handler),
2288         mee_end,
2289 };
2290
2291 static int main_menu2_handler(int id, int keys)
2292 {
2293         static int sel = 0;
2294
2295         me_enable(e_menu_main2, MA_MAIN_SWAP_CD,  ready_to_go);
2296         me_enable(e_menu_main2, MA_MAIN_SWAP_CD_MULTI, ready_to_go && cdrIsoMultidiskCount > 1);
2297         me_enable(e_menu_main2, MA_MAIN_RUN_BIOS, bios_sel != 0);
2298         me_enable(e_menu_main2, MA_MAIN_LOAD_CHEATS, ready_to_go);
2299
2300         return me_loop_d(e_menu_main2, &sel, NULL, draw_frame_main);
2301 }
2302
2303 static const char h_extra[] = "Change CD, manage memcards..\n";
2304
2305 static menu_entry e_menu_main[] =
2306 {
2307         mee_label     (""),
2308         mee_label     (""),
2309         mee_handler_id("Resume game",        MA_MAIN_RESUME_GAME, main_menu_handler),
2310         mee_handler_id("Save State",         MA_MAIN_SAVE_STATE,  main_menu_handler),
2311         mee_handler_id("Load State",         MA_MAIN_LOAD_STATE,  main_menu_handler),
2312         mee_handler_id("Reset game",         MA_MAIN_RESET_GAME,  main_menu_handler),
2313         mee_handler_id("Load CD image",      MA_MAIN_LOAD_ROM,    main_menu_handler),
2314         mee_handler   ("Options",            menu_loop_options),
2315         mee_handler   ("Controls",           menu_loop_keyconfig),
2316         mee_handler_id("Cheats",             MA_MAIN_CHEATS,      main_menu_handler),
2317         mee_handler_h ("Extra stuff",        main_menu2_handler,  h_extra),
2318         mee_handler_id("Credits",            MA_MAIN_CREDITS,     main_menu_handler),
2319         mee_handler_id("Exit",               MA_MAIN_EXIT,        main_menu_handler),
2320         mee_end,
2321 };
2322
2323 // ----------------------------
2324
2325 static void menu_leave_emu(void);
2326
2327 void menu_loop(void)
2328 {
2329         static int warned_about_bios = 0;
2330         static int sel = 0;
2331
2332         menu_leave_emu();
2333
2334         if (config_save_counter == 0) {
2335                 // assume first run
2336                 if (bioses[1] != NULL) {
2337                         // autoselect BIOS to make user's life easier
2338                         snprintf(Config.Bios, sizeof(Config.Bios), "%s", bioses[1]);
2339                         bios_sel = 1;
2340                 }
2341                 else if (!warned_about_bios) {
2342                         menu_bios_warn();
2343                         warned_about_bios = 1;
2344                 }
2345         }
2346
2347         me_enable(e_menu_main, MA_MAIN_RESUME_GAME, ready_to_go);
2348         me_enable(e_menu_main, MA_MAIN_SAVE_STATE,  ready_to_go && CdromId[0]);
2349         me_enable(e_menu_main, MA_MAIN_LOAD_STATE,  ready_to_go && CdromId[0]);
2350         me_enable(e_menu_main, MA_MAIN_RESET_GAME,  ready_to_go);
2351         me_enable(e_menu_main, MA_MAIN_CHEATS,      ready_to_go && NumCheats);
2352
2353         in_set_config_int(0, IN_CFG_BLOCKING, 1);
2354
2355         do {
2356                 me_loop_d(e_menu_main, &sel, NULL, draw_frame_main);
2357         } while (!ready_to_go && !g_emu_want_quit);
2358
2359         /* wait until menu, ok, back is released */
2360         while (in_menu_wait_any(NULL, 50) & (PBTN_MENU|PBTN_MOK|PBTN_MBACK))
2361                 ;
2362
2363         in_set_config_int(0, IN_CFG_BLOCKING, 0);
2364
2365         menu_prepare_emu();
2366 }
2367
2368 static int qsort_strcmp(const void *p1, const void *p2)
2369 {
2370         char * const *s1 = (char * const *)p1;
2371         char * const *s2 = (char * const *)p2;
2372         return strcasecmp(*s1, *s2);
2373 }
2374
2375 static void scan_bios_plugins(void)
2376 {
2377         char fname[MAXPATHLEN];
2378         struct dirent *ent;
2379         int bios_i, gpu_i, spu_i, mc_i;
2380         char *p;
2381         DIR *dir;
2382
2383         bioses[0] = "HLE";
2384         gpu_plugins[0] = "builtin_gpu";
2385         spu_plugins[0] = "builtin_spu";
2386         memcards[0] = "(none)";
2387         bios_i = gpu_i = spu_i = mc_i = 1;
2388
2389         snprintf(fname, sizeof(fname), "%s/", Config.BiosDir);
2390         dir = opendir(fname);
2391         if (dir == NULL) {
2392                 perror("scan_bios_plugins bios opendir");
2393                 goto do_plugins;
2394         }
2395
2396         while (1) {
2397                 struct stat st;
2398
2399                 errno = 0;
2400                 ent = readdir(dir);
2401                 if (ent == NULL) {
2402                         if (errno != 0)
2403                                 perror("readdir");
2404                         break;
2405                 }
2406
2407                 if (ent->d_type != DT_REG && ent->d_type != DT_LNK)
2408                         continue;
2409
2410                 snprintf(fname, sizeof(fname), "%s/%s", Config.BiosDir, ent->d_name);
2411                 if (stat(fname, &st) != 0 || st.st_size != 512*1024) {
2412                         printf("bad BIOS file: %s\n", ent->d_name);
2413                         continue;
2414                 }
2415
2416                 if (bios_i < ARRAY_SIZE(bioses) - 1) {
2417                         bioses[bios_i++] = strdup(ent->d_name);
2418                         continue;
2419                 }
2420
2421                 printf("too many BIOSes, dropping \"%s\"\n", ent->d_name);
2422         }
2423
2424         closedir(dir);
2425
2426 do_plugins:
2427         snprintf(fname, sizeof(fname), "%s/", Config.PluginsDir);
2428         dir = opendir(fname);
2429         if (dir == NULL) {
2430                 perror("scan_bios_plugins plugins opendir");
2431                 goto do_memcards;
2432         }
2433
2434         while (1) {
2435                 void *h, *tmp;
2436
2437                 errno = 0;
2438                 ent = readdir(dir);
2439                 if (ent == NULL) {
2440                         if (errno != 0)
2441                                 perror("readdir");
2442                         break;
2443                 }
2444                 p = strstr(ent->d_name, ".so");
2445                 if (p == NULL)
2446                         continue;
2447
2448                 snprintf(fname, sizeof(fname), "%s/%s", Config.PluginsDir, ent->d_name);
2449                 h = dlopen(fname, RTLD_LAZY | RTLD_LOCAL);
2450                 if (h == NULL) {
2451                         fprintf(stderr, "%s\n", dlerror());
2452                         continue;
2453                 }
2454
2455                 // now what do we have here?
2456                 tmp = dlsym(h, "GPUinit");
2457                 if (tmp) {
2458                         dlclose(h);
2459                         if (gpu_i < ARRAY_SIZE(gpu_plugins) - 1)
2460                                 gpu_plugins[gpu_i++] = strdup(ent->d_name);
2461                         continue;
2462                 }
2463
2464                 tmp = dlsym(h, "SPUinit");
2465                 if (tmp) {
2466                         dlclose(h);
2467                         if (spu_i < ARRAY_SIZE(spu_plugins) - 1)
2468                                 spu_plugins[spu_i++] = strdup(ent->d_name);
2469                         continue;
2470                 }
2471
2472                 fprintf(stderr, "ignoring unidentified plugin: %s\n", fname);
2473                 dlclose(h);
2474         }
2475
2476         closedir(dir);
2477
2478 do_memcards:
2479         dir = opendir("." MEMCARD_DIR);
2480         if (dir == NULL) {
2481                 perror("scan_bios_plugins memcards opendir");
2482                 return;
2483         }
2484
2485         while (1) {
2486                 struct stat st;
2487
2488                 errno = 0;
2489                 ent = readdir(dir);
2490                 if (ent == NULL) {
2491                         if (errno != 0)
2492                                 perror("readdir");
2493                         break;
2494                 }
2495
2496                 if (ent->d_type != DT_REG && ent->d_type != DT_LNK)
2497                         continue;
2498
2499                 snprintf(fname, sizeof(fname), "." MEMCARD_DIR "%s", ent->d_name);
2500                 if (stat(fname, &st) != 0) {
2501                         printf("bad memcard file: %s\n", ent->d_name);
2502                         continue;
2503                 }
2504
2505                 if (mc_i < ARRAY_SIZE(memcards) - 1) {
2506                         memcards[mc_i++] = strdup(ent->d_name);
2507                         continue;
2508                 }
2509
2510                 printf("too many memcards, dropping \"%s\"\n", ent->d_name);
2511         }
2512
2513         if (mc_i > 2)
2514                 qsort(memcards + 1, mc_i - 1, sizeof(memcards[0]), qsort_strcmp);
2515
2516         closedir(dir);
2517 }
2518
2519 void menu_init(void)
2520 {
2521         char buff[MAXPATHLEN];
2522         int i;
2523
2524         cpu_clock_st = cpu_clock = plat_target_cpu_clock_get();
2525
2526         scan_bios_plugins();
2527         menu_init_base();
2528
2529         menu_set_defconfig();
2530         menu_load_config(0);
2531         menu_do_last_cd_img(1);
2532         last_vout_w = 320;
2533         last_vout_h = 240;
2534         last_vout_bpp = 16;
2535
2536         g_menubg_src_ptr = calloc(g_menuscreen_w * g_menuscreen_h * 2, 1);
2537         g_menubg_ptr = calloc(g_menuscreen_w * g_menuscreen_h * 2, 1);
2538         if (g_menubg_src_ptr == NULL || g_menubg_ptr == NULL) {
2539                 fprintf(stderr, "OOM\n");
2540                 exit(1);
2541         }
2542
2543         emu_make_path(buff, "skin/background.png", sizeof(buff));
2544         readpng(g_menubg_src_ptr, buff, READPNG_BG, g_menuscreen_w, g_menuscreen_h);
2545
2546         i = plat_target.cpu_clock_set != NULL
2547                 && plat_target.cpu_clock_get != NULL && cpu_clock_st > 0;
2548         me_enable(e_menu_gfx_options, MA_OPT_CPU_CLOCKS, i);
2549
2550         i = me_id2offset(e_menu_gfx_options, MA_OPT_VOUT_MODE);
2551         e_menu_gfx_options[i].data = plat_target.vout_methods;
2552         me_enable(e_menu_gfx_options, MA_OPT_VOUT_MODE,
2553                 plat_target.vout_methods != NULL);
2554
2555         i = me_id2offset(e_menu_gfx_options, MA_OPT_HWFILTER);
2556         e_menu_gfx_options[i].data = plat_target.hwfilters;
2557         me_enable(e_menu_gfx_options, MA_OPT_HWFILTER,
2558                 plat_target.hwfilters != NULL);
2559
2560         me_enable(e_menu_gfx_options, MA_OPT_GAMMA,
2561                 plat_target.gamma_set != NULL);
2562
2563 #ifdef HAVE_PRE_ARMV7
2564         me_enable(e_menu_gfx_options, MA_OPT_SWFILTER, 0);
2565 #endif
2566         me_enable(e_menu_gfx_options, MA_OPT_VARSCALER, MENU_SHOW_VARSCALER);
2567         me_enable(e_menu_gfx_options, MA_OPT_VOUT_MODE, MENU_SHOW_VOUTMODE);
2568         me_enable(e_menu_gfx_options, MA_OPT_VARSCALER_C, MENU_SHOW_VARSCALER);
2569         me_enable(e_menu_gfx_options, MA_OPT_SCALER2, MENU_SHOW_SCALER2);
2570         me_enable(e_menu_keyconfig, MA_CTRL_NUBS_BTNS, MENU_SHOW_NUBS_BTNS);
2571         me_enable(e_menu_keyconfig, MA_CTRL_VIBRATION, MENU_SHOW_VIBRATION);
2572         me_enable(e_menu_keyconfig, MA_CTRL_DEADZONE, MENU_SHOW_DEADZONE);
2573 }
2574
2575 void menu_notify_mode_change(int w, int h, int bpp)
2576 {
2577         last_vout_w = w;
2578         last_vout_h = h;
2579         last_vout_bpp = bpp;
2580 }
2581
2582 static void menu_leave_emu(void)
2583 {
2584         if (GPU_close != NULL) {
2585                 int ret = GPU_close();
2586                 if (ret)
2587                         fprintf(stderr, "Warning: GPU_close returned %d\n", ret);
2588         }
2589
2590         plat_video_menu_enter(ready_to_go);
2591
2592         memcpy(g_menubg_ptr, g_menubg_src_ptr, g_menuscreen_w * g_menuscreen_h * 2);
2593         if (pl_vout_buf != NULL && ready_to_go) {
2594                 int x = max(0, g_menuscreen_w - last_vout_w);
2595                 int y = max(0, g_menuscreen_h / 2 - last_vout_h / 2);
2596                 int w = min(g_menuscreen_w, last_vout_w);
2597                 int h = min(g_menuscreen_h, last_vout_h);
2598                 u16 *d = (u16 *)g_menubg_ptr + g_menuscreen_w * y + x;
2599                 char *s = pl_vout_buf;
2600
2601                 if (last_vout_bpp == 16) {
2602                         for (; h > 0; h--, d += g_menuscreen_w, s += last_vout_w * 2)
2603                                 menu_darken_bg(d, s, w, 0);
2604                 }
2605                 else {
2606                         for (; h > 0; h--, d += g_menuscreen_w, s += last_vout_w * 3) {
2607                                 rgb888_to_rgb565(d, s, w * 3);
2608                                 menu_darken_bg(d, d, w, 0);
2609                         }
2610                 }
2611         }
2612
2613         if (ready_to_go)
2614                 cpu_clock = plat_target_cpu_clock_get();
2615 }
2616
2617 void menu_prepare_emu(void)
2618 {
2619         R3000Acpu *prev_cpu = psxCpu;
2620
2621         plat_video_menu_leave();
2622
2623         #if !defined(DRC_DISABLE) || defined(LIGHTREC)
2624         psxCpu = (Config.Cpu == CPU_INTERPRETER) ? &psxInt : &psxRec;
2625         #else
2626         psxCpu = &psxInt;
2627         #endif
2628         if (psxCpu != prev_cpu) {
2629                 prev_cpu->Shutdown();
2630                 psxCpu->Init();
2631                 // note that this does not really reset, just clears drc caches
2632                 psxCpu->Reset();
2633         }
2634
2635         menu_sync_config();
2636         psxCpu->ApplyConfig();
2637
2638         // core doesn't care about Config.Cdda changes,
2639         // so handle them manually here
2640         if (Config.Cdda)
2641                 CDR_stop();
2642
2643         if (cpu_clock > 0)
2644                 plat_target_cpu_clock_set(cpu_clock);
2645
2646         // push config to GPU plugin
2647         plugin_call_rearmed_cbs();
2648
2649         if (GPU_open != NULL) {
2650                 int ret = GPU_open(&gpuDisp, "PCSX", NULL);
2651                 if (ret)
2652                         fprintf(stderr, "Warning: GPU_open returned %d\n", ret);
2653         }
2654
2655         dfinput_activate();
2656 }
2657
2658 void menu_update_msg(const char *msg)
2659 {
2660         strncpy(menu_error_msg, msg, sizeof(menu_error_msg));
2661         menu_error_msg[sizeof(menu_error_msg) - 1] = 0;
2662
2663         menu_error_time = plat_get_ticks_ms();
2664         lprintf("msg: %s\n", menu_error_msg);
2665 }
2666
2667 void menu_finish(void)
2668 {
2669         if (cpu_clock_st > 0)
2670                 plat_target_cpu_clock_set(cpu_clock_st);
2671 }