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