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[257];
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_old.lineskip),
438 CE_INTVAL_P(gpu_unai_old.abe_hack),
439 CE_INTVAL_P(gpu_unai_old.no_light),
440 CE_INTVAL_P(gpu_unai_old.no_blend),
441 CE_INTVAL_P(gpu_unai.ilace_force),
442 CE_INTVAL_P(gpu_unai.pixel_skip),
443 CE_INTVAL_P(gpu_unai.lighting),
444 CE_INTVAL_P(gpu_unai.fast_lighting),
445 CE_INTVAL_P(gpu_unai.blending),
446 CE_INTVAL_P(gpu_unai.dithering),
447 CE_INTVAL_P(gpu_unai.scale_hires),
448 CE_INTVAL_P(gpu_neon.allow_interlace),
449 CE_INTVAL_P(gpu_neon.enhancement_enable),
450 CE_INTVAL_P(gpu_neon.enhancement_no_main),
451 CE_INTVAL_P(gpu_peopsgl.bDrawDither),
452 CE_INTVAL_P(gpu_peopsgl.iFilterType),
453 CE_INTVAL_P(gpu_peopsgl.iFrameTexType),
454 CE_INTVAL_P(gpu_peopsgl.iUseMask),
455 CE_INTVAL_P(gpu_peopsgl.bOpaquePass),
456 CE_INTVAL_P(gpu_peopsgl.bAdvancedBlend),
457 CE_INTVAL_P(gpu_peopsgl.bUseFastMdec),
458 CE_INTVAL_P(gpu_peopsgl.iVRamSize),
459 CE_INTVAL_P(gpu_peopsgl.iTexGarbageCollection),
460 CE_INTVAL_P(gpu_peopsgl.dwActFixes),
461 CE_INTVAL_P(screen_centering_type),
462 CE_INTVAL_P(screen_centering_x),
463 CE_INTVAL_P(screen_centering_y),
464 CE_INTVAL(spu_config.iUseReverb),
465 CE_INTVAL(spu_config.iXAPitch),
466 CE_INTVAL(spu_config.iUseInterpolation),
467 CE_INTVAL(spu_config.iTempo),
468 CE_INTVAL(spu_config.iUseThread),
469 CE_INTVAL(config_save_counter),
470 CE_INTVAL(in_evdev_allow_abs_only),
471 CE_INTVAL(volume_boost),
472 CE_INTVAL(psx_clock),
473 CE_INTVAL(new_dynarec_hacks),
474 CE_INTVAL(in_enable_vibration),
477 static char *get_cd_label(void)
479 static char trimlabel[33];
482 strncpy(trimlabel, CdromLabel, 32);
484 for (j = 31; j >= 0; j--)
485 if (trimlabel[j] == ' ')
491 static void make_cfg_fname(char *buf, size_t size, int is_game)
494 snprintf(buf, size, "." PCSX_DOT_DIR "cfg/%.32s-%.9s.cfg", get_cd_label(), CdromId);
496 snprintf(buf, size, "." PCSX_DOT_DIR "%s", cfgfile_basename);
499 static void keys_write_all(FILE *f);
500 static char *mystrip(char *str);
502 static int menu_write_config(int is_game)
504 char cfgfile[MAXPATHLEN];
508 config_save_counter++;
510 make_cfg_fname(cfgfile, sizeof(cfgfile), is_game);
511 f = fopen(cfgfile, "w");
513 printf("menu_write_config: failed to open: %s\n", cfgfile);
517 for (i = 0; i < ARRAY_SIZE(config_data); i++) {
518 fprintf(f, "%s = ", config_data[i].name);
519 switch (config_data[i].len) {
521 fprintf(f, "%s\n", (char *)config_data[i].val);
524 fprintf(f, "%x\n", *(u8 *)config_data[i].val);
527 fprintf(f, "%x\n", *(u16 *)config_data[i].val);
530 fprintf(f, "%x\n", *(u32 *)config_data[i].val);
533 printf("menu_write_config: unhandled len %d for %s\n",
534 (int)config_data[i].len, config_data[i].name);
545 static int menu_do_last_cd_img(int is_get)
547 static const char *defaults[] = { "/media", "/mnt/sd", "/mnt" };
553 snprintf(path, sizeof(path), "." PCSX_DOT_DIR "lastcdimg.txt");
554 f = fopen(path, is_get ? "r" : "w");
561 ret = fread(last_selected_fname, 1, sizeof(last_selected_fname) - 1, f);
562 last_selected_fname[ret] = 0;
563 mystrip(last_selected_fname);
566 fprintf(f, "%s\n", last_selected_fname);
571 for (i = 0; last_selected_fname[0] == 0
572 || STAT(last_selected_fname, &st) != 0; i++)
574 if (i >= ARRAY_SIZE(defaults))
576 strcpy(last_selected_fname, defaults[i]);
583 static void parse_str_val(char *cval, const char *src)
586 strncpy(cval, src, MAXPATHLEN);
587 cval[MAXPATHLEN - 1] = 0;
588 tmp = strchr(cval, '\n');
590 tmp = strchr(cval, '\r');
595 static void keys_load_all(const char *cfg);
597 int menu_load_config(int is_game)
599 char cfgfile[MAXPATHLEN];
605 make_cfg_fname(cfgfile, sizeof(cfgfile), is_game);
606 f = fopen(cfgfile, "r");
608 printf("menu_load_config: failed to open: %s\n", cfgfile);
612 fseek(f, 0, SEEK_END);
615 printf("bad size %ld: %s\n", size, cfgfile);
619 cfg = malloc(size + 1);
623 fseek(f, 0, SEEK_SET);
624 if (fread(cfg, 1, size, f) != size) {
625 printf("failed to read: %s\n", cfgfile);
630 for (i = 0; i < ARRAY_SIZE(config_data); i++) {
634 tmp = strstr(cfg, config_data[i].name);
637 tmp += strlen(config_data[i].name);
638 if (strncmp(tmp, " = ", 3) != 0)
642 if (config_data[i].len == 0) {
643 parse_str_val(config_data[i].val, tmp);
648 val = strtoul(tmp, &tmp2, 16);
649 if (tmp2 == NULL || tmp == tmp2)
650 continue; // parse failed
652 switch (config_data[i].len) {
654 *(u8 *)config_data[i].val = val;
657 *(u16 *)config_data[i].val = val;
660 *(u32 *)config_data[i].val = val;
663 printf("menu_load_config: unhandled len %d for %s\n",
664 (int)config_data[i].len, config_data[i].name);
670 char *tmp = strstr(cfg, "lastcdimg = ");
673 parse_str_val(last_selected_fname, tmp);
688 for (i = bios_sel = 0; bioses[i] != NULL; i++)
689 if (strcmp(Config.Bios, bioses[i]) == 0)
690 { bios_sel = i; break; }
692 for (i = gpu_plugsel = 0; gpu_plugins[i] != NULL; i++)
693 if (strcmp(Config.Gpu, gpu_plugins[i]) == 0)
694 { gpu_plugsel = i; break; }
696 for (i = spu_plugsel = 0; spu_plugins[i] != NULL; i++)
697 if (strcmp(Config.Spu, spu_plugins[i]) == 0)
698 { spu_plugsel = i; break; }
700 // memcard selections
701 char mcd1_old[sizeof(Config.Mcd1)];
702 char mcd2_old[sizeof(Config.Mcd2)];
703 strcpy(mcd1_old, Config.Mcd1);
704 strcpy(mcd2_old, Config.Mcd2);
706 if ((unsigned int)memcard1_sel < ARRAY_SIZE(memcards)) {
707 if (memcard1_sel == 0)
708 strcpy(Config.Mcd1, "none");
709 else if (memcards[memcard1_sel] != NULL)
710 snprintf(Config.Mcd1, sizeof(Config.Mcd1), ".%s%s",
711 MEMCARD_DIR, memcards[memcard1_sel]);
713 if ((unsigned int)memcard2_sel < ARRAY_SIZE(memcards)) {
714 if (memcard2_sel == 0)
715 strcpy(Config.Mcd2, "none");
716 else if (memcards[memcard2_sel] != NULL)
717 snprintf(Config.Mcd2, sizeof(Config.Mcd2), ".%s%s",
718 MEMCARD_DIR, memcards[memcard2_sel]);
720 if (strcmp(mcd1_old, Config.Mcd1) || strcmp(mcd2_old, Config.Mcd2))
721 LoadMcds(Config.Mcd1, Config.Mcd2);
726 static const char *filter_exts[] = {
727 "bin", "img", "mdf", "iso", "cue", "z",
731 "bz", "znx", "pbp", "cbn", NULL
734 // rrrr rggg gggb bbbb
735 static unsigned short fname2color(const char *fname)
737 static const char *other_exts[] = {
738 "ccd", "toc", "mds", "sub", "table", "index", "sbi"
740 const char *ext = strrchr(fname, '.');
746 for (i = 0; filter_exts[i] != NULL; i++)
747 if (strcasecmp(ext, filter_exts[i]) == 0)
749 for (i = 0; i < array_size(other_exts); i++)
750 if (strcasecmp(ext, other_exts[i]) == 0)
755 static void draw_savestate_bg(int slot);
757 #define MENU_ALIGN_LEFT
758 #ifndef HAVE_PRE_ARMV7 // assume hires device
764 #include "libpicofe/menu.c"
766 // a bit of black magic here
767 static void draw_savestate_bg(int slot)
769 static const int psx_widths[8] = { 256, 368, 320, 384, 512, 512, 640, 640 };
771 char fname[MAXPATHLEN];
778 ret = get_state_filename(fname, sizeof(fname), slot);
782 f = gzopen(fname, "rb");
786 if ((ret = (int)gzseek(f, 0x29933d, SEEK_SET)) != 0x29933d) {
787 fprintf(stderr, "gzseek failed: %d\n", ret);
792 gpu = malloc(sizeof(*gpu));
798 ret = gzread(f, gpu, sizeof(*gpu));
800 if (ret != sizeof(*gpu)) {
801 fprintf(stderr, "gzread failed\n");
805 memcpy(g_menubg_ptr, g_menubg_src_ptr, g_menuscreen_w * g_menuscreen_h * 2);
807 if (gpu->ulStatus & 0x800000)
808 goto out; // disabled
810 x = gpu->ulControl[5] & 0x3ff;
811 y = (gpu->ulControl[5] >> 10) & 0x1ff;
812 w = psx_widths[(gpu->ulStatus >> 16) & 7];
813 tmp = gpu->ulControl[7];
814 h = ((tmp >> 10) & 0x3ff) - (tmp & 0x3ff);
815 if (gpu->ulStatus & 0x80000) // doubleheight
817 if (h <= 0 || h > 512)
823 s = (u16 *)gpu->psxVRam + y * 1024 + x;
825 x = max(0, g_menuscreen_w - w) & ~3;
826 y = max(0, g_menuscreen_h / 2 - h / 2);
827 w = min(g_menuscreen_w, w);
828 h = min(g_menuscreen_h, h);
829 d = (u16 *)g_menubg_ptr + g_menuscreen_w * y + x;
831 for (; h > 0; h--, d += g_menuscreen_w, s += 1024) {
832 if (gpu->ulStatus & 0x200000)
833 bgr888_to_rgb565(d, s, w * 3);
835 bgr555_to_rgb565(d, s, w * 2);
837 // darken this so that menu text is visible
838 if (g_menuscreen_w - w < 320)
839 menu_darken_bg(d, d, w, 0);
846 // -------------- key config --------------
848 me_bind_action me_ctrl_actions[] =
850 { "UP ", 1 << DKEY_UP},
851 { "DOWN ", 1 << DKEY_DOWN },
852 { "LEFT ", 1 << DKEY_LEFT },
853 { "RIGHT ", 1 << DKEY_RIGHT },
854 { "TRIANGLE", 1 << DKEY_TRIANGLE },
855 { "CIRCLE ", 1 << DKEY_CIRCLE },
856 { "CROSS ", 1 << DKEY_CROSS },
857 { "SQUARE ", 1 << DKEY_SQUARE },
858 { "L1 ", 1 << DKEY_L1 },
859 { "R1 ", 1 << DKEY_R1 },
860 { "L2 ", 1 << DKEY_L2 },
861 { "R2 ", 1 << DKEY_R2 },
862 { "L3 ", 1 << DKEY_L3 },
863 { "R3 ", 1 << DKEY_R3 },
864 { "START ", 1 << DKEY_START },
865 { "SELECT ", 1 << DKEY_SELECT },
869 me_bind_action emuctrl_actions[] =
871 { "Save State ", 1 << SACTION_SAVE_STATE },
872 { "Load State ", 1 << SACTION_LOAD_STATE },
873 { "Prev Save Slot ", 1 << SACTION_PREV_SSLOT },
874 { "Next Save Slot ", 1 << SACTION_NEXT_SSLOT },
875 { "Toggle Frameskip ", 1 << SACTION_TOGGLE_FSKIP },
876 { "Take Screenshot ", 1 << SACTION_SCREENSHOT },
877 { "Show/Hide FPS ", 1 << SACTION_TOGGLE_FPS },
878 #ifndef HAVE_PRE_ARMV7
879 { "Switch Renderer ", 1 << SACTION_SWITCH_DISPMODE },
881 { "Fast Forward ", 1 << SACTION_FAST_FORWARD },
882 #if MENU_SHOW_MINIMIZE
883 { "Minimize ", 1 << SACTION_MINIMIZE },
885 #if MENU_SHOW_FULLSCREEN
886 { "Toggle fullscreen", 1 << SACTION_TOGGLE_FULLSCREEN },
888 { "Enter Menu ", 1 << SACTION_ENTER_MENU },
889 { "Gun Trigger ", 1 << SACTION_GUN_TRIGGER },
890 { "Gun A button ", 1 << SACTION_GUN_A },
891 { "Gun B button ", 1 << SACTION_GUN_B },
892 { "Gun Offscreen Trigger", 1 << SACTION_GUN_TRIGGER2 },
894 { "Volume Up ", 1 << SACTION_VOLUME_UP },
895 { "Volume Down ", 1 << SACTION_VOLUME_DOWN },
900 static char *mystrip(char *str)
905 for (i = 0; i < len; i++)
906 if (str[i] != ' ') break;
907 if (i > 0) memmove(str, str + i, len - i + 1);
910 for (i = len - 1; i >= 0; i--)
911 if (str[i] != ' ' && str[i] != '\r' && str[i] != '\n') break;
917 static void get_line(char *d, size_t size, const char *s)
922 for (pe = s; *pe != '\r' && *pe != '\n' && *pe != 0; pe++)
931 static void keys_write_all(FILE *f)
935 for (d = 0; d < IN_MAX_DEVS; d++)
937 const int *binds = in_get_dev_binds(d);
938 const char *name = in_get_dev_name(d, 0, 0);
941 if (binds == NULL || name == NULL)
944 fprintf(f, "binddev = %s\n", name);
945 in_get_config(d, IN_CFG_BIND_COUNT, &count);
947 for (k = 0; k < count; k++)
952 act[0] = act[31] = 0;
953 name = in_get_key_name(d, k);
955 kbinds = binds[IN_BIND_OFFS(k, IN_BINDTYPE_PLAYER12)];
956 for (i = 0; kbinds && i < ARRAY_SIZE(me_ctrl_actions) - 1; i++) {
957 mask = me_ctrl_actions[i].mask;
959 strncpy(act, me_ctrl_actions[i].name, 31);
960 fprintf(f, "bind %s = player1 %s\n", name, mystrip(act));
963 mask = me_ctrl_actions[i].mask << 16;
965 strncpy(act, me_ctrl_actions[i].name, 31);
966 fprintf(f, "bind %s = player2 %s\n", name, mystrip(act));
971 kbinds = binds[IN_BIND_OFFS(k, IN_BINDTYPE_EMU)];
972 for (i = 0; kbinds && emuctrl_actions[i].name != NULL; i++) {
973 mask = emuctrl_actions[i].mask;
975 strncpy(act, emuctrl_actions[i].name, 31);
976 fprintf(f, "bind %s = %s\n", name, mystrip(act));
982 for (k = 0; k < array_size(in_adev); k++)
985 fprintf(f, "bind_analog = %d\n", k);
990 static int parse_bind_val(const char *val, int *type)
994 *type = IN_BINDTYPE_NONE;
998 if (strncasecmp(val, "player", 6) == 0)
1000 int player, shift = 0;
1001 player = atoi(val + 6) - 1;
1003 if ((unsigned int)player > 1)
1008 *type = IN_BINDTYPE_PLAYER12;
1009 for (i = 0; me_ctrl_actions[i].name != NULL; i++) {
1010 if (strncasecmp(me_ctrl_actions[i].name, val + 8, strlen(val + 8)) == 0)
1011 return me_ctrl_actions[i].mask << shift;
1014 for (i = 0; emuctrl_actions[i].name != NULL; i++) {
1015 if (strncasecmp(emuctrl_actions[i].name, val, strlen(val)) == 0) {
1016 *type = IN_BINDTYPE_EMU;
1017 return emuctrl_actions[i].mask;
1024 static void keys_load_all(const char *cfg)
1026 char dev[256], key[128], *act;
1032 while (p != NULL && (p = strstr(p, "binddev = ")) != NULL) {
1035 // don't strip 'dev' because there are weird devices
1036 // with names with space at the end
1037 get_line(dev, sizeof(dev), p);
1039 dev_id = in_config_parse_dev(dev);
1041 printf("input: can't handle dev: %s\n", dev);
1045 in_unbind_all(dev_id, -1, -1);
1046 while ((p = strstr(p, "bind"))) {
1047 if (strncmp(p, "binddev = ", 10) == 0)
1050 if (strncmp(p, "bind_analog", 11) == 0) {
1051 ret = sscanf(p, "bind_analog = %d", &bind);
1054 printf("input: parse error: %16s..\n", p);
1057 if ((unsigned int)bind >= array_size(in_adev)) {
1058 printf("input: analog id %d out of range\n", bind);
1061 in_adev[bind] = dev_id;
1067 printf("input: parse error: %16s..\n", p);
1071 get_line(key, sizeof(key), p);
1072 act = strchr(key, '=');
1074 printf("parse failed: %16s..\n", p);
1082 bind = parse_bind_val(act, &bindtype);
1083 if (bind != -1 && bind != 0) {
1084 //printf("bind #%d '%s' %08x (%s)\n", dev_id, key, bind, act);
1085 in_config_bind_key(dev_id, key, bind, bindtype);
1088 lprintf("config: unhandled action \"%s\"\n", act);
1094 static int key_config_loop_wrap(int id, int keys)
1097 case MA_CTRL_PLAYER1:
1098 key_config_loop(me_ctrl_actions, array_size(me_ctrl_actions) - 1, 0);
1100 case MA_CTRL_PLAYER2:
1101 key_config_loop(me_ctrl_actions, array_size(me_ctrl_actions) - 1, 1);
1104 key_config_loop(emuctrl_actions, array_size(emuctrl_actions) - 1, -1);
1112 static const char h_nubmode[] = "Maps nub-like analog controls to PSX ones better\n"
1113 "Might cause problems with real analog sticks";
1114 static const char *adevnames[IN_MAX_DEVS + 2];
1115 static int stick_sel[2];
1117 static menu_entry e_menu_keyconfig_analog[] =
1119 mee_enum ("Left stick (L3)", 0, stick_sel[0], adevnames),
1120 mee_range (" X axis", 0, in_adev_axis[0][0], 0, 7),
1121 mee_range (" Y axis", 0, in_adev_axis[0][1], 0, 7),
1122 mee_onoff_h(" nub mode", 0, in_adev_is_nublike[0], 1, h_nubmode),
1123 mee_enum ("Right stick (R3)", 0, stick_sel[1], adevnames),
1124 mee_range (" X axis", 0, in_adev_axis[1][0], 0, 7),
1125 mee_range (" Y axis", 0, in_adev_axis[1][1], 0, 7),
1126 mee_onoff_h(" nub mode", 0, in_adev_is_nublike[1], 1, h_nubmode),
1130 static int key_config_analog(int id, int keys)
1132 int i, d, count, sel = 0;
1133 int sel2dev_map[IN_MAX_DEVS];
1135 memset(adevnames, 0, sizeof(adevnames));
1136 memset(sel2dev_map, 0xff, sizeof(sel2dev_map));
1137 memset(stick_sel, 0, sizeof(stick_sel));
1139 adevnames[0] = "None";
1141 for (d = 0; d < IN_MAX_DEVS; d++)
1143 const char *name = in_get_dev_name(d, 0, 1);
1148 in_get_config(d, IN_CFG_ABS_AXIS_COUNT, &count);
1152 if (in_adev[0] == d) stick_sel[0] = i;
1153 if (in_adev[1] == d) stick_sel[1] = i;
1155 adevnames[i++] = name;
1157 adevnames[i] = NULL;
1159 me_loop(e_menu_keyconfig_analog, &sel);
1161 in_adev[0] = sel2dev_map[stick_sel[0]];
1162 in_adev[1] = sel2dev_map[stick_sel[1]];
1167 static const char *mgn_dev_name(int id, int *offs)
1169 const char *name = NULL;
1172 if (id == MA_CTRL_DEV_FIRST)
1175 for (; it < IN_MAX_DEVS; it++) {
1176 name = in_get_dev_name(it, 1, 1);
1185 static const char *mgn_saveloadcfg(int id, int *offs)
1190 static int mh_savecfg(int id, int keys)
1192 if (menu_write_config(id == MA_OPT_SAVECFG_GAME ? 1 : 0) == 0)
1193 menu_update_msg("config saved");
1195 menu_update_msg("failed to write config");
1200 static int mh_input_rescan(int id, int keys)
1202 //menu_sync_config();
1204 menu_update_msg("rescan complete.");
1209 static const char *men_in_type_sel[] = {
1210 "Standard (SCPH-1080)",
1211 "Analog (SCPH-1150)",
1216 static const char h_nub_btns[] = "Experimental, keep this OFF if unsure. Select rescan after change.";
1217 static const char h_notsgun[] = "Don't trigger (shoot) when touching screen in gun games.";
1218 static const char h_vibration[]= "Must select analog above and enable this ingame too.";
1220 static menu_entry e_menu_keyconfig[] =
1222 mee_handler_id("Player 1", MA_CTRL_PLAYER1, key_config_loop_wrap),
1223 mee_handler_id("Player 2", MA_CTRL_PLAYER2, key_config_loop_wrap),
1224 mee_handler_id("Analog controls", MA_CTRL_ANALOG, key_config_analog),
1225 mee_handler_id("Emulator/Gun controls", MA_CTRL_EMU, key_config_loop_wrap),
1227 mee_enum ("Port 1 device", 0, in_type_sel1, men_in_type_sel),
1228 mee_enum ("Port 2 device", 0, in_type_sel2, men_in_type_sel),
1229 mee_onoff_h ("Nubs as buttons", MA_CTRL_NUBS_BTNS, in_evdev_allow_abs_only, 1, h_nub_btns),
1230 mee_onoff_h ("Vibration", MA_CTRL_VIBRATION, in_enable_vibration, 1, h_vibration),
1231 mee_range ("Analog deadzone", MA_CTRL_DEADZONE, analog_deadzone, 1, 99),
1232 mee_onoff_h ("No TS Gun trigger", 0, g_opts, OPT_TSGUN_NOTRIGGER, h_notsgun),
1233 mee_cust_nosave("Save global config", MA_OPT_SAVECFG, mh_savecfg, mgn_saveloadcfg),
1234 mee_cust_nosave("Save cfg for loaded game", MA_OPT_SAVECFG_GAME, mh_savecfg, mgn_saveloadcfg),
1235 mee_handler ("Rescan devices:", mh_input_rescan),
1237 mee_label_mk (MA_CTRL_DEV_FIRST, mgn_dev_name),
1238 mee_label_mk (MA_CTRL_DEV_NEXT, mgn_dev_name),
1239 mee_label_mk (MA_CTRL_DEV_NEXT, 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),
1247 static int menu_loop_keyconfig(int id, int keys)
1251 // me_enable(e_menu_keyconfig, MA_OPT_SAVECFG_GAME, ready_to_go && CdromId[0]);
1252 me_loop(e_menu_keyconfig, &sel);
1256 // ------------ gfx options menu ------------
1258 static const char *men_scaler[] = {
1259 "1x1", "integer scaled 2x", "scaled 4:3", "integer scaled 4:3", "fullscreen", "custom", NULL
1261 static const char *men_soft_filter[] = { "None",
1263 "scale2x", "eagle2x",
1266 static const char *men_dummy[] = { NULL };
1267 static const char *men_centering[] = { "Auto", "Ingame", "Borderless", "Force", NULL };
1268 static const char h_scaler[] = "int. 2x - scales w. or h. 2x if it fits on screen\n"
1269 "int. 4:3 - uses integer if possible, else fractional";
1270 static const char h_cscaler[] = "Displays the scaler layer, you can resize it\n"
1271 "using d-pad or move it using R+d-pad";
1272 static const char h_soft_filter[] = "Works only if game uses low resolution modes";
1273 static const char h_gamma[] = "Gamma/brightness adjustment (default 100)";
1275 static const char h_scanline_l[] = "Scanline brightness, 0-100%";
1278 static int menu_loop_cscaler(int id, int keys)
1282 g_scaler = SCALE_CUSTOM;
1284 plat_gvideo_open(Config.PsxType);
1288 menu_draw_begin(0, 1);
1289 memset(g_menuscreen_ptr, 4, g_menuscreen_w * g_menuscreen_h * 2);
1290 text_out16(2, 2, "%d,%d", g_layer_x, g_layer_y);
1291 text_out16(2, 480 - 18, "%dx%d | d-pad: resize, R+d-pad: move", g_layer_w, g_layer_h);
1294 inp = in_menu_wait(PBTN_UP|PBTN_DOWN|PBTN_LEFT|PBTN_RIGHT
1295 |PBTN_R|PBTN_MOK|PBTN_MBACK, NULL, 40);
1296 if (inp & PBTN_UP) g_layer_y--;
1297 if (inp & PBTN_DOWN) g_layer_y++;
1298 if (inp & PBTN_LEFT) g_layer_x--;
1299 if (inp & PBTN_RIGHT) g_layer_x++;
1300 if (!(inp & PBTN_R)) {
1301 if (inp & PBTN_UP) g_layer_h += 2;
1302 if (inp & PBTN_DOWN) g_layer_h -= 2;
1303 if (inp & PBTN_LEFT) g_layer_w += 2;
1304 if (inp & PBTN_RIGHT) g_layer_w -= 2;
1306 if (inp & (PBTN_MOK|PBTN_MBACK))
1309 if (inp & (PBTN_UP|PBTN_DOWN|PBTN_LEFT|PBTN_RIGHT)) {
1310 if (g_layer_x < 0) g_layer_x = 0;
1311 if (g_layer_x > 640) g_layer_x = 640;
1312 if (g_layer_y < 0) g_layer_y = 0;
1313 if (g_layer_y > 420) g_layer_y = 420;
1314 if (g_layer_w < 160) g_layer_w = 160;
1315 if (g_layer_h < 60) g_layer_h = 60;
1316 if (g_layer_x + g_layer_w > 800)
1317 g_layer_w = 800 - g_layer_x;
1318 if (g_layer_y + g_layer_h > 480)
1319 g_layer_h = 480 - g_layer_y;
1321 plat_gvideo_open(Config.PsxType);
1325 plat_gvideo_close();
1330 static menu_entry e_menu_gfx_options[] =
1332 mee_enum ("Screen centering", MA_OPT_CENTERING, pl_rearmed_cbs.screen_centering_type, men_centering),
1333 mee_enum_h ("Scaler", MA_OPT_VARSCALER, g_scaler, men_scaler, h_scaler),
1334 mee_enum ("Video output mode", MA_OPT_VOUT_MODE, plat_target.vout_method, men_dummy),
1335 mee_onoff ("Software Scaling", MA_OPT_SCALER2, soft_scaling, 1),
1336 mee_enum ("Hardware Filter", MA_OPT_HWFILTER, plat_target.hwfilter, men_dummy),
1337 mee_enum_h ("Software Filter", MA_OPT_SWFILTER, soft_filter, men_soft_filter, h_soft_filter),
1339 mee_onoff ("Scanlines", MA_OPT_SCANLINES, scanlines, 1),
1340 mee_range_h ("Scanline brightness", MA_OPT_SCANLINE_LEVEL, scanline_level, 0, 100, h_scanline_l),
1342 mee_range_h ("Gamma adjustment", MA_OPT_GAMMA, g_gamma, 1, 200, h_gamma),
1343 // mee_onoff ("Vsync", 0, vsync, 1),
1344 mee_cust_h ("Setup custom scaler", MA_OPT_VARSCALER_C, menu_loop_cscaler, NULL, h_cscaler),
1348 static int menu_loop_gfx_options(int id, int keys)
1352 me_loop(e_menu_gfx_options, &sel);
1357 // ------------ bios/plugins ------------
1359 #ifdef BUILTIN_GPU_NEON
1361 static const char h_gpu_neon[] =
1362 "Configure built-in NEON GPU plugin";
1363 static const char h_gpu_neon_enhanced[] =
1364 "Renders in double resolution at the cost of lower performance\n"
1365 "(not available for high resolution games)";
1366 static const char h_gpu_neon_enhanced_hack[] =
1367 "Speed hack for above option (glitches some games)";
1368 static const char *men_gpu_interlace[] = { "Off", "On", "Auto", NULL };
1370 static menu_entry e_menu_plugin_gpu_neon[] =
1372 mee_enum ("Enable interlace mode", 0, pl_rearmed_cbs.gpu_neon.allow_interlace, men_gpu_interlace),
1373 mee_onoff_h ("Enhanced resolution", 0, pl_rearmed_cbs.gpu_neon.enhancement_enable, 1, h_gpu_neon_enhanced),
1374 mee_onoff_h ("Enhanced res. speed hack", 0, pl_rearmed_cbs.gpu_neon.enhancement_no_main, 1, h_gpu_neon_enhanced_hack),
1378 static int menu_loop_plugin_gpu_neon(int id, int keys)
1381 me_loop(e_menu_plugin_gpu_neon, &sel);
1387 static menu_entry e_menu_plugin_gpu_unai_old[] =
1389 mee_onoff ("Skip every 2nd line", 0, pl_rearmed_cbs.gpu_unai_old.lineskip, 1),
1390 mee_onoff ("Abe's Odyssey hack", 0, pl_rearmed_cbs.gpu_unai_old.abe_hack, 1),
1391 mee_onoff ("Disable lighting", 0, pl_rearmed_cbs.gpu_unai_old.no_light, 1),
1392 mee_onoff ("Disable blending", 0, pl_rearmed_cbs.gpu_unai_old.no_blend, 1),
1396 static int menu_loop_plugin_gpu_unai_old(int id, int keys)
1399 me_loop(e_menu_plugin_gpu_unai_old, &sel);
1403 static menu_entry e_menu_plugin_gpu_unai[] =
1405 mee_onoff ("Interlace", 0, pl_rearmed_cbs.gpu_unai.ilace_force, 1),
1406 mee_onoff ("Dithering", 0, pl_rearmed_cbs.gpu_unai.dithering, 1),
1407 mee_onoff ("Lighting", 0, pl_rearmed_cbs.gpu_unai.lighting, 1),
1408 mee_onoff ("Fast lighting", 0, pl_rearmed_cbs.gpu_unai.fast_lighting, 1),
1409 mee_onoff ("Blending", 0, pl_rearmed_cbs.gpu_unai.blending, 1),
1410 mee_onoff ("Pixel skip", 0, pl_rearmed_cbs.gpu_unai.pixel_skip, 1),
1414 static int menu_loop_plugin_gpu_unai(int id, int keys)
1417 me_loop(e_menu_plugin_gpu_unai, &sel);
1422 static const char *men_gpu_dithering[] = { "None", "Game dependant", "Always", NULL };
1423 //static const char h_gpu_0[] = "Needed for Chrono Cross";
1424 static const char h_gpu_1[] = "Capcom fighting games";
1425 static const char h_gpu_2[] = "Black screens in Lunar";
1426 static const char h_gpu_3[] = "Compatibility mode";
1427 static const char h_gpu_6[] = "Pandemonium 2";
1428 //static const char h_gpu_7[] = "Skip every second frame";
1429 static const char h_gpu_8[] = "Needed by Dark Forces";
1430 static const char h_gpu_9[] = "better g-colors, worse textures";
1431 static const char h_gpu_10[] = "Toggle busy flags after drawing";
1433 static menu_entry e_menu_plugin_gpu_peops[] =
1435 mee_enum ("Dithering", 0, pl_rearmed_cbs.gpu_peops.iUseDither, men_gpu_dithering),
1436 // mee_onoff_h ("Odd/even bit hack", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<0, h_gpu_0),
1437 mee_onoff_h ("Expand screen width", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<1, h_gpu_1),
1438 mee_onoff_h ("Ignore brightness color", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<2, h_gpu_2),
1439 mee_onoff_h ("Disable coordinate check", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<3, h_gpu_3),
1440 mee_onoff_h ("Lazy screen update", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<6, h_gpu_6),
1441 // mee_onoff_h ("Old frame skipping", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<7, h_gpu_7),
1442 mee_onoff_h ("Repeated flat tex triangles ",0,pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<8, h_gpu_8),
1443 mee_onoff_h ("Draw quads with triangles", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<9, h_gpu_9),
1444 mee_onoff_h ("Fake 'gpu busy' states", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<10, h_gpu_10),
1448 static int menu_loop_plugin_gpu_peops(int id, int keys)
1451 me_loop(e_menu_plugin_gpu_peops, &sel);
1455 static const char *men_peopsgl_texfilter[] = { "None", "Standard", "Extended",
1456 "Standard-sprites", "Extended-sprites", "Standard+sprites", "Extended+sprites", NULL };
1457 static const char *men_peopsgl_fbtex[] = { "Emulated VRam", "Black", "Card", "Card+soft" };
1459 static menu_entry e_menu_plugin_gpu_peopsgl[] =
1461 mee_onoff ("Dithering", 0, pl_rearmed_cbs.gpu_peopsgl.bDrawDither, 1),
1462 mee_enum ("Texture Filtering", 0, pl_rearmed_cbs.gpu_peopsgl.iFilterType, men_peopsgl_texfilter),
1463 mee_enum ("Framebuffer Textures", 0, pl_rearmed_cbs.gpu_peopsgl.iFrameTexType, men_peopsgl_fbtex),
1464 mee_onoff ("Mask Detect", 0, pl_rearmed_cbs.gpu_peopsgl.iUseMask, 1),
1465 mee_onoff ("Opaque Pass", 0, pl_rearmed_cbs.gpu_peopsgl.bOpaquePass, 1),
1466 mee_onoff ("Advanced Blend", 0, pl_rearmed_cbs.gpu_peopsgl.bAdvancedBlend, 1),
1467 mee_onoff ("Use Fast Mdec", 0, pl_rearmed_cbs.gpu_peopsgl.bUseFastMdec, 1),
1468 mee_range ("Texture RAM size (MB)", 0, pl_rearmed_cbs.gpu_peopsgl.iVRamSize, 4, 128),
1469 mee_onoff ("Texture garbage collection", 0, pl_rearmed_cbs.gpu_peopsgl.iTexGarbageCollection, 1),
1470 mee_label ("Fixes/hacks:"),
1471 mee_onoff ("FF7 cursor", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<0),
1472 mee_onoff ("Direct FB updates", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<1),
1473 mee_onoff ("Black brightness", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<2),
1474 mee_onoff ("Swap front detection", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<3),
1475 mee_onoff ("Disable coord check", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<4),
1476 mee_onoff ("No blue glitches (LoD)", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<5),
1477 mee_onoff ("Soft FB access", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<6),
1478 mee_onoff ("FF9 rect", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<9),
1479 mee_onoff ("No subtr. blending", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<10),
1480 mee_onoff ("Lazy upload (DW7)", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<11),
1481 mee_onoff ("Additional uploads", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<15),
1485 static int menu_loop_plugin_gpu_peopsgl(int id, int keys)
1488 me_loop(e_menu_plugin_gpu_peopsgl, &sel);
1492 static const char *men_spu_interp[] = { "None", "Simple", "Gaussian", "Cubic", NULL };
1493 static const char h_spu_volboost[] = "Large values cause distortion";
1494 static const char h_spu_tempo[] = "Slows down audio if emu is too slow\n"
1495 "This is inaccurate and breaks games";
1497 static menu_entry e_menu_plugin_spu[] =
1499 mee_range_h ("Volume boost", 0, volume_boost, -5, 30, h_spu_volboost),
1500 mee_onoff ("Reverb", 0, spu_config.iUseReverb, 1),
1501 mee_enum ("Interpolation", 0, spu_config.iUseInterpolation, men_spu_interp),
1502 //mee_onoff ("Adjust XA pitch", 0, spu_config.iXAPitch, 1),
1503 mee_onoff_h ("Adjust tempo", 0, spu_config.iTempo, 1, h_spu_tempo),
1507 static int menu_loop_plugin_spu(int id, int keys)
1510 me_loop(e_menu_plugin_spu, &sel);
1514 static const char h_bios[] = "HLE is simulated BIOS. BIOS selection is saved in\n"
1515 "savestates and can't be changed there. Must save\n"
1516 "config and reload the game for change to take effect";
1517 static const char h_plugin_gpu[] =
1518 #ifdef BUILTIN_GPU_NEON
1519 "builtin_gpu is the NEON GPU, very fast and accurate\n"
1521 "gpu_peops is Pete's soft GPU, slow but accurate\n"
1522 "gpu_unai_old is from old PCSX4ALL, fast but glitchy\n"
1523 "gpu_unai is newer, more accurate but slower\n"
1524 "gpu_gles Pete's hw GPU, uses 3D chip but is glitchy\n"
1525 "must save config and reload the game if changed";
1526 static const char h_plugin_spu[] = "spunull effectively disables sound\n"
1527 "must save config and reload the game if changed";
1528 static const char h_gpu_peops[] = "Configure P.E.Op.S. SoftGL Driver V1.17";
1529 static const char h_gpu_peopsgl[]= "Configure P.E.Op.S. MesaGL Driver V1.78";
1530 static const char h_gpu_unai_old[] = "Configure Unai/PCSX4ALL Team GPU plugin (old)";
1531 static const char h_gpu_unai[] = "Configure Unai/PCSX4ALL Team plugin (new)";
1532 static const char h_spu[] = "Configure built-in P.E.Op.S. Sound Driver V1.7";
1534 static menu_entry e_menu_plugin_options[] =
1536 mee_enum_h ("BIOS", 0, bios_sel, bioses, h_bios),
1537 mee_enum_h ("GPU plugin", 0, gpu_plugsel, gpu_plugins, h_plugin_gpu),
1538 mee_enum_h ("SPU plugin", 0, spu_plugsel, spu_plugins, h_plugin_spu),
1539 #ifdef BUILTIN_GPU_NEON
1540 mee_handler_h ("Configure built-in GPU plugin", menu_loop_plugin_gpu_neon, h_gpu_neon),
1542 mee_handler_h ("Configure gpu_peops plugin", menu_loop_plugin_gpu_peops, h_gpu_peops),
1543 mee_handler_h ("Configure gpu_unai_old GPU plugin", menu_loop_plugin_gpu_unai_old, h_gpu_unai_old),
1544 mee_handler_h ("Configure gpu_unai GPU plugin", menu_loop_plugin_gpu_unai, h_gpu_unai),
1545 mee_handler_h ("Configure gpu_gles GPU plugin", menu_loop_plugin_gpu_peopsgl, h_gpu_peopsgl),
1546 mee_handler_h ("Configure built-in SPU plugin", menu_loop_plugin_spu, h_spu),
1550 static menu_entry e_menu_main2[];
1552 static int menu_loop_plugin_options(int id, int keys)
1555 me_loop(e_menu_plugin_options, &sel);
1557 // sync BIOS/plugins
1558 snprintf(Config.Bios, sizeof(Config.Bios), "%s", bioses[bios_sel]);
1559 snprintf(Config.Gpu, sizeof(Config.Gpu), "%s", gpu_plugins[gpu_plugsel]);
1560 snprintf(Config.Spu, sizeof(Config.Spu), "%s", spu_plugins[spu_plugsel]);
1561 me_enable(e_menu_main2, MA_MAIN_RUN_BIOS, bios_sel != 0);
1566 // ------------ adv options menu ------------
1569 static const char h_cfg_noch[] = "Disables game-specific compatibility hacks";
1570 static const char h_cfg_nosmc[] = "Will cause crashes when loading, break memcards";
1571 static const char h_cfg_gteunn[] = "May cause graphical glitches";
1572 static const char h_cfg_gteflgs[] = "Will cause graphical glitches";
1574 static const char h_cfg_stalls[] = "Will cause some games to run too fast";
1576 static menu_entry e_menu_speed_hacks[] =
1579 mee_onoff_h ("Disable compat hacks", 0, new_dynarec_hacks, NDHACK_NO_COMPAT_HACKS, h_cfg_noch),
1580 mee_onoff_h ("Disable SMC checks", 0, new_dynarec_hacks, NDHACK_NO_SMC_CHECK, h_cfg_nosmc),
1581 mee_onoff_h ("Assume GTE regs unneeded", 0, new_dynarec_hacks, NDHACK_GTE_UNNEEDED, h_cfg_gteunn),
1582 mee_onoff_h ("Disable GTE flags", 0, new_dynarec_hacks, NDHACK_GTE_NO_FLAGS, h_cfg_gteflgs),
1584 mee_onoff_h ("Disable CPU/GTE stalls", 0, menu_iopts[0], 1, h_cfg_stalls),
1588 static int menu_loop_speed_hacks(int id, int keys)
1591 menu_iopts[0] = Config.DisableStalls;
1592 me_loop(e_menu_speed_hacks, &sel);
1593 Config.DisableStalls = menu_iopts[0];
1597 static const char *men_gpul[] = { "Auto", "Off", "On", NULL };
1599 static const char h_cfg_cpul[] = "Shows CPU usage in %";
1600 static const char h_cfg_spu[] = "Shows active SPU channels\n"
1601 "(green: normal, red: fmod, blue: noise)";
1602 static const char h_cfg_fl[] = "Frame Limiter keeps the game from running too fast";
1603 static const char h_cfg_xa[] = "Disables XA sound, which can sometimes improve performance";
1604 static const char h_cfg_cdda[] = "Disable CD Audio for a performance boost\n"
1605 "(proper .cue/.bin dump is needed otherwise)";
1607 static const char h_cfg_nodrc[] = "Disable dynamic recompiler and use interpreter\n"
1608 "Might be useful to overcome some dynarec bugs";
1610 static const char h_cfg_shacks[] = "Breaks games but may give better performance";
1611 static const char h_cfg_icache[] = "Support F1 games (only when dynarec is off)";
1612 static const char h_cfg_exc[] = "Emulate some PSX's debug hw like breakpoints\n"
1613 "and exceptions (slow, interpreter only, keep off)";
1614 static const char h_cfg_gpul[] = "Try enabling this if the game misses some graphics\n"
1615 "causes a performance hit";
1616 static const char h_cfg_psxclk[] = "Over/under-clock the PSX, default is " DEFAULT_PSX_CLOCK_S "\n"
1617 "(adjust this if the game is too slow/too fast/hangs)";
1619 enum { AMO_XA, AMO_CDDA, AMO_IC, AMO_BP, AMO_CPU, AMO_GPUL };
1621 static menu_entry e_menu_adv_options[] =
1623 mee_onoff_h ("Show CPU load", 0, g_opts, OPT_SHOWCPU, h_cfg_cpul),
1624 mee_onoff_h ("Show SPU channels", 0, g_opts, OPT_SHOWSPU, h_cfg_spu),
1625 mee_onoff_h ("Disable Frame Limiter", 0, g_opts, OPT_NO_FRAMELIM, h_cfg_fl),
1626 mee_onoff_h ("Disable XA Decoding", 0, menu_iopts[AMO_XA], 1, h_cfg_xa),
1627 mee_onoff_h ("Disable CD Audio", 0, menu_iopts[AMO_CDDA], 1, h_cfg_cdda),
1628 mee_onoff_h ("ICache emulation", 0, menu_iopts[AMO_IC], 1, h_cfg_icache),
1629 mee_onoff_h ("BP exception emulation", 0, menu_iopts[AMO_BP], 1, h_cfg_exc),
1630 mee_enum_h ("GPU l-list slow walking",0, menu_iopts[AMO_GPUL], men_gpul, h_cfg_gpul),
1631 #if !defined(DRC_DISABLE) || defined(LIGHTREC)
1632 mee_onoff_h ("Disable dynarec (slow!)",0, menu_iopts[AMO_CPU], 1, h_cfg_nodrc),
1634 mee_range_h ("PSX CPU clock, %", 0, psx_clock, 1, 500, h_cfg_psxclk),
1635 mee_handler_h ("[Speed hacks]", menu_loop_speed_hacks, h_cfg_shacks),
1639 static int menu_loop_adv_options(int id, int keys)
1646 { &Config.Xa, &menu_iopts[AMO_XA] },
1647 { &Config.Cdda, &menu_iopts[AMO_CDDA] },
1648 { &Config.icache_emulation, &menu_iopts[AMO_IC] },
1649 { &Config.PreciseExceptions, &menu_iopts[AMO_BP] },
1650 { &Config.Cpu, &menu_iopts[AMO_CPU] },
1653 for (i = 0; i < ARRAY_SIZE(opts); i++)
1654 *opts[i].mopt = *opts[i].opt;
1655 menu_iopts[AMO_GPUL] = Config.GpuListWalking + 1;
1657 me_loop(e_menu_adv_options, &sel);
1659 for (i = 0; i < ARRAY_SIZE(opts); i++)
1660 *opts[i].opt = *opts[i].mopt;
1661 Config.GpuListWalking = menu_iopts[AMO_GPUL] - 1;
1666 // ------------ options menu ------------
1668 static int mh_restore_defaults(int id, int keys)
1670 menu_set_defconfig();
1671 menu_update_msg("defaults restored");
1675 static const char *men_region[] = { "Auto", "NTSC", "PAL", NULL };
1676 static const char *men_frameskip[] = { "Auto", "Off", "1", "2", "3", NULL };
1678 static const char *men_confirm_save[] = { "OFF", "writes", "loads", "both", NULL };
1679 static const char h_confirm_save[] = "Ask for confirmation when overwriting save,\n"
1680 "loading state or both";
1682 static const char h_restore_def[] = "Switches back to default / recommended\n"
1684 static const char h_frameskip[] = "Warning: frameskip sometimes causes glitches\n";
1686 static menu_entry e_menu_options[] =
1688 // mee_range ("Save slot", 0, state_slot, 0, 9),
1689 // mee_enum_h ("Confirm savestate", 0, dummy, men_confirm_save, h_confirm_save),
1690 mee_enum_h ("Frameskip", 0, frameskip, men_frameskip, h_frameskip),
1691 mee_onoff ("Show FPS", 0, g_opts, OPT_SHOWFPS),
1692 mee_enum ("Region", 0, region, men_region),
1693 mee_range ("CPU clock", MA_OPT_CPU_CLOCKS, cpu_clock, 20, 5000),
1695 mee_onoff ("Use C64x DSP for sound", MA_OPT_SPU_THREAD, spu_config.iUseThread, 1),
1697 mee_onoff ("Threaded SPU", MA_OPT_SPU_THREAD, spu_config.iUseThread, 1),
1699 mee_handler_id("[Display]", MA_OPT_DISP_OPTS, menu_loop_gfx_options),
1700 mee_handler ("[BIOS/Plugins]", menu_loop_plugin_options),
1701 mee_handler ("[Advanced]", menu_loop_adv_options),
1702 mee_cust_nosave("Save global config", MA_OPT_SAVECFG, mh_savecfg, mgn_saveloadcfg),
1703 mee_cust_nosave("Save cfg for loaded game",MA_OPT_SAVECFG_GAME, mh_savecfg, mgn_saveloadcfg),
1704 mee_handler_h ("Restore default config", mh_restore_defaults, h_restore_def),
1708 static int menu_loop_options(int id, int keys)
1712 me_enable(e_menu_options, MA_OPT_CPU_CLOCKS, cpu_clock_st > 0);
1713 me_enable(e_menu_options, MA_OPT_SPU_THREAD, spu_config.iThreadAvail);
1714 me_enable(e_menu_options, MA_OPT_SAVECFG_GAME, ready_to_go && CdromId[0]);
1716 me_loop(e_menu_options, &sel);
1721 // ------------ debug menu ------------
1723 static void draw_frame_debug(GPUFreeze_t *gpuf, int x, int y)
1725 int w = min(g_menuscreen_w, 1024);
1726 int h = min(g_menuscreen_h, 512);
1727 u16 *d = g_menuscreen_ptr;
1728 u16 *s = (u16 *)gpuf->psxVRam + y * 1024 + x;
1732 gpuf->ulFreezeVersion = 1;
1733 if (GPU_freeze != NULL)
1734 GPU_freeze(1, gpuf);
1736 for (; h > 0; h--, d += g_menuscreen_w, s += 1024)
1737 bgr555_to_rgb565(d, s, w * 2);
1739 smalltext_out16(4, 1, "build: "__DATE__ " " __TIME__ " " REV, 0xe7fc);
1740 snprintf(buff, sizeof(buff), "GPU sr: %08x", gpuf->ulStatus);
1741 smalltext_out16(4, (ty += me_sfont_h), buff, 0xe7fc);
1742 snprintf(buff, sizeof(buff), "PC/SP: %08x %08x", psxRegs.pc, psxRegs.GPR.n.sp);
1743 smalltext_out16(4, (ty += me_sfont_h), buff, 0xe7fc);
1746 static void debug_menu_loop(void)
1748 int inp, df_x = 0, df_y = 0;
1751 gpuf = malloc(sizeof(*gpuf));
1757 menu_draw_begin(0, 1);
1758 draw_frame_debug(gpuf, df_x, df_y);
1761 inp = in_menu_wait(PBTN_MOK|PBTN_MBACK|PBTN_MA2|PBTN_MA3|PBTN_L|PBTN_R |
1762 PBTN_UP|PBTN_DOWN|PBTN_LEFT|PBTN_RIGHT, NULL, 10);
1763 if (inp & PBTN_MBACK) break;
1764 else if (inp & PBTN_UP) { if (df_y > 0) df_y--; }
1765 else if (inp & PBTN_DOWN) { if (df_y < 512 - g_menuscreen_h) df_y++; }
1766 else if (inp & PBTN_LEFT) { if (df_x > 0) df_x -= 2; }
1767 else if (inp & PBTN_RIGHT) { if (df_x < 1024 - g_menuscreen_w) df_x += 2; }
1773 // --------- memcard manager ---------
1775 static void draw_mc_icon(int dx, int dy, const u16 *s)
1780 d = (u16 *)g_menuscreen_ptr + g_menuscreen_w * dy + dx;
1782 for (y = 0; y < 16; y++, s += 16) {
1783 for (l = 0; l < 2; l++, d += g_menuscreen_w) {
1784 for (x = 0; x < 16; x++) {
1786 d[x*2] = d[x*2 + 1] = ((p & 0x7c00) >> 10)
1787 | ((p & 0x03e0) << 1) | ((p & 0x1f) << 11);
1793 static void draw_mc_bg(void)
1795 McdBlock *blocks1, *blocks2;
1799 blocks1 = malloc(15 * sizeof(blocks1[0]));
1800 blocks2 = malloc(15 * sizeof(blocks1[0]));
1801 if (blocks1 == NULL || blocks2 == NULL)
1804 for (i = 0; i < 15; i++) {
1805 GetMcdBlockInfo(1, i + 1, &blocks1[i]);
1806 GetMcdBlockInfo(2, i + 1, &blocks2[i]);
1809 menu_draw_begin(1, 1);
1811 memcpy(g_menuscreen_ptr, g_menubg_src_ptr, g_menuscreen_w * g_menuscreen_h * 2);
1813 y = g_menuscreen_h / 2 - 15 * 32 / 2;
1817 maxicons = g_menuscreen_h / 32;
1820 row2 = g_menuscreen_w / 2;
1821 for (i = 0; i < maxicons; i++) {
1822 draw_mc_icon(8, y + i * 32, (u16 *)blocks1[i].Icon);
1823 smalltext_out16(10+32, y + i * 32 + 8, blocks1[i].sTitle, 0xf71e);
1825 draw_mc_icon(row2 + 8, y + i * 32, (u16 *)blocks2[i].Icon);
1826 smalltext_out16(row2 + 10+32, y + i * 32 + 8, blocks2[i].sTitle, 0xf71e);
1829 menu_darken_bg(g_menubg_ptr, g_menuscreen_ptr, g_menuscreen_w * g_menuscreen_h, 0);
1837 static void handle_memcard_sel(void)
1839 strcpy(Config.Mcd1, "none");
1840 if (memcard1_sel != 0)
1841 snprintf(Config.Mcd1, sizeof(Config.Mcd1), ".%s%s", MEMCARD_DIR, memcards[memcard1_sel]);
1842 strcpy(Config.Mcd2, "none");
1843 if (memcard2_sel != 0)
1844 snprintf(Config.Mcd2, sizeof(Config.Mcd2), ".%s%s", MEMCARD_DIR, memcards[memcard2_sel]);
1845 LoadMcds(Config.Mcd1, Config.Mcd2);
1849 static menu_entry e_memcard_options[] =
1851 mee_enum("Memory card 1", 0, memcard1_sel, memcards),
1852 mee_enum("Memory card 2", 0, memcard2_sel, memcards),
1856 static int menu_loop_memcards(int id, int keys)
1862 memcard1_sel = memcard2_sel = 0;
1863 p = strrchr(Config.Mcd1, '/');
1865 for (i = 0; memcards[i] != NULL; i++)
1866 if (strcmp(p + 1, memcards[i]) == 0)
1867 { memcard1_sel = i; break; }
1868 p = strrchr(Config.Mcd2, '/');
1870 for (i = 0; memcards[i] != NULL; i++)
1871 if (strcmp(p + 1, memcards[i]) == 0)
1872 { memcard2_sel = i; break; }
1874 me_loop_d(e_memcard_options, &sel, handle_memcard_sel, NULL);
1876 memcpy(g_menubg_ptr, g_menubg_src_ptr, g_menuscreen_w * g_menuscreen_h * 2);
1881 // ------------ cheats menu ------------
1883 static void draw_cheatlist(int sel)
1885 int max_cnt, start, i, pos, active;
1887 max_cnt = g_menuscreen_h / me_sfont_h;
1888 start = max_cnt / 2 - sel;
1890 menu_draw_begin(1, 1);
1892 for (i = 0; i < NumCheats; i++) {
1894 if (pos < 0) continue;
1895 if (pos >= max_cnt) break;
1896 active = Cheats[i].Enabled;
1897 smalltext_out16(14, pos * me_sfont_h,
1898 active ? "ON " : "OFF", active ? 0xfff6 : 0xffff);
1899 smalltext_out16(14 + me_sfont_w*4, pos * me_sfont_h,
1900 Cheats[i].Descr, active ? 0xfff6 : 0xffff);
1904 smalltext_out16(14, pos * me_sfont_h, "done", 0xffff);
1906 text_out16(5, max_cnt / 2 * me_sfont_h, ">");
1910 static void menu_loop_cheats(void)
1912 static int menu_sel = 0;
1917 draw_cheatlist(menu_sel);
1918 inp = in_menu_wait(PBTN_UP|PBTN_DOWN|PBTN_LEFT|PBTN_RIGHT|PBTN_L|PBTN_R
1919 |PBTN_MOK|PBTN_MBACK, NULL, 33);
1920 if (inp & PBTN_UP ) { menu_sel--; if (menu_sel < 0) menu_sel = NumCheats; }
1921 if (inp & PBTN_DOWN) { menu_sel++; if (menu_sel > NumCheats) menu_sel = 0; }
1922 if (inp &(PBTN_LEFT|PBTN_L)) { menu_sel-=10; if (menu_sel < 0) menu_sel = 0; }
1923 if (inp &(PBTN_RIGHT|PBTN_R)) { menu_sel+=10; if (menu_sel > NumCheats) menu_sel = NumCheats; }
1924 if (inp & PBTN_MOK) { // action
1925 if (menu_sel < NumCheats)
1926 Cheats[menu_sel].Enabled = !Cheats[menu_sel].Enabled;
1929 if (inp & PBTN_MBACK)
1934 // --------- main menu help ----------
1936 static void menu_bios_warn(void)
1939 static const char msg[] =
1940 "You don't seem to have copied any BIOS\n"
1942 MENU_BIOS_PATH "\n\n"
1944 "While many games work fine with fake\n"
1945 "(HLE) BIOS, others (like MGS and FF8)\n"
1946 "require BIOS to work.\n"
1947 "After copying the file, you'll also need\n"
1948 "to select it in the emu's menu:\n"
1949 "options->[BIOS/Plugins]\n\n"
1950 "The file is usually named SCPH1001.BIN,\n"
1951 "but other not compressed files can be\n"
1953 "Press %s or %s to continue";
1954 char tmp_msg[sizeof(msg) + 64];
1956 snprintf(tmp_msg, sizeof(tmp_msg), msg,
1957 in_get_key_name(-1, -PBTN_MOK), in_get_key_name(-1, -PBTN_MBACK));
1960 draw_menu_message(tmp_msg, NULL);
1962 inp = in_menu_wait(PBTN_MOK|PBTN_MBACK, NULL, 70);
1963 if (inp & (PBTN_MBACK|PBTN_MOK))
1968 // ------------ main menu ------------
1970 static menu_entry e_menu_main[];
1972 static void draw_frame_main(void)
1981 if (CdromId[0] != 0) {
1982 snprintf(buff, sizeof(buff), "%.32s/%.9s (running as %s, with %s)",
1983 get_cd_label(), CdromId, Config.PsxType ? "PAL" : "NTSC",
1984 Config.HLE ? "HLE" : "BIOS");
1985 smalltext_out16(4, 1, buff, 0x105f);
1989 capacity = plat_target_bat_capacity_get();
1991 tmp = localtime(<ime);
1992 strftime(ltime_s, sizeof(ltime_s), "%H:%M", tmp);
1993 if (capacity >= 0) {
1994 snprintf(buff, sizeof(buff), "%s %3d%%", ltime_s, capacity);
1999 smalltext_out16(4, 1 + me_sfont_h, out, 0x105f);
2003 static void draw_frame_credits(void)
2005 smalltext_out16(4, 1, "build: " __DATE__ " " __TIME__ " " REV, 0xe7fc);
2008 static const char credits_text[] =
2010 "(C) 1999-2003 PCSX Team\n"
2011 "(C) 2005-2009 PCSX-df Team\n"
2012 "(C) 2009-2011 PCSX-Reloaded Team\n\n"
2013 "ARM recompiler (C) 2009-2011 Ari64\n"
2014 #ifdef BUILTIN_GPU_NEON
2015 "ARM NEON GPU (c) 2011-2012 Exophase\n"
2017 "PEOpS GPU and SPU by Pete Bernert\n"
2018 " and the P.E.Op.S. team\n"
2019 "PCSX4ALL plugin by PCSX4ALL team\n"
2020 " Chui, Franxis, Unai\n\n"
2021 "integration, optimization and\n"
2022 " frontend (C) 2010-2015 notaz\n";
2024 static int reset_game(void)
2030 if (LoadCdrom() == -1)
2036 static int reload_plugins(const char *cdimg)
2042 set_cd_image(cdimg);
2044 pcnt_hook_plugins();
2046 if (OpenPlugins() == -1) {
2047 menu_update_msg("failed to open plugins");
2050 plugin_call_rearmed_cbs();
2052 cdrIsoMultidiskCount = 1;
2054 CdromLabel[0] = '\0';
2059 static int run_bios(void)
2061 boolean origSlowBoot = Config.SlowBoot;
2067 if (reload_plugins(NULL) != 0)
2069 Config.SlowBoot = 1;
2071 Config.SlowBoot = origSlowBoot;
2077 static int run_exe(void)
2079 const char *exts[] = { "exe", NULL };
2082 fname = menu_loop_romsel(last_selected_fname,
2083 sizeof(last_selected_fname), exts, NULL);
2088 if (reload_plugins(NULL) != 0)
2092 if (Load(fname) != 0) {
2093 menu_update_msg("exe load failed, bad file?");
2102 static int run_cd_image(const char *fname)
2104 int autoload_state = g_autostateld_opt;
2107 reload_plugins(fname);
2109 // always autodetect, menu_sync_config will override as needed
2112 if (CheckCdrom() == -1) {
2113 // Only check the CD if we are starting the console with a CD
2115 menu_update_msg("unsupported/invalid CD image");
2121 // Read main executable directly from CDRom and start it
2122 if (LoadCdrom() == -1) {
2124 menu_update_msg("failed to load CD image");
2131 if (autoload_state) {
2132 unsigned int newest = 0;
2133 int time, slot, newest_slot = -1;
2135 for (slot = 0; slot < 10; slot++) {
2136 if (emu_check_save_file(slot, &time)) {
2137 if ((unsigned int)time > newest) {
2144 if (newest_slot >= 0) {
2145 lprintf("autoload slot %d\n", newest_slot);
2146 emu_load_state(newest_slot);
2149 lprintf("no save to autoload.\n");
2156 static int romsel_run(void)
2158 int prev_gpu, prev_spu;
2161 fname = menu_loop_romsel(last_selected_fname,
2162 sizeof(last_selected_fname), filter_exts,
2163 optional_cdimg_filter);
2167 printf("selected file: %s\n", fname);
2169 new_dynarec_clear_full();
2171 if (run_cd_image(fname) != 0)
2174 prev_gpu = gpu_plugsel;
2175 prev_spu = spu_plugsel;
2176 if (menu_load_config(1) != 0)
2177 menu_load_config(0);
2179 // check for plugin changes, have to repeat
2180 // loading if game config changed plugins to reload them
2181 if (prev_gpu != gpu_plugsel || prev_spu != spu_plugsel) {
2182 printf("plugin change detected, reloading plugins..\n");
2183 if (run_cd_image(fname) != 0)
2187 strcpy(last_selected_fname, fname);
2188 menu_do_last_cd_img(0);
2192 static int swap_cd_image(void)
2196 fname = menu_loop_romsel(last_selected_fname,
2197 sizeof(last_selected_fname), filter_exts,
2198 optional_cdimg_filter);
2202 printf("selected file: %s\n", fname);
2205 CdromLabel[0] = '\0';
2207 set_cd_image(fname);
2208 if (ReloadCdromPlugin() < 0) {
2209 menu_update_msg("failed to load cdr plugin");
2212 if (CDR_open() < 0) {
2213 menu_update_msg("failed to open cdr plugin");
2217 SetCdOpenCaseTime(time(NULL) + 2);
2220 strcpy(last_selected_fname, fname);
2224 static int swap_cd_multidisk(void)
2226 cdrIsoMultidiskSelect++;
2228 CdromLabel[0] = '\0';
2231 if (CDR_open() < 0) {
2232 menu_update_msg("failed to open cdr plugin");
2236 SetCdOpenCaseTime(time(NULL) + 2);
2242 static void load_pcsx_cht(void)
2244 static const char *exts[] = { "cht", NULL };
2248 fname = menu_loop_romsel(last_selected_fname,
2249 sizeof(last_selected_fname), exts, NULL);
2253 printf("selected cheat file: %s\n", fname);
2256 if (NumCheats == 0 && NumCodes == 0)
2257 menu_update_msg("failed to load cheats");
2259 snprintf(msg, sizeof(msg), "%d cheat(s) loaded", NumCheats + NumCodes);
2260 menu_update_msg(msg);
2262 me_enable(e_menu_main, MA_MAIN_CHEATS, ready_to_go && NumCheats);
2265 static int main_menu_handler(int id, int keys)
2269 case MA_MAIN_RESUME_GAME:
2273 case MA_MAIN_SAVE_STATE:
2275 return menu_loop_savestate(0);
2277 case MA_MAIN_LOAD_STATE:
2279 return menu_loop_savestate(1);
2281 case MA_MAIN_RESET_GAME:
2282 if (ready_to_go && reset_game() == 0)
2285 case MA_MAIN_LOAD_ROM:
2286 if (romsel_run() == 0)
2289 case MA_MAIN_SWAP_CD:
2290 if (swap_cd_image() == 0)
2293 case MA_MAIN_SWAP_CD_MULTI:
2294 if (swap_cd_multidisk() == 0)
2297 case MA_MAIN_RUN_BIOS:
2298 if (run_bios() == 0)
2301 case MA_MAIN_RUN_EXE:
2305 case MA_MAIN_CHEATS:
2308 case MA_MAIN_LOAD_CHEATS:
2311 case MA_MAIN_CREDITS:
2312 draw_menu_message(credits_text, draw_frame_credits);
2313 in_menu_wait(PBTN_MOK|PBTN_MBACK, NULL, 70);
2316 emu_core_ask_exit();
2319 lprintf("%s: something unknown selected\n", __FUNCTION__);
2326 static menu_entry e_menu_main2[] =
2328 mee_handler_id("Change CD image", MA_MAIN_SWAP_CD, main_menu_handler),
2329 mee_handler_id("Next multidisk CD", MA_MAIN_SWAP_CD_MULTI, main_menu_handler),
2330 mee_handler_id("Run BIOS", MA_MAIN_RUN_BIOS, main_menu_handler),
2331 mee_handler_id("Run EXE", MA_MAIN_RUN_EXE, main_menu_handler),
2332 mee_handler ("Memcard manager", menu_loop_memcards),
2333 mee_handler_id("Load PCSX cheats..", MA_MAIN_LOAD_CHEATS, main_menu_handler),
2337 static int main_menu2_handler(int id, int keys)
2341 me_enable(e_menu_main2, MA_MAIN_SWAP_CD, ready_to_go);
2342 me_enable(e_menu_main2, MA_MAIN_SWAP_CD_MULTI, ready_to_go && cdrIsoMultidiskCount > 1);
2343 me_enable(e_menu_main2, MA_MAIN_RUN_BIOS, bios_sel != 0);
2344 me_enable(e_menu_main2, MA_MAIN_LOAD_CHEATS, ready_to_go);
2346 return me_loop_d(e_menu_main2, &sel, NULL, draw_frame_main);
2349 static const char h_extra[] = "Change CD, manage memcards..\n";
2351 static menu_entry e_menu_main[] =
2355 mee_handler_id("Resume game", MA_MAIN_RESUME_GAME, main_menu_handler),
2356 mee_handler_id("Save State", MA_MAIN_SAVE_STATE, main_menu_handler),
2357 mee_handler_id("Load State", MA_MAIN_LOAD_STATE, main_menu_handler),
2358 mee_handler_id("Reset game", MA_MAIN_RESET_GAME, main_menu_handler),
2359 mee_handler_id("Load CD image", MA_MAIN_LOAD_ROM, main_menu_handler),
2360 mee_handler ("Options", menu_loop_options),
2361 mee_handler ("Controls", menu_loop_keyconfig),
2362 mee_handler_id("Cheats", MA_MAIN_CHEATS, main_menu_handler),
2363 mee_handler_h ("Extra stuff", main_menu2_handler, h_extra),
2364 mee_handler_id("Credits", MA_MAIN_CREDITS, main_menu_handler),
2365 mee_handler_id("Exit", MA_MAIN_EXIT, main_menu_handler),
2369 // ----------------------------
2371 static void menu_leave_emu(void);
2373 void menu_loop(void)
2375 static int warned_about_bios = 0;
2380 if (config_save_counter == 0) {
2382 if (bioses[1] != NULL) {
2383 // autoselect BIOS to make user's life easier
2384 snprintf(Config.Bios, sizeof(Config.Bios), "%s", bioses[1]);
2387 else if (!warned_about_bios) {
2389 warned_about_bios = 1;
2393 me_enable(e_menu_main, MA_MAIN_RESUME_GAME, ready_to_go);
2394 me_enable(e_menu_main, MA_MAIN_SAVE_STATE, ready_to_go && CdromId[0]);
2395 me_enable(e_menu_main, MA_MAIN_LOAD_STATE, ready_to_go && CdromId[0]);
2396 me_enable(e_menu_main, MA_MAIN_RESET_GAME, ready_to_go);
2397 me_enable(e_menu_main, MA_MAIN_CHEATS, ready_to_go && NumCheats);
2399 in_set_config_int(0, IN_CFG_BLOCKING, 1);
2402 me_loop_d(e_menu_main, &sel, NULL, draw_frame_main);
2403 } while (!ready_to_go && !g_emu_want_quit);
2405 /* wait until menu, ok, back is released */
2406 while (in_menu_wait_any(NULL, 50) & (PBTN_MENU|PBTN_MOK|PBTN_MBACK))
2409 in_set_config_int(0, IN_CFG_BLOCKING, 0);
2414 static int qsort_strcmp(const void *p1, const void *p2)
2416 char * const *s1 = (char * const *)p1;
2417 char * const *s2 = (char * const *)p2;
2418 return strcasecmp(*s1, *s2);
2421 static void scan_bios_plugins(void)
2423 char fname[MAXPATHLEN];
2425 int bios_i, gpu_i, spu_i, mc_i;
2430 gpu_plugins[0] = "builtin_gpu";
2431 spu_plugins[0] = "builtin_spu";
2432 memcards[0] = "(none)";
2433 bios_i = gpu_i = spu_i = mc_i = 1;
2435 snprintf(fname, sizeof(fname), "%s/", Config.BiosDir);
2436 dir = opendir(fname);
2438 perror("scan_bios_plugins bios opendir");
2453 if (ent->d_type != DT_REG && ent->d_type != DT_LNK)
2456 snprintf(fname, sizeof(fname), "%s/%s", Config.BiosDir, ent->d_name);
2457 if (stat(fname, &st) != 0
2458 || (st.st_size != 512*1024 && st.st_size != 4*1024*1024)) {
2459 printf("bad BIOS file: %s\n", ent->d_name);
2463 if (bios_i < ARRAY_SIZE(bioses) - 1) {
2464 bioses[bios_i++] = strdup(ent->d_name);
2468 printf("too many BIOSes, dropping \"%s\"\n", ent->d_name);
2474 snprintf(fname, sizeof(fname), "%s/", Config.PluginsDir);
2475 dir = opendir(fname);
2477 perror("scan_bios_plugins plugins opendir");
2491 p = strstr(ent->d_name, ".so");
2495 snprintf(fname, sizeof(fname), "%s/%s", Config.PluginsDir, ent->d_name);
2496 h = dlopen(fname, RTLD_LAZY | RTLD_LOCAL);
2498 fprintf(stderr, "%s\n", dlerror());
2502 // now what do we have here?
2503 tmp = dlsym(h, "GPUinit");
2506 if (gpu_i < ARRAY_SIZE(gpu_plugins) - 1)
2507 gpu_plugins[gpu_i++] = strdup(ent->d_name);
2511 tmp = dlsym(h, "SPUinit");
2514 if (spu_i < ARRAY_SIZE(spu_plugins) - 1)
2515 spu_plugins[spu_i++] = strdup(ent->d_name);
2519 fprintf(stderr, "ignoring unidentified plugin: %s\n", fname);
2526 dir = opendir("." MEMCARD_DIR);
2528 perror("scan_bios_plugins memcards opendir");
2543 if (ent->d_type != DT_REG && ent->d_type != DT_LNK)
2546 snprintf(fname, sizeof(fname), "." MEMCARD_DIR "%s", ent->d_name);
2547 if (stat(fname, &st) != 0) {
2548 printf("bad memcard file: %s\n", ent->d_name);
2552 if (mc_i < ARRAY_SIZE(memcards) - 1) {
2553 memcards[mc_i++] = strdup(ent->d_name);
2557 printf("too many memcards, dropping \"%s\"\n", ent->d_name);
2561 qsort(memcards + 1, mc_i - 1, sizeof(memcards[0]), qsort_strcmp);
2566 void menu_init(void)
2568 char buff[MAXPATHLEN];
2571 cpu_clock_st = cpu_clock = plat_target_cpu_clock_get();
2573 scan_bios_plugins();
2576 menu_set_defconfig();
2577 menu_load_config(0);
2578 menu_do_last_cd_img(1);
2583 g_menubg_src_ptr = calloc(g_menuscreen_w * g_menuscreen_h * 2, 1);
2584 g_menubg_ptr = calloc(g_menuscreen_w * g_menuscreen_h * 2, 1);
2585 if (g_menubg_src_ptr == NULL || g_menubg_ptr == NULL) {
2586 fprintf(stderr, "OOM\n");
2590 emu_make_path(buff, "skin/background.png", sizeof(buff));
2591 readpng(g_menubg_src_ptr, buff, READPNG_BG, g_menuscreen_w, g_menuscreen_h);
2593 i = plat_target.cpu_clock_set != NULL
2594 && plat_target.cpu_clock_get != NULL && cpu_clock_st > 0;
2595 me_enable(e_menu_options, MA_OPT_CPU_CLOCKS, i);
2597 i = me_id2offset(e_menu_gfx_options, MA_OPT_VOUT_MODE);
2598 e_menu_gfx_options[i].data = plat_target.vout_methods;
2599 me_enable(e_menu_gfx_options, MA_OPT_VOUT_MODE,
2600 plat_target.vout_methods != NULL);
2602 i = me_id2offset(e_menu_gfx_options, MA_OPT_HWFILTER);
2603 e_menu_gfx_options[i].data = plat_target.hwfilters;
2604 me_enable(e_menu_gfx_options, MA_OPT_HWFILTER,
2605 plat_target.hwfilters != NULL);
2607 me_enable(e_menu_gfx_options, MA_OPT_GAMMA,
2608 plat_target.gamma_set != NULL);
2610 #ifdef HAVE_PRE_ARMV7
2611 me_enable(e_menu_gfx_options, MA_OPT_SWFILTER, 0);
2613 me_enable(e_menu_gfx_options, MA_OPT_VARSCALER, MENU_SHOW_VARSCALER);
2614 me_enable(e_menu_gfx_options, MA_OPT_VOUT_MODE, MENU_SHOW_VOUTMODE);
2615 me_enable(e_menu_gfx_options, MA_OPT_VARSCALER_C, MENU_SHOW_VARSCALER);
2616 me_enable(e_menu_gfx_options, MA_OPT_SCALER2, MENU_SHOW_SCALER2);
2617 me_enable(e_menu_keyconfig, MA_CTRL_NUBS_BTNS, MENU_SHOW_NUBS_BTNS);
2618 me_enable(e_menu_keyconfig, MA_CTRL_VIBRATION, MENU_SHOW_VIBRATION);
2619 me_enable(e_menu_keyconfig, MA_CTRL_DEADZONE, MENU_SHOW_DEADZONE);
2622 void menu_notify_mode_change(int w, int h, int bpp)
2626 last_vout_bpp = bpp;
2629 static void menu_leave_emu(void)
2631 if (GPU_close != NULL) {
2632 int ret = GPU_close();
2634 fprintf(stderr, "Warning: GPU_close returned %d\n", ret);
2637 plat_video_menu_enter(ready_to_go);
2639 memcpy(g_menubg_ptr, g_menubg_src_ptr, g_menuscreen_w * g_menuscreen_h * 2);
2640 if (pl_vout_buf != NULL && ready_to_go) {
2641 int x = max(0, g_menuscreen_w - last_vout_w);
2642 int y = max(0, g_menuscreen_h / 2 - last_vout_h / 2);
2643 int w = min(g_menuscreen_w, last_vout_w);
2644 int h = min(g_menuscreen_h, last_vout_h);
2645 u16 *d = (u16 *)g_menubg_ptr + g_menuscreen_w * y + x;
2646 char *s = pl_vout_buf;
2648 if (last_vout_bpp == 16) {
2649 for (; h > 0; h--, d += g_menuscreen_w, s += last_vout_w * 2)
2650 menu_darken_bg(d, s, w, 0);
2653 for (; h > 0; h--, d += g_menuscreen_w, s += last_vout_w * 3) {
2654 rgb888_to_rgb565(d, s, w * 3);
2655 menu_darken_bg(d, d, w, 0);
2661 cpu_clock = plat_target_cpu_clock_get();
2664 void menu_prepare_emu(void)
2666 R3000Acpu *prev_cpu = psxCpu;
2668 plat_video_menu_leave();
2670 #if !defined(DRC_DISABLE) || defined(LIGHTREC)
2671 psxCpu = (Config.Cpu == CPU_INTERPRETER) ? &psxInt : &psxRec;
2675 if (psxCpu != prev_cpu) {
2676 prev_cpu->Notify(R3000ACPU_NOTIFY_BEFORE_SAVE, NULL);
2677 prev_cpu->Shutdown();
2680 psxCpu->Notify(R3000ACPU_NOTIFY_AFTER_LOAD, NULL);
2684 psxCpu->ApplyConfig();
2686 // core doesn't care about Config.Cdda changes,
2687 // so handle them manually here
2692 plat_target_cpu_clock_set(cpu_clock);
2694 // push config to GPU plugin
2695 plugin_call_rearmed_cbs();
2697 if (GPU_open != NULL) {
2698 int ret = GPU_open(&gpuDisp, "PCSX", NULL);
2700 fprintf(stderr, "Warning: GPU_open returned %d\n", ret);
2704 void menu_update_msg(const char *msg)
2706 strncpy(menu_error_msg, msg, sizeof(menu_error_msg));
2707 menu_error_msg[sizeof(menu_error_msg) - 1] = 0;
2709 menu_error_time = plat_get_ticks_ms();
2710 lprintf("msg: %s\n", menu_error_msg);
2713 void menu_finish(void)
2715 if (cpu_clock_st > 0)
2716 plat_target_cpu_clock_set(cpu_clock_st);