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