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