notaz.gp2x.de / pcsx_rearmed.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
cdrom: partially implement attenuation
[pcsx_rearmed.git] / frontend / menu.c
... / ...
CommitLineData
1/*
2 * (C) GraÅžvydas "notaz" Ignotas, 2010-2011
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
11#include <stdio.h>
12#include <string.h>
13#include <errno.h>
14#include <dlfcn.h>
15#include <zlib.h>
16
17#include "main.h"
18#include "menu.h"
19#include "config.h"
20#include "plugin.h"
21#include "plugin_lib.h"
22#include "omap.h"
23#include "pandora.h"
24#include "pcnt.h"
25#include "arm_utils.h"
26#include "common/plat.h"
27#include "common/input.h"
28#include "linux/in_evdev.h"
29#include "../libpcsxcore/misc.h"
30#include "../libpcsxcore/cdrom.h"
31#include "../libpcsxcore/psemu_plugin_defs.h"
32#include "../libpcsxcore/new_dynarec/new_dynarec.h"
33#include "../plugins/dfinput/pad.h"
34#include "revision.h"
35
36#define MENU_X2 1
37#define array_size(x) (sizeof(x) / sizeof(x[0]))
38
39typedef enum
40{
41 MA_NONE = 1,
42 MA_MAIN_RESUME_GAME,
43 MA_MAIN_SAVE_STATE,
44 MA_MAIN_LOAD_STATE,
45 MA_MAIN_RESET_GAME,
46 MA_MAIN_LOAD_ROM,
47 MA_MAIN_SWAP_CD,
48 MA_MAIN_RUN_BIOS,
49 MA_MAIN_RUN_EXE,
50 MA_MAIN_CONTROLS,
51 MA_MAIN_CREDITS,
52 MA_MAIN_EXIT,
53 MA_CTRL_PLAYER1,
54 MA_CTRL_PLAYER2,
55 MA_CTRL_EMU,
56 MA_CTRL_DEV_FIRST,
57 MA_CTRL_DEV_NEXT,
58 MA_CTRL_DONE,
59 MA_OPT_SAVECFG,
60 MA_OPT_SAVECFG_GAME,
61 MA_OPT_CPU_CLOCKS,
62 MA_OPT_FILTERING,
63} menu_id;
64
65enum {
66 SCALE_1_1,
67 SCALE_4_3,
68 SCALE_FULLSCREEN,
69 SCALE_CUSTOM,
70};
71
72static int last_psx_w, last_psx_h, last_psx_bpp;
73static int scaling, filter, cpu_clock, cpu_clock_st;
74static char rom_fname_reload[MAXPATHLEN];
75static char last_selected_fname[MAXPATHLEN];
76static int warned_about_bios, region, in_type_sel;
77static int memcard1_sel, memcard2_sel;
78int g_opts;
79
80// sound plugin
81extern int iUseReverb;
82extern int iUseInterpolation;
83extern int iXAPitch;
84extern int iSPUIRQWait;
85extern int iUseTimer;
86
87static const char *bioses[24];
88static const char *gpu_plugins[16];
89static const char *spu_plugins[16];
90static const char *memcards[32];
91static int bios_sel, gpu_plugsel, spu_plugsel;
92
93
94static int min(int x, int y) { return x < y ? x : y; }
95static int max(int x, int y) { return x > y ? x : y; }
96
97void emu_make_path(char *buff, const char *end, int size)
98{
99 int pos, end_len;
100
101 end_len = strlen(end);
102 pos = plat_get_root_dir(buff, size);
103 strncpy(buff + pos, end, size - pos);
104 buff[size - 1] = 0;
105 if (pos + end_len > size - 1)
106 printf("Warning: path truncated: %s\n", buff);
107}
108
109static int emu_check_save_file(int slot)
110{
111 int ret = emu_check_state(slot);
112 return ret == 0 ? 1 : 0;
113}
114
115static int emu_save_load_game(int load, int unused)
116{
117 int ret;
118
119 if (load) {
120 ret = emu_load_state(state_slot);
121
122 // reflect hle/bios mode from savestate
123 if (Config.HLE)
124 bios_sel = 0;
125 else if (bios_sel == 0 && bioses[1] != NULL)
126 // XXX: maybe find the right bios instead
127 bios_sel = 1;
128 }
129 else
130 ret = emu_save_state(state_slot);
131
132 return ret;
133}
134
135// propagate menu settings to the emu vars
136static void menu_sync_config(void)
137{
138 static int allow_abs_only_old;
139
140 Config.PsxAuto = 1;
141 if (region > 0) {
142 Config.PsxAuto = 0;
143 Config.PsxType = region - 1;
144 }
145 in_type = in_type_sel ? PSE_PAD_TYPE_ANALOGPAD : PSE_PAD_TYPE_STANDARD;
146 if (in_evdev_allow_abs_only != allow_abs_only_old) {
147 pandora_rescan_inputs();
148 allow_abs_only_old = in_evdev_allow_abs_only;
149 }
150
151 pl_frame_interval = Config.PsxType ? 20000 : 16667;
152 // used by P.E.Op.S. frameskip code
153 pl_rearmed_cbs.gpu_peops.fFrameRateHz = Config.PsxType ? 50.0f : 59.94f;
154 pl_rearmed_cbs.gpu_peops.dwFrameRateTicks =
155 (100000*100 / (unsigned long)(pl_rearmed_cbs.gpu_peops.fFrameRateHz*100));
156}
157
158static void menu_set_defconfig(void)
159{
160 g_opts = 0;
161 scaling = SCALE_4_3;
162
163 region = 0;
164 in_type_sel = 0;
165 in_evdev_allow_abs_only = 0;
166 Config.Xa = Config.Cdda = Config.Sio =
167 Config.SpuIrq = Config.RCntFix = Config.VSyncWA = 0;
168 Config.CdrReschedule = 0;
169
170 pl_rearmed_cbs.frameskip = 0;
171 pl_rearmed_cbs.gpu_peops.iUseDither = 0;
172 pl_rearmed_cbs.gpu_peops.dwActFixes = 1<<7;
173
174 iUseReverb = 2;
175 iUseInterpolation = 1;
176 iXAPitch = 0;
177 iSPUIRQWait = 1;
178 iUseTimer = 2;
179
180 menu_sync_config();
181}
182
183#define CE_CONFIG_STR(val) \
184 { #val, 0, Config.val }
185
186#define CE_CONFIG_VAL(val) \
187 { #val, sizeof(Config.val), &Config.val }
188
189#define CE_STR(val) \
190 { #val, 0, val }
191
192#define CE_INTVAL(val) \
193 { #val, sizeof(val), &val }
194
195#define CE_INTVAL_P(val) \
196 { #val, sizeof(pl_rearmed_cbs.val), &pl_rearmed_cbs.val }
197
198// 'versioned' var, used when defaults change
199#define CE_INTVAL_V(val, ver) \
200 { #val #ver, sizeof(val), &val }
201
202static const struct {
203 const char *name;
204 size_t len;
205 void *val;
206} config_data[] = {
207 CE_CONFIG_STR(Bios),
208 CE_CONFIG_STR(Gpu),
209 CE_CONFIG_STR(Spu),
210// CE_CONFIG_STR(Cdr),
211 CE_CONFIG_VAL(Xa),
212 CE_CONFIG_VAL(Sio),
213 CE_CONFIG_VAL(Mdec),
214 CE_CONFIG_VAL(Cdda),
215 CE_CONFIG_VAL(Debug),
216 CE_CONFIG_VAL(PsxOut),
217 CE_CONFIG_VAL(SpuIrq),
218 CE_CONFIG_VAL(RCntFix),
219 CE_CONFIG_VAL(VSyncWA),
220 CE_CONFIG_VAL(Cpu),
221 CE_CONFIG_VAL(CdrReschedule),
222 CE_INTVAL(region),
223 CE_INTVAL(scaling),
224 CE_INTVAL(g_layer_x),
225 CE_INTVAL(g_layer_y),
226 CE_INTVAL(g_layer_w),
227 CE_INTVAL(g_layer_h),
228 CE_INTVAL(filter),
229 CE_INTVAL(state_slot),
230 CE_INTVAL(cpu_clock),
231 CE_INTVAL(g_opts),
232 CE_INTVAL(in_type_sel),
233 CE_INTVAL_P(frameskip),
234 CE_INTVAL_P(gpu_peops.iUseDither),
235 CE_INTVAL_P(gpu_peops.dwActFixes),
236 CE_INTVAL(iUseReverb),
237 CE_INTVAL(iXAPitch),
238 CE_INTVAL_V(iUseInterpolation, 2),
239 CE_INTVAL_V(iSPUIRQWait, 2),
240 CE_INTVAL(iUseTimer),
241 CE_INTVAL(warned_about_bios),
242 CE_INTVAL(in_evdev_allow_abs_only),
243};
244
245static char *get_cd_label(void)
246{
247 static char trimlabel[33];
248 int j;
249
250 strncpy(trimlabel, CdromLabel, 32);
251 trimlabel[32] = 0;
252 for (j = 31; j >= 0; j--)
253 if (trimlabel[j] == ' ')
254 trimlabel[j] = 0;
255
256 return trimlabel;
257}
258
259static void make_cfg_fname(char *buf, size_t size, int is_game)
260{
261 if (is_game)
262 snprintf(buf, size, "." PCSX_DOT_DIR "cfg/%.32s-%.9s.cfg", get_cd_label(), CdromId);
263 else
264 snprintf(buf, size, "." PCSX_DOT_DIR "%s", cfgfile_basename);
265}
266
267static void keys_write_all(FILE *f);
268
269static int menu_write_config(int is_game)
270{
271 char cfgfile[MAXPATHLEN];
272 FILE *f;
273 int i;
274
275 make_cfg_fname(cfgfile, sizeof(cfgfile), is_game);
276 f = fopen(cfgfile, "w");
277 if (f == NULL) {
278 printf("menu_write_config: failed to open: %s\n", cfgfile);
279 return -1;
280 }
281
282 for (i = 0; i < ARRAY_SIZE(config_data); i++) {
283 fprintf(f, "%s = ", config_data[i].name);
284 switch (config_data[i].len) {
285 case 0:
286 fprintf(f, "%s\n", (char *)config_data[i].val);
287 break;
288 case 1:
289 fprintf(f, "%x\n", *(u8 *)config_data[i].val);
290 break;
291 case 2:
292 fprintf(f, "%x\n", *(u16 *)config_data[i].val);
293 break;
294 case 4:
295 fprintf(f, "%x\n", *(u32 *)config_data[i].val);
296 break;
297 default:
298 printf("menu_write_config: unhandled len %d for %s\n",
299 config_data[i].len, config_data[i].name);
300 break;
301 }
302 }
303
304 if (!is_game)
305 fprintf(f, "lastcdimg = %s\n", last_selected_fname);
306
307 keys_write_all(f);
308 fclose(f);
309
310 return 0;
311}
312
313static void parse_str_val(char *cval, const char *src)
314{
315 char *tmp;
316 strncpy(cval, src, MAXPATHLEN);
317 cval[MAXPATHLEN - 1] = 0;
318 tmp = strchr(cval, '\n');
319 if (tmp == NULL)
320 tmp = strchr(cval, '\r');
321 if (tmp != NULL)
322 *tmp = 0;
323}
324
325static void keys_load_all(const char *cfg);
326
327static int menu_load_config(int is_game)
328{
329 char cfgfile[MAXPATHLEN];
330 int i, ret = -1;
331 long size;
332 char *cfg;
333 FILE *f;
334
335 make_cfg_fname(cfgfile, sizeof(cfgfile), is_game);
336 f = fopen(cfgfile, "r");
337 if (f == NULL) {
338 printf("menu_load_config: failed to open: %s\n", cfgfile);
339 return -1;
340 }
341
342 fseek(f, 0, SEEK_END);
343 size = ftell(f);
344 if (size <= 0) {
345 printf("bad size %ld: %s\n", size, cfgfile);
346 goto fail;
347 }
348
349 cfg = malloc(size + 1);
350 if (cfg == NULL)
351 goto fail;
352
353 fseek(f, 0, SEEK_SET);
354 if (fread(cfg, 1, size, f) != size) {
355 printf("failed to read: %s\n", cfgfile);
356 goto fail_read;
357 }
358 cfg[size] = 0;
359
360 for (i = 0; i < ARRAY_SIZE(config_data); i++) {
361 char *tmp, *tmp2;
362 u32 val;
363
364 tmp = strstr(cfg, config_data[i].name);
365 if (tmp == NULL)
366 continue;
367 tmp += strlen(config_data[i].name);
368 if (strncmp(tmp, " = ", 3) != 0)
369 continue;
370 tmp += 3;
371
372 if (config_data[i].len == 0) {
373 parse_str_val(config_data[i].val, tmp);
374 continue;
375 }
376
377 tmp2 = NULL;
378 val = strtoul(tmp, &tmp2, 16);
379 if (tmp2 == NULL || tmp == tmp2)
380 continue; // parse failed
381
382 switch (config_data[i].len) {
383 case 1:
384 *(u8 *)config_data[i].val = val;
385 break;
386 case 2:
387 *(u16 *)config_data[i].val = val;
388 break;
389 case 4:
390 *(u32 *)config_data[i].val = val;
391 break;
392 default:
393 printf("menu_load_config: unhandled len %d for %s\n",
394 config_data[i].len, config_data[i].name);
395 break;
396 }
397 }
398
399 if (!is_game) {
400 char *tmp = strstr(cfg, "lastcdimg = ");
401 if (tmp != NULL) {
402 tmp += 12;
403 parse_str_val(last_selected_fname, tmp);
404 }
405 }
406
407 menu_sync_config();
408
409 // sync plugins
410 for (i = bios_sel = 0; bioses[i] != NULL; i++)
411 if (strcmp(Config.Bios, bioses[i]) == 0)
412 { bios_sel = i; break; }
413
414 for (i = gpu_plugsel = 0; gpu_plugins[i] != NULL; i++)
415 if (strcmp(Config.Gpu, gpu_plugins[i]) == 0)
416 { gpu_plugsel = i; break; }
417
418 for (i = spu_plugsel = 0; spu_plugins[i] != NULL; i++)
419 if (strcmp(Config.Spu, spu_plugins[i]) == 0)
420 { spu_plugsel = i; break; }
421
422 keys_load_all(cfg);
423 ret = 0;
424fail_read:
425 free(cfg);
426fail:
427 fclose(f);
428 return ret;
429}
430
431// rrrr rggg gggb bbbb
432static unsigned short fname2color(const char *fname)
433{
434 static const char *cdimg_exts[] = { ".bin", ".img", ".mdf", ".iso", ".cue", ".z", ".bz", ".znx", ".pbp" };
435 static const char *other_exts[] = { ".ccd", ".toc", ".mds", ".sub", ".table", ".index", ".sbi" };
436 const char *ext = strrchr(fname, '.');
437 int i;
438
439 if (ext == NULL)
440 return 0xffff;
441 for (i = 0; i < array_size(cdimg_exts); i++)
442 if (strcasecmp(ext, cdimg_exts[i]) == 0)
443 return 0x7bff;
444 for (i = 0; i < array_size(other_exts); i++)
445 if (strcasecmp(ext, other_exts[i]) == 0)
446 return 0xa514;
447 return 0xffff;
448}
449
450static void draw_savestate_bg(int slot);
451
452static const char *filter_exts[] = {
453 ".mp3", ".MP3", ".txt", ".htm", "html", ".jpg", ".pnd"
454};
455
456#define MENU_ALIGN_LEFT
457#define menu_init menu_init_common
458#include "common/menu.c"
459#undef menu_init
460
461// a bit of black magic here
462static void draw_savestate_bg(int slot)
463{
464 static const int psx_widths[8] = { 256, 368, 320, 384, 512, 512, 640, 640 };
465 int x, y, w, h;
466 char fname[MAXPATHLEN];
467 GPUFreeze_t *gpu;
468 u16 *s, *d;
469 gzFile f;
470 int ret;
471 u32 tmp;
472
473 ret = get_state_filename(fname, sizeof(fname), slot);
474 if (ret != 0)
475 return;
476
477 f = gzopen(fname, "rb");
478 if (f == NULL)
479 return;
480
481 if (gzseek(f, 0x29933d, SEEK_SET) != 0x29933d) {
482 fprintf(stderr, "gzseek failed\n");
483 gzclose(f);
484 return;
485 }
486
487 gpu = malloc(sizeof(*gpu));
488 if (gpu == NULL) {
489 gzclose(f);
490 return;
491 }
492
493 ret = gzread(f, gpu, sizeof(*gpu));
494 gzclose(f);
495 if (ret != sizeof(*gpu)) {
496 fprintf(stderr, "gzread failed\n");
497 goto out;
498 }
499
500 memcpy(g_menubg_ptr, g_menubg_src_ptr, g_menuscreen_w * g_menuscreen_h * 2);
501
502 if (gpu->ulStatus & 0x800000)
503 goto out; // disabled
504
505 x = gpu->ulControl[5] & 0x3ff;
506 y = (gpu->ulControl[5] >> 10) & 0x1ff;
507 s = (u16 *)gpu->psxVRam + y * 1024 + (x & ~1);
508 w = psx_widths[(gpu->ulStatus >> 16) & 7];
509 tmp = gpu->ulControl[7];
510 h = ((tmp >> 10) & 0x3ff) - (tmp & 0x3ff);
511 if (gpu->ulStatus & 0x80000) // doubleheight
512 h *= 2;
513
514 x = max(0, g_menuscreen_w - w) & ~3;
515 y = max(0, g_menuscreen_h / 2 - h / 2);
516 w = min(g_menuscreen_w, w);
517 h = min(g_menuscreen_h, h);
518 d = (u16 *)g_menubg_ptr + g_menuscreen_w * y + x;
519
520 for (; h > 0; h--, d += g_menuscreen_w, s += 1024)
521 if (gpu->ulStatus & 0x200000)
522 bgr888_to_rgb565(d, s, w * 3);
523 else
524 bgr555_to_rgb565(d, s, w * 2);
525
526out:
527 free(gpu);
528}
529
530// ---------- pandora specific -----------
531
532static const char pnd_script_base[] = "sudo -n /usr/pandora/scripts";
533static char **pnd_filter_list;
534
535static int get_cpu_clock(void)
536{
537 FILE *f;
538 int ret = 0;
539 f = fopen("/proc/pandora/cpu_mhz_max", "r");
540 if (f) {
541 fscanf(f, "%d", &ret);
542 fclose(f);
543 }
544 return ret;
545}
546
547static void apply_cpu_clock(void)
548{
549 char buf[128];
550
551 if (cpu_clock != 0 && cpu_clock != get_cpu_clock()) {
552 snprintf(buf, sizeof(buf), "unset DISPLAY; echo y | %s/op_cpuspeed.sh %d",
553 pnd_script_base, cpu_clock);
554 system(buf);
555 }
556}
557
558static void apply_filter(int which)
559{
560 static int old = -1;
561 char buf[128];
562 int i;
563
564 if (pnd_filter_list == NULL || which == old)
565 return;
566
567 for (i = 0; i < which; i++)
568 if (pnd_filter_list[i] == NULL)
569 return;
570
571 if (pnd_filter_list[i] == NULL)
572 return;
573
574 snprintf(buf, sizeof(buf), "%s/op_videofir.sh %s", pnd_script_base, pnd_filter_list[i]);
575 system(buf);
576 old = which;
577}
578
579static void apply_lcdrate(int pal)
580{
581 static int old = -1;
582 char buf[128];
583
584 if (pal == old)
585 return;
586
587 snprintf(buf, sizeof(buf), "%s/op_lcdrate.sh %d",
588 pnd_script_base, pal ? 50 : 60);
589 system(buf);
590 old = pal;
591}
592
593static menu_entry e_menu_gfx_options[];
594
595static void pnd_menu_init(void)
596{
597 struct dirent *ent;
598 int i, count = 0;
599 char **mfilters;
600 char buff[64];
601 DIR *dir;
602
603 cpu_clock_st = cpu_clock = get_cpu_clock();
604
605 dir = opendir("/etc/pandora/conf/dss_fir");
606 if (dir == NULL) {
607 perror("filter opendir");
608 return;
609 }
610
611 while (1) {
612 errno = 0;
613 ent = readdir(dir);
614 if (ent == NULL) {
615 if (errno != 0)
616 perror("readdir");
617 break;
618 }
619
620 if (ent->d_type != DT_REG && ent->d_type != DT_LNK)
621 continue;
622
623 count++;
624 }
625
626 if (count == 0)
627 return;
628
629 mfilters = calloc(count + 1, sizeof(mfilters[0]));
630 if (mfilters == NULL)
631 return;
632
633 rewinddir(dir);
634 for (i = 0; (ent = readdir(dir)); ) {
635 size_t len;
636
637 if (ent->d_type != DT_REG && ent->d_type != DT_LNK)
638 continue;
639
640 len = strlen(ent->d_name);
641
642 // skip pre-HF5 extra files
643 if (len >= 3 && strcmp(ent->d_name + len - 3, "_v3") == 0)
644 continue;
645 if (len >= 3 && strcmp(ent->d_name + len - 3, "_v5") == 0)
646 continue;
647
648 // have to cut "_up_h" for pre-HF5
649 if (len > 5 && strcmp(ent->d_name + len - 5, "_up_h") == 0)
650 len -= 5;
651
652 if (len > sizeof(buff) - 1)
653 continue;
654
655 strncpy(buff, ent->d_name, len);
656 buff[len] = 0;
657 mfilters[i] = strdup(buff);
658 if (mfilters[i] != NULL)
659 i++;
660 }
661 closedir(dir);
662
663 i = me_id2offset(e_menu_gfx_options, MA_OPT_FILTERING);
664 e_menu_gfx_options[i].data = (void *)mfilters;
665 pnd_filter_list = mfilters;
666}
667
668void menu_finish(void)
669{
670 cpu_clock = cpu_clock_st;
671 apply_cpu_clock();
672}
673
674// -------------- key config --------------
675
676me_bind_action me_ctrl_actions[] =
677{
678 { "UP ", 1 << DKEY_UP},
679 { "DOWN ", 1 << DKEY_DOWN },
680 { "LEFT ", 1 << DKEY_LEFT },
681 { "RIGHT ", 1 << DKEY_RIGHT },
682 { "TRIANGLE", 1 << DKEY_TRIANGLE },
683 { "CIRCLE ", 1 << DKEY_CIRCLE },
684 { "CROSS ", 1 << DKEY_CROSS },
685 { "SQUARE ", 1 << DKEY_SQUARE },
686 { "L1 ", 1 << DKEY_L1 },
687 { "R1 ", 1 << DKEY_R1 },
688 { "L2 ", 1 << DKEY_L2 },
689 { "R2 ", 1 << DKEY_R2 },
690 { "L3 ", 1 << DKEY_L3 },
691 { "R3 ", 1 << DKEY_R3 },
692 { "START ", 1 << DKEY_START },
693 { "SELECT ", 1 << DKEY_SELECT },
694 { NULL, 0 }
695};
696
697me_bind_action emuctrl_actions[] =
698{
699 { "Save State ", 1 << SACTION_SAVE_STATE },
700 { "Load State ", 1 << SACTION_LOAD_STATE },
701 { "Prev Save Slot ", 1 << SACTION_PREV_SSLOT },
702 { "Next Save Slot ", 1 << SACTION_NEXT_SSLOT },
703 { "Toggle Frameskip ", 1 << SACTION_TOGGLE_FSKIP },
704 { "Take Screenshot ", 1 << SACTION_SCREENSHOT },
705 { "Enter Menu ", 1 << SACTION_ENTER_MENU },
706 { NULL, 0 }
707};
708
709static char *mystrip(char *str)
710{
711 int i, len;
712
713 len = strlen(str);
714 for (i = 0; i < len; i++)
715 if (str[i] != ' ') break;
716 if (i > 0) memmove(str, str + i, len - i + 1);
717
718 len = strlen(str);
719 for (i = len - 1; i >= 0; i--)
720 if (str[i] != ' ') break;
721 str[i+1] = 0;
722
723 return str;
724}
725
726static void get_line(char *d, size_t size, const char *s)
727{
728 const char *pe;
729 size_t len;
730
731 for (pe = s; *pe != '\r' && *pe != '\n' && *pe != 0; pe++)
732 ;
733 len = pe - s;
734 if (len > size - 1)
735 len = size - 1;
736 strncpy(d, s, len);
737 d[len] = 0;
738
739 mystrip(d);
740}
741
742static void keys_write_all(FILE *f)
743{
744 int d;
745
746 for (d = 0; d < IN_MAX_DEVS; d++)
747 {
748 const int *binds = in_get_dev_binds(d);
749 const char *name = in_get_dev_name(d, 0, 0);
750 int k, count = 0;
751
752 if (binds == NULL || name == NULL)
753 continue;
754
755 fprintf(f, "binddev = %s\n", name);
756 in_get_config(d, IN_CFG_BIND_COUNT, &count);
757
758 for (k = 0; k < count; k++)
759 {
760 int i, kbinds, mask;
761 char act[32];
762
763 act[0] = act[31] = 0;
764 name = in_get_key_name(d, k);
765
766 kbinds = binds[IN_BIND_OFFS(k, IN_BINDTYPE_PLAYER12)];
767 for (i = 0; kbinds && i < ARRAY_SIZE(me_ctrl_actions) - 1; i++) {
768 mask = me_ctrl_actions[i].mask;
769 if (mask & kbinds) {
770 strncpy(act, me_ctrl_actions[i].name, 31);
771 fprintf(f, "bind %s = player1 %s\n", name, mystrip(act));
772 kbinds &= ~mask;
773 }
774 mask = me_ctrl_actions[i].mask << 16;
775 if (mask & kbinds) {
776 strncpy(act, me_ctrl_actions[i].name, 31);
777 fprintf(f, "bind %s = player2 %s\n", name, mystrip(act));
778 kbinds &= ~mask;
779 }
780 }
781
782 kbinds = binds[IN_BIND_OFFS(k, IN_BINDTYPE_EMU)];
783 for (i = 0; kbinds && i < ARRAY_SIZE(emuctrl_actions) - 1; i++) {
784 mask = emuctrl_actions[i].mask;
785 if (mask & kbinds) {
786 strncpy(act, emuctrl_actions[i].name, 31);
787 fprintf(f, "bind %s = %s\n", name, mystrip(act));
788 kbinds &= ~mask;
789 }
790 }
791 }
792 }
793}
794
795static int parse_bind_val(const char *val, int *type)
796{
797 int i;
798
799 *type = IN_BINDTYPE_NONE;
800 if (val[0] == 0)
801 return 0;
802
803 if (strncasecmp(val, "player", 6) == 0)
804 {
805 int player, shift = 0;
806 player = atoi(val + 6) - 1;
807
808 if ((unsigned int)player > 1)
809 return -1;
810 if (player == 1)
811 shift = 16;
812
813 *type = IN_BINDTYPE_PLAYER12;
814 for (i = 0; me_ctrl_actions[i].name != NULL; i++) {
815 if (strncasecmp(me_ctrl_actions[i].name, val + 8, strlen(val + 8)) == 0)
816 return me_ctrl_actions[i].mask << shift;
817 }
818 }
819 for (i = 0; emuctrl_actions[i].name != NULL; i++) {
820 if (strncasecmp(emuctrl_actions[i].name, val, strlen(val)) == 0) {
821 *type = IN_BINDTYPE_EMU;
822 return emuctrl_actions[i].mask;
823 }
824 }
825
826 return -1;
827}
828
829static void keys_load_all(const char *cfg)
830{
831 char dev[256], key[128], *act;
832 const char *p;
833 int bind, bindtype;
834 int dev_id;
835
836 p = cfg;
837 while (p != NULL && (p = strstr(p, "binddev = ")) != NULL) {
838 p += 10;
839
840 get_line(dev, sizeof(dev), p);
841 dev_id = in_config_parse_dev(dev);
842 if (dev_id < 0) {
843 printf("input: can't handle dev: %s\n", dev);
844 continue;
845 }
846
847 in_unbind_all(dev_id, -1, -1);
848 while ((p = strstr(p, "bind"))) {
849 if (strncmp(p, "binddev = ", 10) == 0)
850 break;
851
852 p += 4;
853 if (*p != ' ') {
854 printf("input: parse error: %16s..\n", p);
855 continue;
856 }
857
858 get_line(key, sizeof(key), p);
859 act = strchr(key, '=');
860 if (act == NULL) {
861 printf("parse failed: %16s..\n", p);
862 continue;
863 }
864 *act = 0;
865 act++;
866 mystrip(key);
867 mystrip(act);
868
869 bind = parse_bind_val(act, &bindtype);
870 if (bind != -1 && bind != 0) {
871 //printf("bind #%d '%s' %08x (%s)\n", dev_id, key, bind, act);
872 in_config_bind_key(dev_id, key, bind, bindtype);
873 }
874 else
875 lprintf("config: unhandled action \"%s\"\n", act);
876 }
877 }
878 in_clean_binds();
879}
880
881static int key_config_loop_wrap(int id, int keys)
882{
883 switch (id) {
884 case MA_CTRL_PLAYER1:
885 key_config_loop(me_ctrl_actions, array_size(me_ctrl_actions) - 1, 0);
886 break;
887 case MA_CTRL_PLAYER2:
888 key_config_loop(me_ctrl_actions, array_size(me_ctrl_actions) - 1, 1);
889 break;
890 case MA_CTRL_EMU:
891 key_config_loop(emuctrl_actions, array_size(emuctrl_actions) - 1, -1);
892 break;
893 default:
894 break;
895 }
896 return 0;
897}
898
899static const char *mgn_dev_name(int id, int *offs)
900{
901 const char *name = NULL;
902 static int it = 0;
903
904 if (id == MA_CTRL_DEV_FIRST)
905 it = 0;
906
907 for (; it < IN_MAX_DEVS; it++) {
908 name = in_get_dev_name(it, 1, 1);
909 if (name != NULL)
910 break;
911 }
912
913 it++;
914 return name;
915}
916
917static const char *mgn_saveloadcfg(int id, int *offs)
918{
919 return "";
920}
921
922static int mh_savecfg(int id, int keys)
923{
924 if (menu_write_config(id == MA_OPT_SAVECFG_GAME ? 1 : 0) == 0)
925 me_update_msg("config saved");
926 else
927 me_update_msg("failed to write config");
928
929 return 1;
930}
931
932static int mh_input_rescan(int id, int keys)
933{
934 //menu_sync_config();
935 pandora_rescan_inputs();
936 me_update_msg("rescan complete.");
937
938 return 0;
939}
940
941static const char *men_in_type_sel[] = { "Standard (SCPH-1080)", "Analog (SCPH-1150)", NULL };
942static const char h_nub_btns[] = "Experimental, keep this OFF if unsure. Select rescan after change.";
943
944static menu_entry e_menu_keyconfig[] =
945{
946 mee_handler_id("Player 1", MA_CTRL_PLAYER1, key_config_loop_wrap),
947 mee_handler_id("Player 2", MA_CTRL_PLAYER2, key_config_loop_wrap),
948 mee_handler_id("Emulator controls", MA_CTRL_EMU, key_config_loop_wrap),
949 mee_label (""),
950 mee_enum ("Controller", 0, in_type_sel, men_in_type_sel),
951 mee_onoff_h ("Nubs as buttons", 0, in_evdev_allow_abs_only, 1, h_nub_btns),
952 mee_cust_nosave("Save global config", MA_OPT_SAVECFG, mh_savecfg, mgn_saveloadcfg),
953 mee_cust_nosave("Save cfg for loaded game", MA_OPT_SAVECFG_GAME, mh_savecfg, mgn_saveloadcfg),
954 mee_handler ("Rescan devices", mh_input_rescan),
955 mee_label (""),
956 mee_label ("Input devices:"),
957 mee_label_mk (MA_CTRL_DEV_FIRST, mgn_dev_name),
958 mee_label_mk (MA_CTRL_DEV_NEXT, mgn_dev_name),
959 mee_label_mk (MA_CTRL_DEV_NEXT, mgn_dev_name),
960 mee_label_mk (MA_CTRL_DEV_NEXT, mgn_dev_name),
961 mee_label_mk (MA_CTRL_DEV_NEXT, mgn_dev_name),
962 mee_label_mk (MA_CTRL_DEV_NEXT, mgn_dev_name),
963 mee_label_mk (MA_CTRL_DEV_NEXT, mgn_dev_name),
964 mee_end,
965};
966
967static int menu_loop_keyconfig(int id, int keys)
968{
969 static int sel = 0;
970
971// me_enable(e_menu_keyconfig, MA_OPT_SAVECFG_GAME, ready_to_go && CdromId[0]);
972 me_loop(e_menu_keyconfig, &sel);
973 return 0;
974}
975
976// ------------ gfx options menu ------------
977
978static const char *men_scaler[] = { "1x1", "scaled 4:3", "fullscreen", "custom", NULL };
979static const char h_cscaler[] = "Displays the scaler layer, you can resize it\n"
980 "using d-pad or move it using R+d-pad";
981static const char *men_dummy[] = { NULL };
982
983static int menu_loop_cscaler(int id, int keys)
984{
985 unsigned int inp;
986
987 scaling = SCALE_CUSTOM;
988
989 omap_enable_layer(1);
990
991 for (;;)
992 {
993 menu_draw_begin(0);
994 memset(g_menuscreen_ptr, 4, g_menuscreen_w * g_menuscreen_h * 2);
995 text_out16(2, 2, "%d,%d", g_layer_x, g_layer_y);
996 text_out16(2, 480 - 18, "%dx%d | d-pad: resize, R+d-pad: move", g_layer_w, g_layer_h);
997 menu_draw_end();
998
999 inp = in_menu_wait(PBTN_UP|PBTN_DOWN|PBTN_LEFT|PBTN_RIGHT|PBTN_R|PBTN_MOK|PBTN_MBACK, 40);
1000 if (inp & PBTN_UP) g_layer_y--;
1001 if (inp & PBTN_DOWN) g_layer_y++;
1002 if (inp & PBTN_LEFT) g_layer_x--;
1003 if (inp & PBTN_RIGHT) g_layer_x++;
1004 if (!(inp & PBTN_R)) {
1005 if (inp & PBTN_UP) g_layer_h += 2;
1006 if (inp & PBTN_DOWN) g_layer_h -= 2;
1007 if (inp & PBTN_LEFT) g_layer_w += 2;
1008 if (inp & PBTN_RIGHT) g_layer_w -= 2;
1009 }
1010 if (inp & (PBTN_MOK|PBTN_MBACK))
1011 break;
1012
1013 if (inp & (PBTN_UP|PBTN_DOWN|PBTN_LEFT|PBTN_RIGHT)) {
1014 if (g_layer_x < 0) g_layer_x = 0;
1015 if (g_layer_x > 640) g_layer_x = 640;
1016 if (g_layer_y < 0) g_layer_y = 0;
1017 if (g_layer_y > 420) g_layer_y = 420;
1018 if (g_layer_w < 160) g_layer_w = 160;
1019 if (g_layer_h < 60) g_layer_h = 60;
1020 if (g_layer_x + g_layer_w > 800)
1021 g_layer_w = 800 - g_layer_x;
1022 if (g_layer_y + g_layer_h > 480)
1023 g_layer_h = 480 - g_layer_y;
1024 omap_enable_layer(1);
1025 }
1026 }
1027
1028 omap_enable_layer(0);
1029
1030 return 0;
1031}
1032
1033static menu_entry e_menu_gfx_options[] =
1034{
1035 mee_enum ("Scaler", 0, scaling, men_scaler),
1036 mee_enum ("Filter", MA_OPT_FILTERING, filter, men_dummy),
1037// mee_onoff ("Vsync", 0, vsync, 1),
1038 mee_cust_h ("Setup custom scaler", 0, menu_loop_cscaler, NULL, h_cscaler),
1039 mee_end,
1040};
1041
1042static int menu_loop_gfx_options(int id, int keys)
1043{
1044 static int sel = 0;
1045
1046 me_loop(e_menu_gfx_options, &sel);
1047
1048 return 0;
1049}
1050
1051// ------------ bios/plugins ------------
1052
1053static const char *men_gpu_dithering[] = { "None", "Game dependant", "Always", NULL };
1054static const char h_gpu_0[] = "Needed for Chrono Cross";
1055static const char h_gpu_1[] = "Capcom fighting games";
1056static const char h_gpu_2[] = "Black screens in Lunar";
1057static const char h_gpu_3[] = "Compatibility mode";
1058static const char h_gpu_6[] = "Pandemonium 2";
1059static const char h_gpu_7[] = "Skip every second frame";
1060static const char h_gpu_8[] = "Needed by Dark Forces";
1061static const char h_gpu_9[] = "better g-colors, worse textures";
1062static const char h_gpu_10[] = "Toggle busy flags after drawing";
1063
1064static menu_entry e_menu_plugin_gpu[] =
1065{
1066 mee_enum ("Dithering", 0, pl_rearmed_cbs.gpu_peops.iUseDither, men_gpu_dithering),
1067 mee_onoff_h ("Odd/even bit hack", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<0, h_gpu_0),
1068 mee_onoff_h ("Expand screen width", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<1, h_gpu_1),
1069 mee_onoff_h ("Ignore brightness color", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<2, h_gpu_2),
1070 mee_onoff_h ("Disable coordinate check", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<3, h_gpu_3),
1071 mee_onoff_h ("Lazy screen update", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<6, h_gpu_6),
1072 mee_onoff_h ("Old frame skipping", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<7, h_gpu_7),
1073 mee_onoff_h ("Repeated flat tex triangles ",0,pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<8, h_gpu_8),
1074 mee_onoff_h ("Draw quads with triangles", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<9, h_gpu_9),
1075 mee_onoff_h ("Fake 'gpu busy' states", 0, pl_rearmed_cbs.gpu_peops.dwActFixes, 1<<10, h_gpu_10),
1076 mee_end,
1077};
1078
1079static int menu_loop_plugin_gpu(int id, int keys)
1080{
1081 static int sel = 0;
1082 me_loop(e_menu_plugin_gpu, &sel);
1083 return 0;
1084}
1085
1086static const char *men_spu_reverb[] = { "Off", "Fake", "On", NULL };
1087static const char *men_spu_interp[] = { "None", "Simple", "Gaussian", "Cubic", NULL };
1088static const char h_spu_irq_wait[] = "Wait for CPU (recommended set to ON)";
1089static const char h_spu_thread[] = "Run sound emulation in main thread (recommended)";
1090
1091static menu_entry e_menu_plugin_spu[] =
1092{
1093 mee_enum ("Reverb", 0, iUseReverb, men_spu_reverb),
1094 mee_enum ("Interpolation", 0, iUseInterpolation, men_spu_interp),
1095 mee_onoff ("Adjust XA pitch", 0, iXAPitch, 1),
1096 mee_onoff_h ("SPU IRQ Wait", 0, iSPUIRQWait, 1, h_spu_irq_wait),
1097 mee_onoff_h ("Sound in main thread", 0, iUseTimer, 2, h_spu_thread),
1098 mee_end,
1099};
1100
1101static int menu_loop_plugin_spu(int id, int keys)
1102{
1103 static int sel = 0;
1104 me_loop(e_menu_plugin_spu, &sel);
1105 return 0;
1106}
1107
1108static const char h_bios[] = "HLE is simulated BIOS. BIOS selection is saved in savestates\n"
1109 "and can't be changed there. Must save config and reload\n"
1110 "the game for change to take effect";
1111static const char h_plugin_xpu[] = "Must save config and reload the game\n"
1112 "for plugin change to take effect";
1113static const char h_gpu[] = "Configure P.E.Op.S. SoftGL Driver V1.17";
1114static const char h_spu[] = "Configure built-in P.E.Op.S. Sound Driver V1.7";
1115
1116static menu_entry e_menu_plugin_options[] =
1117{
1118 mee_enum_h ("BIOS", 0, bios_sel, bioses, h_bios),
1119 mee_enum_h ("GPU plugin", 0, gpu_plugsel, gpu_plugins, h_plugin_xpu),
1120 mee_enum_h ("SPU plugin", 0, spu_plugsel, spu_plugins, h_plugin_xpu),
1121 mee_handler_h ("Configure gpu_peops plugin", menu_loop_plugin_gpu, h_gpu),
1122 mee_handler_h ("Configure built-in SPU plugin", menu_loop_plugin_spu, h_spu),
1123 mee_end,
1124};
1125
1126static menu_entry e_menu_main2[];
1127
1128static int menu_loop_plugin_options(int id, int keys)
1129{
1130 static int sel = 0;
1131 me_loop(e_menu_plugin_options, &sel);
1132
1133 // sync BIOS/plugins
1134 snprintf(Config.Bios, sizeof(Config.Bios), "%s", bioses[bios_sel]);
1135 snprintf(Config.Gpu, sizeof(Config.Gpu), "%s", gpu_plugins[gpu_plugsel]);
1136 snprintf(Config.Spu, sizeof(Config.Spu), "%s", spu_plugins[spu_plugsel]);
1137 me_enable(e_menu_main2, MA_MAIN_RUN_BIOS, bios_sel != 0);
1138
1139 return 0;
1140}
1141
1142// ------------ adv options menu ------------
1143
1144static const char *men_cfg_cdrr[] = { "Auto", "ON", "OFF", NULL };
1145static const char h_cfg_cpul[] = "Shows CPU usage in %";
1146static const char h_cfg_fl[] = "Frame Limiter keeps the game from running too fast";
1147static const char h_cfg_xa[] = "Disables XA sound, which can sometimes improve performance";
1148static const char h_cfg_cdda[] = "Disable CD Audio for a performance boost\n"
1149 "(proper .cue/.bin dump is needed otherwise)";
1150static const char h_cfg_sio[] = "You should not need this, breaks games";
1151static const char h_cfg_spuirq[] = "Compatibility tweak; should be left off";
1152static const char h_cfg_rcnt1[] = "Parasite Eve 2, Vandal Hearts 1/2 Fix\n"
1153 "(timing hack, breaks other games)";
1154static const char h_cfg_rcnt2[] = "InuYasha Sengoku Battle Fix\n"
1155 "(timing hack, breaks other games)";
1156static const char h_cfg_cdrr[] = "Compatibility tweak (fixes Team Buddies, maybe more)\n"
1157 "(CD timing hack, breaks FMVs)";
1158static const char h_cfg_nodrc[] = "Disable dynamic recompiler and use interpreter\n"
1159 "Might be useful to overcome some dynarec bugs";
1160
1161static menu_entry e_menu_adv_options[] =
1162{
1163 mee_onoff_h ("Show CPU load", 0, g_opts, OPT_SHOWCPU, h_cfg_cpul),
1164 mee_onoff_h ("Disable Frame Limiter", 0, g_opts, OPT_NO_FRAMELIM, h_cfg_fl),
1165 mee_onoff_h ("Disable XA Decoding", 0, Config.Xa, 1, h_cfg_xa),
1166 mee_onoff_h ("Disable CD Audio", 0, Config.Cdda, 1, h_cfg_cdda),
1167 mee_onoff_h ("SIO IRQ Always Enabled", 0, Config.Sio, 1, h_cfg_sio),
1168 mee_onoff_h ("SPU IRQ Always Enabled", 0, Config.SpuIrq, 1, h_cfg_spuirq),
1169 mee_onoff_h ("Rootcounter hack", 0, Config.RCntFix, 1, h_cfg_rcnt1),
1170 mee_onoff_h ("Rootcounter hack 2", 0, Config.VSyncWA, 1, h_cfg_rcnt2),
1171 mee_enum_h ("CD read reschedule hack",0, Config.CdrReschedule, men_cfg_cdrr, h_cfg_cdrr),
1172 mee_onoff_h ("Disable dynarec (slow!)",0, Config.Cpu, 1, h_cfg_nodrc),
1173 mee_end,
1174};
1175
1176static int menu_loop_adv_options(int id, int keys)
1177{
1178 static int sel = 0;
1179 me_loop(e_menu_adv_options, &sel);
1180 return 0;
1181}
1182
1183// ------------ options menu ------------
1184
1185static int mh_restore_defaults(int id, int keys)
1186{
1187 menu_set_defconfig();
1188 me_update_msg("defaults restored");
1189 return 1;
1190}
1191
1192static const char *men_region[] = { "Auto", "NTSC", "PAL", NULL };
1193/*
1194static const char *men_confirm_save[] = { "OFF", "writes", "loads", "both", NULL };
1195static const char h_confirm_save[] = "Ask for confirmation when overwriting save,\n"
1196 "loading state or both";
1197*/
1198static const char h_restore_def[] = "Switches back to default / recommended\n"
1199 "configuration";
1200static const char h_frameskip[] = "Warning: frameskip sometimes causes glitches\n";
1201
1202static menu_entry e_menu_options[] =
1203{
1204// mee_range ("Save slot", 0, state_slot, 0, 9),
1205// mee_enum_h ("Confirm savestate", 0, dummy, men_confirm_save, h_confirm_save),
1206 mee_onoff_h ("Frameskip", 0, pl_rearmed_cbs.frameskip, 1, h_frameskip),
1207 mee_onoff ("Show FPS", 0, g_opts, OPT_SHOWFPS),
1208 mee_enum ("Region", 0, region, men_region),
1209 mee_range ("CPU clock", MA_OPT_CPU_CLOCKS, cpu_clock, 20, 5000),
1210 mee_handler ("[Display]", menu_loop_gfx_options),
1211 mee_handler ("[BIOS/Plugins]", menu_loop_plugin_options),
1212 mee_handler ("[Advanced]", menu_loop_adv_options),
1213 mee_cust_nosave("Save global config", MA_OPT_SAVECFG, mh_savecfg, mgn_saveloadcfg),
1214 mee_cust_nosave("Save cfg for loaded game",MA_OPT_SAVECFG_GAME, mh_savecfg, mgn_saveloadcfg),
1215 mee_handler_h ("Restore default config", mh_restore_defaults, h_restore_def),
1216 mee_end,
1217};
1218
1219static int menu_loop_options(int id, int keys)
1220{
1221 static int sel = 0;
1222 int i;
1223
1224 i = me_id2offset(e_menu_options, MA_OPT_CPU_CLOCKS);
1225 e_menu_options[i].enabled = cpu_clock != 0 ? 1 : 0;
1226 me_enable(e_menu_options, MA_OPT_SAVECFG_GAME, ready_to_go && CdromId[0]);
1227
1228 me_loop(e_menu_options, &sel);
1229
1230 return 0;
1231}
1232
1233// ------------ debug menu ------------
1234
1235static void draw_frame_debug(GPUFreeze_t *gpuf)
1236{
1237 int w = min(g_menuscreen_w, 1024);
1238 int h = min(g_menuscreen_h, 512);
1239 u16 *d = g_menuscreen_ptr;
1240 u16 *s = (u16 *)gpuf->psxVRam;
1241 char buff[64];
1242 int ty = 1;
1243
1244 gpuf->ulFreezeVersion = 1;
1245 if (GPU_freeze != NULL)
1246 GPU_freeze(1, gpuf);
1247
1248 for (; h > 0; h--, d += g_menuscreen_w, s += 1024)
1249 bgr555_to_rgb565(d, s, w * 2);
1250
1251 smalltext_out16(4, 1, "build: "__DATE__ " " __TIME__ " " REV, 0xe7fc);
1252 snprintf(buff, sizeof(buff), "GPU sr: %08x", gpuf->ulStatus);
1253 smalltext_out16(4, (ty += me_sfont_h), buff, 0xe7fc);
1254 snprintf(buff, sizeof(buff), "PC/SP: %08x %08x", psxRegs.pc, psxRegs.GPR.n.sp);
1255 smalltext_out16(4, (ty += me_sfont_h), buff, 0xe7fc);
1256}
1257
1258static void debug_menu_loop(void)
1259{
1260 GPUFreeze_t *gpuf;
1261 int inp;
1262
1263 gpuf = malloc(sizeof(*gpuf));
1264 if (gpuf == NULL)
1265 return;
1266
1267 while (1)
1268 {
1269 menu_draw_begin(0);
1270 draw_frame_debug(gpuf);
1271 menu_draw_end();
1272
1273 inp = in_menu_wait(PBTN_MOK|PBTN_MBACK|PBTN_MA2|PBTN_MA3|PBTN_L|PBTN_R |
1274 PBTN_UP|PBTN_DOWN|PBTN_LEFT|PBTN_RIGHT, 70);
1275 if (inp & PBTN_MBACK)
1276 break;
1277 }
1278
1279 free(gpuf);
1280}
1281
1282// --------- memcard manager ---------
1283
1284static void draw_mc_icon(int dx, int dy, const u16 *s)
1285{
1286 u16 *d;
1287 int x, y, l, p;
1288
1289 d = (u16 *)g_menuscreen_ptr + g_menuscreen_w * dy + dx;
1290
1291 for (y = 0; y < 16; y++, s += 16) {
1292 for (l = 0; l < 2; l++, d += g_menuscreen_w) {
1293 for (x = 0; x < 16; x++) {
1294 p = s[x];
1295 d[x*2] = d[x*2 + 1] = ((p & 0x7c00) >> 10)
1296 | ((p & 0x03e0) << 1) | ((p & 0x1f) << 11);
1297 }
1298 }
1299 }
1300}
1301
1302static void draw_mc_bg(void)
1303{
1304 McdBlock *blocks1, *blocks2;
1305 int maxicons = 15;
1306 int i, y, row2;
1307
1308 blocks1 = malloc(15 * sizeof(blocks1[0]));
1309 blocks2 = malloc(15 * sizeof(blocks1[0]));
1310 if (blocks1 == NULL || blocks2 == NULL)
1311 goto out;
1312
1313 for (i = 0; i < 15; i++) {
1314 GetMcdBlockInfo(1, i + 1, &blocks1[i]);
1315 GetMcdBlockInfo(2, i + 1, &blocks2[i]);
1316 }
1317
1318 menu_draw_begin(1);
1319
1320 memcpy(g_menuscreen_ptr, g_menubg_src_ptr, g_menuscreen_w * g_menuscreen_h * 2);
1321
1322 y = g_menuscreen_h / 2 - 15 * 32 / 2;
1323 if (y < 0) {
1324 // doesn't fit..
1325 y = 0;
1326 maxicons = g_menuscreen_h / 32;
1327 }
1328
1329 row2 = g_menuscreen_w / 2;
1330 for (i = 0; i < maxicons; i++) {
1331 draw_mc_icon(8, y + i * 32, (u16 *)blocks1[i].Icon);
1332 smalltext_out16(10+32, y + i * 32 + 8, blocks1[i].sTitle, 0xf71e);
1333
1334 draw_mc_icon(row2 + 8, y + i * 32, (u16 *)blocks2[i].Icon);
1335 smalltext_out16(row2 + 10+32, y + i * 32 + 8, blocks2[i].sTitle, 0xf71e);
1336 }
1337
1338 menu_darken_bg(g_menubg_ptr, g_menuscreen_ptr, g_menuscreen_w * g_menuscreen_h, 0);
1339
1340 menu_draw_end();
1341out:
1342 free(blocks1);
1343 free(blocks2);
1344}
1345
1346static void handle_memcard_sel(void)
1347{
1348 Config.Mcd1[0] = 0;
1349 if (memcard1_sel != 0)
1350 snprintf(Config.Mcd1, sizeof(Config.Mcd1), ".%s%s", MEMCARD_DIR, memcards[memcard1_sel]);
1351 Config.Mcd2[0] = 0;
1352 if (memcard2_sel != 0)
1353 snprintf(Config.Mcd2, sizeof(Config.Mcd2), ".%s%s", MEMCARD_DIR, memcards[memcard2_sel]);
1354 LoadMcds(Config.Mcd1, Config.Mcd2);
1355 draw_mc_bg();
1356}
1357
1358static menu_entry e_memcard_options[] =
1359{
1360 mee_enum("Memory card 1", 0, memcard1_sel, memcards),
1361 mee_enum("Memory card 2", 0, memcard2_sel, memcards),
1362 mee_end,
1363};
1364
1365static int menu_loop_memcards(int id, int keys)
1366{
1367 static int sel = 0;
1368 char *p;
1369 int i;
1370
1371 memcard1_sel = memcard2_sel = 0;
1372 p = strrchr(Config.Mcd1, '/');
1373 if (p != NULL)
1374 for (i = 0; memcards[i] != NULL; i++)
1375 if (strcmp(p + 1, memcards[i]) == 0)
1376 { memcard1_sel = i; break; }
1377 p = strrchr(Config.Mcd2, '/');
1378 if (p != NULL)
1379 for (i = 0; memcards[i] != NULL; i++)
1380 if (strcmp(p + 1, memcards[i]) == 0)
1381 { memcard2_sel = i; break; }
1382
1383 me_loop_d(e_memcard_options, &sel, handle_memcard_sel, NULL);
1384
1385 memcpy(g_menubg_ptr, g_menubg_src_ptr, g_menuscreen_w * g_menuscreen_h * 2);
1386
1387 return 0;
1388}
1389
1390// --------- main menu help ----------
1391
1392static void menu_bios_warn(void)
1393{
1394 int inp;
1395 static const char msg[] =
1396 "You don't seem to have copied any BIOS files to\n"
1397 "<SD card>/pandora/appdata/pcsx_rearmed/bios/\n\n"
1398 "While many games work fine with fake (HLE) BIOS,\n"
1399 "others (like MGS and FF8) require BIOS to work.\n"
1400 "After copying the file, you'll also need to\n"
1401 "select it in the emu's options->[BIOS/Plugins]\n\n"
1402 "The file is usually named SCPH1001.BIN, but\n"
1403 "other not compressed files can be used too.\n\n"
1404 "Press (B) or (X) to continue";
1405
1406 while (1)
1407 {
1408 draw_menu_message(msg, NULL);
1409
1410 inp = in_menu_wait(PBTN_MOK|PBTN_MBACK, 70);
1411 if (inp & (PBTN_MBACK|PBTN_MOK))
1412 return;
1413 }
1414}
1415
1416// ------------ main menu ------------
1417
1418void OnFile_Exit();
1419
1420static void draw_frame_main(void)
1421{
1422 if (CdromId[0] != 0) {
1423 char buff[64];
1424 snprintf(buff, sizeof(buff), "%.32s/%.9s (running as %s, with %s)",
1425 get_cd_label(), CdromId, Config.PsxType ? "PAL" : "NTSC",
1426 Config.HLE ? "HLE" : "BIOS");
1427 smalltext_out16(4, 1, buff, 0x105f);
1428 }
1429}
1430
1431static void draw_frame_credits(void)
1432{
1433 smalltext_out16(4, 1, "build: "__DATE__ " " __TIME__ " " REV, 0xe7fc);
1434}
1435
1436static const char credits_text[] =
1437 "PCSX-ReARMed\n\n"
1438 "(C) 1999-2003 PCSX Team\n"
1439 "(C) 2005-2009 PCSX-df Team\n"
1440 "(C) 2009-2011 PCSX-Reloaded Team\n\n"
1441 "GPU and SPU code by Pete Bernert\n"
1442 " and the P.E.Op.S. team\n"
1443 "ARM recompiler (C) 2009-2011 Ari64\n"
1444 "PCSX4ALL plugins by PCSX4ALL team\n"
1445 " Chui, Franxis, Unai\n\n"
1446 "integration, optimization and\n"
1447 " frontend (C) 2010-2011 notaz\n";
1448
1449static int reset_game(void)
1450{
1451 // sanity check
1452 if (bios_sel == 0 && !Config.HLE)
1453 return -1;
1454
1455 ClosePlugins();
1456 OpenPlugins();
1457 SysReset();
1458 if (CheckCdrom() != -1) {
1459 LoadCdrom();
1460 }
1461 return 0;
1462}
1463
1464static int reload_plugins(const char *cdimg)
1465{
1466 pl_fbdev_buf = NULL;
1467
1468 ClosePlugins();
1469
1470 set_cd_image(cdimg);
1471 LoadPlugins();
1472 pcnt_hook_plugins();
1473 NetOpened = 0;
1474 if (OpenPlugins() == -1) {
1475 me_update_msg("failed to open plugins");
1476 return -1;
1477 }
1478 plugin_call_rearmed_cbs();
1479
1480 CdromId[0] = '\0';
1481 CdromLabel[0] = '\0';
1482
1483 return 0;
1484}
1485
1486static int run_bios(void)
1487{
1488 if (bios_sel == 0)
1489 return -1;
1490
1491 ready_to_go = 0;
1492 if (reload_plugins(NULL) != 0)
1493 return -1;
1494 SysReset();
1495
1496 ready_to_go = 1;
1497 return 0;
1498}
1499
1500static int run_exe(void)
1501{
1502 const char *fname;
1503
1504 fname = menu_loop_romsel(last_selected_fname, sizeof(last_selected_fname));
1505 if (fname == NULL)
1506 return -1;
1507
1508 ready_to_go = 0;
1509 if (reload_plugins(NULL) != 0)
1510 return -1;
1511
1512 SysReset();
1513 if (Load(fname) != 0) {
1514 me_update_msg("exe load failed, bad file?");
1515 printf("meh\n");
1516 return -1;
1517 }
1518
1519 ready_to_go = 1;
1520 return 0;
1521}
1522
1523static int run_cd_image(const char *fname)
1524{
1525 ready_to_go = 0;
1526 reload_plugins(fname);
1527
1528 if (CheckCdrom() == -1) {
1529 // Only check the CD if we are starting the console with a CD
1530 ClosePlugins();
1531 me_update_msg("unsupported/invalid CD image");
1532 return -1;
1533 }
1534
1535 SysReset();
1536
1537 // Read main executable directly from CDRom and start it
1538 if (LoadCdrom() == -1) {
1539 ClosePlugins();
1540 me_update_msg("failed to load CD image");
1541 return -1;
1542 }
1543
1544 ready_to_go = 1;
1545 return 0;
1546}
1547
1548static int romsel_run(void)
1549{
1550 int prev_gpu, prev_spu;
1551 const char *fname;
1552
1553 fname = menu_loop_romsel(last_selected_fname, sizeof(last_selected_fname));
1554 if (fname == NULL)
1555 return -1;
1556
1557 printf("selected file: %s\n", fname);
1558
1559 new_dynarec_clear_full();
1560
1561 if (run_cd_image(fname) != 0)
1562 return -1;
1563
1564 prev_gpu = gpu_plugsel;
1565 prev_spu = spu_plugsel;
1566 if (menu_load_config(1) != 0)
1567 menu_load_config(0);
1568
1569 // check for plugin changes, have to repeat
1570 // loading if game config changed plugins to reload them
1571 if (prev_gpu != gpu_plugsel || prev_spu != spu_plugsel) {
1572 printf("plugin change detected, reloading plugins..\n");
1573 if (run_cd_image(fname) != 0)
1574 return -1;
1575 }
1576
1577 strcpy(last_selected_fname, rom_fname_reload);
1578 return 0;
1579}
1580
1581static int swap_cd_image(void)
1582{
1583 char *fname;
1584
1585 fname = menu_loop_romsel(last_selected_fname, sizeof(last_selected_fname));
1586 if (fname == NULL)
1587 return -1;
1588
1589 printf("selected file: %s\n", fname);
1590
1591 CdromId[0] = '\0';
1592 CdromLabel[0] = '\0';
1593
1594 set_cd_image(fname);
1595 if (ReloadCdromPlugin() < 0) {
1596 me_update_msg("failed to load cdr plugin");
1597 return -1;
1598 }
1599 if (CDR_open() < 0) {
1600 me_update_msg("failed to open cdr plugin");
1601 return -1;
1602 }
1603
1604 SetCdOpenCaseTime(time(NULL) + 2);
1605 LidInterrupt();
1606
1607 strcpy(last_selected_fname, rom_fname_reload);
1608 return 0;
1609}
1610
1611static int main_menu_handler(int id, int keys)
1612{
1613 switch (id)
1614 {
1615 case MA_MAIN_RESUME_GAME:
1616 if (ready_to_go)
1617 return 1;
1618 break;
1619 case MA_MAIN_SAVE_STATE:
1620 if (ready_to_go)
1621 return menu_loop_savestate(0);
1622 break;
1623 case MA_MAIN_LOAD_STATE:
1624 if (ready_to_go)
1625 return menu_loop_savestate(1);
1626 break;
1627 case MA_MAIN_RESET_GAME:
1628 if (ready_to_go && reset_game() == 0)
1629 return 1;
1630 break;
1631 case MA_MAIN_LOAD_ROM:
1632 if (romsel_run() == 0)
1633 return 1;
1634 break;
1635 case MA_MAIN_SWAP_CD:
1636 if (swap_cd_image() == 0)
1637 return 1;
1638 break;
1639 case MA_MAIN_RUN_BIOS:
1640 if (run_bios() == 0)
1641 return 1;
1642 break;
1643 case MA_MAIN_RUN_EXE:
1644 if (run_exe() == 0)
1645 return 1;
1646 break;
1647 case MA_MAIN_CREDITS:
1648 draw_menu_message(credits_text, draw_frame_credits);
1649 in_menu_wait(PBTN_MOK|PBTN_MBACK, 70);
1650 break;
1651 case MA_MAIN_EXIT:
1652 OnFile_Exit();
1653 break;
1654 default:
1655 lprintf("%s: something unknown selected\n", __FUNCTION__);
1656 break;
1657 }
1658
1659 return 0;
1660}
1661
1662static menu_entry e_menu_main2[] =
1663{
1664 mee_handler_id("Change CD image", MA_MAIN_SWAP_CD, main_menu_handler),
1665 mee_handler_id("Run BIOS", MA_MAIN_RUN_BIOS, main_menu_handler),
1666 mee_handler_id("Run EXE", MA_MAIN_RUN_EXE, main_menu_handler),
1667 mee_handler ("Memcard manager", menu_loop_memcards),
1668 mee_end,
1669};
1670
1671static int main_menu2_handler(int id, int keys)
1672{
1673 static int sel = 0;
1674
1675 me_enable(e_menu_main2, MA_MAIN_SWAP_CD, ready_to_go);
1676 me_enable(e_menu_main2, MA_MAIN_RUN_BIOS, bios_sel != 0);
1677
1678 return me_loop_d(e_menu_main2, &sel, NULL, draw_frame_main);
1679}
1680
1681static const char h_extra[] = "Change CD, manage memcards..\n";
1682
1683static menu_entry e_menu_main[] =
1684{
1685 mee_label (""),
1686 mee_label (""),
1687 mee_handler_id("Resume game", MA_MAIN_RESUME_GAME, main_menu_handler),
1688 mee_handler_id("Save State", MA_MAIN_SAVE_STATE, main_menu_handler),
1689 mee_handler_id("Load State", MA_MAIN_LOAD_STATE, main_menu_handler),
1690 mee_handler_id("Reset game", MA_MAIN_RESET_GAME, main_menu_handler),
1691 mee_handler_id("Load CD image", MA_MAIN_LOAD_ROM, main_menu_handler),
1692 mee_handler ("Options", menu_loop_options),
1693 mee_handler ("Controls", menu_loop_keyconfig),
1694 mee_handler_h ("Extra stuff", main_menu2_handler, h_extra),
1695 mee_handler_id("Credits", MA_MAIN_CREDITS, main_menu_handler),
1696 mee_handler_id("Exit", MA_MAIN_EXIT, main_menu_handler),
1697 mee_end,
1698};
1699
1700// ----------------------------
1701
1702static void menu_leave_emu(void);
1703
1704void menu_loop(void)
1705{
1706 static int sel = 0;
1707
1708 menu_leave_emu();
1709
1710 if (bioses[1] == NULL && !warned_about_bios) {
1711 menu_bios_warn();
1712 warned_about_bios = 1;
1713 }
1714
1715 me_enable(e_menu_main, MA_MAIN_RESUME_GAME, ready_to_go);
1716 me_enable(e_menu_main, MA_MAIN_SAVE_STATE, ready_to_go && CdromId[0]);
1717 me_enable(e_menu_main, MA_MAIN_LOAD_STATE, ready_to_go && CdromId[0]);
1718 me_enable(e_menu_main, MA_MAIN_RESET_GAME, ready_to_go);
1719
1720 in_set_config_int(0, IN_CFG_BLOCKING, 1);
1721
1722 do {
1723 me_loop_d(e_menu_main, &sel, NULL, draw_frame_main);
1724 } while (!ready_to_go);
1725
1726 /* wait until menu, ok, back is released */
1727 while (in_menu_wait_any(50) & (PBTN_MENU|PBTN_MOK|PBTN_MBACK))
1728 ;
1729
1730 in_set_config_int(0, IN_CFG_BLOCKING, 0);
1731
1732 menu_prepare_emu();
1733}
1734
1735static int qsort_strcmp(const void *p1, const void *p2)
1736{
1737 char * const *s1 = (char * const *)p1;
1738 char * const *s2 = (char * const *)p2;
1739 return strcasecmp(*s1, *s2);
1740}
1741
1742static void scan_bios_plugins(void)
1743{
1744 char fname[MAXPATHLEN];
1745 struct dirent *ent;
1746 int bios_i, gpu_i, spu_i, mc_i;
1747 char *p;
1748 DIR *dir;
1749
1750 bioses[0] = "HLE";
1751 gpu_plugins[0] = "builtin_gpu";
1752 spu_plugins[0] = "builtin_spu";
1753 memcards[0] = "(none)";
1754 bios_i = gpu_i = spu_i = mc_i = 1;
1755
1756 snprintf(fname, sizeof(fname), "%s/", Config.BiosDir);
1757 dir = opendir(fname);
1758 if (dir == NULL) {
1759 perror("scan_bios_plugins bios opendir");
1760 goto do_plugins;
1761 }
1762
1763 while (1) {
1764 struct stat st;
1765
1766 errno = 0;
1767 ent = readdir(dir);
1768 if (ent == NULL) {
1769 if (errno != 0)
1770 perror("readdir");
1771 break;
1772 }
1773
1774 if (ent->d_type != DT_REG && ent->d_type != DT_LNK)
1775 continue;
1776
1777 snprintf(fname, sizeof(fname), "%s/%s", Config.BiosDir, ent->d_name);
1778 if (stat(fname, &st) != 0 || st.st_size != 512*1024) {
1779 printf("bad BIOS file: %s\n", ent->d_name);
1780 continue;
1781 }
1782
1783 if (bios_i < ARRAY_SIZE(bioses) - 1) {
1784 bioses[bios_i++] = strdup(ent->d_name);
1785 continue;
1786 }
1787
1788 printf("too many BIOSes, dropping \"%s\"\n", ent->d_name);
1789 }
1790
1791 closedir(dir);
1792
1793do_plugins:
1794 snprintf(fname, sizeof(fname), "%s/", Config.PluginsDir);
1795 dir = opendir(fname);
1796 if (dir == NULL) {
1797 perror("scan_bios_plugins plugins opendir");
1798 goto do_memcards;
1799 }
1800
1801 while (1) {
1802 void *h, *tmp;
1803
1804 errno = 0;
1805 ent = readdir(dir);
1806 if (ent == NULL) {
1807 if (errno != 0)
1808 perror("readdir");
1809 break;
1810 }
1811 p = strstr(ent->d_name, ".so");
1812 if (p == NULL)
1813 continue;
1814
1815 snprintf(fname, sizeof(fname), "%s/%s", Config.PluginsDir, ent->d_name);
1816 h = dlopen(fname, RTLD_LAZY | RTLD_LOCAL);
1817 if (h == NULL) {
1818 fprintf(stderr, "%s\n", dlerror());
1819 continue;
1820 }
1821
1822 // now what do we have here?
1823 tmp = dlsym(h, "GPUinit");
1824 if (tmp) {
1825 dlclose(h);
1826 if (gpu_i < ARRAY_SIZE(gpu_plugins) - 1)
1827 gpu_plugins[gpu_i++] = strdup(ent->d_name);
1828 continue;
1829 }
1830
1831 tmp = dlsym(h, "SPUinit");
1832 if (tmp) {
1833 dlclose(h);
1834 if (spu_i < ARRAY_SIZE(spu_plugins) - 1)
1835 spu_plugins[spu_i++] = strdup(ent->d_name);
1836 continue;
1837 }
1838
1839 fprintf(stderr, "ignoring unidentified plugin: %s\n", fname);
1840 dlclose(h);
1841 }
1842
1843 closedir(dir);
1844
1845do_memcards:
1846 dir = opendir("." MEMCARD_DIR);
1847 if (dir == NULL) {
1848 perror("scan_bios_plugins memcards opendir");
1849 return;
1850 }
1851
1852 while (1) {
1853 struct stat st;
1854
1855 errno = 0;
1856 ent = readdir(dir);
1857 if (ent == NULL) {
1858 if (errno != 0)
1859 perror("readdir");
1860 break;
1861 }
1862
1863 if (ent->d_type != DT_REG && ent->d_type != DT_LNK)
1864 continue;
1865
1866 snprintf(fname, sizeof(fname), "." MEMCARD_DIR "%s", ent->d_name);
1867 if (stat(fname, &st) != 0) {
1868 printf("bad memcard file: %s\n", ent->d_name);
1869 continue;
1870 }
1871
1872 if (mc_i < ARRAY_SIZE(memcards) - 1) {
1873 memcards[mc_i++] = strdup(ent->d_name);
1874 continue;
1875 }
1876
1877 printf("too many memcards, dropping \"%s\"\n", ent->d_name);
1878 }
1879
1880 if (mc_i > 2)
1881 qsort(memcards + 1, mc_i - 1, sizeof(memcards[0]), qsort_strcmp);
1882
1883 closedir(dir);
1884}
1885
1886void menu_init(void)
1887{
1888 char buff[MAXPATHLEN];
1889
1890 strcpy(last_selected_fname, "/media");
1891
1892 scan_bios_plugins();
1893 pnd_menu_init();
1894 menu_init_common();
1895
1896 menu_set_defconfig();
1897 menu_load_config(0);
1898 last_psx_w = 320;
1899 last_psx_h = 240;
1900 last_psx_bpp = 16;
1901
1902 g_menubg_src_ptr = calloc(g_menuscreen_w * g_menuscreen_h * 2, 1);
1903 if (g_menubg_src_ptr == NULL)
1904 exit(1);
1905 emu_make_path(buff, "skin/background.png", sizeof(buff));
1906 readpng(g_menubg_src_ptr, buff, READPNG_BG, g_menuscreen_w, g_menuscreen_h);
1907}
1908
1909void menu_notify_mode_change(int w, int h, int bpp)
1910{
1911 last_psx_w = w;
1912 last_psx_h = h;
1913 last_psx_bpp = bpp;
1914
1915 if (scaling == SCALE_1_1) {
1916 g_layer_x = 800/2 - w/2; g_layer_y = 480/2 - h/2;
1917 g_layer_w = w; g_layer_h = h;
1918 }
1919}
1920
1921static void menu_leave_emu(void)
1922{
1923 if (GPU_close != NULL) {
1924 int ret = GPU_close();
1925 if (ret)
1926 fprintf(stderr, "Warning: GPU_close returned %d\n", ret);
1927 }
1928
1929 memcpy(g_menubg_ptr, g_menubg_src_ptr, g_menuscreen_w * g_menuscreen_h * 2);
1930 if (pl_fbdev_buf != NULL && ready_to_go && last_psx_bpp == 16) {
1931 int x = max(0, g_menuscreen_w - last_psx_w);
1932 int y = max(0, g_menuscreen_h / 2 - last_psx_h / 2);
1933 int w = min(g_menuscreen_w, last_psx_w);
1934 int h = min(g_menuscreen_h, last_psx_h);
1935 u16 *d = (u16 *)g_menubg_ptr + g_menuscreen_w * y + x;
1936 u16 *s = pl_fbdev_buf;
1937
1938 for (; h > 0; h--, d += g_menuscreen_w, s += last_psx_w)
1939 menu_darken_bg(d, s, w, 0);
1940 }
1941
1942 if (ready_to_go)
1943 cpu_clock = get_cpu_clock();
1944
1945 plat_video_menu_enter(ready_to_go);
1946}
1947
1948void menu_prepare_emu(void)
1949{
1950 R3000Acpu *prev_cpu = psxCpu;
1951
1952 plat_video_menu_leave();
1953
1954 switch (scaling) {
1955 case SCALE_1_1:
1956 menu_notify_mode_change(last_psx_w, last_psx_h, last_psx_bpp);
1957 break;
1958 case SCALE_4_3:
1959 g_layer_x = 80; g_layer_y = 0;
1960 g_layer_w = 640; g_layer_h = 480;
1961 break;
1962 case SCALE_FULLSCREEN:
1963 g_layer_x = 0; g_layer_y = 0;
1964 g_layer_w = 800; g_layer_h = 480;
1965 break;
1966 case SCALE_CUSTOM:
1967 break;
1968 }
1969
1970 psxCpu = (Config.Cpu == CPU_INTERPRETER) ? &psxInt : &psxRec;
1971 if (psxCpu != prev_cpu)
1972 // note that this does not really reset, just clears drc caches
1973 psxCpu->Reset();
1974
1975 // core doesn't care about Config.Cdda changes,
1976 // so handle them manually here
1977 if (Config.Cdda)
1978 CDR_stop();
1979
1980 menu_sync_config();
1981 apply_lcdrate(Config.PsxType);
1982 apply_filter(filter);
1983 apply_cpu_clock();
1984
1985 // push config to GPU plugin
1986 plugin_call_rearmed_cbs();
1987
1988 if (GPU_open != NULL) {
1989 int ret = GPU_open(&gpuDisp, "PCSX", NULL);
1990 if (ret)
1991 fprintf(stderr, "Warning: GPU_open returned %d\n", ret);
1992 }
1993
1994 dfinput_activate(in_type == PSE_PAD_TYPE_ANALOGPAD);
1995}
1996
1997void me_update_msg(const char *msg)
1998{
1999 strncpy(menu_error_msg, msg, sizeof(menu_error_msg));
2000 menu_error_msg[sizeof(menu_error_msg) - 1] = 0;
2001
2002 menu_error_time = plat_get_ticks_ms();
2003 lprintf("msg: %s\n", menu_error_msg);
2004}
2005
ARM optimized PCSX fork