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