notaz.gp2x.de / pcsx_rearmed.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
libretro: adjust options after recent changes
[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_INTVAL(region),
401 CE_INTVAL_V(g_scaler, 3),
402 CE_INTVAL(g_gamma),
403 CE_INTVAL(g_layer_x),
404 CE_INTVAL(g_layer_y),
405 CE_INTVAL(g_layer_w),
406 CE_INTVAL(g_layer_h),
407 CE_INTVAL(soft_filter),
408 CE_INTVAL(scanlines),
409 CE_INTVAL(scanline_level),
410 CE_INTVAL(plat_target.vout_method),
411 CE_INTVAL(plat_target.hwfilter),
412 CE_INTVAL(plat_target.vout_fullscreen),
413 CE_INTVAL(state_slot),
414 CE_INTVAL(cpu_clock),
415 CE_INTVAL(g_opts),
416 CE_INTVAL(in_type_sel1),
417 CE_INTVAL(in_type_sel2),
418 CE_INTVAL(analog_deadzone),
419 CE_INTVAL(memcard1_sel),
420 CE_INTVAL(memcard2_sel),
421 CE_INTVAL(g_autostateld_opt),
422 CE_INTVAL_N("adev0_is_nublike", in_adev_is_nublike[0]),
423 CE_INTVAL_N("adev1_is_nublike", in_adev_is_nublike[1]),
424 CE_INTVAL_V(frameskip, 3),
425 CE_INTVAL_P(thread_rendering),
426 CE_INTVAL_P(gpu_peops.iUseDither),
427 CE_INTVAL_P(gpu_peops.dwActFixes),
428 CE_INTVAL_P(gpu_unai.ilace_force),
429 CE_INTVAL_P(gpu_unai.pixel_skip),
430 CE_INTVAL_P(gpu_unai.lighting),
431 CE_INTVAL_P(gpu_unai.fast_lighting),
432 CE_INTVAL_P(gpu_unai.blending),
433 CE_INTVAL_P(gpu_unai.dithering),
434 CE_INTVAL_P(gpu_unai.lineskip),
435 CE_INTVAL_P(gpu_unai.abe_hack),
436 CE_INTVAL_P(gpu_unai.no_light),
437 CE_INTVAL_P(gpu_unai.no_blend),
438 CE_INTVAL_P(gpu_unai.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_onoff ("Interlace", 0, pl_rearmed_cbs.gpu_unai.ilace_force, 1),
1379 mee_onoff ("Dithering", 0, pl_rearmed_cbs.gpu_unai.dithering, 1),
1380 mee_onoff ("Lighting", 0, pl_rearmed_cbs.gpu_unai.lighting, 1),
1381 mee_onoff ("Fast lighting", 0, pl_rearmed_cbs.gpu_unai.fast_lighting, 1),
1382 mee_onoff ("Blending", 0, pl_rearmed_cbs.gpu_unai.blending, 1),
1383 mee_onoff ("Pixel skip", 0, pl_rearmed_cbs.gpu_unai.pixel_skip, 1),
1384 mee_end,
1385};
1386
1387static int menu_loop_plugin_gpu_unai(int id, int keys)
1388{
1389 int sel = 0;
1390 me_loop(e_menu_plugin_gpu_unai, &sel);
1391 return 0;
1392}
1393
1394static const char *men_gpu_dithering[] = { "None", "Game dependant", "Always", NULL };
1395//static const char h_gpu_0[] = "Needed for Chrono Cross";
1396static const char h_gpu_1[] = "Capcom fighting games";
1397static const char h_gpu_2[] = "Black screens in Lunar";
1398static const char h_gpu_3[] = "Compatibility mode";
1399static const char h_gpu_6[] = "Pandemonium 2";
1400//static const char h_gpu_7[] = "Skip every second frame";
1401static const char h_gpu_8[] = "Needed by Dark Forces";
1402static const char h_gpu_9[] = "better g-colors, worse textures";
1403static const char h_gpu_10[] = "Toggle busy flags after drawing";
1404
1405static menu_entry e_menu_plugin_gpu_peops[] =
1406{
1407 mee_enum ("Dithering", 0, pl_rearmed_cbs.gpu_peops.iUseDither, men_gpu_dithering),
1408// mee_onoff_h ("Odd/even bit hack", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<0, h_gpu_0),
1409 mee_onoff_h ("Expand screen width", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<1, h_gpu_1),
1410 mee_onoff_h ("Ignore brightness color", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<2, h_gpu_2),
1411 mee_onoff_h ("Disable coordinate check", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<3, h_gpu_3),
1412 mee_onoff_h ("Lazy screen update", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<6, h_gpu_6),
1413// mee_onoff_h ("Old frame skipping", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<7, h_gpu_7),
1414 mee_onoff_h ("Repeated flat tex triangles ",0,pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<8, h_gpu_8),
1415 mee_onoff_h ("Draw quads with triangles", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<9, h_gpu_9),
1416 mee_onoff_h ("Fake 'gpu busy' states", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<10, h_gpu_10),
1417 mee_end,
1418};
1419
1420static int menu_loop_plugin_gpu_peops(int id, int keys)
1421{
1422 static int sel = 0;
1423 me_loop(e_menu_plugin_gpu_peops, &sel);
1424 return 0;
1425}
1426
1427static const char *men_peopsgl_texfilter[] = { "None", "Standard", "Extended",
1428 "Standard-sprites", "Extended-sprites", "Standard+sprites", "Extended+sprites", NULL };
1429static const char *men_peopsgl_fbtex[] = { "Emulated VRam", "Black", "Card", "Card+soft" };
1430
1431static menu_entry e_menu_plugin_gpu_peopsgl[] =
1432{
1433 mee_onoff ("Dithering", 0, pl_rearmed_cbs.gpu_peopsgl.bDrawDither, 1),
1434 mee_enum ("Texture Filtering", 0, pl_rearmed_cbs.gpu_peopsgl.iFilterType, men_peopsgl_texfilter),
1435 mee_enum ("Framebuffer Textures", 0, pl_rearmed_cbs.gpu_peopsgl.iFrameTexType, men_peopsgl_fbtex),
1436 mee_onoff ("Mask Detect", 0, pl_rearmed_cbs.gpu_peopsgl.iUseMask, 1),
1437 mee_onoff ("Opaque Pass", 0, pl_rearmed_cbs.gpu_peopsgl.bOpaquePass, 1),
1438 mee_onoff ("Advanced Blend", 0, pl_rearmed_cbs.gpu_peopsgl.bAdvancedBlend, 1),
1439 mee_onoff ("Use Fast Mdec", 0, pl_rearmed_cbs.gpu_peopsgl.bUseFastMdec, 1),
1440 mee_range ("Texture RAM size (MB)", 0, pl_rearmed_cbs.gpu_peopsgl.iVRamSize, 4, 128),
1441 mee_onoff ("Texture garbage collection", 0, pl_rearmed_cbs.gpu_peopsgl.iTexGarbageCollection, 1),
1442 mee_label ("Fixes/hacks:"),
1443 mee_onoff ("FF7 cursor", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<0),
1444 mee_onoff ("Direct FB updates", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<1),
1445 mee_onoff ("Black brightness", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<2),
1446 mee_onoff ("Swap front detection", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<3),
1447 mee_onoff ("Disable coord check", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<4),
1448 mee_onoff ("No blue glitches (LoD)", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<5),
1449 mee_onoff ("Soft FB access", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<6),
1450 mee_onoff ("FF9 rect", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<9),
1451 mee_onoff ("No subtr. blending", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<10),
1452 mee_onoff ("Lazy upload (DW7)", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<11),
1453 mee_onoff ("Additional uploads", 0, pl_rearmed_cbs.gpu_peopsgl.dwActFixes, 1<<15),
1454 mee_end,
1455};
1456
1457static int menu_loop_plugin_gpu_peopsgl(int id, int keys)
1458{
1459 static int sel = 0;
1460 me_loop(e_menu_plugin_gpu_peopsgl, &sel);
1461 return 0;
1462}
1463
1464static const char *men_spu_interp[] = { "None", "Simple", "Gaussian", "Cubic", NULL };
1465static const char h_spu_volboost[] = "Large values cause distortion";
1466static const char h_spu_tempo[] = "Slows down audio if emu is too slow\n"
1467 "This is inaccurate and breaks games";
1468
1469static menu_entry e_menu_plugin_spu[] =
1470{
1471 mee_range_h ("Volume boost", 0, volume_boost, -5, 30, h_spu_volboost),
1472 mee_onoff ("Reverb", 0, spu_config.iUseReverb, 1),
1473 mee_enum ("Interpolation", 0, spu_config.iUseInterpolation, men_spu_interp),
1474 //mee_onoff ("Adjust XA pitch", 0, spu_config.iXAPitch, 1),
1475 mee_onoff_h ("Adjust tempo", 0, spu_config.iTempo, 1, h_spu_tempo),
1476 mee_end,
1477};
1478
1479static int menu_loop_plugin_spu(int id, int keys)
1480{
1481 static int sel = 0;
1482 me_loop(e_menu_plugin_spu, &sel);
1483 return 0;
1484}
1485
1486static const char h_bios[] = "HLE is simulated BIOS. BIOS selection is saved in\n"
1487 "savestates and can't be changed there. Must save\n"
1488 "config and reload the game for change to take effect";
1489static const char h_plugin_gpu[] =
1490#ifdef BUILTIN_GPU_NEON
1491 "builtin_gpu is the NEON GPU, very fast and accurate\n"
1492#endif
1493 "gpu_peops is Pete's soft GPU, slow but accurate\n"
1494 "gpu_unai is GPU from PCSX4ALL, fast but glitchy\n"
1495 "gpu_gles Pete's hw GPU, uses 3D chip but is glitchy\n"
1496 "must save config and reload the game if changed";
1497static const char h_plugin_spu[] = "spunull effectively disables sound\n"
1498 "must save config and reload the game if changed";
1499static const char h_gpu_peops[] = "Configure P.E.Op.S. SoftGL Driver V1.17";
1500static const char h_gpu_peopsgl[]= "Configure P.E.Op.S. MesaGL Driver V1.78";
1501static const char h_gpu_unai[] = "Configure Unai/PCSX4ALL Team GPU plugin";
1502static const char h_spu[] = "Configure built-in P.E.Op.S. Sound Driver V1.7";
1503
1504static menu_entry e_menu_plugin_options[] =
1505{
1506 mee_enum_h ("BIOS", 0, bios_sel, bioses, h_bios),
1507 mee_enum_h ("GPU plugin", 0, gpu_plugsel, gpu_plugins, h_plugin_gpu),
1508 mee_enum_h ("SPU plugin", 0, spu_plugsel, spu_plugins, h_plugin_spu),
1509#ifdef BUILTIN_GPU_NEON
1510 mee_handler_h ("Configure built-in GPU plugin", menu_loop_plugin_gpu_neon, h_gpu_neon),
1511#endif
1512 mee_handler_h ("Configure gpu_peops plugin", menu_loop_plugin_gpu_peops, h_gpu_peops),
1513 mee_handler_h ("Configure gpu_unai GPU plugin", menu_loop_plugin_gpu_unai, h_gpu_unai),
1514 mee_handler_h ("Configure gpu_gles GPU plugin", menu_loop_plugin_gpu_peopsgl, h_gpu_peopsgl),
1515 mee_handler_h ("Configure built-in SPU plugin", menu_loop_plugin_spu, h_spu),
1516 mee_end,
1517};
1518
1519static menu_entry e_menu_main2[];
1520
1521static int menu_loop_plugin_options(int id, int keys)
1522{
1523 static int sel = 0;
1524 me_loop(e_menu_plugin_options, &sel);
1525
1526 // sync BIOS/plugins
1527 snprintf(Config.Bios, sizeof(Config.Bios), "%s", bioses[bios_sel]);
1528 snprintf(Config.Gpu, sizeof(Config.Gpu), "%s", gpu_plugins[gpu_plugsel]);
1529 snprintf(Config.Spu, sizeof(Config.Spu), "%s", spu_plugins[spu_plugsel]);
1530 me_enable(e_menu_main2, MA_MAIN_RUN_BIOS, bios_sel != 0);
1531
1532 return 0;
1533}
1534
1535// ------------ adv options menu ------------
1536
1537#ifndef DRC_DISABLE
1538static const char h_cfg_noch[] = "Disables game-specific compatibility hacks";
1539static const char h_cfg_nosmc[] = "Will cause crashes when loading, break memcards";
1540static const char h_cfg_gteunn[] = "May cause graphical glitches";
1541static const char h_cfg_gteflgs[] = "Will cause graphical glitches";
1542#endif
1543static const char h_cfg_stalls[] = "Will cause some games to run too fast";
1544
1545static menu_entry e_menu_speed_hacks[] =
1546{
1547#ifndef DRC_DISABLE
1548 mee_onoff_h ("Disable compat hacks", 0, new_dynarec_hacks, NDHACK_NO_COMPAT_HACKS, h_cfg_noch),
1549 mee_onoff_h ("Disable SMC checks", 0, new_dynarec_hacks, NDHACK_NO_SMC_CHECK, h_cfg_nosmc),
1550 mee_onoff_h ("Assume GTE regs unneeded", 0, new_dynarec_hacks, NDHACK_GTE_UNNEEDED, h_cfg_gteunn),
1551 mee_onoff_h ("Disable GTE flags", 0, new_dynarec_hacks, NDHACK_GTE_NO_FLAGS, h_cfg_gteflgs),
1552#endif
1553 mee_onoff_h ("Disable CPU/GTE stalls", 0, menu_iopts[0], 1, h_cfg_stalls),
1554 mee_end,
1555};
1556
1557static int menu_loop_speed_hacks(int id, int keys)
1558{
1559 static int sel = 0;
1560 menu_iopts[0] = Config.DisableStalls;
1561 me_loop(e_menu_speed_hacks, &sel);
1562 Config.DisableStalls = menu_iopts[0];
1563 return 0;
1564}
1565
1566static const char h_cfg_cpul[] = "Shows CPU usage in %";
1567static const char h_cfg_spu[] = "Shows active SPU channels\n"
1568 "(green: normal, red: fmod, blue: noise)";
1569static const char h_cfg_fl[] = "Frame Limiter keeps the game from running too fast";
1570static const char h_cfg_xa[] = "Disables XA sound, which can sometimes improve performance";
1571static const char h_cfg_cdda[] = "Disable CD Audio for a performance boost\n"
1572 "(proper .cue/.bin dump is needed otherwise)";
1573#ifndef DRC_DISABLE
1574static const char h_cfg_nodrc[] = "Disable dynamic recompiler and use interpreter\n"
1575 "Might be useful to overcome some dynarec bugs";
1576#endif
1577static const char h_cfg_shacks[] = "Breaks games but may give better performance";
1578static const char h_cfg_icache[] = "Support F1 games (only when dynarec is off)";
1579static const char h_cfg_psxclk[] = "Over/under-clock the PSX, default is " DEFAULT_PSX_CLOCK_S "\n"
1580 "(adjust this if the game is too slow/too fast/hangs)";
1581
1582enum { AMO_XA, AMO_CDDA, AMO_IC, AMO_CPU };
1583
1584static menu_entry e_menu_adv_options[] =
1585{
1586 mee_onoff_h ("Show CPU load", 0, g_opts, OPT_SHOWCPU, h_cfg_cpul),
1587 mee_onoff_h ("Show SPU channels", 0, g_opts, OPT_SHOWSPU, h_cfg_spu),
1588 mee_onoff_h ("Disable Frame Limiter", 0, g_opts, OPT_NO_FRAMELIM, h_cfg_fl),
1589 mee_onoff_h ("Disable XA Decoding", 0, menu_iopts[AMO_XA], 1, h_cfg_xa),
1590 mee_onoff_h ("Disable CD Audio", 0, menu_iopts[AMO_CDDA], 1, h_cfg_cdda),
1591 mee_onoff_h ("ICache emulation", 0, menu_iopts[AMO_IC], 1, h_cfg_icache),
1592#if !defined(DRC_DISABLE) || defined(LIGHTREC)
1593 mee_onoff_h ("Disable dynarec (slow!)",0, menu_iopts[AMO_CPU], 1, h_cfg_nodrc),
1594#endif
1595 mee_range_h ("PSX CPU clock, %", 0, psx_clock, 1, 500, h_cfg_psxclk),
1596 mee_handler_h ("[Speed hacks]", menu_loop_speed_hacks, h_cfg_shacks),
1597 mee_end,
1598};
1599
1600static int menu_loop_adv_options(int id, int keys)
1601{
1602 static int sel = 0;
1603 static struct {
1604 boolean *opt;
1605 int *mopt;
1606 } opts[] = {
1607 { &Config.Xa, &menu_iopts[AMO_XA] },
1608 { &Config.Cdda, &menu_iopts[AMO_CDDA] },
1609 { &Config.icache_emulation, &menu_iopts[AMO_IC] },
1610 { &Config.Cpu, &menu_iopts[AMO_CPU] },
1611 };
1612 int i;
1613 for (i = 0; i < ARRAY_SIZE(opts); i++)
1614 *opts[i].mopt = *opts[i].opt;
1615 me_loop(e_menu_adv_options, &sel);
1616 for (i = 0; i < ARRAY_SIZE(opts); i++)
1617 *opts[i].opt = *opts[i].mopt;
1618 return 0;
1619}
1620
1621// ------------ options menu ------------
1622
1623static int mh_restore_defaults(int id, int keys)
1624{
1625 menu_set_defconfig();
1626 menu_update_msg("defaults restored");
1627 return 1;
1628}
1629
1630static const char *men_region[] = { "Auto", "NTSC", "PAL", NULL };
1631static const char *men_frameskip[] = { "Auto", "Off", "1", "2", "3", NULL };
1632/*
1633static const char *men_confirm_save[] = { "OFF", "writes", "loads", "both", NULL };
1634static const char h_confirm_save[] = "Ask for confirmation when overwriting save,\n"
1635 "loading state or both";
1636*/
1637static const char h_restore_def[] = "Switches back to default / recommended\n"
1638 "configuration";
1639static const char h_frameskip[] = "Warning: frameskip sometimes causes glitches\n";
1640
1641static menu_entry e_menu_options[] =
1642{
1643// mee_range ("Save slot", 0, state_slot, 0, 9),
1644// mee_enum_h ("Confirm savestate", 0, dummy, men_confirm_save, h_confirm_save),
1645 mee_enum_h ("Frameskip", 0, frameskip, men_frameskip, h_frameskip),
1646 mee_onoff ("Show FPS", 0, g_opts, OPT_SHOWFPS),
1647 mee_enum ("Region", 0, region, men_region),
1648 mee_range ("CPU clock", MA_OPT_CPU_CLOCKS, cpu_clock, 20, 5000),
1649#ifdef C64X_DSP
1650 mee_onoff ("Use C64x DSP for sound", MA_OPT_SPU_THREAD, spu_config.iUseThread, 1),
1651#else
1652 mee_onoff ("Threaded SPU", MA_OPT_SPU_THREAD, spu_config.iUseThread, 1),
1653#endif
1654 mee_handler_id("[Display]", MA_OPT_DISP_OPTS, menu_loop_gfx_options),
1655 mee_handler ("[BIOS/Plugins]", menu_loop_plugin_options),
1656 mee_handler ("[Advanced]", menu_loop_adv_options),
1657 mee_cust_nosave("Save global config", MA_OPT_SAVECFG, mh_savecfg, mgn_saveloadcfg),
1658 mee_cust_nosave("Save cfg for loaded game",MA_OPT_SAVECFG_GAME, mh_savecfg, mgn_saveloadcfg),
1659 mee_handler_h ("Restore default config", mh_restore_defaults, h_restore_def),
1660 mee_end,
1661};
1662
1663static int menu_loop_options(int id, int keys)
1664{
1665 static int sel = 0;
1666
1667 me_enable(e_menu_options, MA_OPT_CPU_CLOCKS, cpu_clock_st > 0);
1668 me_enable(e_menu_options, MA_OPT_SPU_THREAD, spu_config.iThreadAvail);
1669 me_enable(e_menu_options, MA_OPT_SAVECFG_GAME, ready_to_go && CdromId[0]);
1670
1671 me_loop(e_menu_options, &sel);
1672
1673 return 0;
1674}
1675
1676// ------------ debug menu ------------
1677
1678static void draw_frame_debug(GPUFreeze_t *gpuf, int x, int y)
1679{
1680 int w = min(g_menuscreen_w, 1024);
1681 int h = min(g_menuscreen_h, 512);
1682 u16 *d = g_menuscreen_ptr;
1683 u16 *s = (u16 *)gpuf->psxVRam + y * 1024 + x;
1684 char buff[64];
1685 int ty = 1;
1686
1687 gpuf->ulFreezeVersion = 1;
1688 if (GPU_freeze != NULL)
1689 GPU_freeze(1, gpuf);
1690
1691 for (; h > 0; h--, d += g_menuscreen_w, s += 1024)
1692 bgr555_to_rgb565(d, s, w * 2);
1693
1694 smalltext_out16(4, 1, "build: "__DATE__ " " __TIME__ " " REV, 0xe7fc);
1695 snprintf(buff, sizeof(buff), "GPU sr: %08x", gpuf->ulStatus);
1696 smalltext_out16(4, (ty += me_sfont_h), buff, 0xe7fc);
1697 snprintf(buff, sizeof(buff), "PC/SP: %08x %08x", psxRegs.pc, psxRegs.GPR.n.sp);
1698 smalltext_out16(4, (ty += me_sfont_h), buff, 0xe7fc);
1699}
1700
1701static void debug_menu_loop(void)
1702{
1703 int inp, df_x = 0, df_y = 0;
1704 GPUFreeze_t *gpuf;
1705
1706 gpuf = malloc(sizeof(*gpuf));
1707 if (gpuf == NULL)
1708 return;
1709
1710 while (1)
1711 {
1712 menu_draw_begin(0, 1);
1713 draw_frame_debug(gpuf, df_x, df_y);
1714 menu_draw_end();
1715
1716 inp = in_menu_wait(PBTN_MOK|PBTN_MBACK|PBTN_MA2|PBTN_MA3|PBTN_L|PBTN_R |
1717 PBTN_UP|PBTN_DOWN|PBTN_LEFT|PBTN_RIGHT, NULL, 10);
1718 if (inp & PBTN_MBACK) break;
1719 else if (inp & PBTN_UP) { if (df_y > 0) df_y--; }
1720 else if (inp & PBTN_DOWN) { if (df_y < 512 - g_menuscreen_h) df_y++; }
1721 else if (inp & PBTN_LEFT) { if (df_x > 0) df_x -= 2; }
1722 else if (inp & PBTN_RIGHT) { if (df_x < 1024 - g_menuscreen_w) df_x += 2; }
1723 }
1724
1725 free(gpuf);
1726}
1727
1728// --------- memcard manager ---------
1729
1730static void draw_mc_icon(int dx, int dy, const u16 *s)
1731{
1732 u16 *d;
1733 int x, y, l, p;
1734
1735 d = (u16 *)g_menuscreen_ptr + g_menuscreen_w * dy + dx;
1736
1737 for (y = 0; y < 16; y++, s += 16) {
1738 for (l = 0; l < 2; l++, d += g_menuscreen_w) {
1739 for (x = 0; x < 16; x++) {
1740 p = s[x];
1741 d[x*2] = d[x*2 + 1] = ((p & 0x7c00) >> 10)
1742 | ((p & 0x03e0) << 1) | ((p & 0x1f) << 11);
1743 }
1744 }
1745 }
1746}
1747
1748static void draw_mc_bg(void)
1749{
1750 McdBlock *blocks1, *blocks2;
1751 int maxicons = 15;
1752 int i, y, row2;
1753
1754 blocks1 = malloc(15 * sizeof(blocks1[0]));
1755 blocks2 = malloc(15 * sizeof(blocks1[0]));
1756 if (blocks1 == NULL || blocks2 == NULL)
1757 goto out;
1758
1759 for (i = 0; i < 15; i++) {
1760 GetMcdBlockInfo(1, i + 1, &blocks1[i]);
1761 GetMcdBlockInfo(2, i + 1, &blocks2[i]);
1762 }
1763
1764 menu_draw_begin(1, 1);
1765
1766 memcpy(g_menuscreen_ptr, g_menubg_src_ptr, g_menuscreen_w * g_menuscreen_h * 2);
1767
1768 y = g_menuscreen_h / 2 - 15 * 32 / 2;
1769 if (y < 0) {
1770 // doesn't fit..
1771 y = 0;
1772 maxicons = g_menuscreen_h / 32;
1773 }
1774
1775 row2 = g_menuscreen_w / 2;
1776 for (i = 0; i < maxicons; i++) {
1777 draw_mc_icon(8, y + i * 32, (u16 *)blocks1[i].Icon);
1778 smalltext_out16(10+32, y + i * 32 + 8, blocks1[i].sTitle, 0xf71e);
1779
1780 draw_mc_icon(row2 + 8, y + i * 32, (u16 *)blocks2[i].Icon);
1781 smalltext_out16(row2 + 10+32, y + i * 32 + 8, blocks2[i].sTitle, 0xf71e);
1782 }
1783
1784 menu_darken_bg(g_menubg_ptr, g_menuscreen_ptr, g_menuscreen_w * g_menuscreen_h, 0);
1785
1786 menu_draw_end();
1787out:
1788 free(blocks1);
1789 free(blocks2);
1790}
1791
1792static void handle_memcard_sel(void)
1793{
1794 strcpy(Config.Mcd1, "none");
1795 if (memcard1_sel != 0)
1796 snprintf(Config.Mcd1, sizeof(Config.Mcd1), ".%s%s", MEMCARD_DIR, memcards[memcard1_sel]);
1797 strcpy(Config.Mcd2, "none");
1798 if (memcard2_sel != 0)
1799 snprintf(Config.Mcd2, sizeof(Config.Mcd2), ".%s%s", MEMCARD_DIR, memcards[memcard2_sel]);
1800 LoadMcds(Config.Mcd1, Config.Mcd2);
1801 draw_mc_bg();
1802}
1803
1804static menu_entry e_memcard_options[] =
1805{
1806 mee_enum("Memory card 1", 0, memcard1_sel, memcards),
1807 mee_enum("Memory card 2", 0, memcard2_sel, memcards),
1808 mee_end,
1809};
1810
1811static int menu_loop_memcards(int id, int keys)
1812{
1813 static int sel = 0;
1814 char *p;
1815 int i;
1816
1817 memcard1_sel = memcard2_sel = 0;
1818 p = strrchr(Config.Mcd1, '/');
1819 if (p != NULL)
1820 for (i = 0; memcards[i] != NULL; i++)
1821 if (strcmp(p + 1, memcards[i]) == 0)
1822 { memcard1_sel = i; break; }
1823 p = strrchr(Config.Mcd2, '/');
1824 if (p != NULL)
1825 for (i = 0; memcards[i] != NULL; i++)
1826 if (strcmp(p + 1, memcards[i]) == 0)
1827 { memcard2_sel = i; break; }
1828
1829 me_loop_d(e_memcard_options, &sel, handle_memcard_sel, NULL);
1830
1831 memcpy(g_menubg_ptr, g_menubg_src_ptr, g_menuscreen_w * g_menuscreen_h * 2);
1832
1833 return 0;
1834}
1835
1836// ------------ cheats menu ------------
1837
1838static void draw_cheatlist(int sel)
1839{
1840 int max_cnt, start, i, pos, active;
1841
1842 max_cnt = g_menuscreen_h / me_sfont_h;
1843 start = max_cnt / 2 - sel;
1844
1845 menu_draw_begin(1, 1);
1846
1847 for (i = 0; i < NumCheats; i++) {
1848 pos = start + i;
1849 if (pos < 0) continue;
1850 if (pos >= max_cnt) break;
1851 active = Cheats[i].Enabled;
1852 smalltext_out16(14, pos * me_sfont_h,
1853 active ? "ON " : "OFF", active ? 0xfff6 : 0xffff);
1854 smalltext_out16(14 + me_sfont_w*4, pos * me_sfont_h,
1855 Cheats[i].Descr, active ? 0xfff6 : 0xffff);
1856 }
1857 pos = start + i;
1858 if (pos < max_cnt)
1859 smalltext_out16(14, pos * me_sfont_h, "done", 0xffff);
1860
1861 text_out16(5, max_cnt / 2 * me_sfont_h, ">");
1862 menu_draw_end();
1863}
1864
1865static void menu_loop_cheats(void)
1866{
1867 static int menu_sel = 0;
1868 int inp;
1869
1870 for (;;)
1871 {
1872 draw_cheatlist(menu_sel);
1873 inp = in_menu_wait(PBTN_UP|PBTN_DOWN|PBTN_LEFT|PBTN_RIGHT|PBTN_L|PBTN_R
1874 |PBTN_MOK|PBTN_MBACK, NULL, 33);
1875 if (inp & PBTN_UP ) { menu_sel--; if (menu_sel < 0) menu_sel = NumCheats; }
1876 if (inp & PBTN_DOWN) { menu_sel++; if (menu_sel > NumCheats) menu_sel = 0; }
1877 if (inp &(PBTN_LEFT|PBTN_L)) { menu_sel-=10; if (menu_sel < 0) menu_sel = 0; }
1878 if (inp &(PBTN_RIGHT|PBTN_R)) { menu_sel+=10; if (menu_sel > NumCheats) menu_sel = NumCheats; }
1879 if (inp & PBTN_MOK) { // action
1880 if (menu_sel < NumCheats)
1881 Cheats[menu_sel].Enabled = !Cheats[menu_sel].Enabled;
1882 else break;
1883 }
1884 if (inp & PBTN_MBACK)
1885 break;
1886 }
1887}
1888
1889// --------- main menu help ----------
1890
1891static void menu_bios_warn(void)
1892{
1893 int inp;
1894 static const char msg[] =
1895 "You don't seem to have copied any BIOS\n"
1896 "files to\n"
1897 MENU_BIOS_PATH "\n\n"
1898
1899 "While many games work fine with fake\n"
1900 "(HLE) BIOS, others (like MGS and FF8)\n"
1901 "require BIOS to work.\n"
1902 "After copying the file, you'll also need\n"
1903 "to select it in the emu's menu:\n"
1904 "options->[BIOS/Plugins]\n\n"
1905 "The file is usually named SCPH1001.BIN,\n"
1906 "but other not compressed files can be\n"
1907 "used too.\n\n"
1908 "Press %s or %s to continue";
1909 char tmp_msg[sizeof(msg) + 64];
1910
1911 snprintf(tmp_msg, sizeof(tmp_msg), msg,
1912 in_get_key_name(-1, -PBTN_MOK), in_get_key_name(-1, -PBTN_MBACK));
1913 while (1)
1914 {
1915 draw_menu_message(tmp_msg, NULL);
1916
1917 inp = in_menu_wait(PBTN_MOK|PBTN_MBACK, NULL, 70);
1918 if (inp & (PBTN_MBACK|PBTN_MOK))
1919 return;
1920 }
1921}
1922
1923// ------------ main menu ------------
1924
1925static menu_entry e_menu_main[];
1926
1927static void draw_frame_main(void)
1928{
1929 struct tm *tmp;
1930 time_t ltime;
1931 int capacity;
1932 char ltime_s[16];
1933 char buff[64];
1934 char *out;
1935
1936 if (CdromId[0] != 0) {
1937 snprintf(buff, sizeof(buff), "%.32s/%.9s (running as %s, with %s)",
1938 get_cd_label(), CdromId, Config.PsxType ? "PAL" : "NTSC",
1939 Config.HLE ? "HLE" : "BIOS");
1940 smalltext_out16(4, 1, buff, 0x105f);
1941 }
1942
1943 if (ready_to_go) {
1944 capacity = plat_target_bat_capacity_get();
1945 ltime = time(NULL);
1946 tmp = localtime(&ltime);
1947 strftime(ltime_s, sizeof(ltime_s), "%H:%M", tmp);
1948 if (capacity >= 0) {
1949 snprintf(buff, sizeof(buff), "%s %3d%%", ltime_s, capacity);
1950 out = buff;
1951 }
1952 else
1953 out = ltime_s;
1954 smalltext_out16(4, 1 + me_sfont_h, out, 0x105f);
1955 }
1956}
1957
1958static void draw_frame_credits(void)
1959{
1960 smalltext_out16(4, 1, "build: " __DATE__ " " __TIME__ " " REV, 0xe7fc);
1961}
1962
1963static const char credits_text[] =
1964 "PCSX-ReARMed\n\n"
1965 "(C) 1999-2003 PCSX Team\n"
1966 "(C) 2005-2009 PCSX-df Team\n"
1967 "(C) 2009-2011 PCSX-Reloaded Team\n\n"
1968 "ARM recompiler (C) 2009-2011 Ari64\n"
1969#ifdef BUILTIN_GPU_NEON
1970 "ARM NEON GPU (c) 2011-2012 Exophase\n"
1971#endif
1972 "PEOpS GPU and SPU by Pete Bernert\n"
1973 " and the P.E.Op.S. team\n"
1974 "PCSX4ALL plugin by PCSX4ALL team\n"
1975 " Chui, Franxis, Unai\n\n"
1976 "integration, optimization and\n"
1977 " frontend (C) 2010-2015 notaz\n";
1978
1979static int reset_game(void)
1980{
1981 // sanity check
1982 if (bios_sel == 0 && !Config.HLE)
1983 return -1;
1984
1985 ClosePlugins();
1986 OpenPlugins();
1987 SysReset();
1988 if (CheckCdrom() != -1) {
1989 LoadCdrom();
1990 }
1991 return 0;
1992}
1993
1994static int reload_plugins(const char *cdimg)
1995{
1996 pl_vout_buf = NULL;
1997
1998 ClosePlugins();
1999
2000 set_cd_image(cdimg);
2001 LoadPlugins();
2002 pcnt_hook_plugins();
2003 NetOpened = 0;
2004 if (OpenPlugins() == -1) {
2005 menu_update_msg("failed to open plugins");
2006 return -1;
2007 }
2008 plugin_call_rearmed_cbs();
2009
2010 cdrIsoMultidiskCount = 1;
2011 CdromId[0] = '\0';
2012 CdromLabel[0] = '\0';
2013
2014 return 0;
2015}
2016
2017static int run_bios(void)
2018{
2019 if (bios_sel == 0)
2020 return -1;
2021
2022 ready_to_go = 0;
2023 if (reload_plugins(NULL) != 0)
2024 return -1;
2025 SysReset();
2026
2027 ready_to_go = 1;
2028 return 0;
2029}
2030
2031static int run_exe(void)
2032{
2033 const char *exts[] = { "exe", NULL };
2034 const char *fname;
2035
2036 fname = menu_loop_romsel(last_selected_fname,
2037 sizeof(last_selected_fname), exts, NULL);
2038 if (fname == NULL)
2039 return -1;
2040
2041 ready_to_go = 0;
2042 if (reload_plugins(NULL) != 0)
2043 return -1;
2044
2045 SysReset();
2046 if (Load(fname) != 0) {
2047 menu_update_msg("exe load failed, bad file?");
2048 printf("meh\n");
2049 return -1;
2050 }
2051
2052 ready_to_go = 1;
2053 return 0;
2054}
2055
2056static int run_cd_image(const char *fname)
2057{
2058 int autoload_state = g_autostateld_opt;
2059
2060 ready_to_go = 0;
2061 reload_plugins(fname);
2062
2063 // always autodetect, menu_sync_config will override as needed
2064 Config.PsxAuto = 1;
2065
2066 if (CheckCdrom() == -1) {
2067 // Only check the CD if we are starting the console with a CD
2068 ClosePlugins();
2069 menu_update_msg("unsupported/invalid CD image");
2070 return -1;
2071 }
2072
2073 SysReset();
2074
2075 // Read main executable directly from CDRom and start it
2076 if (LoadCdrom() == -1) {
2077 ClosePlugins();
2078 menu_update_msg("failed to load CD image");
2079 return -1;
2080 }
2081
2082 emu_on_new_cd(1);
2083 ready_to_go = 1;
2084
2085 if (autoload_state) {
2086 unsigned int newest = 0;
2087 int time, slot, newest_slot = -1;
2088
2089 for (slot = 0; slot < 10; slot++) {
2090 if (emu_check_save_file(slot, &time)) {
2091 if ((unsigned int)time > newest) {
2092 newest = time;
2093 newest_slot = slot;
2094 }
2095 }
2096 }
2097
2098 if (newest_slot >= 0) {
2099 lprintf("autoload slot %d\n", newest_slot);
2100 emu_load_state(newest_slot);
2101 }
2102 else {
2103 lprintf("no save to autoload.\n");
2104 }
2105 }
2106
2107 return 0;
2108}
2109
2110static int romsel_run(void)
2111{
2112 int prev_gpu, prev_spu;
2113 const char *fname;
2114
2115 fname = menu_loop_romsel(last_selected_fname,
2116 sizeof(last_selected_fname), filter_exts,
2117 optional_cdimg_filter);
2118 if (fname == NULL)
2119 return -1;
2120
2121 printf("selected file: %s\n", fname);
2122
2123 new_dynarec_clear_full();
2124
2125 if (run_cd_image(fname) != 0)
2126 return -1;
2127
2128 prev_gpu = gpu_plugsel;
2129 prev_spu = spu_plugsel;
2130 if (menu_load_config(1) != 0)
2131 menu_load_config(0);
2132
2133 // check for plugin changes, have to repeat
2134 // loading if game config changed plugins to reload them
2135 if (prev_gpu != gpu_plugsel || prev_spu != spu_plugsel) {
2136 printf("plugin change detected, reloading plugins..\n");
2137 if (run_cd_image(fname) != 0)
2138 return -1;
2139 }
2140
2141 strcpy(last_selected_fname, fname);
2142 menu_do_last_cd_img(0);
2143 return 0;
2144}
2145
2146static int swap_cd_image(void)
2147{
2148 const char *fname;
2149
2150 fname = menu_loop_romsel(last_selected_fname,
2151 sizeof(last_selected_fname), filter_exts,
2152 optional_cdimg_filter);
2153 if (fname == NULL)
2154 return -1;
2155
2156 printf("selected file: %s\n", fname);
2157
2158 CdromId[0] = '\0';
2159 CdromLabel[0] = '\0';
2160
2161 set_cd_image(fname);
2162 if (ReloadCdromPlugin() < 0) {
2163 menu_update_msg("failed to load cdr plugin");
2164 return -1;
2165 }
2166 if (CDR_open() < 0) {
2167 menu_update_msg("failed to open cdr plugin");
2168 return -1;
2169 }
2170
2171 SetCdOpenCaseTime(time(NULL) + 2);
2172 LidInterrupt();
2173
2174 strcpy(last_selected_fname, fname);
2175 return 0;
2176}
2177
2178static int swap_cd_multidisk(void)
2179{
2180 cdrIsoMultidiskSelect++;
2181 CdromId[0] = '\0';
2182 CdromLabel[0] = '\0';
2183
2184 CDR_close();
2185 if (CDR_open() < 0) {
2186 menu_update_msg("failed to open cdr plugin");
2187 return -1;
2188 }
2189
2190 SetCdOpenCaseTime(time(NULL) + 2);
2191 LidInterrupt();
2192
2193 return 0;
2194}
2195
2196static void load_pcsx_cht(void)
2197{
2198 static const char *exts[] = { "cht", NULL };
2199 const char *fname;
2200 char msg[64];
2201
2202 fname = menu_loop_romsel(last_selected_fname,
2203 sizeof(last_selected_fname), exts, NULL);
2204 if (fname == NULL)
2205 return;
2206
2207 printf("selected cheat file: %s\n", fname);
2208 LoadCheats(fname);
2209
2210 if (NumCheats == 0 && NumCodes == 0)
2211 menu_update_msg("failed to load cheats");
2212 else {
2213 snprintf(msg, sizeof(msg), "%d cheat(s) loaded", NumCheats + NumCodes);
2214 menu_update_msg(msg);
2215 }
2216 me_enable(e_menu_main, MA_MAIN_CHEATS, ready_to_go && NumCheats);
2217}
2218
2219static int main_menu_handler(int id, int keys)
2220{
2221 switch (id)
2222 {
2223 case MA_MAIN_RESUME_GAME:
2224 if (ready_to_go)
2225 return 1;
2226 break;
2227 case MA_MAIN_SAVE_STATE:
2228 if (ready_to_go)
2229 return menu_loop_savestate(0);
2230 break;
2231 case MA_MAIN_LOAD_STATE:
2232 if (ready_to_go)
2233 return menu_loop_savestate(1);
2234 break;
2235 case MA_MAIN_RESET_GAME:
2236 if (ready_to_go && reset_game() == 0)
2237 return 1;
2238 break;
2239 case MA_MAIN_LOAD_ROM:
2240 if (romsel_run() == 0)
2241 return 1;
2242 break;
2243 case MA_MAIN_SWAP_CD:
2244 if (swap_cd_image() == 0)
2245 return 1;
2246 break;
2247 case MA_MAIN_SWAP_CD_MULTI:
2248 if (swap_cd_multidisk() == 0)
2249 return 1;
2250 break;
2251 case MA_MAIN_RUN_BIOS:
2252 if (run_bios() == 0)
2253 return 1;
2254 break;
2255 case MA_MAIN_RUN_EXE:
2256 if (run_exe() == 0)
2257 return 1;
2258 break;
2259 case MA_MAIN_CHEATS:
2260 menu_loop_cheats();
2261 break;
2262 case MA_MAIN_LOAD_CHEATS:
2263 load_pcsx_cht();
2264 break;
2265 case MA_MAIN_CREDITS:
2266 draw_menu_message(credits_text, draw_frame_credits);
2267 in_menu_wait(PBTN_MOK|PBTN_MBACK, NULL, 70);
2268 break;
2269 case MA_MAIN_EXIT:
2270 emu_core_ask_exit();
2271 return 1;
2272 default:
2273 lprintf("%s: something unknown selected\n", __FUNCTION__);
2274 break;
2275 }
2276
2277 return 0;
2278}
2279
2280static menu_entry e_menu_main2[] =
2281{
2282 mee_handler_id("Change CD image", MA_MAIN_SWAP_CD, main_menu_handler),
2283 mee_handler_id("Next multidisk CD", MA_MAIN_SWAP_CD_MULTI, main_menu_handler),
2284 mee_handler_id("Run BIOS", MA_MAIN_RUN_BIOS, main_menu_handler),
2285 mee_handler_id("Run EXE", MA_MAIN_RUN_EXE, main_menu_handler),
2286 mee_handler ("Memcard manager", menu_loop_memcards),
2287 mee_handler_id("Load PCSX cheats..", MA_MAIN_LOAD_CHEATS, main_menu_handler),
2288 mee_end,
2289};
2290
2291static int main_menu2_handler(int id, int keys)
2292{
2293 static int sel = 0;
2294
2295 me_enable(e_menu_main2, MA_MAIN_SWAP_CD, ready_to_go);
2296 me_enable(e_menu_main2, MA_MAIN_SWAP_CD_MULTI, ready_to_go && cdrIsoMultidiskCount > 1);
2297 me_enable(e_menu_main2, MA_MAIN_RUN_BIOS, bios_sel != 0);
2298 me_enable(e_menu_main2, MA_MAIN_LOAD_CHEATS, ready_to_go);
2299
2300 return me_loop_d(e_menu_main2, &sel, NULL, draw_frame_main);
2301}
2302
2303static const char h_extra[] = "Change CD, manage memcards..\n";
2304
2305static menu_entry e_menu_main[] =
2306{
2307 mee_label (""),
2308 mee_label (""),
2309 mee_handler_id("Resume game", MA_MAIN_RESUME_GAME, main_menu_handler),
2310 mee_handler_id("Save State", MA_MAIN_SAVE_STATE, main_menu_handler),
2311 mee_handler_id("Load State", MA_MAIN_LOAD_STATE, main_menu_handler),
2312 mee_handler_id("Reset game", MA_MAIN_RESET_GAME, main_menu_handler),
2313 mee_handler_id("Load CD image", MA_MAIN_LOAD_ROM, main_menu_handler),
2314 mee_handler ("Options", menu_loop_options),
2315 mee_handler ("Controls", menu_loop_keyconfig),
2316 mee_handler_id("Cheats", MA_MAIN_CHEATS, main_menu_handler),
2317 mee_handler_h ("Extra stuff", main_menu2_handler, h_extra),
2318 mee_handler_id("Credits", MA_MAIN_CREDITS, main_menu_handler),
2319 mee_handler_id("Exit", MA_MAIN_EXIT, main_menu_handler),
2320 mee_end,
2321};
2322
2323// ----------------------------
2324
2325static void menu_leave_emu(void);
2326
2327void menu_loop(void)
2328{
2329 static int warned_about_bios = 0;
2330 static int sel = 0;
2331
2332 menu_leave_emu();
2333
2334 if (config_save_counter == 0) {
2335 // assume first run
2336 if (bioses[1] != NULL) {
2337 // autoselect BIOS to make user's life easier
2338 snprintf(Config.Bios, sizeof(Config.Bios), "%s", bioses[1]);
2339 bios_sel = 1;
2340 }
2341 else if (!warned_about_bios) {
2342 menu_bios_warn();
2343 warned_about_bios = 1;
2344 }
2345 }
2346
2347 me_enable(e_menu_main, MA_MAIN_RESUME_GAME, ready_to_go);
2348 me_enable(e_menu_main, MA_MAIN_SAVE_STATE, ready_to_go && CdromId[0]);
2349 me_enable(e_menu_main, MA_MAIN_LOAD_STATE, ready_to_go && CdromId[0]);
2350 me_enable(e_menu_main, MA_MAIN_RESET_GAME, ready_to_go);
2351 me_enable(e_menu_main, MA_MAIN_CHEATS, ready_to_go && NumCheats);
2352
2353 in_set_config_int(0, IN_CFG_BLOCKING, 1);
2354
2355 do {
2356 me_loop_d(e_menu_main, &sel, NULL, draw_frame_main);
2357 } while (!ready_to_go && !g_emu_want_quit);
2358
2359 /* wait until menu, ok, back is released */
2360 while (in_menu_wait_any(NULL, 50) & (PBTN_MENU|PBTN_MOK|PBTN_MBACK))
2361 ;
2362
2363 in_set_config_int(0, IN_CFG_BLOCKING, 0);
2364
2365 menu_prepare_emu();
2366}
2367
2368static int qsort_strcmp(const void *p1, const void *p2)
2369{
2370 char * const *s1 = (char * const *)p1;
2371 char * const *s2 = (char * const *)p2;
2372 return strcasecmp(*s1, *s2);
2373}
2374
2375static void scan_bios_plugins(void)
2376{
2377 char fname[MAXPATHLEN];
2378 struct dirent *ent;
2379 int bios_i, gpu_i, spu_i, mc_i;
2380 char *p;
2381 DIR *dir;
2382
2383 bioses[0] = "HLE";
2384 gpu_plugins[0] = "builtin_gpu";
2385 spu_plugins[0] = "builtin_spu";
2386 memcards[0] = "(none)";
2387 bios_i = gpu_i = spu_i = mc_i = 1;
2388
2389 snprintf(fname, sizeof(fname), "%s/", Config.BiosDir);
2390 dir = opendir(fname);
2391 if (dir == NULL) {
2392 perror("scan_bios_plugins bios opendir");
2393 goto do_plugins;
2394 }
2395
2396 while (1) {
2397 struct stat st;
2398
2399 errno = 0;
2400 ent = readdir(dir);
2401 if (ent == NULL) {
2402 if (errno != 0)
2403 perror("readdir");
2404 break;
2405 }
2406
2407 if (ent->d_type != DT_REG && ent->d_type != DT_LNK)
2408 continue;
2409
2410 snprintf(fname, sizeof(fname), "%s/%s", Config.BiosDir, ent->d_name);
2411 if (stat(fname, &st) != 0 || st.st_size != 512*1024) {
2412 printf("bad BIOS file: %s\n", ent->d_name);
2413 continue;
2414 }
2415
2416 if (bios_i < ARRAY_SIZE(bioses) - 1) {
2417 bioses[bios_i++] = strdup(ent->d_name);
2418 continue;
2419 }
2420
2421 printf("too many BIOSes, dropping \"%s\"\n", ent->d_name);
2422 }
2423
2424 closedir(dir);
2425
2426do_plugins:
2427 snprintf(fname, sizeof(fname), "%s/", Config.PluginsDir);
2428 dir = opendir(fname);
2429 if (dir == NULL) {
2430 perror("scan_bios_plugins plugins opendir");
2431 goto do_memcards;
2432 }
2433
2434 while (1) {
2435 void *h, *tmp;
2436
2437 errno = 0;
2438 ent = readdir(dir);
2439 if (ent == NULL) {
2440 if (errno != 0)
2441 perror("readdir");
2442 break;
2443 }
2444 p = strstr(ent->d_name, ".so");
2445 if (p == NULL)
2446 continue;
2447
2448 snprintf(fname, sizeof(fname), "%s/%s", Config.PluginsDir, ent->d_name);
2449 h = dlopen(fname, RTLD_LAZY | RTLD_LOCAL);
2450 if (h == NULL) {
2451 fprintf(stderr, "%s\n", dlerror());
2452 continue;
2453 }
2454
2455 // now what do we have here?
2456 tmp = dlsym(h, "GPUinit");
2457 if (tmp) {
2458 dlclose(h);
2459 if (gpu_i < ARRAY_SIZE(gpu_plugins) - 1)
2460 gpu_plugins[gpu_i++] = strdup(ent->d_name);
2461 continue;
2462 }
2463
2464 tmp = dlsym(h, "SPUinit");
2465 if (tmp) {
2466 dlclose(h);
2467 if (spu_i < ARRAY_SIZE(spu_plugins) - 1)
2468 spu_plugins[spu_i++] = strdup(ent->d_name);
2469 continue;
2470 }
2471
2472 fprintf(stderr, "ignoring unidentified plugin: %s\n", fname);
2473 dlclose(h);
2474 }
2475
2476 closedir(dir);
2477
2478do_memcards:
2479 dir = opendir("." MEMCARD_DIR);
2480 if (dir == NULL) {
2481 perror("scan_bios_plugins memcards opendir");
2482 return;
2483 }
2484
2485 while (1) {
2486 struct stat st;
2487
2488 errno = 0;
2489 ent = readdir(dir);
2490 if (ent == NULL) {
2491 if (errno != 0)
2492 perror("readdir");
2493 break;
2494 }
2495
2496 if (ent->d_type != DT_REG && ent->d_type != DT_LNK)
2497 continue;
2498
2499 snprintf(fname, sizeof(fname), "." MEMCARD_DIR "%s", ent->d_name);
2500 if (stat(fname, &st) != 0) {
2501 printf("bad memcard file: %s\n", ent->d_name);
2502 continue;
2503 }
2504
2505 if (mc_i < ARRAY_SIZE(memcards) - 1) {
2506 memcards[mc_i++] = strdup(ent->d_name);
2507 continue;
2508 }
2509
2510 printf("too many memcards, dropping \"%s\"\n", ent->d_name);
2511 }
2512
2513 if (mc_i > 2)
2514 qsort(memcards + 1, mc_i - 1, sizeof(memcards[0]), qsort_strcmp);
2515
2516 closedir(dir);
2517}
2518
2519void menu_init(void)
2520{
2521 char buff[MAXPATHLEN];
2522 int i;
2523
2524 cpu_clock_st = cpu_clock = plat_target_cpu_clock_get();
2525
2526 scan_bios_plugins();
2527 menu_init_base();
2528
2529 menu_set_defconfig();
2530 menu_load_config(0);
2531 menu_do_last_cd_img(1);
2532 last_vout_w = 320;
2533 last_vout_h = 240;
2534 last_vout_bpp = 16;
2535
2536 g_menubg_src_ptr = calloc(g_menuscreen_w * g_menuscreen_h * 2, 1);
2537 g_menubg_ptr = calloc(g_menuscreen_w * g_menuscreen_h * 2, 1);
2538 if (g_menubg_src_ptr == NULL || g_menubg_ptr == NULL) {
2539 fprintf(stderr, "OOM\n");
2540 exit(1);
2541 }
2542
2543 emu_make_path(buff, "skin/background.png", sizeof(buff));
2544 readpng(g_menubg_src_ptr, buff, READPNG_BG, g_menuscreen_w, g_menuscreen_h);
2545
2546 i = plat_target.cpu_clock_set != NULL
2547 && plat_target.cpu_clock_get != NULL && cpu_clock_st > 0;
2548 me_enable(e_menu_gfx_options, MA_OPT_CPU_CLOCKS, i);
2549
2550 i = me_id2offset(e_menu_gfx_options, MA_OPT_VOUT_MODE);
2551 e_menu_gfx_options[i].data = plat_target.vout_methods;
2552 me_enable(e_menu_gfx_options, MA_OPT_VOUT_MODE,
2553 plat_target.vout_methods != NULL);
2554
2555 i = me_id2offset(e_menu_gfx_options, MA_OPT_HWFILTER);
2556 e_menu_gfx_options[i].data = plat_target.hwfilters;
2557 me_enable(e_menu_gfx_options, MA_OPT_HWFILTER,
2558 plat_target.hwfilters != NULL);
2559
2560 me_enable(e_menu_gfx_options, MA_OPT_GAMMA,
2561 plat_target.gamma_set != NULL);
2562
2563#ifdef HAVE_PRE_ARMV7
2564 me_enable(e_menu_gfx_options, MA_OPT_SWFILTER, 0);
2565#endif
2566 me_enable(e_menu_gfx_options, MA_OPT_VARSCALER, MENU_SHOW_VARSCALER);
2567 me_enable(e_menu_gfx_options, MA_OPT_VOUT_MODE, MENU_SHOW_VOUTMODE);
2568 me_enable(e_menu_gfx_options, MA_OPT_VARSCALER_C, MENU_SHOW_VARSCALER);
2569 me_enable(e_menu_gfx_options, MA_OPT_SCALER2, MENU_SHOW_SCALER2);
2570 me_enable(e_menu_keyconfig, MA_CTRL_NUBS_BTNS, MENU_SHOW_NUBS_BTNS);
2571 me_enable(e_menu_keyconfig, MA_CTRL_VIBRATION, MENU_SHOW_VIBRATION);
2572 me_enable(e_menu_keyconfig, MA_CTRL_DEADZONE, MENU_SHOW_DEADZONE);
2573}
2574
2575void menu_notify_mode_change(int w, int h, int bpp)
2576{
2577 last_vout_w = w;
2578 last_vout_h = h;
2579 last_vout_bpp = bpp;
2580}
2581
2582static void menu_leave_emu(void)
2583{
2584 if (GPU_close != NULL) {
2585 int ret = GPU_close();
2586 if (ret)
2587 fprintf(stderr, "Warning: GPU_close returned %d\n", ret);
2588 }
2589
2590 plat_video_menu_enter(ready_to_go);
2591
2592 memcpy(g_menubg_ptr, g_menubg_src_ptr, g_menuscreen_w * g_menuscreen_h * 2);
2593 if (pl_vout_buf != NULL && ready_to_go) {
2594 int x = max(0, g_menuscreen_w - last_vout_w);
2595 int y = max(0, g_menuscreen_h / 2 - last_vout_h / 2);
2596 int w = min(g_menuscreen_w, last_vout_w);
2597 int h = min(g_menuscreen_h, last_vout_h);
2598 u16 *d = (u16 *)g_menubg_ptr + g_menuscreen_w * y + x;
2599 char *s = pl_vout_buf;
2600
2601 if (last_vout_bpp == 16) {
2602 for (; h > 0; h--, d += g_menuscreen_w, s += last_vout_w * 2)
2603 menu_darken_bg(d, s, w, 0);
2604 }
2605 else {
2606 for (; h > 0; h--, d += g_menuscreen_w, s += last_vout_w * 3) {
2607 rgb888_to_rgb565(d, s, w * 3);
2608 menu_darken_bg(d, d, w, 0);
2609 }
2610 }
2611 }
2612
2613 if (ready_to_go)
2614 cpu_clock = plat_target_cpu_clock_get();
2615}
2616
2617void menu_prepare_emu(void)
2618{
2619 R3000Acpu *prev_cpu = psxCpu;
2620
2621 plat_video_menu_leave();
2622
2623 #if !defined(DRC_DISABLE) || defined(LIGHTREC)
2624 psxCpu = (Config.Cpu == CPU_INTERPRETER) ? &psxInt : &psxRec;
2625 #else
2626 psxCpu = &psxInt;
2627 #endif
2628 if (psxCpu != prev_cpu) {
2629 prev_cpu->Shutdown();
2630 psxCpu->Init();
2631 // note that this does not really reset, just clears drc caches
2632 psxCpu->Reset();
2633 }
2634
2635 menu_sync_config();
2636 psxCpu->ApplyConfig();
2637
2638 // core doesn't care about Config.Cdda changes,
2639 // so handle them manually here
2640 if (Config.Cdda)
2641 CDR_stop();
2642
2643 if (cpu_clock > 0)
2644 plat_target_cpu_clock_set(cpu_clock);
2645
2646 // push config to GPU plugin
2647 plugin_call_rearmed_cbs();
2648
2649 if (GPU_open != NULL) {
2650 int ret = GPU_open(&gpuDisp, "PCSX", NULL);
2651 if (ret)
2652 fprintf(stderr, "Warning: GPU_open returned %d\n", ret);
2653 }
2654
2655 dfinput_activate();
2656}
2657
2658void menu_update_msg(const char *msg)
2659{
2660 strncpy(menu_error_msg, msg, sizeof(menu_error_msg));
2661 menu_error_msg[sizeof(menu_error_msg) - 1] = 0;
2662
2663 menu_error_time = plat_get_ticks_ms();
2664 lprintf("msg: %s\n", menu_error_msg);
2665}
2666
2667void menu_finish(void)
2668{
2669 if (cpu_clock_st > 0)
2670 plat_target_cpu_clock_set(cpu_clock_st);
2671}
ARM optimized PCSX fork