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