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