notaz.gp2x.de / pcsx_rearmed.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
handle more GP0 status bits
[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 return 0;
2015}
2016
2017static int reload_plugins(const char *cdimg)
2018{
2019 pl_vout_buf = NULL;
2020
2021 ClosePlugins();
2022
2023 set_cd_image(cdimg);
2024 LoadPlugins();
2025 pcnt_hook_plugins();
2026 NetOpened = 0;
2027 if (OpenPlugins() == -1) {
2028 menu_update_msg("failed to open plugins");
2029 return -1;
2030 }
2031 plugin_call_rearmed_cbs();
2032
2033 cdrIsoMultidiskCount = 1;
2034 CdromId[0] = '\0';
2035 CdromLabel[0] = '\0';
2036
2037 return 0;
2038}
2039
2040static int run_bios(void)
2041{
2042 boolean origSlowBoot = Config.SlowBoot;
2043
2044 if (bios_sel == 0)
2045 return -1;
2046
2047 ready_to_go = 0;
2048 if (reload_plugins(NULL) != 0)
2049 return -1;
2050 Config.SlowBoot = 1;
2051 SysReset();
2052 Config.SlowBoot = origSlowBoot;
2053
2054 ready_to_go = 1;
2055 return 0;
2056}
2057
2058static int run_exe(void)
2059{
2060 const char *exts[] = { "exe", NULL };
2061 const char *fname;
2062
2063 fname = menu_loop_romsel(last_selected_fname,
2064 sizeof(last_selected_fname), exts, NULL);
2065 if (fname == NULL)
2066 return -1;
2067
2068 ready_to_go = 0;
2069 if (reload_plugins(NULL) != 0)
2070 return -1;
2071
2072 SysReset();
2073 if (Load(fname) != 0) {
2074 menu_update_msg("exe load failed, bad file?");
2075 printf("meh\n");
2076 return -1;
2077 }
2078
2079 ready_to_go = 1;
2080 return 0;
2081}
2082
2083static int run_cd_image(const char *fname)
2084{
2085 int autoload_state = g_autostateld_opt;
2086
2087 ready_to_go = 0;
2088 reload_plugins(fname);
2089
2090 // always autodetect, menu_sync_config will override as needed
2091 Config.PsxAuto = 1;
2092
2093 if (CheckCdrom() == -1) {
2094 // Only check the CD if we are starting the console with a CD
2095 ClosePlugins();
2096 menu_update_msg("unsupported/invalid CD image");
2097 return -1;
2098 }
2099
2100 SysReset();
2101
2102 // Read main executable directly from CDRom and start it
2103 if (LoadCdrom() == -1) {
2104 ClosePlugins();
2105 menu_update_msg("failed to load CD image");
2106 return -1;
2107 }
2108
2109 emu_on_new_cd(1);
2110 ready_to_go = 1;
2111
2112 if (autoload_state) {
2113 unsigned int newest = 0;
2114 int time, slot, newest_slot = -1;
2115
2116 for (slot = 0; slot < 10; slot++) {
2117 if (emu_check_save_file(slot, &time)) {
2118 if ((unsigned int)time > newest) {
2119 newest = time;
2120 newest_slot = slot;
2121 }
2122 }
2123 }
2124
2125 if (newest_slot >= 0) {
2126 lprintf("autoload slot %d\n", newest_slot);
2127 emu_load_state(newest_slot);
2128 }
2129 else {
2130 lprintf("no save to autoload.\n");
2131 }
2132 }
2133
2134 return 0;
2135}
2136
2137static int romsel_run(void)
2138{
2139 int prev_gpu, prev_spu;
2140 const char *fname;
2141
2142 fname = menu_loop_romsel(last_selected_fname,
2143 sizeof(last_selected_fname), filter_exts,
2144 optional_cdimg_filter);
2145 if (fname == NULL)
2146 return -1;
2147
2148 printf("selected file: %s\n", fname);
2149
2150 new_dynarec_clear_full();
2151
2152 if (run_cd_image(fname) != 0)
2153 return -1;
2154
2155 prev_gpu = gpu_plugsel;
2156 prev_spu = spu_plugsel;
2157 if (menu_load_config(1) != 0)
2158 menu_load_config(0);
2159
2160 // check for plugin changes, have to repeat
2161 // loading if game config changed plugins to reload them
2162 if (prev_gpu != gpu_plugsel || prev_spu != spu_plugsel) {
2163 printf("plugin change detected, reloading plugins..\n");
2164 if (run_cd_image(fname) != 0)
2165 return -1;
2166 }
2167
2168 strcpy(last_selected_fname, fname);
2169 menu_do_last_cd_img(0);
2170 return 0;
2171}
2172
2173static int swap_cd_image(void)
2174{
2175 const char *fname;
2176
2177 fname = menu_loop_romsel(last_selected_fname,
2178 sizeof(last_selected_fname), filter_exts,
2179 optional_cdimg_filter);
2180 if (fname == NULL)
2181 return -1;
2182
2183 printf("selected file: %s\n", fname);
2184
2185 CdromId[0] = '\0';
2186 CdromLabel[0] = '\0';
2187
2188 set_cd_image(fname);
2189 if (ReloadCdromPlugin() < 0) {
2190 menu_update_msg("failed to load cdr plugin");
2191 return -1;
2192 }
2193 if (CDR_open() < 0) {
2194 menu_update_msg("failed to open cdr plugin");
2195 return -1;
2196 }
2197
2198 SetCdOpenCaseTime(time(NULL) + 2);
2199 LidInterrupt();
2200
2201 strcpy(last_selected_fname, fname);
2202 return 0;
2203}
2204
2205static int swap_cd_multidisk(void)
2206{
2207 cdrIsoMultidiskSelect++;
2208 CdromId[0] = '\0';
2209 CdromLabel[0] = '\0';
2210
2211 CDR_close();
2212 if (CDR_open() < 0) {
2213 menu_update_msg("failed to open cdr plugin");
2214 return -1;
2215 }
2216
2217 SetCdOpenCaseTime(time(NULL) + 2);
2218 LidInterrupt();
2219
2220 return 0;
2221}
2222
2223static void load_pcsx_cht(void)
2224{
2225 static const char *exts[] = { "cht", NULL };
2226 const char *fname;
2227 char msg[64];
2228
2229 fname = menu_loop_romsel(last_selected_fname,
2230 sizeof(last_selected_fname), exts, NULL);
2231 if (fname == NULL)
2232 return;
2233
2234 printf("selected cheat file: %s\n", fname);
2235 LoadCheats(fname);
2236
2237 if (NumCheats == 0 && NumCodes == 0)
2238 menu_update_msg("failed to load cheats");
2239 else {
2240 snprintf(msg, sizeof(msg), "%d cheat(s) loaded", NumCheats + NumCodes);
2241 menu_update_msg(msg);
2242 }
2243 me_enable(e_menu_main, MA_MAIN_CHEATS, ready_to_go && NumCheats);
2244}
2245
2246static int main_menu_handler(int id, int keys)
2247{
2248 switch (id)
2249 {
2250 case MA_MAIN_RESUME_GAME:
2251 if (ready_to_go)
2252 return 1;
2253 break;
2254 case MA_MAIN_SAVE_STATE:
2255 if (ready_to_go)
2256 return menu_loop_savestate(0);
2257 break;
2258 case MA_MAIN_LOAD_STATE:
2259 if (ready_to_go)
2260 return menu_loop_savestate(1);
2261 break;
2262 case MA_MAIN_RESET_GAME:
2263 if (ready_to_go && reset_game() == 0)
2264 return 1;
2265 break;
2266 case MA_MAIN_LOAD_ROM:
2267 if (romsel_run() == 0)
2268 return 1;
2269 break;
2270 case MA_MAIN_SWAP_CD:
2271 if (swap_cd_image() == 0)
2272 return 1;
2273 break;
2274 case MA_MAIN_SWAP_CD_MULTI:
2275 if (swap_cd_multidisk() == 0)
2276 return 1;
2277 break;
2278 case MA_MAIN_RUN_BIOS:
2279 if (run_bios() == 0)
2280 return 1;
2281 break;
2282 case MA_MAIN_RUN_EXE:
2283 if (run_exe() == 0)
2284 return 1;
2285 break;
2286 case MA_MAIN_CHEATS:
2287 menu_loop_cheats();
2288 break;
2289 case MA_MAIN_LOAD_CHEATS:
2290 load_pcsx_cht();
2291 break;
2292 case MA_MAIN_CREDITS:
2293 draw_menu_message(credits_text, draw_frame_credits);
2294 in_menu_wait(PBTN_MOK|PBTN_MBACK, NULL, 70);
2295 break;
2296 case MA_MAIN_EXIT:
2297 emu_core_ask_exit();
2298 return 1;
2299 default:
2300 lprintf("%s: something unknown selected\n", __FUNCTION__);
2301 break;
2302 }
2303
2304 return 0;
2305}
2306
2307static menu_entry e_menu_main2[] =
2308{
2309 mee_handler_id("Change CD image", MA_MAIN_SWAP_CD, main_menu_handler),
2310 mee_handler_id("Next multidisk CD", MA_MAIN_SWAP_CD_MULTI, main_menu_handler),
2311 mee_handler_id("Run BIOS", MA_MAIN_RUN_BIOS, main_menu_handler),
2312 mee_handler_id("Run EXE", MA_MAIN_RUN_EXE, main_menu_handler),
2313 mee_handler ("Memcard manager", menu_loop_memcards),
2314 mee_handler_id("Load PCSX cheats..", MA_MAIN_LOAD_CHEATS, main_menu_handler),
2315 mee_end,
2316};
2317
2318static int main_menu2_handler(int id, int keys)
2319{
2320 static int sel = 0;
2321
2322 me_enable(e_menu_main2, MA_MAIN_SWAP_CD, ready_to_go);
2323 me_enable(e_menu_main2, MA_MAIN_SWAP_CD_MULTI, ready_to_go && cdrIsoMultidiskCount > 1);
2324 me_enable(e_menu_main2, MA_MAIN_RUN_BIOS, bios_sel != 0);
2325 me_enable(e_menu_main2, MA_MAIN_LOAD_CHEATS, ready_to_go);
2326
2327 return me_loop_d(e_menu_main2, &sel, NULL, draw_frame_main);
2328}
2329
2330static const char h_extra[] = "Change CD, manage memcards..\n";
2331
2332static menu_entry e_menu_main[] =
2333{
2334 mee_label (""),
2335 mee_label (""),
2336 mee_handler_id("Resume game", MA_MAIN_RESUME_GAME, main_menu_handler),
2337 mee_handler_id("Save State", MA_MAIN_SAVE_STATE, main_menu_handler),
2338 mee_handler_id("Load State", MA_MAIN_LOAD_STATE, main_menu_handler),
2339 mee_handler_id("Reset game", MA_MAIN_RESET_GAME, main_menu_handler),
2340 mee_handler_id("Load CD image", MA_MAIN_LOAD_ROM, main_menu_handler),
2341 mee_handler ("Options", menu_loop_options),
2342 mee_handler ("Controls", menu_loop_keyconfig),
2343 mee_handler_id("Cheats", MA_MAIN_CHEATS, main_menu_handler),
2344 mee_handler_h ("Extra stuff", main_menu2_handler, h_extra),
2345 mee_handler_id("Credits", MA_MAIN_CREDITS, main_menu_handler),
2346 mee_handler_id("Exit", MA_MAIN_EXIT, main_menu_handler),
2347 mee_end,
2348};
2349
2350// ----------------------------
2351
2352static void menu_leave_emu(void);
2353
2354void menu_loop(void)
2355{
2356 static int warned_about_bios = 0;
2357 static int sel = 0;
2358
2359 menu_leave_emu();
2360
2361 if (config_save_counter == 0) {
2362 // assume first run
2363 if (bioses[1] != NULL) {
2364 // autoselect BIOS to make user's life easier
2365 snprintf(Config.Bios, sizeof(Config.Bios), "%s", bioses[1]);
2366 bios_sel = 1;
2367 }
2368 else if (!warned_about_bios) {
2369 menu_bios_warn();
2370 warned_about_bios = 1;
2371 }
2372 }
2373
2374 me_enable(e_menu_main, MA_MAIN_RESUME_GAME, ready_to_go);
2375 me_enable(e_menu_main, MA_MAIN_SAVE_STATE, ready_to_go && CdromId[0]);
2376 me_enable(e_menu_main, MA_MAIN_LOAD_STATE, ready_to_go && CdromId[0]);
2377 me_enable(e_menu_main, MA_MAIN_RESET_GAME, ready_to_go);
2378 me_enable(e_menu_main, MA_MAIN_CHEATS, ready_to_go && NumCheats);
2379
2380 in_set_config_int(0, IN_CFG_BLOCKING, 1);
2381
2382 do {
2383 me_loop_d(e_menu_main, &sel, NULL, draw_frame_main);
2384 } while (!ready_to_go && !g_emu_want_quit);
2385
2386 /* wait until menu, ok, back is released */
2387 while (in_menu_wait_any(NULL, 50) & (PBTN_MENU|PBTN_MOK|PBTN_MBACK))
2388 ;
2389
2390 in_set_config_int(0, IN_CFG_BLOCKING, 0);
2391
2392 menu_prepare_emu();
2393}
2394
2395static int qsort_strcmp(const void *p1, const void *p2)
2396{
2397 char * const *s1 = (char * const *)p1;
2398 char * const *s2 = (char * const *)p2;
2399 return strcasecmp(*s1, *s2);
2400}
2401
2402static void scan_bios_plugins(void)
2403{
2404 char fname[MAXPATHLEN];
2405 struct dirent *ent;
2406 int bios_i, gpu_i, spu_i, mc_i;
2407 char *p;
2408 DIR *dir;
2409
2410 bioses[0] = "HLE";
2411 gpu_plugins[0] = "builtin_gpu";
2412 spu_plugins[0] = "builtin_spu";
2413 memcards[0] = "(none)";
2414 bios_i = gpu_i = spu_i = mc_i = 1;
2415
2416 snprintf(fname, sizeof(fname), "%s/", Config.BiosDir);
2417 dir = opendir(fname);
2418 if (dir == NULL) {
2419 perror("scan_bios_plugins bios opendir");
2420 goto do_plugins;
2421 }
2422
2423 while (1) {
2424 struct stat st;
2425
2426 errno = 0;
2427 ent = readdir(dir);
2428 if (ent == NULL) {
2429 if (errno != 0)
2430 perror("readdir");
2431 break;
2432 }
2433
2434 if (ent->d_type != DT_REG && ent->d_type != DT_LNK)
2435 continue;
2436
2437 snprintf(fname, sizeof(fname), "%s/%s", Config.BiosDir, ent->d_name);
2438 if (stat(fname, &st) != 0 || st.st_size != 512*1024) {
2439 printf("bad BIOS file: %s\n", ent->d_name);
2440 continue;
2441 }
2442
2443 if (bios_i < ARRAY_SIZE(bioses) - 1) {
2444 bioses[bios_i++] = strdup(ent->d_name);
2445 continue;
2446 }
2447
2448 printf("too many BIOSes, dropping \"%s\"\n", ent->d_name);
2449 }
2450
2451 closedir(dir);
2452
2453do_plugins:
2454 snprintf(fname, sizeof(fname), "%s/", Config.PluginsDir);
2455 dir = opendir(fname);
2456 if (dir == NULL) {
2457 perror("scan_bios_plugins plugins opendir");
2458 goto do_memcards;
2459 }
2460
2461 while (1) {
2462 void *h, *tmp;
2463
2464 errno = 0;
2465 ent = readdir(dir);
2466 if (ent == NULL) {
2467 if (errno != 0)
2468 perror("readdir");
2469 break;
2470 }
2471 p = strstr(ent->d_name, ".so");
2472 if (p == NULL)
2473 continue;
2474
2475 snprintf(fname, sizeof(fname), "%s/%s", Config.PluginsDir, ent->d_name);
2476 h = dlopen(fname, RTLD_LAZY | RTLD_LOCAL);
2477 if (h == NULL) {
2478 fprintf(stderr, "%s\n", dlerror());
2479 continue;
2480 }
2481
2482 // now what do we have here?
2483 tmp = dlsym(h, "GPUinit");
2484 if (tmp) {
2485 dlclose(h);
2486 if (gpu_i < ARRAY_SIZE(gpu_plugins) - 1)
2487 gpu_plugins[gpu_i++] = strdup(ent->d_name);
2488 continue;
2489 }
2490
2491 tmp = dlsym(h, "SPUinit");
2492 if (tmp) {
2493 dlclose(h);
2494 if (spu_i < ARRAY_SIZE(spu_plugins) - 1)
2495 spu_plugins[spu_i++] = strdup(ent->d_name);
2496 continue;
2497 }
2498
2499 fprintf(stderr, "ignoring unidentified plugin: %s\n", fname);
2500 dlclose(h);
2501 }
2502
2503 closedir(dir);
2504
2505do_memcards:
2506 dir = opendir("." MEMCARD_DIR);
2507 if (dir == NULL) {
2508 perror("scan_bios_plugins memcards opendir");
2509 return;
2510 }
2511
2512 while (1) {
2513 struct stat st;
2514
2515 errno = 0;
2516 ent = readdir(dir);
2517 if (ent == NULL) {
2518 if (errno != 0)
2519 perror("readdir");
2520 break;
2521 }
2522
2523 if (ent->d_type != DT_REG && ent->d_type != DT_LNK)
2524 continue;
2525
2526 snprintf(fname, sizeof(fname), "." MEMCARD_DIR "%s", ent->d_name);
2527 if (stat(fname, &st) != 0) {
2528 printf("bad memcard file: %s\n", ent->d_name);
2529 continue;
2530 }
2531
2532 if (mc_i < ARRAY_SIZE(memcards) - 1) {
2533 memcards[mc_i++] = strdup(ent->d_name);
2534 continue;
2535 }
2536
2537 printf("too many memcards, dropping \"%s\"\n", ent->d_name);
2538 }
2539
2540 if (mc_i > 2)
2541 qsort(memcards + 1, mc_i - 1, sizeof(memcards[0]), qsort_strcmp);
2542
2543 closedir(dir);
2544}
2545
2546void menu_init(void)
2547{
2548 char buff[MAXPATHLEN];
2549 int i;
2550
2551 cpu_clock_st = cpu_clock = plat_target_cpu_clock_get();
2552
2553 scan_bios_plugins();
2554 menu_init_base();
2555
2556 menu_set_defconfig();
2557 menu_load_config(0);
2558 menu_do_last_cd_img(1);
2559 last_vout_w = 320;
2560 last_vout_h = 240;
2561 last_vout_bpp = 16;
2562
2563 g_menubg_src_ptr = calloc(g_menuscreen_w * g_menuscreen_h * 2, 1);
2564 g_menubg_ptr = calloc(g_menuscreen_w * g_menuscreen_h * 2, 1);
2565 if (g_menubg_src_ptr == NULL || g_menubg_ptr == NULL) {
2566 fprintf(stderr, "OOM\n");
2567 exit(1);
2568 }
2569
2570 emu_make_path(buff, "skin/background.png", sizeof(buff));
2571 readpng(g_menubg_src_ptr, buff, READPNG_BG, g_menuscreen_w, g_menuscreen_h);
2572
2573 i = plat_target.cpu_clock_set != NULL
2574 && plat_target.cpu_clock_get != NULL && cpu_clock_st > 0;
2575 me_enable(e_menu_gfx_options, MA_OPT_CPU_CLOCKS, i);
2576
2577 i = me_id2offset(e_menu_gfx_options, MA_OPT_VOUT_MODE);
2578 e_menu_gfx_options[i].data = plat_target.vout_methods;
2579 me_enable(e_menu_gfx_options, MA_OPT_VOUT_MODE,
2580 plat_target.vout_methods != NULL);
2581
2582 i = me_id2offset(e_menu_gfx_options, MA_OPT_HWFILTER);
2583 e_menu_gfx_options[i].data = plat_target.hwfilters;
2584 me_enable(e_menu_gfx_options, MA_OPT_HWFILTER,
2585 plat_target.hwfilters != NULL);
2586
2587 me_enable(e_menu_gfx_options, MA_OPT_GAMMA,
2588 plat_target.gamma_set != NULL);
2589
2590#ifdef HAVE_PRE_ARMV7
2591 me_enable(e_menu_gfx_options, MA_OPT_SWFILTER, 0);
2592#endif
2593 me_enable(e_menu_gfx_options, MA_OPT_VARSCALER, MENU_SHOW_VARSCALER);
2594 me_enable(e_menu_gfx_options, MA_OPT_VOUT_MODE, MENU_SHOW_VOUTMODE);
2595 me_enable(e_menu_gfx_options, MA_OPT_VARSCALER_C, MENU_SHOW_VARSCALER);
2596 me_enable(e_menu_gfx_options, MA_OPT_SCALER2, MENU_SHOW_SCALER2);
2597 me_enable(e_menu_keyconfig, MA_CTRL_NUBS_BTNS, MENU_SHOW_NUBS_BTNS);
2598 me_enable(e_menu_keyconfig, MA_CTRL_VIBRATION, MENU_SHOW_VIBRATION);
2599 me_enable(e_menu_keyconfig, MA_CTRL_DEADZONE, MENU_SHOW_DEADZONE);
2600}
2601
2602void menu_notify_mode_change(int w, int h, int bpp)
2603{
2604 last_vout_w = w;
2605 last_vout_h = h;
2606 last_vout_bpp = bpp;
2607}
2608
2609static void menu_leave_emu(void)
2610{
2611 if (GPU_close != NULL) {
2612 int ret = GPU_close();
2613 if (ret)
2614 fprintf(stderr, "Warning: GPU_close returned %d\n", ret);
2615 }
2616
2617 plat_video_menu_enter(ready_to_go);
2618
2619 memcpy(g_menubg_ptr, g_menubg_src_ptr, g_menuscreen_w * g_menuscreen_h * 2);
2620 if (pl_vout_buf != NULL && ready_to_go) {
2621 int x = max(0, g_menuscreen_w - last_vout_w);
2622 int y = max(0, g_menuscreen_h / 2 - last_vout_h / 2);
2623 int w = min(g_menuscreen_w, last_vout_w);
2624 int h = min(g_menuscreen_h, last_vout_h);
2625 u16 *d = (u16 *)g_menubg_ptr + g_menuscreen_w * y + x;
2626 char *s = pl_vout_buf;
2627
2628 if (last_vout_bpp == 16) {
2629 for (; h > 0; h--, d += g_menuscreen_w, s += last_vout_w * 2)
2630 menu_darken_bg(d, s, w, 0);
2631 }
2632 else {
2633 for (; h > 0; h--, d += g_menuscreen_w, s += last_vout_w * 3) {
2634 rgb888_to_rgb565(d, s, w * 3);
2635 menu_darken_bg(d, d, w, 0);
2636 }
2637 }
2638 }
2639
2640 if (ready_to_go)
2641 cpu_clock = plat_target_cpu_clock_get();
2642}
2643
2644void menu_prepare_emu(void)
2645{
2646 R3000Acpu *prev_cpu = psxCpu;
2647
2648 plat_video_menu_leave();
2649
2650 #if !defined(DRC_DISABLE) || defined(LIGHTREC)
2651 psxCpu = (Config.Cpu == CPU_INTERPRETER) ? &psxInt : &psxRec;
2652 #else
2653 psxCpu = &psxInt;
2654 #endif
2655 if (psxCpu != prev_cpu) {
2656 prev_cpu->Notify(R3000ACPU_NOTIFY_BEFORE_SAVE, NULL);
2657 prev_cpu->Shutdown();
2658 psxCpu->Init();
2659 psxCpu->Reset();
2660 psxCpu->Notify(R3000ACPU_NOTIFY_AFTER_LOAD, NULL);
2661 }
2662
2663 menu_sync_config();
2664 psxCpu->ApplyConfig();
2665
2666 // core doesn't care about Config.Cdda changes,
2667 // so handle them manually here
2668 if (Config.Cdda)
2669 CDR_stop();
2670
2671 if (cpu_clock > 0)
2672 plat_target_cpu_clock_set(cpu_clock);
2673
2674 // push config to GPU plugin
2675 plugin_call_rearmed_cbs();
2676
2677 if (GPU_open != NULL) {
2678 int ret = GPU_open(&gpuDisp, "PCSX", NULL);
2679 if (ret)
2680 fprintf(stderr, "Warning: GPU_open returned %d\n", ret);
2681 }
2682
2683 dfinput_activate();
2684}
2685
2686void menu_update_msg(const char *msg)
2687{
2688 strncpy(menu_error_msg, msg, sizeof(menu_error_msg));
2689 menu_error_msg[sizeof(menu_error_msg) - 1] = 0;
2690
2691 menu_error_time = plat_get_ticks_ms();
2692 lprintf("msg: %s\n", menu_error_msg);
2693}
2694
2695void menu_finish(void)
2696{
2697 if (cpu_clock_st > 0)
2698 plat_target_cpu_clock_set(cpu_clock_st);
2699}
ARM optimized PCSX fork