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