frontend/menu.c

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