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