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