2 * (C) GraÅžvydas "notaz" Ignotas, 2010-2015
4 * This work is licensed under the terms of any of these licenses
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.
22 #include <sys/types.h>
31 #include "plugin_lib.h"
35 #include "libpicofe/plat.h"
36 #include "libpicofe/input.h"
37 #include "libpicofe/linux/in_evdev.h"
38 #include "libpicofe/plat.h"
39 #include "../libpcsxcore/misc.h"
40 #include "../libpcsxcore/cdrom.h"
41 #include "../libpcsxcore/cdriso.h"
42 #include "../libpcsxcore/cheat.h"
43 #include "../libpcsxcore/new_dynarec/new_dynarec.h"
44 #include "../plugins/dfsound/spu_config.h"
45 #include "psemu_plugin_defs.h"
46 #include "arm_features.h"
49 #define REARMED_BIRTHDAY_TIME 1293306830 /* 25 Dec 2010 */
51 #define array_size(x) (sizeof(x) / sizeof(x[0]))
62 MA_MAIN_SWAP_CD_MULTI,
93 MA_OPT_SCANLINE_LEVEL,
97 static int last_vout_w, last_vout_h, last_vout_bpp;
98 static int cpu_clock, cpu_clock_st, volume_boost;
99 static int frameskip = 1; // 0 - auto, 1 - off
100 static char last_selected_fname[MAXPATHLEN];
101 static int config_save_counter, region, in_type_sel1, in_type_sel2;
102 static int psx_clock;
103 static int memcard1_sel = -1, memcard2_sel = -1;
104 extern int g_autostateld_opt;
105 static int menu_iopts[8];
106 int g_opts, g_scaler, g_gamma = 100;
107 int scanlines, scanline_level = 20;
108 int soft_scaling, analog_deadzone; // for Caanoo
111 #ifndef HAVE_PRE_ARMV7
112 #define DEFAULT_PSX_CLOCK (10000 / CYCLE_MULT_DEFAULT)
113 #define DEFAULT_PSX_CLOCK_S "57"
115 #define DEFAULT_PSX_CLOCK 50
116 #define DEFAULT_PSX_CLOCK_S "50"
119 static const char *bioses[32];
120 static const char *gpu_plugins[16];
121 static const char *spu_plugins[16];
122 static const char *memcards[32];
123 static int bios_sel, gpu_plugsel, spu_plugsel;
125 #ifndef UI_FEATURES_H
126 #define MENU_BIOS_PATH "bios/"
127 #define MENU_SHOW_VARSCALER 0
128 #define MENU_SHOW_VOUTMODE 1
129 #define MENU_SHOW_SCALER2 0
130 #define MENU_SHOW_NUBS_BTNS 0
131 #define MENU_SHOW_VIBRATION 0
132 #define MENU_SHOW_DEADZONE 0
133 #define MENU_SHOW_MINIMIZE 0
134 #define MENU_SHOW_FULLSCREEN 1
135 #define MENU_SHOW_VOLUME 0
138 static int min(int x, int y) { return x < y ? x : y; }
139 static int max(int x, int y) { return x > y ? x : y; }
141 void emu_make_path(char *buff, const char *end, int size)
145 end_len = strlen(end);
146 pos = plat_get_root_dir(buff, size);
147 strncpy(buff + pos, end, size - pos);
149 if (pos + end_len > size - 1)
150 printf("Warning: path truncated: %s\n", buff);
153 static int emu_check_save_file(int slot, int *time)
155 char fname[MAXPATHLEN];
159 ret = emu_check_state(slot);
160 if (ret != 0 || time == NULL)
161 return ret == 0 ? 1 : 0;
163 ret = get_state_filename(fname, sizeof(fname), slot);
167 ret = stat(fname, &status);
171 if (status.st_mtime < REARMED_BIRTHDAY_TIME)
172 return 1; // probably bad rtc like on some Caanoos
174 *time = status.st_mtime;
179 static int emu_save_load_game(int load, int unused)
184 ret = emu_load_state(state_slot);
186 // reflect hle/bios mode from savestate
189 else if (bios_sel == 0 && bioses[1] != NULL)
190 // XXX: maybe find the right bios instead
194 ret = emu_save_state(state_slot);
199 static void rm_namelist_entry(struct dirent **namelist,
200 int count, const char *name)
204 for (i = 1; i < count; i++) {
205 if (namelist[i] == NULL || namelist[i]->d_type == DT_DIR)
208 if (strcmp(name, namelist[i]->d_name) == 0) {
216 static int optional_cdimg_filter(struct dirent **namelist, int count,
220 char buf[256], buf2[256];
221 int i, d, ret, good_cue;
228 for (i = 1; i < count; i++) {
229 if (namelist[i] == NULL || namelist[i]->d_type == DT_DIR)
232 ext = strrchr(namelist[i]->d_name, '.');
234 // should not happen but whatever
241 // first find .cue files and remove files they reference
242 if (strcasecmp(ext, "cue") == 0)
244 snprintf(buf, sizeof(buf), "%s/%s", basedir,
245 namelist[i]->d_name);
255 while (fgets(buf, sizeof(buf), f)) {
256 ret = sscanf(buf, " FILE \"%256[^\"]\"", buf2);
258 ret = sscanf(buf, " FILE %256s", buf2);
262 p = strrchr(buf2, '/');
264 p = strrchr(buf2, '\\');
270 snprintf(buf, sizeof(buf), "%s/%s", basedir, p);
271 ret = STAT(buf, &statf);
273 rm_namelist_entry(namelist, count, p);
286 p = strcasestr(namelist[i]->d_name, "track");
288 ret = strtoul(p + 5, NULL, 10);
298 for (i = d = 1; i < count; i++)
299 if (namelist[i] != NULL)
300 namelist[d++] = namelist[i];
305 // propagate menu settings to the emu vars
306 static void menu_sync_config(void)
308 static int allow_abs_only_old;
313 Config.PsxType = region - 1;
315 Config.cycle_multiplier = 10000 / psx_clock;
317 switch (in_type_sel1) {
318 case 1: in_type[0] = PSE_PAD_TYPE_ANALOGPAD; break;
319 case 2: in_type[0] = PSE_PAD_TYPE_NEGCON; break;
320 case 3: in_type[0] = PSE_PAD_TYPE_NONE; break;
321 default: in_type[0] = PSE_PAD_TYPE_STANDARD;
323 switch (in_type_sel2) {
324 case 1: in_type[1] = PSE_PAD_TYPE_ANALOGPAD; break;
325 case 2: in_type[1] = PSE_PAD_TYPE_NEGCON; break;
326 case 3: in_type[1] = PSE_PAD_TYPE_NONE; break;
327 default: in_type[1] = PSE_PAD_TYPE_STANDARD;
329 if (in_evdev_allow_abs_only != allow_abs_only_old) {
331 allow_abs_only_old = in_evdev_allow_abs_only;
334 spu_config.iVolume = 768 + 128 * volume_boost;
335 pl_rearmed_cbs.frameskip = frameskip - 1;
336 pl_timing_prepare(Config.PsxType);
339 static void menu_set_defconfig(void)
341 emu_set_default_config();
344 g_scaler = SCALE_4_3;
347 frameskip = 1; // 1 - off
348 analog_deadzone = 50;
353 plat_target.vout_fullscreen = 0;
354 psx_clock = DEFAULT_PSX_CLOCK;
357 in_type_sel1 = in_type_sel2 = 0;
358 in_evdev_allow_abs_only = 0;
363 #define CE_CONFIG_STR(val) \
364 { #val, 0, Config.val }
366 #define CE_CONFIG_VAL(val) \
367 { #val, sizeof(Config.val), &Config.val }
369 #define CE_STR(val) \
372 #define CE_INTVAL(val) \
373 { #val, sizeof(val), &val }
375 #define CE_INTVAL_N(name, val) \
376 { name, sizeof(val), &val }
378 #define CE_INTVAL_P(val) \
379 { #val, sizeof(pl_rearmed_cbs.val), &pl_rearmed_cbs.val }
381 // 'versioned' var, used when defaults change
382 #define CE_CONFIG_STR_V(val, ver) \
383 { #val #ver, 0, Config.val }
385 #define CE_INTVAL_V(val, ver) \
386 { #val #ver, sizeof(val), &val }
388 #define CE_INTVAL_PV(val, ver) \
389 { #val #ver, sizeof(pl_rearmed_cbs.val), &pl_rearmed_cbs.val }
391 static const struct {
397 CE_CONFIG_STR_V(Gpu, 3),
399 // CE_CONFIG_STR(Cdr),
403 CE_CONFIG_VAL(Debug),
404 CE_CONFIG_VAL(PsxOut),
405 CE_CONFIG_VAL(icache_emulation),
406 CE_CONFIG_VAL(DisableStalls),
408 CE_CONFIG_VAL(GpuListWalking),
409 CE_CONFIG_VAL(PreciseExceptions),
411 CE_INTVAL_V(g_scaler, 3),
413 CE_INTVAL(g_layer_x),
414 CE_INTVAL(g_layer_y),
415 CE_INTVAL(g_layer_w),
416 CE_INTVAL(g_layer_h),
417 CE_INTVAL(soft_filter),
418 CE_INTVAL(scanlines),
419 CE_INTVAL(scanline_level),
420 CE_INTVAL(plat_target.vout_method),
421 CE_INTVAL(plat_target.hwfilter),
422 CE_INTVAL(plat_target.vout_fullscreen),
423 CE_INTVAL(state_slot),
424 CE_INTVAL(cpu_clock),
426 CE_INTVAL(in_type_sel1),
427 CE_INTVAL(in_type_sel2),
428 CE_INTVAL(analog_deadzone),
429 CE_INTVAL(memcard1_sel),
430 CE_INTVAL(memcard2_sel),
431 CE_INTVAL(g_autostateld_opt),
432 CE_INTVAL_N("adev0_is_nublike", in_adev_is_nublike[0]),
433 CE_INTVAL_N("adev1_is_nublike", in_adev_is_nublike[1]),
434 CE_INTVAL_V(frameskip, 4),
435 CE_INTVAL_P(gpu_peops.iUseDither),
436 CE_INTVAL_P(gpu_peops.dwActFixes),
437 CE_INTVAL_P(gpu_unai.lineskip),
438 CE_INTVAL_P(gpu_unai.abe_hack),
439 CE_INTVAL_P(gpu_unai.no_light),
440 CE_INTVAL_P(gpu_unai.no_blend),
442 CE_INTVAL_P(gpu_senquack.ilace_force),
443 CE_INTVAL_P(gpu_senquack.pixel_skip),
444 CE_INTVAL_P(gpu_senquack.lighting),
445 CE_INTVAL_P(gpu_senquack.fast_lighting),
446 CE_INTVAL_P(gpu_senquack.blending),
447 CE_INTVAL_P(gpu_senquack.dithering),
448 CE_INTVAL_P(gpu_senquack.scale_hires),
450 CE_INTVAL_P(gpu_neon.allow_interlace),
451 CE_INTVAL_P(gpu_neon.enhancement_enable),
452 CE_INTVAL_P(gpu_neon.enhancement_no_main),
453 CE_INTVAL_P(gpu_peopsgl.bDrawDither),
454 CE_INTVAL_P(gpu_peopsgl.iFilterType),
455 CE_INTVAL_P(gpu_peopsgl.iFrameTexType),
456 CE_INTVAL_P(gpu_peopsgl.iUseMask),
457 CE_INTVAL_P(gpu_peopsgl.bOpaquePass),
458 CE_INTVAL_P(gpu_peopsgl.bAdvancedBlend),
459 CE_INTVAL_P(gpu_peopsgl.bUseFastMdec),
460 CE_INTVAL_P(gpu_peopsgl.iVRamSize),
461 CE_INTVAL_P(gpu_peopsgl.iTexGarbageCollection),
462 CE_INTVAL_P(gpu_peopsgl.dwActFixes),
463 CE_INTVAL_P(screen_centering_type),
464 CE_INTVAL_P(screen_centering_x),
465 CE_INTVAL_P(screen_centering_y),
466 CE_INTVAL(spu_config.iUseReverb),
467 CE_INTVAL(spu_config.iXAPitch),
468 CE_INTVAL(spu_config.iUseInterpolation),
469 CE_INTVAL(spu_config.iTempo),
470 CE_INTVAL(spu_config.iUseThread),
471 CE_INTVAL(config_save_counter),
472 CE_INTVAL(in_evdev_allow_abs_only),
473 CE_INTVAL(volume_boost),
474 CE_INTVAL(psx_clock),
475 CE_INTVAL(new_dynarec_hacks),
476 CE_INTVAL(in_enable_vibration),
479 static char *get_cd_label(void)
481 static char trimlabel[33];
484 strncpy(trimlabel, CdromLabel, 32);
486 for (j = 31; j >= 0; j--)
487 if (trimlabel[j] == ' ')
493 static void make_cfg_fname(char *buf, size_t size, int is_game)
496 snprintf(buf, size, "." PCSX_DOT_DIR "cfg/%.32s-%.9s.cfg", get_cd_label(), CdromId);
498 snprintf(buf, size, "." PCSX_DOT_DIR "%s", cfgfile_basename);
501 static void keys_write_all(FILE *f);
502 static char *mystrip(char *str);
504 static int menu_write_config(int is_game)
506 char cfgfile[MAXPATHLEN];
510 config_save_counter++;
512 make_cfg_fname(cfgfile, sizeof(cfgfile), is_game);
513 f = fopen(cfgfile, "w");
515 printf("menu_write_config: failed to open: %s\n", cfgfile);
519 for (i = 0; i < ARRAY_SIZE(config_data); i++) {
520 fprintf(f, "%s = ", config_data[i].name);
521 switch (config_data[i].len) {
523 fprintf(f, "%s\n", (char *)config_data[i].val);
526 fprintf(f, "%x\n", *(u8 *)config_data[i].val);
529 fprintf(f, "%x\n", *(u16 *)config_data[i].val);
532 fprintf(f, "%x\n", *(u32 *)config_data[i].val);
535 printf("menu_write_config: unhandled len %d for %s\n",
536 (int)config_data[i].len, config_data[i].name);
547 static int menu_do_last_cd_img(int is_get)
549 static const char *defaults[] = { "/media", "/mnt/sd", "/mnt" };
555 snprintf(path, sizeof(path), "." PCSX_DOT_DIR "lastcdimg.txt");
556 f = fopen(path, is_get ? "r" : "w");
563 ret = fread(last_selected_fname, 1, sizeof(last_selected_fname) - 1, f);
564 last_selected_fname[ret] = 0;
565 mystrip(last_selected_fname);
568 fprintf(f, "%s\n", last_selected_fname);
573 for (i = 0; last_selected_fname[0] == 0
574 || STAT(last_selected_fname, &st) != 0; i++)
576 if (i >= ARRAY_SIZE(defaults))
578 strcpy(last_selected_fname, defaults[i]);
585 static void parse_str_val(char *cval, const char *src)
588 strncpy(cval, src, MAXPATHLEN);
589 cval[MAXPATHLEN - 1] = 0;
590 tmp = strchr(cval, '\n');
592 tmp = strchr(cval, '\r');
597 static void keys_load_all(const char *cfg);
599 int menu_load_config(int is_game)
601 char cfgfile[MAXPATHLEN];
607 make_cfg_fname(cfgfile, sizeof(cfgfile), is_game);
608 f = fopen(cfgfile, "r");
610 printf("menu_load_config: failed to open: %s\n", cfgfile);
614 fseek(f, 0, SEEK_END);
617 printf("bad size %ld: %s\n", size, cfgfile);
621 cfg = malloc(size + 1);
625 fseek(f, 0, SEEK_SET);
626 if (fread(cfg, 1, size, f) != size) {
627 printf("failed to read: %s\n", cfgfile);
632 for (i = 0; i < ARRAY_SIZE(config_data); i++) {
636 tmp = strstr(cfg, config_data[i].name);
639 tmp += strlen(config_data[i].name);
640 if (strncmp(tmp, " = ", 3) != 0)
644 if (config_data[i].len == 0) {
645 parse_str_val(config_data[i].val, tmp);
650 val = strtoul(tmp, &tmp2, 16);
651 if (tmp2 == NULL || tmp == tmp2)
652 continue; // parse failed
654 switch (config_data[i].len) {
656 *(u8 *)config_data[i].val = val;
659 *(u16 *)config_data[i].val = val;
662 *(u32 *)config_data[i].val = val;
665 printf("menu_load_config: unhandled len %d for %s\n",
666 (int)config_data[i].len, config_data[i].name);
672 char *tmp = strstr(cfg, "lastcdimg = ");
675 parse_str_val(last_selected_fname, tmp);
690 for (i = bios_sel = 0; bioses[i] != NULL; i++)
691 if (strcmp(Config.Bios, bioses[i]) == 0)
692 { bios_sel = i; break; }
694 for (i = gpu_plugsel = 0; gpu_plugins[i] != NULL; i++)
695 if (strcmp(Config.Gpu, gpu_plugins[i]) == 0)
696 { gpu_plugsel = i; break; }
698 for (i = spu_plugsel = 0; spu_plugins[i] != NULL; i++)
699 if (strcmp(Config.Spu, spu_plugins[i]) == 0)
700 { spu_plugsel = i; break; }
702 // memcard selections
703 char mcd1_old[sizeof(Config.Mcd1)];
704 char mcd2_old[sizeof(Config.Mcd2)];
705 strcpy(mcd1_old, Config.Mcd1);
706 strcpy(mcd2_old, Config.Mcd2);
708 if ((unsigned int)memcard1_sel < ARRAY_SIZE(memcards)) {
709 if (memcard1_sel == 0)
710 strcpy(Config.Mcd1, "none");
711 else if (memcards[memcard1_sel] != NULL)
712 snprintf(Config.Mcd1, sizeof(Config.Mcd1), ".%s%s",
713 MEMCARD_DIR, memcards[memcard1_sel]);
715 if ((unsigned int)memcard2_sel < ARRAY_SIZE(memcards)) {
716 if (memcard2_sel == 0)
717 strcpy(Config.Mcd2, "none");
718 else if (memcards[memcard2_sel] != NULL)
719 snprintf(Config.Mcd2, sizeof(Config.Mcd2), ".%s%s",
720 MEMCARD_DIR, memcards[memcard2_sel]);
722 if (strcmp(mcd1_old, Config.Mcd1) || strcmp(mcd2_old, Config.Mcd2))
723 LoadMcds(Config.Mcd1, Config.Mcd2);
728 static const char *filter_exts[] = {
729 "bin", "img", "mdf", "iso", "cue", "z",
733 "bz", "znx", "pbp", "cbn", NULL
736 // rrrr rggg gggb bbbb
737 static unsigned short fname2color(const char *fname)
739 static const char *other_exts[] = {
740 "ccd", "toc", "mds", "sub", "table", "index", "sbi"
742 const char *ext = strrchr(fname, '.');
748 for (i = 0; filter_exts[i] != NULL; i++)
749 if (strcasecmp(ext, filter_exts[i]) == 0)
751 for (i = 0; i < array_size(other_exts); i++)
752 if (strcasecmp(ext, other_exts[i]) == 0)
757 static void draw_savestate_bg(int slot);
759 #define MENU_ALIGN_LEFT
760 #ifndef HAVE_PRE_ARMV7 // assume hires device
766 #include "libpicofe/menu.c"
768 // a bit of black magic here
769 static void draw_savestate_bg(int slot)
771 static const int psx_widths[8] = { 256, 368, 320, 384, 512, 512, 640, 640 };
773 char fname[MAXPATHLEN];
780 ret = get_state_filename(fname, sizeof(fname), slot);
784 f = gzopen(fname, "rb");
788 if ((ret = (int)gzseek(f, 0x29933d, SEEK_SET)) != 0x29933d) {
789 fprintf(stderr, "gzseek failed: %d\n", ret);
794 gpu = malloc(sizeof(*gpu));
800 ret = gzread(f, gpu, sizeof(*gpu));
802 if (ret != sizeof(*gpu)) {
803 fprintf(stderr, "gzread failed\n");
807 memcpy(g_menubg_ptr, g_menubg_src_ptr, g_menuscreen_w * g_menuscreen_h * 2);
809 if (gpu->ulStatus & 0x800000)
810 goto out; // disabled
812 x = gpu->ulControl[5] & 0x3ff;
813 y = (gpu->ulControl[5] >> 10) & 0x1ff;
814 w = psx_widths[(gpu->ulStatus >> 16) & 7];
815 tmp = gpu->ulControl[7];
816 h = ((tmp >> 10) & 0x3ff) - (tmp & 0x3ff);
817 if (gpu->ulStatus & 0x80000) // doubleheight
819 if (h <= 0 || h > 512)
825 s = (u16 *)gpu->psxVRam + y * 1024 + x;
827 x = max(0, g_menuscreen_w - w) & ~3;
828 y = max(0, g_menuscreen_h / 2 - h / 2);
829 w = min(g_menuscreen_w, w);
830 h = min(g_menuscreen_h, h);
831 d = (u16 *)g_menubg_ptr + g_menuscreen_w * y + x;
833 for (; h > 0; h--, d += g_menuscreen_w, s += 1024) {
834 if (gpu->ulStatus & 0x200000)
835 bgr888_to_rgb565(d, s, w * 3);
837 bgr555_to_rgb565(d, s, w * 2);
839 // darken this so that menu text is visible
840 if (g_menuscreen_w - w < 320)
841 menu_darken_bg(d, d, w, 0);
848 // -------------- key config --------------
850 me_bind_action me_ctrl_actions[] =
852 { "UP ", 1 << DKEY_UP},
853 { "DOWN ", 1 << DKEY_DOWN },
854 { "LEFT ", 1 << DKEY_LEFT },
855 { "RIGHT ", 1 << DKEY_RIGHT },
856 { "TRIANGLE", 1 << DKEY_TRIANGLE },
857 { "CIRCLE ", 1 << DKEY_CIRCLE },
858 { "CROSS ", 1 << DKEY_CROSS },
859 { "SQUARE ", 1 << DKEY_SQUARE },
860 { "L1 ", 1 << DKEY_L1 },
861 { "R1 ", 1 << DKEY_R1 },
862 { "L2 ", 1 << DKEY_L2 },
863 { "R2 ", 1 << DKEY_R2 },
864 { "L3 ", 1 << DKEY_L3 },
865 { "R3 ", 1 << DKEY_R3 },
866 { "START ", 1 << DKEY_START },
867 { "SELECT ", 1 << DKEY_SELECT },
871 me_bind_action emuctrl_actions[] =
873 { "Save State ", 1 << SACTION_SAVE_STATE },
874 { "Load State ", 1 << SACTION_LOAD_STATE },
875 { "Prev Save Slot ", 1 << SACTION_PREV_SSLOT },
876 { "Next Save Slot ", 1 << SACTION_NEXT_SSLOT },
877 { "Toggle Frameskip ", 1 << SACTION_TOGGLE_FSKIP },
878 { "Take Screenshot ", 1 << SACTION_SCREENSHOT },
879 { "Show/Hide FPS ", 1 << SACTION_TOGGLE_FPS },
880 #ifndef HAVE_PRE_ARMV7
881 { "Switch Renderer ", 1 << SACTION_SWITCH_DISPMODE },
883 { "Fast Forward ", 1 << SACTION_FAST_FORWARD },
884 #if MENU_SHOW_MINIMIZE
885 { "Minimize ", 1 << SACTION_MINIMIZE },
887 #if MENU_SHOW_FULLSCREEN
888 { "Toggle fullscreen", 1 << SACTION_TOGGLE_FULLSCREEN },
890 { "Enter Menu ", 1 << SACTION_ENTER_MENU },
891 { "Gun Trigger ", 1 << SACTION_GUN_TRIGGER },
892 { "Gun A button ", 1 << SACTION_GUN_A },
893 { "Gun B button ", 1 << SACTION_GUN_B },
894 { "Gun Offscreen Trigger", 1 << SACTION_GUN_TRIGGER2 },
896 { "Volume Up ", 1 << SACTION_VOLUME_UP },
897 { "Volume Down ", 1 << SACTION_VOLUME_DOWN },
902 static char *mystrip(char *str)
907 for (i = 0; i < len; i++)
908 if (str[i] != ' ') break;
909 if (i > 0) memmove(str, str + i, len - i + 1);
912 for (i = len - 1; i >= 0; i--)
913 if (str[i] != ' ' && str[i] != '\r' && str[i] != '\n') break;
919 static void get_line(char *d, size_t size, const char *s)
924 for (pe = s; *pe != '\r' && *pe != '\n' && *pe != 0; pe++)
933 static void keys_write_all(FILE *f)
937 for (d = 0; d < IN_MAX_DEVS; d++)
939 const int *binds = in_get_dev_binds(d);
940 const char *name = in_get_dev_name(d, 0, 0);
943 if (binds == NULL || name == NULL)
946 fprintf(f, "binddev = %s\n", name);
947 in_get_config(d, IN_CFG_BIND_COUNT, &count);
949 for (k = 0; k < count; k++)
954 act[0] = act[31] = 0;
955 name = in_get_key_name(d, k);
957 kbinds = binds[IN_BIND_OFFS(k, IN_BINDTYPE_PLAYER12)];
958 for (i = 0; kbinds && i < ARRAY_SIZE(me_ctrl_actions) - 1; i++) {
959 mask = me_ctrl_actions[i].mask;
961 strncpy(act, me_ctrl_actions[i].name, 31);
962 fprintf(f, "bind %s = player1 %s\n", name, mystrip(act));
965 mask = me_ctrl_actions[i].mask << 16;
967 strncpy(act, me_ctrl_actions[i].name, 31);
968 fprintf(f, "bind %s = player2 %s\n", name, mystrip(act));
973 kbinds = binds[IN_BIND_OFFS(k, IN_BINDTYPE_EMU)];
974 for (i = 0; kbinds && emuctrl_actions[i].name != NULL; i++) {
975 mask = emuctrl_actions[i].mask;
977 strncpy(act, emuctrl_actions[i].name, 31);
978 fprintf(f, "bind %s = %s\n", name, mystrip(act));
984 for (k = 0; k < array_size(in_adev); k++)
987 fprintf(f, "bind_analog = %d\n", k);
992 static int parse_bind_val(const char *val, int *type)
996 *type = IN_BINDTYPE_NONE;
1000 if (strncasecmp(val, "player", 6) == 0)
1002 int player, shift = 0;
1003 player = atoi(val + 6) - 1;
1005 if ((unsigned int)player > 1)
1010 *type = IN_BINDTYPE_PLAYER12;
1011 for (i = 0; me_ctrl_actions[i].name != NULL; i++) {
1012 if (strncasecmp(me_ctrl_actions[i].name, val + 8, strlen(val + 8)) == 0)
1013 return me_ctrl_actions[i].mask << shift;
1016 for (i = 0; emuctrl_actions[i].name != NULL; i++) {
1017 if (strncasecmp(emuctrl_actions[i].name, val, strlen(val)) == 0) {
1018 *type = IN_BINDTYPE_EMU;
1019 return emuctrl_actions[i].mask;
1026 static void keys_load_all(const char *cfg)
1028 char dev[256], key[128], *act;
1034 while (p != NULL && (p = strstr(p, "binddev = ")) != NULL) {
1037 // don't strip 'dev' because there are weird devices
1038 // with names with space at the end
1039 get_line(dev, sizeof(dev), p);
1041 dev_id = in_config_parse_dev(dev);
1043 printf("input: can't handle dev: %s\n", dev);
1047 in_unbind_all(dev_id, -1, -1);
1048 while ((p = strstr(p, "bind"))) {
1049 if (strncmp(p, "binddev = ", 10) == 0)
1052 if (strncmp(p, "bind_analog", 11) == 0) {
1053 ret = sscanf(p, "bind_analog = %d", &bind);
1056 printf("input: parse error: %16s..\n", p);
1059 if ((unsigned int)bind >= array_size(in_adev)) {
1060 printf("input: analog id %d out of range\n", bind);
1063 in_adev[bind] = dev_id;
1069 printf("input: parse error: %16s..\n", p);
1073 get_line(key, sizeof(key), p);
1074 act = strchr(key, '=');
1076 printf("parse failed: %16s..\n", p);
1084 bind = parse_bind_val(act, &bindtype);
1085 if (bind != -1 && bind != 0) {
1086 //printf("bind #%d '%s' %08x (%s)\n", dev_id, key, bind, act);
1087 in_config_bind_key(dev_id, key, bind, bindtype);
1090 lprintf("config: unhandled action \"%s\"\n", act);
1096 static int key_config_loop_wrap(int id, int keys)
1099 case MA_CTRL_PLAYER1:
1100 key_config_loop(me_ctrl_actions, array_size(me_ctrl_actions) - 1, 0);
1102 case MA_CTRL_PLAYER2:
1103 key_config_loop(me_ctrl_actions, array_size(me_ctrl_actions) - 1, 1);
1106 key_config_loop(emuctrl_actions, array_size(emuctrl_actions) - 1, -1);
1114 static const char h_nubmode[] = "Maps nub-like analog controls to PSX ones better\n"
1115 "Might cause problems with real analog sticks";
1116 static const char *adevnames[IN_MAX_DEVS + 2];
1117 static int stick_sel[2];
1119 static menu_entry e_menu_keyconfig_analog[] =
1121 mee_enum ("Left stick (L3)", 0, stick_sel[0], adevnames),
1122 mee_range (" X axis", 0, in_adev_axis[0][0], 0, 7),
1123 mee_range (" Y axis", 0, in_adev_axis[0][1], 0, 7),
1124 mee_onoff_h(" nub mode", 0, in_adev_is_nublike[0], 1, h_nubmode),
1125 mee_enum ("Right stick (R3)", 0, stick_sel[1], adevnames),
1126 mee_range (" X axis", 0, in_adev_axis[1][0], 0, 7),
1127 mee_range (" Y axis", 0, in_adev_axis[1][1], 0, 7),
1128 mee_onoff_h(" nub mode", 0, in_adev_is_nublike[1], 1, h_nubmode),
1132 static int key_config_analog(int id, int keys)
1134 int i, d, count, sel = 0;
1135 int sel2dev_map[IN_MAX_DEVS];
1137 memset(adevnames, 0, sizeof(adevnames));
1138 memset(sel2dev_map, 0xff, sizeof(sel2dev_map));
1139 memset(stick_sel, 0, sizeof(stick_sel));
1141 adevnames[0] = "None";
1143 for (d = 0; d < IN_MAX_DEVS; d++)
1145 const char *name = in_get_dev_name(d, 0, 1);
1150 in_get_config(d, IN_CFG_ABS_AXIS_COUNT, &count);
1154 if (in_adev[0] == d) stick_sel[0] = i;
1155 if (in_adev[1] == d) stick_sel[1] = i;
1157 adevnames[i++] = name;
1159 adevnames[i] = NULL;
1161 me_loop(e_menu_keyconfig_analog, &sel);
1163 in_adev[0] = sel2dev_map[stick_sel[0]];
1164 in_adev[1] = sel2dev_map[stick_sel[1]];
1169 static const char *mgn_dev_name(int id, int *offs)
1171 const char *name = NULL;
1174 if (id == MA_CTRL_DEV_FIRST)
1177 for (; it < IN_MAX_DEVS; it++) {
1178 name = in_get_dev_name(it, 1, 1);
1187 static const char *mgn_saveloadcfg(int id, int *offs)
1192 static int mh_savecfg(int id, int keys)
1194 if (menu_write_config(id == MA_OPT_SAVECFG_GAME ? 1 : 0) == 0)
1195 menu_update_msg("config saved");
1197 menu_update_msg("failed to write config");
1202 static int mh_input_rescan(int id, int keys)
1204 //menu_sync_config();
1206 menu_update_msg("rescan complete.");
1211 static const char *men_in_type_sel[] = {
1212 "Standard (SCPH-1080)",
1213 "Analog (SCPH-1150)",
1218 static const char h_nub_btns[] = "Experimental, keep this OFF if unsure. Select rescan after change.";
1219 static const char h_notsgun[] = "Don't trigger (shoot) when touching screen in gun games.";
1220 static const char h_vibration[]= "Must select analog above and enable this ingame too.";
1222 static menu_entry e_menu_keyconfig[] =
1224 mee_handler_id("Player 1", MA_CTRL_PLAYER1, key_config_loop_wrap),
1225 mee_handler_id("Player 2", MA_CTRL_PLAYER2, key_config_loop_wrap),
1226 mee_handler_id("Analog controls", MA_CTRL_ANALOG, key_config_analog),
1227 mee_handler_id("Emulator/Gun controls", MA_CTRL_EMU, key_config_loop_wrap),
1229 mee_enum ("Port 1 device", 0, in_type_sel1, men_in_type_sel),
1230 mee_enum ("Port 2 device", 0, in_type_sel2, men_in_type_sel),
1231 mee_onoff_h ("Nubs as buttons", MA_CTRL_NUBS_BTNS, in_evdev_allow_abs_only, 1, h_nub_btns),
1232 mee_onoff_h ("Vibration", MA_CTRL_VIBRATION, in_enable_vibration, 1, h_vibration),
1233 mee_range ("Analog deadzone", MA_CTRL_DEADZONE, analog_deadzone, 1, 99),
1234 mee_onoff_h ("No TS Gun trigger", 0, g_opts, OPT_TSGUN_NOTRIGGER, h_notsgun),
1235 mee_cust_nosave("Save global config", MA_OPT_SAVECFG, mh_savecfg, mgn_saveloadcfg),
1236 mee_cust_nosave("Save cfg for loaded game", MA_OPT_SAVECFG_GAME, mh_savecfg, mgn_saveloadcfg),
1237 mee_handler ("Rescan devices:", mh_input_rescan),
1239 mee_label_mk (MA_CTRL_DEV_FIRST, mgn_dev_name),
1240 mee_label_mk (MA_CTRL_DEV_NEXT, mgn_dev_name),
1241 mee_label_mk (MA_CTRL_DEV_NEXT, mgn_dev_name),
1242 mee_label_mk (MA_CTRL_DEV_NEXT, mgn_dev_name),
1243 mee_label_mk (MA_CTRL_DEV_NEXT, mgn_dev_name),
1244 mee_label_mk (MA_CTRL_DEV_NEXT, mgn_dev_name),
1245 mee_label_mk (MA_CTRL_DEV_NEXT, mgn_dev_name),
1249 static int menu_loop_keyconfig(int id, int keys)
1253 // me_enable(e_menu_keyconfig, MA_OPT_SAVECFG_GAME, ready_to_go && CdromId[0]);
1254 me_loop(e_menu_keyconfig, &sel);
1258 // ------------ gfx options menu ------------
1260 static const char *men_scaler[] = {
1261 "1x1", "integer scaled 2x", "scaled 4:3", "integer scaled 4:3", "fullscreen", "custom", NULL
1263 static const char *men_soft_filter[] = { "None",
1265 "scale2x", "eagle2x",
1268 static const char *men_dummy[] = { NULL };
1269 static const char *men_centering[] = { "Auto", "Ingame", "Borderless", "Force", NULL };
1270 static const char h_scaler[] = "int. 2x - scales w. or h. 2x if it fits on screen\n"
1271 "int. 4:3 - uses integer if possible, else fractional";
1272 static const char h_cscaler[] = "Displays the scaler layer, you can resize it\n"
1273 "using d-pad or move it using R+d-pad";
1274 static const char h_soft_filter[] = "Works only if game uses low resolution modes";
1275 static const char h_gamma[] = "Gamma/brightness adjustment (default 100)";
1277 static const char h_scanline_l[] = "Scanline brightness, 0-100%";
1280 static int menu_loop_cscaler(int id, int keys)
1284 g_scaler = SCALE_CUSTOM;
1286 plat_gvideo_open(Config.PsxType);
1290 menu_draw_begin(0, 1);
1291 memset(g_menuscreen_ptr, 4, g_menuscreen_w * g_menuscreen_h * 2);
1292 text_out16(2, 2, "%d,%d", g_layer_x, g_layer_y);
1293 text_out16(2, 480 - 18, "%dx%d | d-pad: resize, R+d-pad: move", g_layer_w, g_layer_h);
1296 inp = in_menu_wait(PBTN_UP|PBTN_DOWN|PBTN_LEFT|PBTN_RIGHT
1297 |PBTN_R|PBTN_MOK|PBTN_MBACK, NULL, 40);
1298 if (inp & PBTN_UP) g_layer_y--;
1299 if (inp & PBTN_DOWN) g_layer_y++;
1300 if (inp & PBTN_LEFT) g_layer_x--;
1301 if (inp & PBTN_RIGHT) g_layer_x++;
1302 if (!(inp & PBTN_R)) {
1303 if (inp & PBTN_UP) g_layer_h += 2;
1304 if (inp & PBTN_DOWN) g_layer_h -= 2;
1305 if (inp & PBTN_LEFT) g_layer_w += 2;
1306 if (inp & PBTN_RIGHT) g_layer_w -= 2;
1308 if (inp & (PBTN_MOK|PBTN_MBACK))
1311 if (inp & (PBTN_UP|PBTN_DOWN|PBTN_LEFT|PBTN_RIGHT)) {
1312 if (g_layer_x < 0) g_layer_x = 0;
1313 if (g_layer_x > 640) g_layer_x = 640;
1314 if (g_layer_y < 0) g_layer_y = 0;
1315 if (g_layer_y > 420) g_layer_y = 420;
1316 if (g_layer_w < 160) g_layer_w = 160;
1317 if (g_layer_h < 60) g_layer_h = 60;
1318 if (g_layer_x + g_layer_w > 800)
1319 g_layer_w = 800 - g_layer_x;
1320 if (g_layer_y + g_layer_h > 480)
1321 g_layer_h = 480 - g_layer_y;
1323 plat_gvideo_open(Config.PsxType);
1327 plat_gvideo_close();
1332 static menu_entry e_menu_gfx_options[] =
1334 mee_enum ("Screen centering", MA_OPT_CENTERING, pl_rearmed_cbs.screen_centering_type, men_centering),
1335 mee_enum_h ("Scaler", MA_OPT_VARSCALER, g_scaler, men_scaler, h_scaler),
1336 mee_enum ("Video output mode", MA_OPT_VOUT_MODE, plat_target.vout_method, men_dummy),
1337 mee_onoff ("Software Scaling", MA_OPT_SCALER2, soft_scaling, 1),
1338 mee_enum ("Hardware Filter", MA_OPT_HWFILTER, plat_target.hwfilter, men_dummy),
1339 mee_enum_h ("Software Filter", MA_OPT_SWFILTER, soft_filter, men_soft_filter, h_soft_filter),
1341 mee_onoff ("Scanlines", MA_OPT_SCANLINES, scanlines, 1),
1342 mee_range_h ("Scanline brightness", MA_OPT_SCANLINE_LEVEL, scanline_level, 0, 100, h_scanline_l),
1344 mee_range_h ("Gamma adjustment", MA_OPT_GAMMA, g_gamma, 1, 200, h_gamma),
1345 // mee_onoff ("Vsync", 0, vsync, 1),
1346 mee_cust_h ("Setup custom scaler", MA_OPT_VARSCALER_C, menu_loop_cscaler, NULL, h_cscaler),
1350 static int menu_loop_gfx_options(int id, int keys)
1354 me_loop(e_menu_gfx_options, &sel);
1359 // ------------ bios/plugins ------------
1361 #ifdef BUILTIN_GPU_NEON
1363 static const char h_gpu_neon[] =
1364 "Configure built-in NEON GPU plugin";
1365 static const char h_gpu_neon_enhanced[] =
1366 "Renders in double resolution at the cost of lower performance\n"
1367 "(not available for high resolution games)";
1368 static const char h_gpu_neon_enhanced_hack[] =
1369 "Speed hack for above option (glitches some games)";
1370 static const char *men_gpu_interlace[] = { "Off", "On", "Auto", NULL };
1372 static menu_entry e_menu_plugin_gpu_neon[] =
1374 mee_enum ("Enable interlace mode", 0, pl_rearmed_cbs.gpu_neon.allow_interlace, men_gpu_interlace),
1375 mee_onoff_h ("Enhanced resolution", 0, pl_rearmed_cbs.gpu_neon.enhancement_enable, 1, h_gpu_neon_enhanced),
1376 mee_onoff_h ("Enhanced res. speed hack", 0, pl_rearmed_cbs.gpu_neon.enhancement_no_main, 1, h_gpu_neon_enhanced_hack),
1380 static int menu_loop_plugin_gpu_neon(int id, int keys)
1383 me_loop(e_menu_plugin_gpu_neon, &sel);
1389 static menu_entry e_menu_plugin_gpu_unai[] =
1391 mee_onoff ("Skip every 2nd line", 0, pl_rearmed_cbs.gpu_unai.lineskip, 1),
1392 mee_onoff ("Abe's Odyssey hack", 0, pl_rearmed_cbs.gpu_unai.abe_hack, 1),
1393 mee_onoff ("Disable lighting", 0, pl_rearmed_cbs.gpu_unai.no_light, 1),
1394 mee_onoff ("Disable blending", 0, pl_rearmed_cbs.gpu_unai.no_blend, 1),
1398 static int menu_loop_plugin_gpu_unai(int id, int keys)
1401 me_loop(e_menu_plugin_gpu_unai, &sel);
1405 static menu_entry e_menu_plugin_gpu_senquack[] =
1408 mee_onoff ("Interlace", 0, pl_rearmed_cbs.gpu_senquack.ilace_force, 1),
1409 mee_onoff ("Dithering", 0, pl_rearmed_cbs.gpu_senquack.dithering, 1),
1410 mee_onoff ("Lighting", 0, pl_rearmed_cbs.gpu_senquack.lighting, 1),
1411 mee_onoff ("Fast lighting", 0, pl_rearmed_cbs.gpu_senquack.fast_lighting, 1),
1412 mee_onoff ("Blending", 0, pl_rearmed_cbs.gpu_senquack.blending, 1),
1413 mee_onoff ("Pixel skip", 0, pl_rearmed_cbs.gpu_senquack.pixel_skip, 1),
1418 static int menu_loop_plugin_gpu_senquack(int id, int keys)
1421 me_loop(e_menu_plugin_gpu_senquack, &sel);
1426 static const char *men_gpu_dithering[] = { "None", "Game dependant", "Always", NULL };
1427 //static const char h_gpu_0[] = "Needed for Chrono Cross";
1428 static const char h_gpu_1[] = "Capcom fighting games";
1429 static const char h_gpu_2[] = "Black screens in Lunar";
1430 static const char h_gpu_3[] = "Compatibility mode";
1431 static const char h_gpu_6[] = "Pandemonium 2";
1432 //static const char h_gpu_7[] = "Skip every second frame";
1433 static const char h_gpu_8[] = "Needed by Dark Forces";
1434 static const char h_gpu_9[] = "better g-colors, worse textures";
1435 static const char h_gpu_10[] = "Toggle busy flags after drawing";
1437 static menu_entry e_menu_plugin_gpu_peops[] =
1439 mee_enum ("Dithering", 0, pl_rearmed_cbs.gpu_peops.iUseDither, men_gpu_dithering),
1440 // mee_onoff_h ("Odd/even bit hack", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<0, h_gpu_0),
1441 mee_onoff_h ("Expand screen width", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<1, h_gpu_1),
1442 mee_onoff_h ("Ignore brightness color", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<2, h_gpu_2),
1443 mee_onoff_h ("Disable coordinate check", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<3, h_gpu_3),
1444 mee_onoff_h ("Lazy screen update", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<6, h_gpu_6),
1445 // mee_onoff_h ("Old frame skipping", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<7, h_gpu_7),
1446 mee_onoff_h ("Repeated flat tex triangles ",0,pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<8, h_gpu_8),
1447 mee_onoff_h ("Draw quads with triangles", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<9, h_gpu_9),
1448 mee_onoff_h ("Fake 'gpu busy' states", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<10, h_gpu_10),
1452 static int menu_loop_plugin_gpu_peops(int id, int keys)
1455 me_loop(e_menu_plugin_gpu_peops, &sel);
1459 static const char *men_peopsgl_texfilter[] = { "None", "Standard", "Extended",
1460 "Standard-sprites", "Extended-sprites", "Standard+sprites", "Extended+sprites", NULL };
1461 static const char *men_peopsgl_fbtex[] = { "Emulated VRam", "Black", "Card", "Card+soft" };
1463 static menu_entry e_menu_plugin_gpu_peopsgl[] =
1465 mee_onoff ("Dithering", 0, pl_rearmed_cbs.gpu_peopsgl.bDrawDither, 1),
1466 mee_enum ("Texture Filtering", 0, pl_rearmed_cbs.gpu_peopsgl.iFilterType, men_peopsgl_texfilter),
1467 mee_enum ("Framebuffer Textures", 0, pl_rearmed_cbs.gpu_peopsgl.iFrameTexType, men_peopsgl_fbtex),
1468 mee_onoff ("Mask Detect", 0, pl_rearmed_cbs.gpu_peopsgl.iUseMask, 1),
1469 mee_onoff ("Opaque Pass", 0, pl_rearmed_cbs.gpu_peopsgl.bOpaquePass, 1),
1470 mee_onoff ("Advanced Blend", 0, pl_rearmed_cbs.gpu_peopsgl.bAdvancedBlend, 1),
1471 mee_onoff ("Use Fast Mdec", 0, pl_rearmed_cbs.gpu_peopsgl.bUseFastMdec, 1),
1472 mee_range ("Texture RAM size (MB)", 0, pl_rearmed_cbs.gpu_peopsgl.iVRamSize, 4, 128),
1473 mee_onoff ("Texture garbage collection", 0, pl_rearmed_cbs.gpu_peopsgl.iTexGarbageCollection, 1),
1474 mee_label ("Fixes/hacks:"),
1475 mee_onoff ("FF7 cursor", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<0),
1476 mee_onoff ("Direct FB updates", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<1),
1477 mee_onoff ("Black brightness", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<2),
1478 mee_onoff ("Swap front detection", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<3),
1479 mee_onoff ("Disable coord check", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<4),
1480 mee_onoff ("No blue glitches (LoD)", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<5),
1481 mee_onoff ("Soft FB access", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<6),
1482 mee_onoff ("FF9 rect", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<9),
1483 mee_onoff ("No subtr. blending", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<10),
1484 mee_onoff ("Lazy upload (DW7)", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<11),
1485 mee_onoff ("Additional uploads", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<15),
1489 static int menu_loop_plugin_gpu_peopsgl(int id, int keys)
1492 me_loop(e_menu_plugin_gpu_peopsgl, &sel);
1496 static const char *men_spu_interp[] = { "None", "Simple", "Gaussian", "Cubic", NULL };
1497 static const char h_spu_volboost[] = "Large values cause distortion";
1498 static const char h_spu_tempo[] = "Slows down audio if emu is too slow\n"
1499 "This is inaccurate and breaks games";
1501 static menu_entry e_menu_plugin_spu[] =
1503 mee_range_h ("Volume boost", 0, volume_boost, -5, 30, h_spu_volboost),
1504 mee_onoff ("Reverb", 0, spu_config.iUseReverb, 1),
1505 mee_enum ("Interpolation", 0, spu_config.iUseInterpolation, men_spu_interp),
1506 //mee_onoff ("Adjust XA pitch", 0, spu_config.iXAPitch, 1),
1507 mee_onoff_h ("Adjust tempo", 0, spu_config.iTempo, 1, h_spu_tempo),
1511 static int menu_loop_plugin_spu(int id, int keys)
1514 me_loop(e_menu_plugin_spu, &sel);
1518 static const char h_bios[] = "HLE is simulated BIOS. BIOS selection is saved in\n"
1519 "savestates and can't be changed there. Must save\n"
1520 "config and reload the game for change to take effect";
1521 static const char h_plugin_gpu[] =
1522 #ifdef BUILTIN_GPU_NEON
1523 "builtin_gpu is the NEON GPU, very fast and accurate\n"
1525 "gpu_peops is Pete's soft GPU, slow but accurate\n"
1526 "gpu_unai is GPU from PCSX4ALL, fast but glitchy\n"
1527 "gpu_senquack is more accurate but slower\n"
1528 "gpu_gles Pete's hw GPU, uses 3D chip but is glitchy\n"
1529 "must save config and reload the game if changed";
1530 static const char h_plugin_spu[] = "spunull effectively disables sound\n"
1531 "must save config and reload the game if changed";
1532 static const char h_gpu_peops[] = "Configure P.E.Op.S. SoftGL Driver V1.17";
1533 static const char h_gpu_peopsgl[]= "Configure P.E.Op.S. MesaGL Driver V1.78";
1534 static const char h_gpu_unai[] = "Configure Unai/PCSX4ALL Team GPU plugin";
1535 static const char h_gpu_senquack[] = "Configure Unai/PCSX4ALL Senquack plugin";
1536 static const char h_spu[] = "Configure built-in P.E.Op.S. Sound Driver V1.7";
1538 static menu_entry e_menu_plugin_options[] =
1540 mee_enum_h ("BIOS", 0, bios_sel, bioses, h_bios),
1541 mee_enum_h ("GPU plugin", 0, gpu_plugsel, gpu_plugins, h_plugin_gpu),
1542 mee_enum_h ("SPU plugin", 0, spu_plugsel, spu_plugins, h_plugin_spu),
1543 #ifdef BUILTIN_GPU_NEON
1544 mee_handler_h ("Configure built-in GPU plugin", menu_loop_plugin_gpu_neon, h_gpu_neon),
1546 mee_handler_h ("Configure gpu_peops plugin", menu_loop_plugin_gpu_peops, h_gpu_peops),
1547 mee_handler_h ("Configure gpu_unai GPU plugin", menu_loop_plugin_gpu_unai, h_gpu_unai),
1548 mee_handler_h ("Configure gpu_senquack GPU plugin", menu_loop_plugin_gpu_senquack, h_gpu_senquack),
1549 mee_handler_h ("Configure gpu_gles GPU plugin", menu_loop_plugin_gpu_peopsgl, h_gpu_peopsgl),
1550 mee_handler_h ("Configure built-in SPU plugin", menu_loop_plugin_spu, h_spu),
1554 static menu_entry e_menu_main2[];
1556 static int menu_loop_plugin_options(int id, int keys)
1559 me_loop(e_menu_plugin_options, &sel);
1561 // sync BIOS/plugins
1562 snprintf(Config.Bios, sizeof(Config.Bios), "%s", bioses[bios_sel]);
1563 snprintf(Config.Gpu, sizeof(Config.Gpu), "%s", gpu_plugins[gpu_plugsel]);
1564 snprintf(Config.Spu, sizeof(Config.Spu), "%s", spu_plugins[spu_plugsel]);
1565 me_enable(e_menu_main2, MA_MAIN_RUN_BIOS, bios_sel != 0);
1570 // ------------ adv options menu ------------
1573 static const char h_cfg_noch[] = "Disables game-specific compatibility hacks";
1574 static const char h_cfg_nosmc[] = "Will cause crashes when loading, break memcards";
1575 static const char h_cfg_gteunn[] = "May cause graphical glitches";
1576 static const char h_cfg_gteflgs[] = "Will cause graphical glitches";
1578 static const char h_cfg_stalls[] = "Will cause some games to run too fast";
1580 static menu_entry e_menu_speed_hacks[] =
1583 mee_onoff_h ("Disable compat hacks", 0, new_dynarec_hacks, NDHACK_NO_COMPAT_HACKS, h_cfg_noch),
1584 mee_onoff_h ("Disable SMC checks", 0, new_dynarec_hacks, NDHACK_NO_SMC_CHECK, h_cfg_nosmc),
1585 mee_onoff_h ("Assume GTE regs unneeded", 0, new_dynarec_hacks, NDHACK_GTE_UNNEEDED, h_cfg_gteunn),
1586 mee_onoff_h ("Disable GTE flags", 0, new_dynarec_hacks, NDHACK_GTE_NO_FLAGS, h_cfg_gteflgs),
1588 mee_onoff_h ("Disable CPU/GTE stalls", 0, menu_iopts[0], 1, h_cfg_stalls),
1592 static int menu_loop_speed_hacks(int id, int keys)
1595 menu_iopts[0] = Config.DisableStalls;
1596 me_loop(e_menu_speed_hacks, &sel);
1597 Config.DisableStalls = menu_iopts[0];
1601 static const char *men_gpul[] = { "Auto", "Off", "On", NULL };
1603 static const char h_cfg_cpul[] = "Shows CPU usage in %";
1604 static const char h_cfg_spu[] = "Shows active SPU channels\n"
1605 "(green: normal, red: fmod, blue: noise)";
1606 static const char h_cfg_fl[] = "Frame Limiter keeps the game from running too fast";
1607 static const char h_cfg_xa[] = "Disables XA sound, which can sometimes improve performance";
1608 static const char h_cfg_cdda[] = "Disable CD Audio for a performance boost\n"
1609 "(proper .cue/.bin dump is needed otherwise)";
1611 static const char h_cfg_nodrc[] = "Disable dynamic recompiler and use interpreter\n"
1612 "Might be useful to overcome some dynarec bugs";
1614 static const char h_cfg_shacks[] = "Breaks games but may give better performance";
1615 static const char h_cfg_icache[] = "Support F1 games (only when dynarec is off)";
1616 static const char h_cfg_exc[] = "Emulate some PSX's debug hw like breakpoints\n"
1617 "and exceptions (slow, interpreter only, keep off)";
1618 static const char h_cfg_gpul[] = "Try enabling this if the game misses some graphics\n"
1619 "causes a performance hit";
1620 static const char h_cfg_psxclk[] = "Over/under-clock the PSX, default is " DEFAULT_PSX_CLOCK_S "\n"
1621 "(adjust this if the game is too slow/too fast/hangs)";
1623 enum { AMO_XA, AMO_CDDA, AMO_IC, AMO_BP, AMO_CPU, AMO_GPUL };
1625 static menu_entry e_menu_adv_options[] =
1627 mee_onoff_h ("Show CPU load", 0, g_opts, OPT_SHOWCPU, h_cfg_cpul),
1628 mee_onoff_h ("Show SPU channels", 0, g_opts, OPT_SHOWSPU, h_cfg_spu),
1629 mee_onoff_h ("Disable Frame Limiter", 0, g_opts, OPT_NO_FRAMELIM, h_cfg_fl),
1630 mee_onoff_h ("Disable XA Decoding", 0, menu_iopts[AMO_XA], 1, h_cfg_xa),
1631 mee_onoff_h ("Disable CD Audio", 0, menu_iopts[AMO_CDDA], 1, h_cfg_cdda),
1632 mee_onoff_h ("ICache emulation", 0, menu_iopts[AMO_IC], 1, h_cfg_icache),
1633 mee_onoff_h ("BP exception emulation", 0, menu_iopts[AMO_BP], 1, h_cfg_exc),
1634 mee_enum_h ("GPU l-list slow walking",0, menu_iopts[AMO_GPUL], men_gpul, h_cfg_gpul),
1635 #if !defined(DRC_DISABLE) || defined(LIGHTREC)
1636 mee_onoff_h ("Disable dynarec (slow!)",0, menu_iopts[AMO_CPU], 1, h_cfg_nodrc),
1638 mee_range_h ("PSX CPU clock, %", 0, psx_clock, 1, 500, h_cfg_psxclk),
1639 mee_handler_h ("[Speed hacks]", menu_loop_speed_hacks, h_cfg_shacks),
1643 static int menu_loop_adv_options(int id, int keys)
1650 { &Config.Xa, &menu_iopts[AMO_XA] },
1651 { &Config.Cdda, &menu_iopts[AMO_CDDA] },
1652 { &Config.icache_emulation, &menu_iopts[AMO_IC] },
1653 { &Config.PreciseExceptions, &menu_iopts[AMO_BP] },
1654 { &Config.Cpu, &menu_iopts[AMO_CPU] },
1657 for (i = 0; i < ARRAY_SIZE(opts); i++)
1658 *opts[i].mopt = *opts[i].opt;
1659 menu_iopts[AMO_GPUL] = Config.GpuListWalking + 1;
1661 me_loop(e_menu_adv_options, &sel);
1663 for (i = 0; i < ARRAY_SIZE(opts); i++)
1664 *opts[i].opt = *opts[i].mopt;
1665 Config.GpuListWalking = menu_iopts[AMO_GPUL] - 1;
1670 // ------------ options menu ------------
1672 static int mh_restore_defaults(int id, int keys)
1674 menu_set_defconfig();
1675 menu_update_msg("defaults restored");
1679 static const char *men_region[] = { "Auto", "NTSC", "PAL", NULL };
1680 static const char *men_frameskip[] = { "Auto", "Off", "1", "2", "3", NULL };
1682 static const char *men_confirm_save[] = { "OFF", "writes", "loads", "both", NULL };
1683 static const char h_confirm_save[] = "Ask for confirmation when overwriting save,\n"
1684 "loading state or both";
1686 static const char h_restore_def[] = "Switches back to default / recommended\n"
1688 static const char h_frameskip[] = "Warning: frameskip sometimes causes glitches\n";
1690 static menu_entry e_menu_options[] =
1692 // mee_range ("Save slot", 0, state_slot, 0, 9),
1693 // mee_enum_h ("Confirm savestate", 0, dummy, men_confirm_save, h_confirm_save),
1694 mee_enum_h ("Frameskip", 0, frameskip, men_frameskip, h_frameskip),
1695 mee_onoff ("Show FPS", 0, g_opts, OPT_SHOWFPS),
1696 mee_enum ("Region", 0, region, men_region),
1697 mee_range ("CPU clock", MA_OPT_CPU_CLOCKS, cpu_clock, 20, 5000),
1699 mee_onoff ("Use C64x DSP for sound", MA_OPT_SPU_THREAD, spu_config.iUseThread, 1),
1701 mee_onoff ("Threaded SPU", MA_OPT_SPU_THREAD, spu_config.iUseThread, 1),
1703 mee_handler_id("[Display]", MA_OPT_DISP_OPTS, menu_loop_gfx_options),
1704 mee_handler ("[BIOS/Plugins]", menu_loop_plugin_options),
1705 mee_handler ("[Advanced]", menu_loop_adv_options),
1706 mee_cust_nosave("Save global config", MA_OPT_SAVECFG, mh_savecfg, mgn_saveloadcfg),
1707 mee_cust_nosave("Save cfg for loaded game",MA_OPT_SAVECFG_GAME, mh_savecfg, mgn_saveloadcfg),
1708 mee_handler_h ("Restore default config", mh_restore_defaults, h_restore_def),
1712 static int menu_loop_options(int id, int keys)
1716 me_enable(e_menu_options, MA_OPT_CPU_CLOCKS, cpu_clock_st > 0);
1717 me_enable(e_menu_options, MA_OPT_SPU_THREAD, spu_config.iThreadAvail);
1718 me_enable(e_menu_options, MA_OPT_SAVECFG_GAME, ready_to_go && CdromId[0]);
1720 me_loop(e_menu_options, &sel);
1725 // ------------ debug menu ------------
1727 static void draw_frame_debug(GPUFreeze_t *gpuf, int x, int y)
1729 int w = min(g_menuscreen_w, 1024);
1730 int h = min(g_menuscreen_h, 512);
1731 u16 *d = g_menuscreen_ptr;
1732 u16 *s = (u16 *)gpuf->psxVRam + y * 1024 + x;
1736 gpuf->ulFreezeVersion = 1;
1737 if (GPU_freeze != NULL)
1738 GPU_freeze(1, gpuf);
1740 for (; h > 0; h--, d += g_menuscreen_w, s += 1024)
1741 bgr555_to_rgb565(d, s, w * 2);
1743 smalltext_out16(4, 1, "build: "__DATE__ " " __TIME__ " " REV, 0xe7fc);
1744 snprintf(buff, sizeof(buff), "GPU sr: %08x", gpuf->ulStatus);
1745 smalltext_out16(4, (ty += me_sfont_h), buff, 0xe7fc);
1746 snprintf(buff, sizeof(buff), "PC/SP: %08x %08x", psxRegs.pc, psxRegs.GPR.n.sp);
1747 smalltext_out16(4, (ty += me_sfont_h), buff, 0xe7fc);
1750 static void debug_menu_loop(void)
1752 int inp, df_x = 0, df_y = 0;
1755 gpuf = malloc(sizeof(*gpuf));
1761 menu_draw_begin(0, 1);
1762 draw_frame_debug(gpuf, df_x, df_y);
1765 inp = in_menu_wait(PBTN_MOK|PBTN_MBACK|PBTN_MA2|PBTN_MA3|PBTN_L|PBTN_R |
1766 PBTN_UP|PBTN_DOWN|PBTN_LEFT|PBTN_RIGHT, NULL, 10);
1767 if (inp & PBTN_MBACK) break;
1768 else if (inp & PBTN_UP) { if (df_y > 0) df_y--; }
1769 else if (inp & PBTN_DOWN) { if (df_y < 512 - g_menuscreen_h) df_y++; }
1770 else if (inp & PBTN_LEFT) { if (df_x > 0) df_x -= 2; }
1771 else if (inp & PBTN_RIGHT) { if (df_x < 1024 - g_menuscreen_w) df_x += 2; }
1777 // --------- memcard manager ---------
1779 static void draw_mc_icon(int dx, int dy, const u16 *s)
1784 d = (u16 *)g_menuscreen_ptr + g_menuscreen_w * dy + dx;
1786 for (y = 0; y < 16; y++, s += 16) {
1787 for (l = 0; l < 2; l++, d += g_menuscreen_w) {
1788 for (x = 0; x < 16; x++) {
1790 d[x*2] = d[x*2 + 1] = ((p & 0x7c00) >> 10)
1791 | ((p & 0x03e0) << 1) | ((p & 0x1f) << 11);
1797 static void draw_mc_bg(void)
1799 McdBlock *blocks1, *blocks2;
1803 blocks1 = malloc(15 * sizeof(blocks1[0]));
1804 blocks2 = malloc(15 * sizeof(blocks1[0]));
1805 if (blocks1 == NULL || blocks2 == NULL)
1808 for (i = 0; i < 15; i++) {
1809 GetMcdBlockInfo(1, i + 1, &blocks1[i]);
1810 GetMcdBlockInfo(2, i + 1, &blocks2[i]);
1813 menu_draw_begin(1, 1);
1815 memcpy(g_menuscreen_ptr, g_menubg_src_ptr, g_menuscreen_w * g_menuscreen_h * 2);
1817 y = g_menuscreen_h / 2 - 15 * 32 / 2;
1821 maxicons = g_menuscreen_h / 32;
1824 row2 = g_menuscreen_w / 2;
1825 for (i = 0; i < maxicons; i++) {
1826 draw_mc_icon(8, y + i * 32, (u16 *)blocks1[i].Icon);
1827 smalltext_out16(10+32, y + i * 32 + 8, blocks1[i].sTitle, 0xf71e);
1829 draw_mc_icon(row2 + 8, y + i * 32, (u16 *)blocks2[i].Icon);
1830 smalltext_out16(row2 + 10+32, y + i * 32 + 8, blocks2[i].sTitle, 0xf71e);
1833 menu_darken_bg(g_menubg_ptr, g_menuscreen_ptr, g_menuscreen_w * g_menuscreen_h, 0);
1841 static void handle_memcard_sel(void)
1843 strcpy(Config.Mcd1, "none");
1844 if (memcard1_sel != 0)
1845 snprintf(Config.Mcd1, sizeof(Config.Mcd1), ".%s%s", MEMCARD_DIR, memcards[memcard1_sel]);
1846 strcpy(Config.Mcd2, "none");
1847 if (memcard2_sel != 0)
1848 snprintf(Config.Mcd2, sizeof(Config.Mcd2), ".%s%s", MEMCARD_DIR, memcards[memcard2_sel]);
1849 LoadMcds(Config.Mcd1, Config.Mcd2);
1853 static menu_entry e_memcard_options[] =
1855 mee_enum("Memory card 1", 0, memcard1_sel, memcards),
1856 mee_enum("Memory card 2", 0, memcard2_sel, memcards),
1860 static int menu_loop_memcards(int id, int keys)
1866 memcard1_sel = memcard2_sel = 0;
1867 p = strrchr(Config.Mcd1, '/');
1869 for (i = 0; memcards[i] != NULL; i++)
1870 if (strcmp(p + 1, memcards[i]) == 0)
1871 { memcard1_sel = i; break; }
1872 p = strrchr(Config.Mcd2, '/');
1874 for (i = 0; memcards[i] != NULL; i++)
1875 if (strcmp(p + 1, memcards[i]) == 0)
1876 { memcard2_sel = i; break; }
1878 me_loop_d(e_memcard_options, &sel, handle_memcard_sel, NULL);
1880 memcpy(g_menubg_ptr, g_menubg_src_ptr, g_menuscreen_w * g_menuscreen_h * 2);
1885 // ------------ cheats menu ------------
1887 static void draw_cheatlist(int sel)
1889 int max_cnt, start, i, pos, active;
1891 max_cnt = g_menuscreen_h / me_sfont_h;
1892 start = max_cnt / 2 - sel;
1894 menu_draw_begin(1, 1);
1896 for (i = 0; i < NumCheats; i++) {
1898 if (pos < 0) continue;
1899 if (pos >= max_cnt) break;
1900 active = Cheats[i].Enabled;
1901 smalltext_out16(14, pos * me_sfont_h,
1902 active ? "ON " : "OFF", active ? 0xfff6 : 0xffff);
1903 smalltext_out16(14 + me_sfont_w*4, pos * me_sfont_h,
1904 Cheats[i].Descr, active ? 0xfff6 : 0xffff);
1908 smalltext_out16(14, pos * me_sfont_h, "done", 0xffff);
1910 text_out16(5, max_cnt / 2 * me_sfont_h, ">");
1914 static void menu_loop_cheats(void)
1916 static int menu_sel = 0;
1921 draw_cheatlist(menu_sel);
1922 inp = in_menu_wait(PBTN_UP|PBTN_DOWN|PBTN_LEFT|PBTN_RIGHT|PBTN_L|PBTN_R
1923 |PBTN_MOK|PBTN_MBACK, NULL, 33);
1924 if (inp & PBTN_UP ) { menu_sel--; if (menu_sel < 0) menu_sel = NumCheats; }
1925 if (inp & PBTN_DOWN) { menu_sel++; if (menu_sel > NumCheats) menu_sel = 0; }
1926 if (inp &(PBTN_LEFT|PBTN_L)) { menu_sel-=10; if (menu_sel < 0) menu_sel = 0; }
1927 if (inp &(PBTN_RIGHT|PBTN_R)) { menu_sel+=10; if (menu_sel > NumCheats) menu_sel = NumCheats; }
1928 if (inp & PBTN_MOK) { // action
1929 if (menu_sel < NumCheats)
1930 Cheats[menu_sel].Enabled = !Cheats[menu_sel].Enabled;
1933 if (inp & PBTN_MBACK)
1938 // --------- main menu help ----------
1940 static void menu_bios_warn(void)
1943 static const char msg[] =
1944 "You don't seem to have copied any BIOS\n"
1946 MENU_BIOS_PATH "\n\n"
1948 "While many games work fine with fake\n"
1949 "(HLE) BIOS, others (like MGS and FF8)\n"
1950 "require BIOS to work.\n"
1951 "After copying the file, you'll also need\n"
1952 "to select it in the emu's menu:\n"
1953 "options->[BIOS/Plugins]\n\n"
1954 "The file is usually named SCPH1001.BIN,\n"
1955 "but other not compressed files can be\n"
1957 "Press %s or %s to continue";
1958 char tmp_msg[sizeof(msg) + 64];
1960 snprintf(tmp_msg, sizeof(tmp_msg), msg,
1961 in_get_key_name(-1, -PBTN_MOK), in_get_key_name(-1, -PBTN_MBACK));
1964 draw_menu_message(tmp_msg, NULL);
1966 inp = in_menu_wait(PBTN_MOK|PBTN_MBACK, NULL, 70);
1967 if (inp & (PBTN_MBACK|PBTN_MOK))
1972 // ------------ main menu ------------
1974 static menu_entry e_menu_main[];
1976 static void draw_frame_main(void)
1985 if (CdromId[0] != 0) {
1986 snprintf(buff, sizeof(buff), "%.32s/%.9s (running as %s, with %s)",
1987 get_cd_label(), CdromId, Config.PsxType ? "PAL" : "NTSC",
1988 Config.HLE ? "HLE" : "BIOS");
1989 smalltext_out16(4, 1, buff, 0x105f);
1993 capacity = plat_target_bat_capacity_get();
1995 tmp = localtime(<ime);
1996 strftime(ltime_s, sizeof(ltime_s), "%H:%M", tmp);
1997 if (capacity >= 0) {
1998 snprintf(buff, sizeof(buff), "%s %3d%%", ltime_s, capacity);
2003 smalltext_out16(4, 1 + me_sfont_h, out, 0x105f);
2007 static void draw_frame_credits(void)
2009 smalltext_out16(4, 1, "build: " __DATE__ " " __TIME__ " " REV, 0xe7fc);
2012 static const char credits_text[] =
2014 "(C) 1999-2003 PCSX Team\n"
2015 "(C) 2005-2009 PCSX-df Team\n"
2016 "(C) 2009-2011 PCSX-Reloaded Team\n\n"
2017 "ARM recompiler (C) 2009-2011 Ari64\n"
2018 #ifdef BUILTIN_GPU_NEON
2019 "ARM NEON GPU (c) 2011-2012 Exophase\n"
2021 "PEOpS GPU and SPU by Pete Bernert\n"
2022 " and the P.E.Op.S. team\n"
2023 "PCSX4ALL plugin by PCSX4ALL team\n"
2024 " Chui, Franxis, Unai\n\n"
2025 "integration, optimization and\n"
2026 " frontend (C) 2010-2015 notaz\n";
2028 static int reset_game(void)
2034 if (LoadCdrom() == -1)
2040 static int reload_plugins(const char *cdimg)
2046 set_cd_image(cdimg);
2048 pcnt_hook_plugins();
2050 if (OpenPlugins() == -1) {
2051 menu_update_msg("failed to open plugins");
2054 plugin_call_rearmed_cbs();
2056 cdrIsoMultidiskCount = 1;
2058 CdromLabel[0] = '\0';
2063 static int run_bios(void)
2065 boolean origSlowBoot = Config.SlowBoot;
2071 if (reload_plugins(NULL) != 0)
2073 Config.SlowBoot = 1;
2075 Config.SlowBoot = origSlowBoot;
2081 static int run_exe(void)
2083 const char *exts[] = { "exe", NULL };
2086 fname = menu_loop_romsel(last_selected_fname,
2087 sizeof(last_selected_fname), exts, NULL);
2092 if (reload_plugins(NULL) != 0)
2096 if (Load(fname) != 0) {
2097 menu_update_msg("exe load failed, bad file?");
2106 static int run_cd_image(const char *fname)
2108 int autoload_state = g_autostateld_opt;
2111 reload_plugins(fname);
2113 // always autodetect, menu_sync_config will override as needed
2116 if (CheckCdrom() == -1) {
2117 // Only check the CD if we are starting the console with a CD
2119 menu_update_msg("unsupported/invalid CD image");
2125 // Read main executable directly from CDRom and start it
2126 if (LoadCdrom() == -1) {
2128 menu_update_msg("failed to load CD image");
2135 if (autoload_state) {
2136 unsigned int newest = 0;
2137 int time, slot, newest_slot = -1;
2139 for (slot = 0; slot < 10; slot++) {
2140 if (emu_check_save_file(slot, &time)) {
2141 if ((unsigned int)time > newest) {
2148 if (newest_slot >= 0) {
2149 lprintf("autoload slot %d\n", newest_slot);
2150 emu_load_state(newest_slot);
2153 lprintf("no save to autoload.\n");
2160 static int romsel_run(void)
2162 int prev_gpu, prev_spu;
2165 fname = menu_loop_romsel(last_selected_fname,
2166 sizeof(last_selected_fname), filter_exts,
2167 optional_cdimg_filter);
2171 printf("selected file: %s\n", fname);
2173 new_dynarec_clear_full();
2175 if (run_cd_image(fname) != 0)
2178 prev_gpu = gpu_plugsel;
2179 prev_spu = spu_plugsel;
2180 if (menu_load_config(1) != 0)
2181 menu_load_config(0);
2183 // check for plugin changes, have to repeat
2184 // loading if game config changed plugins to reload them
2185 if (prev_gpu != gpu_plugsel || prev_spu != spu_plugsel) {
2186 printf("plugin change detected, reloading plugins..\n");
2187 if (run_cd_image(fname) != 0)
2191 strcpy(last_selected_fname, fname);
2192 menu_do_last_cd_img(0);
2196 static int swap_cd_image(void)
2200 fname = menu_loop_romsel(last_selected_fname,
2201 sizeof(last_selected_fname), filter_exts,
2202 optional_cdimg_filter);
2206 printf("selected file: %s\n", fname);
2209 CdromLabel[0] = '\0';
2211 set_cd_image(fname);
2212 if (ReloadCdromPlugin() < 0) {
2213 menu_update_msg("failed to load cdr plugin");
2216 if (CDR_open() < 0) {
2217 menu_update_msg("failed to open cdr plugin");
2221 SetCdOpenCaseTime(time(NULL) + 2);
2224 strcpy(last_selected_fname, fname);
2228 static int swap_cd_multidisk(void)
2230 cdrIsoMultidiskSelect++;
2232 CdromLabel[0] = '\0';
2235 if (CDR_open() < 0) {
2236 menu_update_msg("failed to open cdr plugin");
2240 SetCdOpenCaseTime(time(NULL) + 2);
2246 static void load_pcsx_cht(void)
2248 static const char *exts[] = { "cht", NULL };
2252 fname = menu_loop_romsel(last_selected_fname,
2253 sizeof(last_selected_fname), exts, NULL);
2257 printf("selected cheat file: %s\n", fname);
2260 if (NumCheats == 0 && NumCodes == 0)
2261 menu_update_msg("failed to load cheats");
2263 snprintf(msg, sizeof(msg), "%d cheat(s) loaded", NumCheats + NumCodes);
2264 menu_update_msg(msg);
2266 me_enable(e_menu_main, MA_MAIN_CHEATS, ready_to_go && NumCheats);
2269 static int main_menu_handler(int id, int keys)
2273 case MA_MAIN_RESUME_GAME:
2277 case MA_MAIN_SAVE_STATE:
2279 return menu_loop_savestate(0);
2281 case MA_MAIN_LOAD_STATE:
2283 return menu_loop_savestate(1);
2285 case MA_MAIN_RESET_GAME:
2286 if (ready_to_go && reset_game() == 0)
2289 case MA_MAIN_LOAD_ROM:
2290 if (romsel_run() == 0)
2293 case MA_MAIN_SWAP_CD:
2294 if (swap_cd_image() == 0)
2297 case MA_MAIN_SWAP_CD_MULTI:
2298 if (swap_cd_multidisk() == 0)
2301 case MA_MAIN_RUN_BIOS:
2302 if (run_bios() == 0)
2305 case MA_MAIN_RUN_EXE:
2309 case MA_MAIN_CHEATS:
2312 case MA_MAIN_LOAD_CHEATS:
2315 case MA_MAIN_CREDITS:
2316 draw_menu_message(credits_text, draw_frame_credits);
2317 in_menu_wait(PBTN_MOK|PBTN_MBACK, NULL, 70);
2320 emu_core_ask_exit();
2323 lprintf("%s: something unknown selected\n", __FUNCTION__);
2330 static menu_entry e_menu_main2[] =
2332 mee_handler_id("Change CD image", MA_MAIN_SWAP_CD, main_menu_handler),
2333 mee_handler_id("Next multidisk CD", MA_MAIN_SWAP_CD_MULTI, main_menu_handler),
2334 mee_handler_id("Run BIOS", MA_MAIN_RUN_BIOS, main_menu_handler),
2335 mee_handler_id("Run EXE", MA_MAIN_RUN_EXE, main_menu_handler),
2336 mee_handler ("Memcard manager", menu_loop_memcards),
2337 mee_handler_id("Load PCSX cheats..", MA_MAIN_LOAD_CHEATS, main_menu_handler),
2341 static int main_menu2_handler(int id, int keys)
2345 me_enable(e_menu_main2, MA_MAIN_SWAP_CD, ready_to_go);
2346 me_enable(e_menu_main2, MA_MAIN_SWAP_CD_MULTI, ready_to_go && cdrIsoMultidiskCount > 1);
2347 me_enable(e_menu_main2, MA_MAIN_RUN_BIOS, bios_sel != 0);
2348 me_enable(e_menu_main2, MA_MAIN_LOAD_CHEATS, ready_to_go);
2350 return me_loop_d(e_menu_main2, &sel, NULL, draw_frame_main);
2353 static const char h_extra[] = "Change CD, manage memcards..\n";
2355 static menu_entry e_menu_main[] =
2359 mee_handler_id("Resume game", MA_MAIN_RESUME_GAME, main_menu_handler),
2360 mee_handler_id("Save State", MA_MAIN_SAVE_STATE, main_menu_handler),
2361 mee_handler_id("Load State", MA_MAIN_LOAD_STATE, main_menu_handler),
2362 mee_handler_id("Reset game", MA_MAIN_RESET_GAME, main_menu_handler),
2363 mee_handler_id("Load CD image", MA_MAIN_LOAD_ROM, main_menu_handler),
2364 mee_handler ("Options", menu_loop_options),
2365 mee_handler ("Controls", menu_loop_keyconfig),
2366 mee_handler_id("Cheats", MA_MAIN_CHEATS, main_menu_handler),
2367 mee_handler_h ("Extra stuff", main_menu2_handler, h_extra),
2368 mee_handler_id("Credits", MA_MAIN_CREDITS, main_menu_handler),
2369 mee_handler_id("Exit", MA_MAIN_EXIT, main_menu_handler),
2373 // ----------------------------
2375 static void menu_leave_emu(void);
2377 void menu_loop(void)
2379 static int warned_about_bios = 0;
2384 if (config_save_counter == 0) {
2386 if (bioses[1] != NULL) {
2387 // autoselect BIOS to make user's life easier
2388 snprintf(Config.Bios, sizeof(Config.Bios), "%s", bioses[1]);
2391 else if (!warned_about_bios) {
2393 warned_about_bios = 1;
2397 me_enable(e_menu_main, MA_MAIN_RESUME_GAME, ready_to_go);
2398 me_enable(e_menu_main, MA_MAIN_SAVE_STATE, ready_to_go && CdromId[0]);
2399 me_enable(e_menu_main, MA_MAIN_LOAD_STATE, ready_to_go && CdromId[0]);
2400 me_enable(e_menu_main, MA_MAIN_RESET_GAME, ready_to_go);
2401 me_enable(e_menu_main, MA_MAIN_CHEATS, ready_to_go && NumCheats);
2403 in_set_config_int(0, IN_CFG_BLOCKING, 1);
2406 me_loop_d(e_menu_main, &sel, NULL, draw_frame_main);
2407 } while (!ready_to_go && !g_emu_want_quit);
2409 /* wait until menu, ok, back is released */
2410 while (in_menu_wait_any(NULL, 50) & (PBTN_MENU|PBTN_MOK|PBTN_MBACK))
2413 in_set_config_int(0, IN_CFG_BLOCKING, 0);
2418 static int qsort_strcmp(const void *p1, const void *p2)
2420 char * const *s1 = (char * const *)p1;
2421 char * const *s2 = (char * const *)p2;
2422 return strcasecmp(*s1, *s2);
2425 static void scan_bios_plugins(void)
2427 char fname[MAXPATHLEN];
2429 int bios_i, gpu_i, spu_i, mc_i;
2434 gpu_plugins[0] = "builtin_gpu";
2435 spu_plugins[0] = "builtin_spu";
2436 memcards[0] = "(none)";
2437 bios_i = gpu_i = spu_i = mc_i = 1;
2439 snprintf(fname, sizeof(fname), "%s/", Config.BiosDir);
2440 dir = opendir(fname);
2442 perror("scan_bios_plugins bios opendir");
2457 if (ent->d_type != DT_REG && ent->d_type != DT_LNK)
2460 snprintf(fname, sizeof(fname), "%s/%s", Config.BiosDir, ent->d_name);
2461 if (stat(fname, &st) != 0
2462 || (st.st_size != 512*1024 && st.st_size != 4*1024*1024)) {
2463 printf("bad BIOS file: %s\n", ent->d_name);
2467 if (bios_i < ARRAY_SIZE(bioses) - 1) {
2468 bioses[bios_i++] = strdup(ent->d_name);
2472 printf("too many BIOSes, dropping \"%s\"\n", ent->d_name);
2478 snprintf(fname, sizeof(fname), "%s/", Config.PluginsDir);
2479 dir = opendir(fname);
2481 perror("scan_bios_plugins plugins opendir");
2495 p = strstr(ent->d_name, ".so");
2499 snprintf(fname, sizeof(fname), "%s/%s", Config.PluginsDir, ent->d_name);
2500 h = dlopen(fname, RTLD_LAZY | RTLD_LOCAL);
2502 fprintf(stderr, "%s\n", dlerror());
2506 // now what do we have here?
2507 tmp = dlsym(h, "GPUinit");
2510 if (gpu_i < ARRAY_SIZE(gpu_plugins) - 1)
2511 gpu_plugins[gpu_i++] = strdup(ent->d_name);
2515 tmp = dlsym(h, "SPUinit");
2518 if (spu_i < ARRAY_SIZE(spu_plugins) - 1)
2519 spu_plugins[spu_i++] = strdup(ent->d_name);
2523 fprintf(stderr, "ignoring unidentified plugin: %s\n", fname);
2530 dir = opendir("." MEMCARD_DIR);
2532 perror("scan_bios_plugins memcards opendir");
2547 if (ent->d_type != DT_REG && ent->d_type != DT_LNK)
2550 snprintf(fname, sizeof(fname), "." MEMCARD_DIR "%s", ent->d_name);
2551 if (stat(fname, &st) != 0) {
2552 printf("bad memcard file: %s\n", ent->d_name);
2556 if (mc_i < ARRAY_SIZE(memcards) - 1) {
2557 memcards[mc_i++] = strdup(ent->d_name);
2561 printf("too many memcards, dropping \"%s\"\n", ent->d_name);
2565 qsort(memcards + 1, mc_i - 1, sizeof(memcards[0]), qsort_strcmp);
2570 void menu_init(void)
2572 char buff[MAXPATHLEN];
2575 cpu_clock_st = cpu_clock = plat_target_cpu_clock_get();
2577 scan_bios_plugins();
2580 menu_set_defconfig();
2581 menu_load_config(0);
2582 menu_do_last_cd_img(1);
2587 g_menubg_src_ptr = calloc(g_menuscreen_w * g_menuscreen_h * 2, 1);
2588 g_menubg_ptr = calloc(g_menuscreen_w * g_menuscreen_h * 2, 1);
2589 if (g_menubg_src_ptr == NULL || g_menubg_ptr == NULL) {
2590 fprintf(stderr, "OOM\n");
2594 emu_make_path(buff, "skin/background.png", sizeof(buff));
2595 readpng(g_menubg_src_ptr, buff, READPNG_BG, g_menuscreen_w, g_menuscreen_h);
2597 i = plat_target.cpu_clock_set != NULL
2598 && plat_target.cpu_clock_get != NULL && cpu_clock_st > 0;
2599 me_enable(e_menu_options, MA_OPT_CPU_CLOCKS, i);
2601 i = me_id2offset(e_menu_gfx_options, MA_OPT_VOUT_MODE);
2602 e_menu_gfx_options[i].data = plat_target.vout_methods;
2603 me_enable(e_menu_gfx_options, MA_OPT_VOUT_MODE,
2604 plat_target.vout_methods != NULL);
2606 i = me_id2offset(e_menu_gfx_options, MA_OPT_HWFILTER);
2607 e_menu_gfx_options[i].data = plat_target.hwfilters;
2608 me_enable(e_menu_gfx_options, MA_OPT_HWFILTER,
2609 plat_target.hwfilters != NULL);
2611 me_enable(e_menu_gfx_options, MA_OPT_GAMMA,
2612 plat_target.gamma_set != NULL);
2614 #ifdef HAVE_PRE_ARMV7
2615 me_enable(e_menu_gfx_options, MA_OPT_SWFILTER, 0);
2617 me_enable(e_menu_gfx_options, MA_OPT_VARSCALER, MENU_SHOW_VARSCALER);
2618 me_enable(e_menu_gfx_options, MA_OPT_VOUT_MODE, MENU_SHOW_VOUTMODE);
2619 me_enable(e_menu_gfx_options, MA_OPT_VARSCALER_C, MENU_SHOW_VARSCALER);
2620 me_enable(e_menu_gfx_options, MA_OPT_SCALER2, MENU_SHOW_SCALER2);
2621 me_enable(e_menu_keyconfig, MA_CTRL_NUBS_BTNS, MENU_SHOW_NUBS_BTNS);
2622 me_enable(e_menu_keyconfig, MA_CTRL_VIBRATION, MENU_SHOW_VIBRATION);
2623 me_enable(e_menu_keyconfig, MA_CTRL_DEADZONE, MENU_SHOW_DEADZONE);
2626 void menu_notify_mode_change(int w, int h, int bpp)
2630 last_vout_bpp = bpp;
2633 static void menu_leave_emu(void)
2635 if (GPU_close != NULL) {
2636 int ret = GPU_close();
2638 fprintf(stderr, "Warning: GPU_close returned %d\n", ret);
2641 plat_video_menu_enter(ready_to_go);
2643 memcpy(g_menubg_ptr, g_menubg_src_ptr, g_menuscreen_w * g_menuscreen_h * 2);
2644 if (pl_vout_buf != NULL && ready_to_go) {
2645 int x = max(0, g_menuscreen_w - last_vout_w);
2646 int y = max(0, g_menuscreen_h / 2 - last_vout_h / 2);
2647 int w = min(g_menuscreen_w, last_vout_w);
2648 int h = min(g_menuscreen_h, last_vout_h);
2649 u16 *d = (u16 *)g_menubg_ptr + g_menuscreen_w * y + x;
2650 char *s = pl_vout_buf;
2652 if (last_vout_bpp == 16) {
2653 for (; h > 0; h--, d += g_menuscreen_w, s += last_vout_w * 2)
2654 menu_darken_bg(d, s, w, 0);
2657 for (; h > 0; h--, d += g_menuscreen_w, s += last_vout_w * 3) {
2658 rgb888_to_rgb565(d, s, w * 3);
2659 menu_darken_bg(d, d, w, 0);
2665 cpu_clock = plat_target_cpu_clock_get();
2668 void menu_prepare_emu(void)
2670 R3000Acpu *prev_cpu = psxCpu;
2672 plat_video_menu_leave();
2674 #if !defined(DRC_DISABLE) || defined(LIGHTREC)
2675 psxCpu = (Config.Cpu == CPU_INTERPRETER) ? &psxInt : &psxRec;
2679 if (psxCpu != prev_cpu) {
2680 prev_cpu->Notify(R3000ACPU_NOTIFY_BEFORE_SAVE, NULL);
2681 prev_cpu->Shutdown();
2684 psxCpu->Notify(R3000ACPU_NOTIFY_AFTER_LOAD, NULL);
2688 psxCpu->ApplyConfig();
2690 // core doesn't care about Config.Cdda changes,
2691 // so handle them manually here
2696 plat_target_cpu_clock_set(cpu_clock);
2698 // push config to GPU plugin
2699 plugin_call_rearmed_cbs();
2701 if (GPU_open != NULL) {
2702 int ret = GPU_open(&gpuDisp, "PCSX", NULL);
2704 fprintf(stderr, "Warning: GPU_open returned %d\n", ret);
2708 void menu_update_msg(const char *msg)
2710 strncpy(menu_error_msg, msg, sizeof(menu_error_msg));
2711 menu_error_msg[sizeof(menu_error_msg) - 1] = 0;
2713 menu_error_time = plat_get_ticks_ms();
2714 lprintf("msg: %s\n", menu_error_msg);
2717 void menu_finish(void)
2719 if (cpu_clock_st > 0)
2720 plat_target_cpu_clock_set(cpu_clock_st);