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