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