log some build info
[pcsx_rearmed.git] / frontend / main.c
1 /*
2  * (C) notaz, 2010-2012
3  *
4  * This work is licensed under the terms of the GNU GPLv2 or later.
5  * See the COPYING file in the top-level directory.
6  */
7
8 #include <stdio.h>
9 #include <string.h>
10 #include <stdarg.h>
11 #include <unistd.h>
12 #include <signal.h>
13 #include <time.h>
14 #if !defined(_WIN32) && !defined(NO_DYLIB)
15 #include <dlfcn.h>
16 #endif
17
18 #include "main.h"
19 #include "plugin.h"
20 #include "plugin_lib.h"
21 #include "pcnt.h"
22 #include "menu.h"
23 #include "plat.h"
24 #include "../libpcsxcore/misc.h"
25 #include "../libpcsxcore/cheat.h"
26 #include "../libpcsxcore/sio.h"
27 #include "../libpcsxcore/new_dynarec/new_dynarec.h"
28 #include "../plugins/cdrcimg/cdrcimg.h"
29 #include "../plugins/dfsound/spu_config.h"
30 #include "arm_features.h"
31 #include "revision.h"
32
33 #if defined(__has_builtin)
34 #define DO_CPU_CHECKS __has_builtin(__builtin_cpu_init)
35 #elif defined(__x86_64__) || defined(__i386__)
36 #define DO_CPU_CHECKS 1
37 #else
38 #define DO_CPU_CHECKS 0
39 #endif
40
41 #ifndef NO_FRONTEND
42 #include "libpicofe/input.h"
43 #include "libpicofe/plat.h"
44 #include "libpicofe/readpng.h"
45
46 static void toggle_fast_forward(int force_off);
47 static void check_profile(void);
48 static void check_memcards(void);
49 #endif
50 #ifndef BOOT_MSG
51 #define BOOT_MSG "Booting up..."
52 #endif
53
54 // don't include debug.h - it breaks ARM build (R1 redefined)
55 static void StartDebugger() {}
56 static void StopDebugger() {}
57
58 int ready_to_go, g_emu_want_quit, g_emu_resetting;
59 unsigned long gpuDisp;
60 char cfgfile_basename[MAXPATHLEN];
61 int state_slot;
62 enum sched_action emu_action, emu_action_old;
63 char hud_msg[64];
64 int hud_new_msg;
65
66 static void make_path(char *buf, size_t size, const char *dir, const char *fname)
67 {
68         if (fname)
69                 snprintf(buf, size, ".%s%s", dir, fname);
70         else
71                 snprintf(buf, size, ".%s", dir);
72 }
73 #define MAKE_PATH(buf, dir, fname) \
74         make_path(buf, sizeof(buf), dir, fname)
75
76 static int get_gameid_filename(char *buf, int size, const char *fmt, int i) {
77         char trimlabel[33];
78         int j;
79
80         strncpy(trimlabel, CdromLabel, 32);
81         trimlabel[32] = 0;
82         for (j = 31; j >= 0; j--)
83                 if (trimlabel[j] == ' ')
84                         trimlabel[j] = 0;
85                 else
86                         continue;
87
88         snprintf(buf, size, fmt, trimlabel, CdromId, i);
89
90         return 0;
91 }
92
93 void set_cd_image(const char *fname)
94 {
95         const char *ext = NULL;
96         
97         if (fname != NULL)
98                 ext = strrchr(fname, '.');
99
100         if (ext && (
101             strcasecmp(ext, ".z") == 0 || strcasecmp(ext, ".bz") == 0 ||
102             strcasecmp(ext, ".znx") == 0 /*|| strcasecmp(ext, ".pbp") == 0*/)) {
103                 SetIsoFile(NULL);
104                 cdrcimg_set_fname(fname);
105                 strcpy(Config.Cdr, "builtin_cdrcimg");
106         } else {
107                 SetIsoFile(fname);
108                 strcpy(Config.Cdr, "builtin_cdr");
109         }
110 }
111
112 static void set_default_paths(void)
113 {
114 #ifndef NO_FRONTEND
115         snprintf(Config.PatchesDir, sizeof(Config.PatchesDir), "." PATCHES_DIR);
116         MAKE_PATH(Config.Mcd1, MEMCARD_DIR, "card1.mcd");
117         MAKE_PATH(Config.Mcd2, MEMCARD_DIR, "card2.mcd");
118         strcpy(Config.BiosDir, "bios");
119 #endif
120
121         strcpy(Config.PluginsDir, "plugins");
122         strcpy(Config.Gpu, "builtin_gpu");
123         strcpy(Config.Spu, "builtin_spu");
124         strcpy(Config.Cdr, "builtin_cdr");
125         strcpy(Config.Pad1, "builtin_pad");
126         strcpy(Config.Pad2, "builtin_pad");
127         strcpy(Config.Net, "Disabled");
128 }
129
130 void emu_set_default_config(void)
131 {
132         // try to set sane config on which most games work
133         Config.Xa = Config.Cdda = 0;
134         Config.icache_emulation = 0;
135         Config.PsxAuto = 1;
136         Config.cycle_multiplier = CYCLE_MULT_DEFAULT;
137         Config.GpuListWalking = -1;
138
139         pl_rearmed_cbs.gpu_neon.allow_interlace = 2; // auto
140         pl_rearmed_cbs.gpu_neon.enhancement_enable =
141         pl_rearmed_cbs.gpu_neon.enhancement_no_main = 0;
142         pl_rearmed_cbs.gpu_peops.iUseDither = 0;
143         pl_rearmed_cbs.gpu_peops.dwActFixes = 1<<7;
144 #if 0
145         pl_rearmed_cbs.gpu_senquack.ilace_force = 0;
146         pl_rearmed_cbs.gpu_senquack.pixel_skip = 0;
147         pl_rearmed_cbs.gpu_senquack.lighting = 1;
148         pl_rearmed_cbs.gpu_senquack.fast_lighting = 0;
149         pl_rearmed_cbs.gpu_senquack.blending = 1;
150         pl_rearmed_cbs.gpu_senquack.dithering = 0;
151 #else
152         pl_rearmed_cbs.gpu_unai.lighting = 1;
153         pl_rearmed_cbs.gpu_unai.blending = 1;
154 #endif
155         pl_rearmed_cbs.gpu_unai.abe_hack =
156         pl_rearmed_cbs.gpu_unai.no_light =
157         pl_rearmed_cbs.gpu_unai.no_blend = 0;
158         memset(&pl_rearmed_cbs.gpu_peopsgl, 0, sizeof(pl_rearmed_cbs.gpu_peopsgl));
159         pl_rearmed_cbs.gpu_peopsgl.iVRamSize = 64;
160         pl_rearmed_cbs.gpu_peopsgl.iTexGarbageCollection = 1;
161
162         spu_config.iUseReverb = 1;
163         spu_config.iUseInterpolation = 1;
164         spu_config.iXAPitch = 0;
165         spu_config.iVolume = 768;
166         spu_config.iTempo = 0;
167         // may cause issues, no effect if only 1 core is detected
168         spu_config.iUseThread = 0;
169 #if defined(HAVE_PRE_ARMV7) && !defined(_3DS) /* XXX GPH hack */
170         spu_config.iUseReverb = 0;
171         spu_config.iUseInterpolation = 0;
172 #ifndef HAVE_LIBRETRO
173         spu_config.iTempo = 1;
174 #endif
175 #endif
176         new_dynarec_hacks = 0;
177
178         in_type[0] = PSE_PAD_TYPE_STANDARD;
179         in_type[1] = PSE_PAD_TYPE_STANDARD;
180 }
181
182 void do_emu_action(void)
183 {
184         int ret;
185
186         emu_action_old = emu_action;
187
188         switch (emu_action) {
189         case SACTION_LOAD_STATE:
190                 ret = emu_load_state(state_slot);
191                 snprintf(hud_msg, sizeof(hud_msg), ret == 0 ? "LOADED" : "FAIL!");
192                 break;
193         case SACTION_SAVE_STATE:
194                 ret = emu_save_state(state_slot);
195                 snprintf(hud_msg, sizeof(hud_msg), ret == 0 ? "SAVED" : "FAIL!");
196                 break;
197 #ifndef NO_FRONTEND
198         case SACTION_ENTER_MENU:
199                 toggle_fast_forward(1);
200                 menu_loop();
201                 return;
202         case SACTION_NEXT_SSLOT:
203                 state_slot++;
204                 if (state_slot > 9)
205                         state_slot = 0;
206                 goto do_state_slot;
207         case SACTION_PREV_SSLOT:
208                 state_slot--;
209                 if (state_slot < 0)
210                         state_slot = 9;
211 do_state_slot:
212                 snprintf(hud_msg, sizeof(hud_msg), "STATE SLOT %d [%s]", state_slot,
213                         emu_check_state(state_slot) == 0 ? "USED" : "FREE");
214                 hud_new_msg = 3;
215                 SysPrintf("* %s\n", hud_msg);
216                 break;
217         case SACTION_TOGGLE_FSKIP:
218                 pl_rearmed_cbs.fskip_advice = 0;
219                 pl_rearmed_cbs.frameskip++;
220                 if (pl_rearmed_cbs.frameskip > 1)
221                         pl_rearmed_cbs.frameskip = -1;
222                 snprintf(hud_msg, sizeof(hud_msg), "FRAMESKIP: %s",
223                         pl_rearmed_cbs.frameskip == -1 ? "AUTO" :
224                         pl_rearmed_cbs.frameskip == 0 ? "OFF" : "1" );
225                 plugin_call_rearmed_cbs();
226                 break;
227         case SACTION_SWITCH_DISPMODE:
228                 pl_switch_dispmode();
229                 plugin_call_rearmed_cbs();
230                 if (GPU_open != NULL && GPU_close != NULL) {
231                         GPU_close();
232                         GPU_open(&gpuDisp, "PCSX", NULL);
233                 }
234                 break;
235         case SACTION_FAST_FORWARD:
236                 toggle_fast_forward(0);
237                 plugin_call_rearmed_cbs();
238                 break;
239         case SACTION_TOGGLE_FPS:
240                 if ((g_opts & (OPT_SHOWFPS|OPT_SHOWCPU))
241                     == (OPT_SHOWFPS|OPT_SHOWCPU))
242                         g_opts &= ~(OPT_SHOWFPS|OPT_SHOWCPU);
243                 else if (g_opts & OPT_SHOWFPS)
244                         g_opts |= OPT_SHOWCPU;
245                 else
246                         g_opts |= OPT_SHOWFPS;
247                 break;
248         case SACTION_TOGGLE_FULLSCREEN:
249                 plat_target.vout_fullscreen = !plat_target.vout_fullscreen;
250                 if (GPU_open != NULL && GPU_close != NULL) {
251                         GPU_close();
252                         GPU_open(&gpuDisp, "PCSX", NULL);
253                 }
254                 break;
255         case SACTION_SCREENSHOT:
256                 {
257                         char buf[MAXPATHLEN];
258                         void *scrbuf;
259                         int w, h, bpp;
260                         time_t t = time(NULL);
261                         struct tm *tb = localtime(&t);
262                         int ti = tb->tm_yday * 1000000 + tb->tm_hour * 10000 +
263                                 tb->tm_min * 100 + tb->tm_sec;
264
265                         scrbuf = pl_prepare_screenshot(&w, &h, &bpp);
266                         get_gameid_filename(buf, sizeof(buf),
267                                 "screenshots/%.32s-%.9s.%d.png", ti);
268                         ret = -1;
269                         if (scrbuf != 0 && bpp == 16)
270                                 ret = writepng(buf, scrbuf, w, h);
271                         if (ret == 0)
272                                 snprintf(hud_msg, sizeof(hud_msg), "SCREENSHOT TAKEN");
273                         break;
274                 }
275         case SACTION_VOLUME_UP:
276         case SACTION_VOLUME_DOWN:
277                 {
278                         static int volume;
279                         plat_target_step_volume(&volume,
280                                 emu_action == SACTION_VOLUME_UP ? 1 : -1);
281                 }
282                 return;
283         case SACTION_MINIMIZE:
284                 if (GPU_close != NULL)
285                         GPU_close();
286
287                 plat_minimize();
288
289                 if (GPU_open != NULL) {
290                         ret = GPU_open(&gpuDisp, "PCSX", NULL);
291                         if (ret)
292                                 SysMessage("GPU_open returned %d", ret);
293                 }
294                 return;
295 #endif
296         default:
297                 return;
298         }
299
300         hud_new_msg = 3;
301 }
302
303 static char basic_lcase(char c)
304 {
305         if ('A' <= c && c <= 'Z')
306                 return c - 'A' + 'a';
307         return c;
308 }
309
310 static int cdidcmp(const char *id1, const char *id2)
311 {
312         while (*id1 != 0 && *id2 != 0) {
313                 if (*id1 == '_') { id1++; continue; }
314                 if (*id2 == '_') { id2++; continue; }
315                 if (basic_lcase(*id1) != basic_lcase(*id2))
316                         break;
317                 id1++;
318                 id2++;
319         }
320
321         return *id1 - *id2;
322 }
323
324 static void parse_cwcheat(void)
325 {
326         char line[256], buf[256], name[256], *p;
327         int newcheat = 1;
328         u32 a, v;
329         FILE *f;
330
331         f = fopen("cheatpops.db", "r");
332         if (f == NULL)
333                 return;
334
335         /* find the game */
336         while (fgets(line, sizeof(line), f)) {
337                 if (sscanf(line, "_S %63s", buf) != 1)
338                         continue;
339                 if (cdidcmp(buf, CdromId) == 0)
340                         break;
341         }
342
343         if (feof(f))
344                 goto out;
345
346         SysPrintf("cwcheat section found for %s\n", CdromId);
347         while (fgets(line, sizeof(line), f))
348         {
349                 p = line + strlen(line);
350                 for (p--; p >= line && (*p == '\r' || *p == '\n' || *p == ' '); p--)
351                         *p = 0;
352                 if (*p == 0 || *p == '#' || *p == ';')
353                         continue;
354
355                 if (strncmp(line, "_S", 2) == 0)
356                         break;
357                 if (strncmp(line, "_G", 2) == 0) {
358                         SysPrintf("  cwcheat game name: '%s'\n", line + 3);
359                         continue;
360                 }
361                 if (strncmp(line, "_C0", 3) == 0) {
362                         if (!newcheat && Cheats[NumCheats - 1].n == 0) {
363                                 SysPrintf("cheat '%s' failed to parse\n", name);
364                                 free(Cheats[NumCheats - 1].Descr);
365                                 NumCheats--;
366                         }
367                         snprintf(name, sizeof(name), "%s", line + 4);
368                         newcheat = 1;
369                         continue;
370                 }
371                 if (sscanf(line, "_L %x %x", &a, &v) != 2) {
372                         SysPrintf("line failed to parse: '%s'\n", line);
373                         continue;
374                 }
375
376                 if (newcheat) {
377                         if (NumCheats >= NumCheatsAllocated) {
378                                 NumCheatsAllocated += 16;
379                                 Cheats = realloc(Cheats, sizeof(Cheat) *
380                                                 NumCheatsAllocated);
381                                 if (Cheats == NULL)
382                                         break;
383                         }
384                         Cheats[NumCheats].Descr = strdup(name);
385                         Cheats[NumCheats].Enabled = 0;
386                         Cheats[NumCheats].WasEnabled = 0;
387                         Cheats[NumCheats].First = NumCodes;
388                         Cheats[NumCheats].n = 0;
389                         NumCheats++;
390                         newcheat = 0;
391                 }
392
393                 if (NumCodes >= NumCodesAllocated) {
394                         NumCodesAllocated += 16;
395                         CheatCodes = realloc(CheatCodes, sizeof(CheatCode) *
396                                 NumCodesAllocated);
397                         if (CheatCodes == NULL)
398                                 break;
399                 }
400                 CheatCodes[NumCodes].Addr = a;
401                 CheatCodes[NumCodes].Val = v;
402                 NumCodes++;
403                 Cheats[NumCheats - 1].n++;
404         }
405
406 out:
407         fclose(f);
408 }
409
410 void emu_on_new_cd(int show_hud_msg)
411 {
412         ClearAllCheats();
413         parse_cwcheat();
414
415         if (Config.HLE) {
416                 SysPrintf("note: running with HLE BIOS, expect compatibility problems\n");
417                 SysPrintf("----------------------------------------------------------\n");
418         }
419
420         if (show_hud_msg) {
421                 snprintf(hud_msg, sizeof(hud_msg), BOOT_MSG);
422                 hud_new_msg = 3;
423         }
424 }
425
426 static void log_wrong_cpu(void)
427 {
428 #if DO_CPU_CHECKS
429         __builtin_cpu_init();
430         #define CHECK_CPU(name) if (!__builtin_cpu_supports(name)) \
431                 SysPrintf("ERROR: compiled for " name ", which is unsupported by the CPU\n")
432 #ifdef __SSE2__
433         CHECK_CPU("sse2");
434 #endif
435 #ifdef __SSSE3__
436         CHECK_CPU("ssse3");
437 #endif
438 #ifdef __SSE4_1__
439         CHECK_CPU("sse4.1");
440 #endif
441 #endif // DO_CPU_CHECKS
442 }
443
444 #define MKSTR2(x) #x
445 #define MKSTR(x) MKSTR2(x)
446 static const char *get_build_info(void)
447 {
448         return " ("
449 #ifdef __VERSION__
450                 "cc " __VERSION__ " "
451 #endif
452 #if defined(__SIZEOF_POINTER__) && __SIZEOF_POINTER__ == 8
453                 "64bit "
454 #elif defined(__SIZEOF_POINTER__) && __SIZEOF_POINTER__ == 4
455                 "32bit "
456 #endif
457 #if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
458                 "be "
459 #endif
460 #if defined(__PIC__) || defined(__pic__)
461                 "pic "
462 #endif
463 #if defined(__aarch64__)
464                 "arm64"
465 #elif defined(__arm__)
466                 "arm"
467 #endif
468 #ifdef __ARM_ARCH
469                 "v" MKSTR(__ARM_ARCH) " "
470 #endif
471 #if defined(__AVX__)
472                 "avx "
473 #elif defined(__SSSE3__)
474                 "ssse3 "
475 #elif defined(__ARM_NEON) || defined(__ARM_NEON__)
476                 "neon "
477 #endif
478 #if defined(LIGHTREC)
479                 "lightrec "
480 #elif !defined(DRC_DISABLE)
481                 "ari64 "
482 #endif
483                 "gpu=" MKSTR(BUILTIN_GPU)
484                 ")";
485 }
486
487 int emu_core_preinit(void)
488 {
489         // what is the name of the config file?
490         // it may be redefined by -cfg on the command line
491         strcpy(cfgfile_basename, "pcsx.cfg");
492
493 #ifdef IOS
494         emuLog = fopen("/User/Documents/pcsxr.log", "w");
495         if (emuLog == NULL)
496                 emuLog = fopen("pcsxr.log", "w");
497         if (emuLog == NULL)
498 #endif
499         emuLog = stdout;
500
501         log_wrong_cpu();
502
503         SetIsoFile(NULL);
504
505         memset(&Config, 0, sizeof(Config));
506
507         set_default_paths();
508         emu_set_default_config();
509         strcpy(Config.Bios, "HLE");
510
511         return 0;
512 }
513
514 int emu_core_init(void)
515 {
516         SysPrintf("Starting PCSX-ReARMed " REV "%s\n", get_build_info());
517
518 #ifndef NO_FRONTEND
519         check_profile();
520         check_memcards();
521 #endif
522
523         if (EmuInit() == -1) {
524                 SysPrintf("PSX emulator couldn't be initialized.\n");
525                 return -1;
526         }
527
528         LoadMcds(Config.Mcd1, Config.Mcd2);
529
530         if (Config.Debug) {
531                 StartDebugger();
532         }
533
534         return 0;
535 }
536
537 void emu_core_ask_exit(void)
538 {
539         stop++;
540         g_emu_want_quit = 1;
541 }
542
543 #ifndef NO_FRONTEND
544
545 #include <sys/stat.h>
546 #include <sys/types.h>
547
548 static void create_profile_dir(const char *directory) {
549         char path[MAXPATHLEN];
550
551         MAKE_PATH(path, directory, NULL);
552         mkdir(path, S_IRWXU | S_IRWXG);
553 }
554
555 static void check_profile(void) {
556         // make sure that ~/.pcsx exists
557         create_profile_dir(PCSX_DOT_DIR);
558
559         create_profile_dir(BIOS_DIR);
560         create_profile_dir(MEMCARD_DIR);
561         create_profile_dir(STATES_DIR);
562         create_profile_dir(PLUGINS_DIR);
563         create_profile_dir(PLUGINS_CFG_DIR);
564         create_profile_dir(CHEATS_DIR);
565         create_profile_dir(PATCHES_DIR);
566         create_profile_dir(PCSX_DOT_DIR "cfg");
567         create_profile_dir("/screenshots/");
568 }
569
570 static void check_memcards(void)
571 {
572         char buf[MAXPATHLEN];
573         FILE *f;
574         int i;
575
576         for (i = 1; i <= 9; i++) {
577                 snprintf(buf, sizeof(buf), ".%scard%d.mcd", MEMCARD_DIR, i);
578
579                 f = fopen(buf, "rb");
580                 if (f == NULL) {
581                         SysPrintf("Creating memcard: %s\n", buf);
582                         CreateMcd(buf);
583                 }
584                 else
585                         fclose(f);
586         }
587 }
588
589 int main(int argc, char *argv[])
590 {
591         char file[MAXPATHLEN] = "";
592         char path[MAXPATHLEN];
593         const char *cdfile = NULL;
594         const char *loadst_f = NULL;
595         int psxout = 0;
596         int loadst = 0;
597         int i;
598
599         emu_core_preinit();
600
601         // read command line options
602         for (i = 1; i < argc; i++) {
603                      if (!strcmp(argv[i], "-psxout")) psxout = 1;
604                 else if (!strcmp(argv[i], "-load")) loadst = atol(argv[++i]);
605                 else if (!strcmp(argv[i], "-cfg")) {
606                         if (i+1 >= argc) break;
607                         strncpy(cfgfile_basename, argv[++i], MAXPATHLEN-100);   /* TODO buffer overruns */
608                         SysPrintf("Using config file %s.\n", cfgfile_basename);
609                 }
610                 else if (!strcmp(argv[i], "-cdfile")) {
611                         char isofilename[MAXPATHLEN];
612
613                         if (i+1 >= argc) break;
614                         strncpy(isofilename, argv[++i], MAXPATHLEN);
615                         if (isofilename[0] != '/') {
616                                 getcwd(path, MAXPATHLEN);
617                                 if (strlen(path) + strlen(isofilename) + 1 < MAXPATHLEN) {
618                                         strcat(path, "/");
619                                         strcat(path, isofilename);
620                                         strcpy(isofilename, path);
621                                 } else
622                                         isofilename[0] = 0;
623                         }
624
625                         cdfile = isofilename;
626                 }
627                 else if (!strcmp(argv[i], "-loadf")) {
628                         if (i+1 >= argc) break;
629                         loadst_f = argv[++i];
630                 }
631                 else if (!strcmp(argv[i], "-h") ||
632                          !strcmp(argv[i], "-help") ||
633                          !strcmp(argv[i], "--help")) {
634                          printf("PCSX-ReARMed " REV "\n");
635                          printf("%s\n", _(
636                                                         " pcsx [options] [file]\n"
637                                                         "\toptions:\n"
638                                                         "\t-cdfile FILE\tRuns a CD image file\n"
639                                                         "\t-cfg FILE\tLoads desired configuration file (default: ~/.pcsx/pcsx.cfg)\n"
640                                                         "\t-psxout\t\tEnable PSX output\n"
641                                                         "\t-load STATENUM\tLoads savestate STATENUM (1-5)\n"
642                                                         "\t-h -help\tDisplay this message\n"
643                                                         "\tfile\t\tLoads a PSX EXE file\n"));
644                          return 0;
645                 } else {
646                         strncpy(file, argv[i], MAXPATHLEN);
647                         if (file[0] != '/') {
648                                 getcwd(path, MAXPATHLEN);
649                                 if (strlen(path) + strlen(file) + 1 < MAXPATHLEN) {
650                                         strcat(path, "/");
651                                         strcat(path, file);
652                                         strcpy(file, path);
653                                 } else
654                                         file[0] = 0;
655                         }
656                 }
657         }
658
659         if (cdfile)
660                 set_cd_image(cdfile);
661
662         // frontend stuff
663         // init input but leave probing to platform code,
664         // they add input drivers and may need to modify them after probe
665         in_init();
666         pl_init();
667         plat_init();
668         menu_init(); // loads config
669
670         if (emu_core_init() != 0)
671                 return 1;
672
673         if (psxout)
674                 Config.PsxOut = 1;
675
676         if (LoadPlugins() == -1) {
677                 // FIXME: this recovery doesn't work, just delete bad config and bail out
678                 // SysMessage("could not load plugins, retrying with defaults\n");
679                 set_default_paths();
680                 snprintf(path, sizeof(path), "." PCSX_DOT_DIR "%s", cfgfile_basename);
681                 remove(path);
682                 SysMessage("Failed loading plugins!");
683                 return 1;
684         }
685         pcnt_hook_plugins();
686
687         if (OpenPlugins() == -1) {
688                 return 1;
689         }
690         plugin_call_rearmed_cbs();
691
692         CheckCdrom();
693         SysReset();
694
695         if (file[0] != '\0') {
696                 if (Load(file) != -1)
697                         ready_to_go = 1;
698         } else {
699                 if (cdfile) {
700                         if (LoadCdrom() == -1) {
701                                 ClosePlugins();
702                                 SysPrintf(_("Could not load CD-ROM!\n"));
703                                 return -1;
704                         }
705                         emu_on_new_cd(!loadst);
706                         ready_to_go = 1;
707                 }
708         }
709
710         if (loadst_f) {
711                 int ret = LoadState(loadst_f);
712                 SysPrintf("%s state file: %s\n",
713                         ret ? "failed to load" : "loaded", loadst_f);
714                 ready_to_go |= ret == 0;
715         }
716
717         if (ready_to_go) {
718                 menu_prepare_emu();
719
720                 // If a state has been specified, then load that
721                 if (loadst) {
722                         int ret = emu_load_state(loadst - 1);
723                         SysPrintf("%s state %d\n",
724                                 ret ? "failed to load" : "loaded", loadst);
725                 }
726         }
727         else
728                 menu_loop();
729
730         pl_start_watchdog();
731
732         while (!g_emu_want_quit)
733         {
734                 stop = 0;
735                 emu_action = SACTION_NONE;
736
737                 psxCpu->Execute();
738                 if (emu_action != SACTION_NONE)
739                         do_emu_action();
740         }
741
742         printf("Exit..\n");
743         ClosePlugins();
744         SysClose();
745         menu_finish();
746         plat_finish();
747
748         return 0;
749 }
750
751 static void toggle_fast_forward(int force_off)
752 {
753         static int fast_forward;
754         static int normal_g_opts;
755         static int normal_enhancement_enable;
756         //static int normal_frameskip;
757
758         if (force_off && !fast_forward)
759                 return;
760
761         fast_forward = !fast_forward;
762         if (fast_forward) {
763                 normal_g_opts = g_opts;
764                 //normal_frameskip = pl_rearmed_cbs.frameskip;
765                 normal_enhancement_enable =
766                         pl_rearmed_cbs.gpu_neon.enhancement_enable;
767
768                 g_opts |= OPT_NO_FRAMELIM;
769                 // pl_rearmed_cbs.frameskip = 3; // too broken
770                 pl_rearmed_cbs.gpu_neon.enhancement_enable = 0;
771         } else {
772                 g_opts = normal_g_opts;
773                 //pl_rearmed_cbs.frameskip = normal_frameskip;
774                 pl_rearmed_cbs.gpu_neon.enhancement_enable =
775                         normal_enhancement_enable;
776
777                 pl_timing_prepare(Config.PsxType);
778         }
779
780         if (!force_off)
781                 snprintf(hud_msg, sizeof(hud_msg), "FAST FORWARD %s",
782                         fast_forward ? "ON" : "OFF");
783 }
784
785 static void SignalExit(int sig) {
786         // only to restore framebuffer/resolution on some devices
787         plat_finish();
788         _exit(1);
789 }
790 #endif
791
792 void SysRunGui() {
793         printf("SysRunGui\n");
794 }
795
796 static void CALLBACK dummy_lace()
797 {
798 }
799
800 void SysReset() {
801         // rearmed hack: EmuReset() runs some code when real BIOS is used,
802         // but we usually do reset from menu while GPU is not open yet,
803         // so we need to prevent updateLace() call..
804         void *real_lace = GPU_updateLace;
805         GPU_updateLace = dummy_lace;
806         g_emu_resetting = 1;
807
808         // reset can run code, timing must be set
809         pl_timing_prepare(Config.PsxType);
810
811    // hmh core forgets this
812         CDR_stop();
813    
814         EmuReset();
815
816         GPU_updateLace = real_lace;
817         g_emu_resetting = 0;
818 }
819
820 void SysClose() {
821         EmuShutdown();
822         ReleasePlugins();
823
824         StopDebugger();
825
826         if (emuLog != NULL && emuLog != stdout && emuLog != stderr) {
827                 fclose(emuLog);
828                 emuLog = NULL;
829         }
830 }
831
832 int get_state_filename(char *buf, int size, int i) {
833         return get_gameid_filename(buf, size,
834                 "." STATES_DIR "%.32s-%.9s.%3.3d", i);
835 }
836
837 int emu_check_state(int slot)
838 {
839         char fname[MAXPATHLEN];
840         int ret;
841
842         ret = get_state_filename(fname, sizeof(fname), slot);
843         if (ret != 0)
844                 return ret;
845
846         return CheckState(fname);
847 }
848
849 int emu_save_state(int slot)
850 {
851         char fname[MAXPATHLEN];
852         int ret;
853
854         ret = get_state_filename(fname, sizeof(fname), slot);
855         if (ret != 0)
856                 return ret;
857
858         ret = SaveState(fname);
859 #if defined(HAVE_PRE_ARMV7) && !defined(_3DS) && !defined(__SWITCH__) /* XXX GPH hack */
860         sync();
861 #endif
862         SysPrintf("* %s \"%s\" [%d]\n",
863                 ret == 0 ? "saved" : "failed to save", fname, slot);
864         return ret;
865 }
866
867 int emu_load_state(int slot)
868 {
869         char fname[MAXPATHLEN];
870         int ret;
871
872         hud_msg[0] = 0;
873
874         ret = get_state_filename(fname, sizeof(fname), slot);
875         if (ret != 0)
876                 return ret;
877
878         return LoadState(fname);
879 }
880
881 #ifndef HAVE_LIBRETRO
882 #ifndef ANDROID
883
884 void SysPrintf(const char *fmt, ...) {
885         va_list list;
886
887         va_start(list, fmt);
888         vfprintf(emuLog, fmt, list);
889         va_end(list);
890         fflush(emuLog);
891 }
892
893 #else
894
895 #include <android/log.h>
896
897 void SysPrintf(const char *fmt, ...) {
898         va_list list;
899
900         va_start(list, fmt);
901         __android_log_vprint(ANDROID_LOG_INFO, "PCSX", fmt, list);
902         va_end(list);
903 }
904
905 #endif
906 #endif /* HAVE_LIBRETRO */
907
908 void SysMessage(const char *fmt, ...) {
909         va_list list;
910         char msg[512];
911         int ret;
912
913         va_start(list, fmt);
914         ret = vsnprintf(msg, sizeof(msg), fmt, list);
915         va_end(list);
916
917         if (ret < sizeof(msg) && msg[ret - 1] == '\n')
918                 msg[ret - 1] = 0;
919
920         SysPrintf("%s\n", msg);
921 }
922
923 #define PARSEPATH(dst, src) \
924         ptr = src + strlen(src); \
925         while (*ptr != '\\' && ptr != src) ptr--; \
926         if (ptr != src) { \
927                 strcpy(dst, ptr+1); \
928         }
929
930 static int _OpenPlugins(void) {
931         int ret;
932
933 #ifndef NO_FRONTEND
934         signal(SIGINT, SignalExit);
935         signal(SIGPIPE, SignalExit);
936 #endif
937
938         ret = CDR_open();
939         if (ret < 0) { SysMessage(_("Error opening CD-ROM plugin!")); return -1; }
940         ret = SPU_open();
941         if (ret < 0) { SysMessage(_("Error opening SPU plugin!")); return -1; }
942         SPU_registerCallback(SPUirq);
943         SPU_registerScheduleCb(SPUschedule);
944         // pcsx-rearmed: we handle gpu elsewhere
945         //ret = GPU_open(&gpuDisp, "PCSX", NULL);
946         //if (ret < 0) { SysMessage(_("Error opening GPU plugin!")); return -1; }
947         ret = PAD1_open(&gpuDisp);
948         if (ret < 0) { SysMessage(_("Error opening Controller 1 plugin!")); return -1; }
949         ret = PAD2_open(&gpuDisp);
950         if (ret < 0) { SysMessage(_("Error opening Controller 2 plugin!")); return -1; }
951
952         if (Config.UseNet && !NetOpened) {
953                 netInfo info;
954                 char path[MAXPATHLEN * 2];
955                 char dotdir[MAXPATHLEN];
956
957                 MAKE_PATH(dotdir, "/.pcsx/plugins/", NULL);
958
959                 strcpy(info.EmuName, "PCSX");
960                 memcpy(info.CdromID, CdromId, 9); /* no \0 trailing character? */
961                 memcpy(info.CdromLabel, CdromLabel, 9);
962                 info.CdromLabel[9] = '\0';
963                 info.psxMem = psxM;
964                 info.GPU_showScreenPic = GPU_showScreenPic;
965                 info.GPU_displayText = GPU_displayText;
966                 info.GPU_showScreenPic = GPU_showScreenPic;
967                 info.PAD_setSensitive = PAD1_setSensitive;
968                 sprintf(path, "%s%s", Config.BiosDir, Config.Bios);
969                 strcpy(info.BIOSpath, path);
970                 strcpy(info.MCD1path, Config.Mcd1);
971                 strcpy(info.MCD2path, Config.Mcd2);
972                 sprintf(path, "%s%s", dotdir, Config.Gpu);
973                 strcpy(info.GPUpath, path);
974                 sprintf(path, "%s%s", dotdir, Config.Spu);
975                 strcpy(info.SPUpath, path);
976                 sprintf(path, "%s%s", dotdir, Config.Cdr);
977                 strcpy(info.CDRpath, path);
978                 NET_setInfo(&info);
979
980                 ret = NET_open(&gpuDisp);
981                 if (ret < 0) {
982                         if (ret == -2) {
983                                 // -2 is returned when something in the info
984                                 // changed and needs to be synced
985                                 char *ptr;
986
987                                 PARSEPATH(Config.Bios, info.BIOSpath);
988                                 PARSEPATH(Config.Gpu,  info.GPUpath);
989                                 PARSEPATH(Config.Spu,  info.SPUpath);
990                                 PARSEPATH(Config.Cdr,  info.CDRpath);
991
992                                 strcpy(Config.Mcd1, info.MCD1path);
993                                 strcpy(Config.Mcd2, info.MCD2path);
994                                 return -2;
995                         } else {
996                                 Config.UseNet = FALSE;
997                         }
998                 } else {
999                         if (NET_queryPlayer() == 1) {
1000                                 if (SendPcsxInfo() == -1) Config.UseNet = FALSE;
1001                         } else {
1002                                 if (RecvPcsxInfo() == -1) Config.UseNet = FALSE;
1003                         }
1004                 }
1005                 NetOpened = TRUE;
1006         } else if (Config.UseNet) {
1007                 NET_resume();
1008         }
1009
1010         return 0;
1011 }
1012
1013 int OpenPlugins() {
1014         int ret;
1015
1016         while ((ret = _OpenPlugins()) == -2) {
1017                 ReleasePlugins();
1018                 LoadMcds(Config.Mcd1, Config.Mcd2);
1019                 if (LoadPlugins() == -1) return -1;
1020         }
1021         return ret;
1022 }
1023
1024 void ClosePlugins() {
1025         int ret;
1026
1027 #ifndef NO_FRONTEND
1028         signal(SIGINT, SIG_DFL);
1029         signal(SIGPIPE, SIG_DFL);
1030 #endif
1031
1032         ret = CDR_close();
1033         if (ret < 0) { SysMessage(_("Error closing CD-ROM plugin!")); return; }
1034         ret = SPU_close();
1035         if (ret < 0) { SysMessage(_("Error closing SPU plugin!")); return; }
1036         ret = PAD1_close();
1037         if (ret < 0) { SysMessage(_("Error closing Controller 1 Plugin!")); return; }
1038         ret = PAD2_close();
1039         if (ret < 0) { SysMessage(_("Error closing Controller 2 plugin!")); return; }
1040         // pcsx-rearmed: we handle gpu elsewhere
1041         //ret = GPU_close();
1042         //if (ret < 0) { SysMessage(_("Error closing GPU plugin!")); return; }
1043
1044         if (Config.UseNet) {
1045                 NET_pause();
1046         }
1047 }
1048
1049 /* we hook statically linked plugins here */
1050 static const char *builtin_plugins[] = {
1051         "builtin_gpu", "builtin_spu", "builtin_cdr", "builtin_pad",
1052         "builtin_cdrcimg",
1053 };
1054
1055 static const int builtin_plugin_ids[] = {
1056         PLUGIN_GPU, PLUGIN_SPU, PLUGIN_CDR, PLUGIN_PAD,
1057         PLUGIN_CDRCIMG,
1058 };
1059
1060 void *SysLoadLibrary(const char *lib) {
1061         const char *tmp = strrchr(lib, '/');
1062         void *ret = NULL;
1063         int i;
1064
1065         SysPrintf("plugin: %s\n", lib);
1066
1067         if (tmp != NULL) {
1068                 tmp++;
1069                 for (i = 0; i < ARRAY_SIZE(builtin_plugins); i++)
1070                         if (strcmp(tmp, builtin_plugins[i]) == 0)
1071                                 return (void *)(uintptr_t)(PLUGIN_DL_BASE + builtin_plugin_ids[i]);
1072         }
1073
1074 #if !defined(_WIN32) && !defined(NO_DYLIB)
1075         ret = dlopen(lib, RTLD_NOW);
1076         if (ret == NULL)
1077                 SysMessage("dlopen: %s", dlerror());
1078 #else
1079         /* no external plugin support, abi is no longer
1080          * compatible with psemu/pcsx anyway */
1081 #endif
1082         return ret;
1083 }
1084
1085 void *SysLoadSym(void *lib, const char *sym) {
1086         unsigned int plugid = (unsigned int)(uintptr_t)lib;
1087
1088         if (PLUGIN_DL_BASE <= plugid && plugid < PLUGIN_DL_BASE + ARRAY_SIZE(builtin_plugins))
1089                 return plugin_link(plugid - PLUGIN_DL_BASE, sym);
1090
1091 #if !defined(_WIN32) && !defined(NO_DYLIB)
1092         return dlsym(lib, sym);
1093 #else
1094         return NULL;
1095 #endif
1096 }
1097
1098 const char *SysLibError() {
1099 #if defined(NO_DYLIB)
1100    return NULL;
1101 #elif !defined(_WIN32)
1102         return dlerror();
1103 #else
1104         return "not supported";
1105 #endif
1106 }
1107
1108 void SysCloseLibrary(void *lib) {
1109         unsigned int plugid = (unsigned int)(uintptr_t)lib;
1110
1111         if (PLUGIN_DL_BASE <= plugid && plugid < PLUGIN_DL_BASE + ARRAY_SIZE(builtin_plugins))
1112                 return;
1113
1114 #if !defined(_WIN32) && !defined(NO_DYLIB)
1115         dlclose(lib);
1116 #endif
1117 }