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