notaz.gp2x.de / picodrive.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
32x: drc: new smc handling, write handlers adjusted.
[picodrive.git] / platform / common / emu.c
... / ...
CommitLineData
1// (c) Copyright 2006-2009 notaz, All rights reserved.\r
2// Free for non-commercial use.\r
3\r
4// For commercial use, separate licencing terms must be obtained.\r
5\r
6#include <stdio.h>\r
7#include <stdlib.h>\r
8#include <stdarg.h>\r
9#ifndef NO_SYNC\r
10#include <unistd.h>\r
11#endif\r
12\r
13#include "emu.h"\r
14#include "menu.h"\r
15#include "fonts.h"\r
16#include "lprintf.h"\r
17#include "config.h"\r
18#include "plat.h"\r
19#include "input.h"\r
20#include "posix.h"\r
21\r
22#include <pico/pico_int.h>\r
23#include <pico/patch.h>\r
24#include <pico/cd/cue.h>\r
25\r
26\r
27#define STATUS_MSG_TIMEOUT 2000\r
28\r
29void *g_screen_ptr;\r
30\r
31#if !SCREEN_SIZE_FIXED\r
32int g_screen_width = SCREEN_WIDTH;\r
33int g_screen_height = SCREEN_HEIGHT;\r
34#endif\r
35\r
36char *PicoConfigFile = "config.cfg";\r
37currentConfig_t currentConfig, defaultConfig;\r
38int state_slot = 0;\r
39int config_slot = 0, config_slot_current = 0;\r
40int pico_pen_x = 320/2, pico_pen_y = 240/2;\r
41int pico_inp_mode = 0;\r
42int engineState = PGS_Menu;\r
43\r
44/* tmp buff to reduce stack usage for plats with small stack */\r
45static char static_buff[512];\r
46/* TODO: len checking */\r
47char rom_fname_reload[512];\r
48char rom_fname_loaded[512];\r
49int rom_loaded = 0;\r
50int reset_timing = 0;\r
51static unsigned int notice_msg_time; /* when started showing */\r
52static char noticeMsg[40];\r
53\r
54unsigned char *movie_data = NULL;\r
55static int movie_size = 0;\r
56\r
57\r
58/* don't use tolower() for easy old glibc binary compatibility */\r
59static void strlwr_(char *string)\r
60{\r
61 char *p;\r
62 for (p = string; *p; p++)\r
63 if ('A' <= *p && *p <= 'Z')\r
64 *p += 'a' - 'A';\r
65}\r
66\r
67static int try_rfn_cut(char *fname)\r
68{\r
69 FILE *tmp;\r
70 char *p;\r
71\r
72 p = fname + strlen(fname) - 1;\r
73 for (; p > fname; p--)\r
74 if (*p == '.') break;\r
75 *p = 0;\r
76\r
77 if((tmp = fopen(fname, "rb"))) {\r
78 fclose(tmp);\r
79 return 1;\r
80 }\r
81 return 0;\r
82}\r
83\r
84static void get_ext(const char *file, char *ext)\r
85{\r
86 const char *p;\r
87\r
88 p = file + strlen(file) - 4;\r
89 if (p < file) p = file;\r
90 strncpy(ext, p, 4);\r
91 ext[4] = 0;\r
92 strlwr_(ext);\r
93}\r
94\r
95void emu_status_msg(const char *format, ...)\r
96{\r
97 va_list vl;\r
98 int ret;\r
99\r
100 va_start(vl, format);\r
101 ret = vsnprintf(noticeMsg, sizeof(noticeMsg), format, vl);\r
102 va_end(vl);\r
103\r
104 /* be sure old text gets overwritten */\r
105 for (; ret < 28; ret++)\r
106 noticeMsg[ret] = ' ';\r
107 noticeMsg[ret] = 0;\r
108\r
109 notice_msg_time = plat_get_ticks_ms();\r
110}\r
111\r
112static const char * const biosfiles_us[] = { "us_scd1_9210", "us_scd2_9306", "SegaCDBIOS9303" };\r
113static const char * const biosfiles_eu[] = { "eu_mcd1_9210", "eu_mcd2_9306", "eu_mcd2_9303" };\r
114static const char * const biosfiles_jp[] = { "jp_mcd1_9112", "jp_mcd1_9111" };\r
115\r
116static int find_bios(int region, char **bios_file)\r
117{\r
118 int i, count;\r
119 const char * const *files;\r
120 FILE *f = NULL;\r
121\r
122 if (region == 4) { // US\r
123 files = biosfiles_us;\r
124 count = sizeof(biosfiles_us) / sizeof(char *);\r
125 } else if (region == 8) { // EU\r
126 files = biosfiles_eu;\r
127 count = sizeof(biosfiles_eu) / sizeof(char *);\r
128 } else if (region == 1 || region == 2) {\r
129 files = biosfiles_jp;\r
130 count = sizeof(biosfiles_jp) / sizeof(char *);\r
131 } else {\r
132 return 0;\r
133 }\r
134\r
135 for (i = 0; i < count; i++)\r
136 {\r
137 emu_make_path(static_buff, files[i], sizeof(static_buff) - 4);\r
138 strcat(static_buff, ".bin");\r
139 f = fopen(static_buff, "rb");\r
140 if (f) break;\r
141\r
142 static_buff[strlen(static_buff) - 4] = 0;\r
143 strcat(static_buff, ".zip");\r
144 f = fopen(static_buff, "rb");\r
145 if (f) break;\r
146 }\r
147\r
148 if (f) {\r
149 lprintf("using bios: %s\n", static_buff);\r
150 fclose(f);\r
151 if (bios_file)\r
152 *bios_file = static_buff;\r
153 return 1;\r
154 } else {\r
155 sprintf(static_buff, "no %s BIOS files found, read docs",\r
156 region != 4 ? (region == 8 ? "EU" : "JAP") : "USA");\r
157 me_update_msg(static_buff);\r
158 return 0;\r
159 }\r
160}\r
161\r
162/* check if the name begins with BIOS name */\r
163/*\r
164static int emu_isBios(const char *name)\r
165{\r
166 int i;\r
167 for (i = 0; i < sizeof(biosfiles_us)/sizeof(biosfiles_us[0]); i++)\r
168 if (strstr(name, biosfiles_us[i]) != NULL) return 1;\r
169 for (i = 0; i < sizeof(biosfiles_eu)/sizeof(biosfiles_eu[0]); i++)\r
170 if (strstr(name, biosfiles_eu[i]) != NULL) return 1;\r
171 for (i = 0; i < sizeof(biosfiles_jp)/sizeof(biosfiles_jp[0]); i++)\r
172 if (strstr(name, biosfiles_jp[i]) != NULL) return 1;\r
173 return 0;\r
174}\r
175*/\r
176\r
177static unsigned char id_header[0x100];\r
178\r
179/* checks if fname points to valid MegaCD image */\r
180static int emu_cd_check(int *pregion, const char *fname_in)\r
181{\r
182 const char *fname = fname_in;\r
183 unsigned char buf[32];\r
184 pm_file *cd_f;\r
185 int region = 4; // 1: Japan, 4: US, 8: Europe\r
186 char ext[5];\r
187 cue_track_type type = CT_UNKNOWN;\r
188 cue_data_t *cue_data = NULL;\r
189\r
190 get_ext(fname_in, ext);\r
191 if (strcasecmp(ext, ".cue") == 0) {\r
192 cue_data = cue_parse(fname_in);\r
193 if (cue_data != NULL) {\r
194 fname = cue_data->tracks[1].fname;\r
195 type = cue_data->tracks[1].type;\r
196 }\r
197 else\r
198 return -1;\r
199 }\r
200\r
201 cd_f = pm_open(fname);\r
202 if (cue_data != NULL)\r
203 cue_destroy(cue_data);\r
204\r
205 if (cd_f == NULL) return 0; // let the upper level handle this\r
206\r
207 if (pm_read(buf, 32, cd_f) != 32) {\r
208 pm_close(cd_f);\r
209 return -1;\r
210 }\r
211\r
212 if (!strncasecmp("SEGADISCSYSTEM", (char *)buf+0x00, 14)) {\r
213 if (type && type != CT_ISO)\r
214 elprintf(EL_STATUS, ".cue has wrong type: %i", type);\r
215 type = CT_ISO; // Sega CD (ISO)\r
216 }\r
217 if (!strncasecmp("SEGADISCSYSTEM", (char *)buf+0x10, 14)) {\r
218 if (type && type != CT_BIN)\r
219 elprintf(EL_STATUS, ".cue has wrong type: %i", type);\r
220 type = CT_BIN; // Sega CD (BIN)\r
221 }\r
222\r
223 if (type == CT_UNKNOWN) {\r
224 pm_close(cd_f);\r
225 return 0;\r
226 }\r
227\r
228 pm_seek(cd_f, (type == CT_ISO) ? 0x100 : 0x110, SEEK_SET);\r
229 pm_read(id_header, sizeof(id_header), cd_f);\r
230\r
231 /* it seems we have a CD image here. Try to detect region now.. */\r
232 pm_seek(cd_f, (type == CT_ISO) ? 0x100+0x10B : 0x110+0x10B, SEEK_SET);\r
233 pm_read(buf, 1, cd_f);\r
234 pm_close(cd_f);\r
235\r
236 if (buf[0] == 0x64) region = 8; // EU\r
237 if (buf[0] == 0xa1) region = 1; // JAP\r
238\r
239 lprintf("detected %s Sega/Mega CD image with %s region\n",\r
240 type == CT_BIN ? "BIN" : "ISO", region != 4 ? (region == 8 ? "EU" : "JAP") : "USA");\r
241\r
242 if (pregion != NULL) *pregion = region;\r
243\r
244 return type;\r
245}\r
246\r
247static int detect_media(const char *fname)\r
248{\r
249 static const short sms_offsets[] = { 0x7ff0, 0x3ff0, 0x1ff0 };\r
250 static const char *sms_exts[] = { "sms", "gg", "sg" };\r
251 static const char *md_exts[] = { "gen", "bin", "smd" };\r
252 char buff0[32], buff[32];\r
253 unsigned short *d16;\r
254 pm_file *pmf;\r
255 char ext[5];\r
256 int i;\r
257\r
258 get_ext(fname, ext);\r
259\r
260 // detect wrong extensions\r
261 if (!strcmp(ext, ".srm") || !strcmp(ext, "s.gz") || !strcmp(ext, ".mds")) // s.gz ~ .mds.gz\r
262 return PM_BAD;\r
263\r
264 /* don't believe in extensions, except .cue */\r
265 if (strcasecmp(ext, ".cue") == 0)\r
266 return PM_CD;\r
267\r
268 pmf = pm_open(fname);\r
269 if (pmf == NULL)\r
270 return PM_BAD;\r
271\r
272 if (pm_read(buff0, 32, pmf) != 32) {\r
273 pm_close(pmf);\r
274 return PM_BAD;\r
275 }\r
276\r
277 if (strncasecmp("SEGADISCSYSTEM", buff0 + 0x00, 14) == 0 ||\r
278 strncasecmp("SEGADISCSYSTEM", buff0 + 0x10, 14) == 0) {\r
279 pm_close(pmf);\r
280 return PM_CD;\r
281 }\r
282\r
283 /* check for SMD evil */\r
284 if (pmf->size >= 0x4200 && (pmf->size & 0x3fff) == 0x200) {\r
285 if (pm_seek(pmf, sms_offsets[0] + 0x200, SEEK_SET) == sms_offsets[0] + 0x200 &&\r
286 pm_read(buff, 16, pmf) == 16 &&\r
287 strncmp("TMR SEGA", buff, 8) == 0)\r
288 goto looks_like_sms;\r
289\r
290 /* could parse further but don't bother */\r
291 goto extension_check;\r
292 }\r
293\r
294 /* MD header? Act as TMSS BIOS here */\r
295 if (pm_seek(pmf, 0x100, SEEK_SET) == 0x100 && pm_read(buff, 16, pmf) == 16) {\r
296 if (strncmp(buff, "SEGA", 4) == 0 || strncmp(buff, " SEG", 4) == 0)\r
297 goto looks_like_md;\r
298 }\r
299\r
300 for (i = 0; i < array_size(sms_offsets); i++) {\r
301 if (pm_seek(pmf, sms_offsets[i], SEEK_SET) != sms_offsets[i])\r
302 continue;\r
303\r
304 if (pm_read(buff, 16, pmf) != 16)\r
305 continue;\r
306\r
307 if (strncmp("TMR SEGA", buff, 8) == 0)\r
308 goto looks_like_sms;\r
309 }\r
310\r
311extension_check:\r
312 /* probably some headerless thing. Maybe check the extension after all. */\r
313 for (i = 0; i < array_size(md_exts); i++)\r
314 if (strcasecmp(pmf->ext, md_exts[i]) == 0)\r
315 goto looks_like_md;\r
316\r
317 for (i = 0; i < array_size(sms_exts); i++)\r
318 if (strcasecmp(pmf->ext, sms_exts[i]) == 0)\r
319 goto looks_like_sms;\r
320\r
321 /* If everything else fails, make a guess on the reset vector */\r
322 d16 = (unsigned short *)(buff0 + 4);\r
323 if ((((d16[0] << 16) | d16[1]) & 0xffffff) >= pmf->size) {\r
324 lprintf("bad MD reset vector, assuming SMS\n");\r
325 goto looks_like_sms;\r
326 }\r
327\r
328looks_like_md:\r
329 pm_close(pmf);\r
330 return PM_MD_CART;\r
331\r
332looks_like_sms:\r
333 pm_close(pmf);\r
334 return PM_MARK3;\r
335}\r
336\r
337static int extract_text(char *dest, const unsigned char *src, int len, int swab)\r
338{\r
339 char *p = dest;\r
340 int i;\r
341\r
342 if (swab) swab = 1;\r
343\r
344 for (i = len - 1; i >= 0; i--)\r
345 {\r
346 if (src[i^swab] != ' ') break;\r
347 }\r
348 len = i + 1;\r
349\r
350 for (i = 0; i < len; i++)\r
351 {\r
352 unsigned char s = src[i^swab];\r
353 if (s >= 0x20 && s < 0x7f && s != '#' && s != '|' &&\r
354 s != '[' && s != ']' && s != '\\')\r
355 {\r
356 *p++ = s;\r
357 }\r
358 else\r
359 {\r
360 sprintf(p, "\\%02x", s);\r
361 p += 3;\r
362 }\r
363 }\r
364\r
365 return p - dest;\r
366}\r
367\r
368static char *emu_make_rom_id(void)\r
369{\r
370 static char id_string[3+0xe*3+0x3*3+0x30*3+3];\r
371 int pos, swab = 1;\r
372\r
373 if (PicoAHW & PAHW_MCD) {\r
374 strcpy(id_string, "CD|");\r
375 swab = 0;\r
376 }\r
377 else strcpy(id_string, "MD|");\r
378 pos = 3;\r
379\r
380 pos += extract_text(id_string + pos, id_header + 0x80, 0x0e, swab); // serial\r
381 id_string[pos] = '|'; pos++;\r
382 pos += extract_text(id_string + pos, id_header + 0xf0, 0x03, swab); // region\r
383 id_string[pos] = '|'; pos++;\r
384 pos += extract_text(id_string + pos, id_header + 0x50, 0x30, swab); // overseas name\r
385 id_string[pos] = 0;\r
386\r
387 return id_string;\r
388}\r
389\r
390// buffer must be at least 150 byte long\r
391void emu_get_game_name(char *str150)\r
392{\r
393 int ret, swab = (PicoAHW & PAHW_MCD) ? 0 : 1;\r
394 char *s, *d;\r
395\r
396 ret = extract_text(str150, id_header + 0x50, 0x30, swab); // overseas name\r
397\r
398 for (s = d = str150 + 1; s < str150+ret; s++)\r
399 {\r
400 if (*s == 0) break;\r
401 if (*s != ' ' || d[-1] != ' ')\r
402 *d++ = *s;\r
403 }\r
404 *d = 0;\r
405}\r
406\r
407static void shutdown_MCD(void)\r
408{\r
409 if ((PicoAHW & PAHW_MCD) && Pico_mcd != NULL)\r
410 Stop_CD();\r
411 PicoAHW &= ~PAHW_MCD;\r
412}\r
413\r
414static void system_announce(void)\r
415{\r
416 const char *sys_name, *tv_standard;\r
417 int fps;\r
418\r
419 if (PicoAHW & PAHW_SMS) {\r
420 sys_name = "Master System";\r
421 } else if (PicoAHW & PAHW_PICO) {\r
422 sys_name = "Pico";\r
423 } else if (PicoAHW & PAHW_MCD) {\r
424 sys_name = "Mega CD";\r
425 if ((Pico.m.hardware & 0xc0) == 0x80)\r
426 sys_name = "Sega CD";\r
427 } else if (PicoAHW & PAHW_32X) {\r
428 sys_name = "32X";\r
429 } else {\r
430 sys_name = "MegaDrive";\r
431 if ((Pico.m.hardware & 0xc0) == 0x80)\r
432 sys_name = "Genesis";\r
433 }\r
434 tv_standard = Pico.m.pal ? "PAL" : "NTSC";\r
435 fps = Pico.m.pal ? 50 : 60;\r
436\r
437 emu_status_msg("%s %s / %dFPS", tv_standard, sys_name, fps);\r
438}\r
439\r
440// note: this function might mangle rom_fname\r
441// XXX: portions of this code should move to pico/\r
442int emu_reload_rom(char *rom_fname)\r
443{\r
444 unsigned int rom_size = 0;\r
445 char *used_rom_name = rom_fname;\r
446 unsigned char *rom_data = NULL;\r
447 char ext[5];\r
448 pm_file *rom = NULL;\r
449 int cd_state = CIT_NOT_CD;\r
450 int ret, media_type, cd_region;\r
451 int cfg_loaded = 0, bad_rom = 0;\r
452\r
453 lprintf("emu_ReloadRom(%s)\n", rom_fname);\r
454\r
455 get_ext(rom_fname, ext);\r
456\r
457 // check for movie file\r
458 if (movie_data) {\r
459 free(movie_data);\r
460 movie_data = 0;\r
461 }\r
462 if (!strcmp(ext, ".gmv"))\r
463 {\r
464 // check for both gmv and rom\r
465 int dummy;\r
466 FILE *movie_file = fopen(rom_fname, "rb");\r
467 if(!movie_file) {\r
468 me_update_msg("Failed to open movie.");\r
469 return 0;\r
470 }\r
471 fseek(movie_file, 0, SEEK_END);\r
472 movie_size = ftell(movie_file);\r
473 fseek(movie_file, 0, SEEK_SET);\r
474 if(movie_size < 64+3) {\r
475 me_update_msg("Invalid GMV file.");\r
476 fclose(movie_file);\r
477 return 0;\r
478 }\r
479 movie_data = malloc(movie_size);\r
480 if(movie_data == NULL) {\r
481 me_update_msg("low memory.");\r
482 fclose(movie_file);\r
483 return 0;\r
484 }\r
485 fread(movie_data, 1, movie_size, movie_file);\r
486 fclose(movie_file);\r
487 if (strncmp((char *)movie_data, "Gens Movie TEST", 15) != 0) {\r
488 me_update_msg("Invalid GMV file.");\r
489 return 0;\r
490 }\r
491 dummy = try_rfn_cut(rom_fname) || try_rfn_cut(rom_fname);\r
492 if (!dummy) {\r
493 me_update_msg("Could't find a ROM for movie.");\r
494 return 0;\r
495 }\r
496 get_ext(rom_fname, ext);\r
497 lprintf("gmv loaded for %s\n", rom_fname);\r
498 }\r
499 else if (!strcmp(ext, ".pat"))\r
500 {\r
501 int dummy;\r
502 PicoPatchLoad(rom_fname);\r
503 dummy = try_rfn_cut(rom_fname) || try_rfn_cut(rom_fname);\r
504 if (!dummy) {\r
505 me_update_msg("Could't find a ROM to patch.");\r
506 return 0;\r
507 }\r
508 get_ext(rom_fname, ext);\r
509 }\r
510\r
511 media_type = detect_media(rom_fname);\r
512 if (media_type == PM_BAD) {\r
513 me_update_msg("Not a ROM/CD img selected.");\r
514 return 0;\r
515 }\r
516\r
517 shutdown_MCD();\r
518 PicoPatchUnload();\r
519 PicoCartUnload();\r
520 rom_loaded = 0;\r
521\r
522 PicoAHW = 0;\r
523\r
524 if (media_type == PM_CD)\r
525 {\r
526 // check for MegaCD image\r
527 cd_state = emu_cd_check(&cd_region, rom_fname);\r
528 if (cd_state >= 0 && cd_state != CIT_NOT_CD)\r
529 {\r
530 // valid CD image, check for BIOS..\r
531\r
532 // we need to have config loaded at this point\r
533 ret = emu_read_config(1, 0);\r
534 if (!ret) emu_read_config(0, 0);\r
535 cfg_loaded = 1;\r
536\r
537 if (PicoRegionOverride) {\r
538 cd_region = PicoRegionOverride;\r
539 lprintf("override region to %s\n", cd_region != 4 ?\r
540 (cd_region == 8 ? "EU" : "JAP") : "USA");\r
541 }\r
542 if (!find_bios(cd_region, &used_rom_name))\r
543 return 0;\r
544\r
545 get_ext(used_rom_name, ext);\r
546 PicoAHW |= PAHW_MCD;\r
547 }\r
548 else {\r
549 me_update_msg("Invalid CD image");\r
550 return 0;\r
551 }\r
552 }\r
553 else if (media_type == PM_MARK3) {\r
554 lprintf("detected SMS ROM\n");\r
555 PicoAHW = PAHW_SMS;\r
556 }\r
557\r
558 rom = pm_open(used_rom_name);\r
559 if (rom == NULL) {\r
560 me_update_msg("Failed to open ROM");\r
561 return 0;\r
562 }\r
563\r
564 menu_romload_prepare(used_rom_name); // also CD load\r
565 used_rom_name = NULL; // uses static_buff\r
566\r
567 ret = PicoCartLoad(rom, &rom_data, &rom_size, (PicoAHW & PAHW_SMS) ? 1 : 0);\r
568 pm_close(rom);\r
569 if (ret != 0) {\r
570 if (ret == 2) me_update_msg("Out of memory");\r
571 else if (ret == 3) me_update_msg("Read failed");\r
572 else me_update_msg("PicoCartLoad() failed.");\r
573 goto fail;\r
574 }\r
575\r
576 // detect wrong files\r
577 if (strncmp((char *)rom_data, "Pico", 4) == 0)\r
578 bad_rom = 1;\r
579 else if (!(PicoAHW & PAHW_SMS)) {\r
580 unsigned short *d = (unsigned short *)(rom_data + 4);\r
581 if ((((d[0] << 16) | d[1]) & 0xffffff) >= (int)rom_size) {\r
582 lprintf("bad reset vector\n");\r
583 bad_rom = 1;\r
584 }\r
585 }\r
586\r
587 if (bad_rom) {\r
588 me_update_msg("Bad ROM detected.");\r
589 goto fail;\r
590 }\r
591\r
592 // load config for this ROM (do this before insert to get correct region)\r
593 if (!(PicoAHW & PAHW_MCD))\r
594 memcpy(id_header, rom_data + 0x100, sizeof(id_header));\r
595 if (!cfg_loaded) {\r
596 ret = emu_read_config(1, 0);\r
597 if (!ret) emu_read_config(0, 0);\r
598 }\r
599\r
600 emu_make_path(static_buff, "carthw.cfg", sizeof(static_buff));\r
601 if (PicoCartInsert(rom_data, rom_size, static_buff)) {\r
602 me_update_msg("Failed to load ROM.");\r
603 goto fail;\r
604 }\r
605\r
606 // insert CD if it was detected\r
607 if (cd_state != CIT_NOT_CD) {\r
608 ret = Insert_CD(rom_fname, cd_state);\r
609 if (ret != 0) {\r
610 PicoCartUnload();\r
611 rom_data = NULL; // freed by unload\r
612 me_update_msg("Insert_CD() failed, invalid CD image?");\r
613 goto fail;\r
614 }\r
615 }\r
616\r
617 menu_romload_end();\r
618\r
619 if (PicoPatches) {\r
620 PicoPatchPrepare();\r
621 PicoPatchApply();\r
622 }\r
623\r
624 // additional movie stuff\r
625 if (movie_data)\r
626 {\r
627 if (movie_data[0x14] == '6')\r
628 PicoOpt |= POPT_6BTN_PAD; // 6 button pad\r
629 else PicoOpt &= ~POPT_6BTN_PAD;\r
630 PicoOpt |= POPT_DIS_VDP_FIFO; // no VDP fifo timing\r
631 if (movie_data[0xF] >= 'A') {\r
632 if (movie_data[0x16] & 0x80) {\r
633 PicoRegionOverride = 8;\r
634 } else {\r
635 PicoRegionOverride = 4;\r
636 }\r
637 PicoReset();\r
638 // TODO: bits 6 & 5\r
639 }\r
640 movie_data[0x18+30] = 0;\r
641 emu_status_msg("MOVIE: %s", (char *) &movie_data[0x18]);\r
642 }\r
643 else\r
644 {\r
645 system_announce();\r
646 PicoOpt &= ~POPT_DIS_VDP_FIFO;\r
647 }\r
648\r
649 strncpy(rom_fname_loaded, rom_fname, sizeof(rom_fname_loaded)-1);\r
650 rom_fname_loaded[sizeof(rom_fname_loaded)-1] = 0;\r
651 rom_loaded = 1;\r
652\r
653 // load SRAM for this ROM\r
654 if (currentConfig.EmuOpt & EOPT_EN_SRAM)\r
655 emu_save_load_game(1, 1);\r
656\r
657 return 1;\r
658\r
659fail:\r
660 if (rom_data)\r
661 free(rom_data);\r
662 menu_romload_end();\r
663 return 0;\r
664}\r
665\r
666int emu_swap_cd(const char *fname)\r
667{\r
668 cd_img_type cd_type;\r
669 int ret = -1;\r
670\r
671 cd_type = emu_cd_check(NULL, fname);\r
672 if (cd_type != CIT_NOT_CD)\r
673 ret = Insert_CD(fname, cd_type);\r
674 if (ret != 0) {\r
675 me_update_msg("Load failed, invalid CD image?");\r
676 return 0;\r
677 }\r
678\r
679 strncpy(rom_fname_loaded, fname, sizeof(rom_fname_loaded)-1);\r
680 rom_fname_loaded[sizeof(rom_fname_loaded)-1] = 0;\r
681 return 1;\r
682}\r
683\r
684static void romfname_ext(char *dst, const char *prefix, const char *ext)\r
685{\r
686 char *p;\r
687 int prefix_len = 0;\r
688\r
689 // make save filename\r
690 p = rom_fname_loaded + strlen(rom_fname_loaded) - 1;\r
691 for (; p >= rom_fname_loaded && *p != PATH_SEP_C; p--); p++;\r
692 *dst = 0;\r
693 if (prefix) {\r
694 int len = plat_get_root_dir(dst, 512);\r
695 strcpy(dst + len, prefix);\r
696 prefix_len = len + strlen(prefix);\r
697 }\r
698#ifdef UIQ3\r
699 else p = rom_fname_loaded; // backward compatibility\r
700#endif\r
701 strncpy(dst + prefix_len, p, 511-prefix_len);\r
702 dst[511-8] = 0;\r
703 if (dst[strlen(dst)-4] == '.') dst[strlen(dst)-4] = 0;\r
704 if (ext) strcat(dst, ext);\r
705}\r
706\r
707// <base dir><end>\r
708void emu_make_path(char *buff, const char *end, int size)\r
709{\r
710 int pos, end_len;\r
711\r
712 end_len = strlen(end);\r
713 pos = plat_get_root_dir(buff, size);\r
714 strncpy(buff + pos, end, size - pos);\r
715 buff[size - 1] = 0;\r
716 if (pos + end_len > size - 1)\r
717 lprintf("Warning: path truncated: %s\n", buff);\r
718}\r
719\r
720static void make_config_cfg(char *cfg_buff_512)\r
721{\r
722 emu_make_path(cfg_buff_512, PicoConfigFile, 512-6);\r
723 if (config_slot != 0)\r
724 {\r
725 char *p = strrchr(cfg_buff_512, '.');\r
726 if (p == NULL)\r
727 p = cfg_buff_512 + strlen(cfg_buff_512);\r
728 sprintf(p, ".%i.cfg", config_slot);\r
729 }\r
730 cfg_buff_512[511] = 0;\r
731}\r
732\r
733void emu_set_defconfig(void)\r
734{\r
735 memcpy(&currentConfig, &defaultConfig, sizeof(currentConfig));\r
736 PicoOpt = currentConfig.s_PicoOpt;\r
737 PsndRate = currentConfig.s_PsndRate;\r
738 PicoRegionOverride = currentConfig.s_PicoRegion;\r
739 PicoAutoRgnOrder = currentConfig.s_PicoAutoRgnOrder;\r
740 PicoCDBuffers = currentConfig.s_PicoCDBuffers;\r
741}\r
742\r
743int emu_read_config(int game, int no_defaults)\r
744{\r
745 char cfg[512];\r
746 int ret;\r
747\r
748 if (!no_defaults)\r
749 emu_set_defconfig();\r
750\r
751 if (!game)\r
752 {\r
753 make_config_cfg(cfg);\r
754 ret = config_readsect(cfg, NULL);\r
755 }\r
756 else\r
757 {\r
758 char *sect = emu_make_rom_id();\r
759\r
760 // try new .cfg way\r
761 if (config_slot != 0)\r
762 sprintf(cfg, "game.%i.cfg", config_slot);\r
763 else strcpy(cfg, "game.cfg");\r
764\r
765 ret = -1;\r
766 if (config_havesect(cfg, sect))\r
767 {\r
768 // read user's config\r
769 int vol = currentConfig.volume;\r
770 emu_set_defconfig();\r
771 ret = config_readsect(cfg, sect);\r
772 currentConfig.volume = vol; // make vol global (bah)\r
773 }\r
774 else\r
775 {\r
776 // read global config, and apply game_def.cfg on top\r
777 make_config_cfg(cfg);\r
778 config_readsect(cfg, NULL);\r
779 emu_make_path(cfg, "game_def.cfg", sizeof(cfg));\r
780 ret = config_readsect(cfg, sect);\r
781 }\r
782\r
783 if (ret == 0)\r
784 {\r
785 lprintf("loaded cfg from sect \"%s\"\n", sect);\r
786 }\r
787 }\r
788\r
789 plat_validate_config();\r
790\r
791 // some sanity checks\r
792#ifdef PSP\r
793 /* TODO: mv to plat_validate_config() */\r
794 if (currentConfig.CPUclock < 10 || currentConfig.CPUclock > 4096) currentConfig.CPUclock = 200;\r
795 if (currentConfig.gamma < -4 || currentConfig.gamma > 16) currentConfig.gamma = 0;\r
796 if (currentConfig.gamma2 < 0 || currentConfig.gamma2 > 2) currentConfig.gamma2 = 0;\r
797#endif\r
798 if (currentConfig.volume < 0 || currentConfig.volume > 99)\r
799 currentConfig.volume = 50;\r
800\r
801 if (ret == 0)\r
802 config_slot_current = config_slot;\r
803\r
804 return (ret == 0);\r
805}\r
806\r
807\r
808int emu_write_config(int is_game)\r
809{\r
810 char cfg[512], *game_sect = NULL;\r
811 int ret, write_lrom = 0;\r
812\r
813 if (!is_game)\r
814 {\r
815 make_config_cfg(cfg);\r
816 write_lrom = 1;\r
817 } else {\r
818 if (config_slot != 0)\r
819 sprintf(cfg, "game.%i.cfg", config_slot);\r
820 else strcpy(cfg, "game.cfg");\r
821 game_sect = emu_make_rom_id();\r
822 lprintf("emu_write_config: sect \"%s\"\n", game_sect);\r
823 }\r
824\r
825 lprintf("emu_write_config: %s ", cfg);\r
826 ret = config_writesect(cfg, game_sect);\r
827 if (write_lrom) config_writelrom(cfg);\r
828#ifndef NO_SYNC\r
829 sync();\r
830#endif\r
831 lprintf((ret == 0) ? "(ok)\n" : "(failed)\n");\r
832\r
833 if (ret == 0) config_slot_current = config_slot;\r
834 return ret == 0;\r
835}\r
836\r
837\r
838/* always using built-in font */\r
839\r
840#define mk_text_out(name, type, val, topleft, step_x, step_y) \\r
841void name(int x, int y, const char *text) \\r
842{ \\r
843 int i, l, len = strlen(text); \\r
844 type *screen = (type *)(topleft) + x * step_x + y * step_y; \\r
845 \\r
846 for (i = 0; i < len; i++, screen += 8 * step_x) \\r
847 { \\r
848 for (l = 0; l < 8; l++) \\r
849 { \\r
850 unsigned char fd = fontdata8x8[text[i] * 8 + l];\\r
851 type *s = screen + l * step_y; \\r
852 if (fd&0x80) s[step_x * 0] = val; \\r
853 if (fd&0x40) s[step_x * 1] = val; \\r
854 if (fd&0x20) s[step_x * 2] = val; \\r
855 if (fd&0x10) s[step_x * 3] = val; \\r
856 if (fd&0x08) s[step_x * 4] = val; \\r
857 if (fd&0x04) s[step_x * 5] = val; \\r
858 if (fd&0x02) s[step_x * 6] = val; \\r
859 if (fd&0x01) s[step_x * 7] = val; \\r
860 } \\r
861 } \\r
862}\r
863\r
864mk_text_out(emu_text_out8, unsigned char, 0xf0, g_screen_ptr, 1, g_screen_width)\r
865mk_text_out(emu_text_out16, unsigned short, 0xffff, g_screen_ptr, 1, g_screen_width)\r
866mk_text_out(emu_text_out8_rot, unsigned char, 0xf0,\r
867 (char *)g_screen_ptr + (g_screen_width - 1) * g_screen_height, -g_screen_height, 1)\r
868mk_text_out(emu_text_out16_rot, unsigned short, 0xffff,\r
869 (short *)g_screen_ptr + (g_screen_width - 1) * g_screen_height, -g_screen_height, 1)\r
870\r
871#undef mk_text_out\r
872\r
873\r
874void update_movie(void)\r
875{\r
876 int offs = Pico.m.frame_count*3 + 0x40;\r
877 if (offs+3 > movie_size) {\r
878 free(movie_data);\r
879 movie_data = 0;\r
880 emu_status_msg("END OF MOVIE.");\r
881 lprintf("END OF MOVIE.\n");\r
882 } else {\r
883 // MXYZ SACB RLDU\r
884 PicoPad[0] = ~movie_data[offs] & 0x8f; // ! SCBA RLDU\r
885 if(!(movie_data[offs] & 0x10)) PicoPad[0] |= 0x40; // C\r
886 if(!(movie_data[offs] & 0x20)) PicoPad[0] |= 0x10; // A\r
887 if(!(movie_data[offs] & 0x40)) PicoPad[0] |= 0x20; // B\r
888 PicoPad[1] = ~movie_data[offs+1] & 0x8f; // ! SCBA RLDU\r
889 if(!(movie_data[offs+1] & 0x10)) PicoPad[1] |= 0x40; // C\r
890 if(!(movie_data[offs+1] & 0x20)) PicoPad[1] |= 0x10; // A\r
891 if(!(movie_data[offs+1] & 0x40)) PicoPad[1] |= 0x20; // B\r
892 PicoPad[0] |= (~movie_data[offs+2] & 0x0A) << 8; // ! MZYX\r
893 if(!(movie_data[offs+2] & 0x01)) PicoPad[0] |= 0x0400; // X\r
894 if(!(movie_data[offs+2] & 0x04)) PicoPad[0] |= 0x0100; // Z\r
895 PicoPad[1] |= (~movie_data[offs+2] & 0xA0) << 4; // ! MZYX\r
896 if(!(movie_data[offs+2] & 0x10)) PicoPad[1] |= 0x0400; // X\r
897 if(!(movie_data[offs+2] & 0x40)) PicoPad[1] |= 0x0100; // Z\r
898 }\r
899}\r
900\r
901static int try_ropen_file(const char *fname)\r
902{\r
903 FILE *f;\r
904\r
905 f = fopen(fname, "rb");\r
906 if (f) {\r
907 fclose(f);\r
908 return 1;\r
909 }\r
910 return 0;\r
911}\r
912\r
913char *emu_get_save_fname(int load, int is_sram, int slot)\r
914{\r
915 char *saveFname = static_buff;\r
916 char ext[16];\r
917\r
918 if (is_sram)\r
919 {\r
920 strcpy(ext, (PicoAHW & PAHW_MCD) ? ".brm" : ".srm");\r
921 romfname_ext(saveFname, (PicoAHW & PAHW_MCD) ? "brm"PATH_SEP : "srm"PATH_SEP, ext);\r
922 if (!load)\r
923 return saveFname;\r
924\r
925 if (try_ropen_file(saveFname))\r
926 return saveFname;\r
927\r
928 romfname_ext(saveFname, NULL, ext);\r
929 if (try_ropen_file(saveFname))\r
930 return saveFname;\r
931 }\r
932 else\r
933 {\r
934 const char *ext_main = (currentConfig.EmuOpt & EOPT_GZIP_SAVES) ? ".mds.gz" : ".mds";\r
935 const char *ext_othr = (currentConfig.EmuOpt & EOPT_GZIP_SAVES) ? ".mds" : ".mds.gz";\r
936 ext[0] = 0;\r
937 if (slot > 0 && slot < 10)\r
938 sprintf(ext, ".%i", slot);\r
939 strcat(ext, ext_main);\r
940\r
941 if (!load) {\r
942 romfname_ext(saveFname, "mds" PATH_SEP, ext);\r
943 return saveFname;\r
944 }\r
945 else {\r
946 romfname_ext(saveFname, "mds" PATH_SEP, ext);\r
947 if (try_ropen_file(saveFname))\r
948 return saveFname;\r
949\r
950 romfname_ext(saveFname, NULL, ext);\r
951 if (try_ropen_file(saveFname))\r
952 return saveFname;\r
953\r
954 // try the other ext\r
955 ext[0] = 0;\r
956 if (slot > 0 && slot < 10)\r
957 sprintf(ext, ".%i", slot);\r
958 strcat(ext, ext_othr);\r
959\r
960 romfname_ext(saveFname, "mds"PATH_SEP, ext);\r
961 if (try_ropen_file(saveFname))\r
962 return saveFname;\r
963 }\r
964 }\r
965\r
966 return NULL;\r
967}\r
968\r
969int emu_check_save_file(int slot)\r
970{\r
971 return emu_get_save_fname(1, 0, slot) ? 1 : 0;\r
972}\r
973\r
974int emu_save_load_game(int load, int sram)\r
975{\r
976 int ret = 0;\r
977 char *saveFname;\r
978\r
979 // make save filename\r
980 saveFname = emu_get_save_fname(load, sram, state_slot);\r
981 if (saveFname == NULL) {\r
982 if (!sram)\r
983 emu_status_msg(load ? "LOAD FAILED (missing file)" : "SAVE FAILED");\r
984 return -1;\r
985 }\r
986\r
987 lprintf("saveLoad (%i, %i): %s\n", load, sram, saveFname);\r
988\r
989 if (sram)\r
990 {\r
991 FILE *sramFile;\r
992 int sram_size;\r
993 unsigned char *sram_data;\r
994 int truncate = 1;\r
995 if (PicoAHW & PAHW_MCD)\r
996 {\r
997 if (PicoOpt & POPT_EN_MCD_RAMCART) {\r
998 sram_size = 0x12000;\r
999 sram_data = SRam.data;\r
1000 if (sram_data)\r
1001 memcpy32((int *)sram_data, (int *)Pico_mcd->bram, 0x2000/4);\r
1002 } else {\r
1003 sram_size = 0x2000;\r
1004 sram_data = Pico_mcd->bram;\r
1005 truncate = 0; // the .brm may contain RAM cart data after normal brm\r
1006 }\r
1007 } else {\r
1008 sram_size = SRam.size;\r
1009 sram_data = SRam.data;\r
1010 }\r
1011 if (!sram_data) return 0; // SRam forcefully disabled for this game\r
1012\r
1013 if (load)\r
1014 {\r
1015 sramFile = fopen(saveFname, "rb");\r
1016 if(!sramFile) return -1;\r
1017 fread(sram_data, 1, sram_size, sramFile);\r
1018 fclose(sramFile);\r
1019 if ((PicoAHW & PAHW_MCD) && (PicoOpt&POPT_EN_MCD_RAMCART))\r
1020 memcpy32((int *)Pico_mcd->bram, (int *)sram_data, 0x2000/4);\r
1021 } else {\r
1022 // sram save needs some special processing\r
1023 // see if we have anything to save\r
1024 for (; sram_size > 0; sram_size--)\r
1025 if (sram_data[sram_size-1]) break;\r
1026\r
1027 if (sram_size) {\r
1028 sramFile = fopen(saveFname, truncate ? "wb" : "r+b");\r
1029 if (!sramFile) sramFile = fopen(saveFname, "wb"); // retry\r
1030 if (!sramFile) return -1;\r
1031 ret = fwrite(sram_data, 1, sram_size, sramFile);\r
1032 ret = (ret != sram_size) ? -1 : 0;\r
1033 fclose(sramFile);\r
1034#ifndef NO_SYNC\r
1035 sync();\r
1036#endif\r
1037 }\r
1038 }\r
1039 return ret;\r
1040 }\r
1041 else\r
1042 {\r
1043 ret = PicoState(saveFname, !load);\r
1044 if (!ret) {\r
1045#ifndef NO_SYNC\r
1046 if (!load) sync();\r
1047#endif\r
1048 emu_status_msg(load ? "STATE LOADED" : "STATE SAVED");\r
1049 } else {\r
1050 emu_status_msg(load ? "LOAD FAILED" : "SAVE FAILED");\r
1051 ret = -1;\r
1052 }\r
1053\r
1054 return ret;\r
1055 }\r
1056}\r
1057\r
1058void emu_set_fastforward(int set_on)\r
1059{\r
1060 static void *set_PsndOut = NULL;\r
1061 static int set_Frameskip, set_EmuOpt, is_on = 0;\r
1062\r
1063 if (set_on && !is_on) {\r
1064 set_PsndOut = PsndOut;\r
1065 set_Frameskip = currentConfig.Frameskip;\r
1066 set_EmuOpt = currentConfig.EmuOpt;\r
1067 PsndOut = NULL;\r
1068 currentConfig.Frameskip = 8;\r
1069 currentConfig.EmuOpt &= ~4;\r
1070 currentConfig.EmuOpt |= 0x40000;\r
1071 is_on = 1;\r
1072 emu_status_msg("FAST FORWARD");\r
1073 }\r
1074 else if (!set_on && is_on) {\r
1075 PsndOut = set_PsndOut;\r
1076 currentConfig.Frameskip = set_Frameskip;\r
1077 currentConfig.EmuOpt = set_EmuOpt;\r
1078 PsndRerate(1);\r
1079 is_on = 0;\r
1080 }\r
1081}\r
1082\r
1083static void emu_tray_open(void)\r
1084{\r
1085 engineState = PGS_TrayMenu;\r
1086}\r
1087\r
1088static void emu_tray_close(void)\r
1089{\r
1090 emu_status_msg("CD tray closed.");\r
1091}\r
1092\r
1093void emu_32x_startup(void)\r
1094{\r
1095 plat_video_toggle_renderer(0, 1, 0);\r
1096 system_announce();\r
1097}\r
1098\r
1099void emu_reset_game(void)\r
1100{\r
1101 PicoReset();\r
1102 reset_timing = 1;\r
1103}\r
1104\r
1105void run_events_pico(unsigned int events)\r
1106{\r
1107 int lim_x;\r
1108\r
1109 if (events & PEV_PICO_SWINP) {\r
1110 pico_inp_mode++;\r
1111 if (pico_inp_mode > 2)\r
1112 pico_inp_mode = 0;\r
1113 switch (pico_inp_mode) {\r
1114 case 2: emu_status_msg("Input: Pen on Pad"); break;\r
1115 case 1: emu_status_msg("Input: Pen on Storyware"); break;\r
1116 case 0: emu_status_msg("Input: Joystick");\r
1117 PicoPicohw.pen_pos[0] = PicoPicohw.pen_pos[1] = 0x8000;\r
1118 break;\r
1119 }\r
1120 }\r
1121 if (events & PEV_PICO_PPREV) {\r
1122 PicoPicohw.page--;\r
1123 if (PicoPicohw.page < 0)\r
1124 PicoPicohw.page = 0;\r
1125 emu_status_msg("Page %i", PicoPicohw.page);\r
1126 }\r
1127 if (events & PEV_PICO_PNEXT) {\r
1128 PicoPicohw.page++;\r
1129 if (PicoPicohw.page > 6)\r
1130 PicoPicohw.page = 6;\r
1131 emu_status_msg("Page %i", PicoPicohw.page);\r
1132 }\r
1133\r
1134 if (pico_inp_mode == 0)\r
1135 return;\r
1136\r
1137 /* handle other input modes */\r
1138 if (PicoPad[0] & 1) pico_pen_y--;\r
1139 if (PicoPad[0] & 2) pico_pen_y++;\r
1140 if (PicoPad[0] & 4) pico_pen_x--;\r
1141 if (PicoPad[0] & 8) pico_pen_x++;\r
1142 PicoPad[0] &= ~0x0f; // release UDLR\r
1143\r
1144 lim_x = (Pico.video.reg[12]&1) ? 319 : 255;\r
1145 if (pico_pen_y < 8)\r
1146 pico_pen_y = 8;\r
1147 if (pico_pen_y > 224 - PICO_PEN_ADJUST_Y)\r
1148 pico_pen_y = 224 - PICO_PEN_ADJUST_Y;\r
1149 if (pico_pen_x < 0)\r
1150 pico_pen_x = 0;\r
1151 if (pico_pen_x > lim_x - PICO_PEN_ADJUST_X)\r
1152 pico_pen_x = lim_x - PICO_PEN_ADJUST_X;\r
1153\r
1154 PicoPicohw.pen_pos[0] = pico_pen_x;\r
1155 if (!(Pico.video.reg[12] & 1))\r
1156 PicoPicohw.pen_pos[0] += pico_pen_x / 4;\r
1157 PicoPicohw.pen_pos[0] += 0x3c;\r
1158 PicoPicohw.pen_pos[1] = pico_inp_mode == 1 ? (0x2f8 + pico_pen_y) : (0x1fc + pico_pen_y);\r
1159}\r
1160\r
1161static void do_turbo(int *pad, int acts)\r
1162{\r
1163 static int turbo_pad = 0;\r
1164 static unsigned char turbo_cnt[3] = { 0, 0, 0 };\r
1165 int inc = currentConfig.turbo_rate * 2;\r
1166\r
1167 if (acts & 0x1000) {\r
1168 turbo_cnt[0] += inc;\r
1169 if (turbo_cnt[0] >= 60)\r
1170 turbo_pad ^= 0x10, turbo_cnt[0] = 0;\r
1171 }\r
1172 if (acts & 0x2000) {\r
1173 turbo_cnt[1] += inc;\r
1174 if (turbo_cnt[1] >= 60)\r
1175 turbo_pad ^= 0x20, turbo_cnt[1] = 0;\r
1176 }\r
1177 if (acts & 0x4000) {\r
1178 turbo_cnt[2] += inc;\r
1179 if (turbo_cnt[2] >= 60)\r
1180 turbo_pad ^= 0x40, turbo_cnt[2] = 0;\r
1181 }\r
1182 *pad |= turbo_pad & (acts >> 8);\r
1183}\r
1184\r
1185static void run_events_ui(unsigned int which)\r
1186{\r
1187 if (which & (PEV_STATE_LOAD|PEV_STATE_SAVE))\r
1188 {\r
1189 int do_it = 1;\r
1190 if ( emu_check_save_file(state_slot) &&\r
1191 (((which & PEV_STATE_LOAD) && (currentConfig.EmuOpt & EOPT_CONFIRM_LOAD)) ||\r
1192 ((which & PEV_STATE_SAVE) && (currentConfig.EmuOpt & EOPT_CONFIRM_SAVE))) )\r
1193 {\r
1194 const char *nm;\r
1195 char tmp[64];\r
1196 int keys, len;\r
1197\r
1198 strcpy(tmp, (which & PEV_STATE_LOAD) ? "LOAD STATE?" : "OVERWRITE SAVE?");\r
1199 len = strlen(tmp);\r
1200 nm = in_get_key_name(-1, -PBTN_MA3);\r
1201 snprintf(tmp + len, sizeof(tmp) - len, "(%s=yes, ", nm);\r
1202 len = strlen(tmp);\r
1203 nm = in_get_key_name(-1, -PBTN_MBACK);\r
1204 snprintf(tmp + len, sizeof(tmp) - len, "%s=no)", nm);\r
1205\r
1206 plat_status_msg_busy_first(tmp);\r
1207\r
1208 in_set_blocking(1);\r
1209 while (in_menu_wait_any(50) & (PBTN_MA3|PBTN_MBACK))\r
1210 ;\r
1211 while ( !((keys = in_menu_wait_any(50)) & (PBTN_MA3|PBTN_MBACK)) )\r
1212 ;\r
1213 if (keys & PBTN_MBACK)\r
1214 do_it = 0;\r
1215 while (in_menu_wait_any(50) & (PBTN_MA3|PBTN_MBACK))\r
1216 ;\r
1217 in_set_blocking(0);\r
1218 }\r
1219 if (do_it) {\r
1220 plat_status_msg_busy_first((which & PEV_STATE_LOAD) ? "LOADING STATE" : "SAVING STATE");\r
1221 PicoStateProgressCB = plat_status_msg_busy_next;\r
1222 emu_save_load_game((which & PEV_STATE_LOAD) ? 1 : 0, 0);\r
1223 PicoStateProgressCB = NULL;\r
1224 }\r
1225 }\r
1226 if ((which & PEV_SWITCH_RND) && !(PicoAHW & PAHW_32X))\r
1227 {\r
1228 plat_video_toggle_renderer(1, 0, 0);\r
1229 }\r
1230 if (which & (PEV_SSLOT_PREV|PEV_SSLOT_NEXT))\r
1231 {\r
1232 if (which & PEV_SSLOT_PREV) {\r
1233 state_slot -= 1;\r
1234 if (state_slot < 0)\r
1235 state_slot = 9;\r
1236 } else {\r
1237 state_slot += 1;\r
1238 if (state_slot > 9)\r
1239 state_slot = 0;\r
1240 }\r
1241\r
1242 emu_status_msg("SAVE SLOT %i [%s]", state_slot,\r
1243 emu_check_save_file(state_slot) ? "USED" : "FREE");\r
1244 }\r
1245 if (which & PEV_MENU)\r
1246 engineState = PGS_Menu;\r
1247}\r
1248\r
1249void emu_update_input(void)\r
1250{\r
1251 static int prev_events = 0;\r
1252 int actions[IN_BINDTYPE_COUNT] = { 0, };\r
1253 int pl_actions[2];\r
1254 int events;\r
1255\r
1256 in_update(actions);\r
1257\r
1258 pl_actions[0] = actions[IN_BINDTYPE_PLAYER12];\r
1259 pl_actions[1] = actions[IN_BINDTYPE_PLAYER12] >> 16;\r
1260\r
1261 PicoPad[0] = pl_actions[0] & 0xfff;\r
1262 PicoPad[1] = pl_actions[1] & 0xfff;\r
1263\r
1264 if (pl_actions[0] & 0x7000)\r
1265 do_turbo(&PicoPad[0], pl_actions[0]);\r
1266 if (pl_actions[1] & 0x7000)\r
1267 do_turbo(&PicoPad[1], pl_actions[1]);\r
1268\r
1269 events = actions[IN_BINDTYPE_EMU] & PEV_MASK;\r
1270\r
1271 // volume is treated in special way and triggered every frame\r
1272 if (events & (PEV_VOL_DOWN|PEV_VOL_UP))\r
1273 plat_update_volume(1, events & PEV_VOL_UP);\r
1274\r
1275 if ((events ^ prev_events) & PEV_FF) {\r
1276 emu_set_fastforward(events & PEV_FF);\r
1277 plat_update_volume(0, 0);\r
1278 reset_timing = 1;\r
1279 }\r
1280\r
1281 events &= ~prev_events;\r
1282\r
1283 if (PicoAHW == PAHW_PICO)\r
1284 run_events_pico(events);\r
1285 if (events)\r
1286 run_events_ui(events);\r
1287 if (movie_data)\r
1288 update_movie();\r
1289\r
1290 prev_events = actions[IN_BINDTYPE_EMU] & PEV_MASK;\r
1291}\r
1292\r
1293static void mkdir_path(char *path_with_reserve, int pos, const char *name)\r
1294{\r
1295 strcpy(path_with_reserve + pos, name);\r
1296 if (plat_is_dir(path_with_reserve))\r
1297 return;\r
1298 if (mkdir(path_with_reserve, 0777) < 0)\r
1299 lprintf("failed to create: %s\n", path_with_reserve);\r
1300}\r
1301\r
1302void emu_init(void)\r
1303{\r
1304 char path[512];\r
1305 int pos;\r
1306\r
1307#if 0\r
1308 // FIXME: handle through menu, etc\r
1309 FILE *f;\r
1310 f = fopen("32X_M_BIOS.BIN", "rb");\r
1311 p32x_bios_m = malloc(2048);\r
1312 fread(p32x_bios_m, 1, 2048, f);\r
1313 fclose(f);\r
1314 f = fopen("32X_S_BIOS.BIN", "rb");\r
1315 p32x_bios_s = malloc(1024);\r
1316 fread(p32x_bios_s, 1, 1024, f);\r
1317 fclose(f);\r
1318#endif\r
1319\r
1320 /* make dirs for saves */\r
1321 pos = plat_get_root_dir(path, sizeof(path) - 4);\r
1322 mkdir_path(path, pos, "mds");\r
1323 mkdir_path(path, pos, "srm");\r
1324 mkdir_path(path, pos, "brm");\r
1325\r
1326 make_config_cfg(path);\r
1327 config_readlrom(path);\r
1328\r
1329 PicoInit();\r
1330 PicoMessage = plat_status_msg_busy_next;\r
1331 PicoMCDopenTray = emu_tray_open;\r
1332 PicoMCDcloseTray = emu_tray_close;\r
1333}\r
1334\r
1335void emu_finish(void)\r
1336{\r
1337 // save SRAM\r
1338 if ((currentConfig.EmuOpt & EOPT_EN_SRAM) && SRam.changed) {\r
1339 emu_save_load_game(0, 1);\r
1340 SRam.changed = 0;\r
1341 }\r
1342\r
1343 if (!(currentConfig.EmuOpt & EOPT_NO_AUTOSVCFG)) {\r
1344 char cfg[512];\r
1345 make_config_cfg(cfg);\r
1346 config_writelrom(cfg);\r
1347#ifndef NO_SYNC\r
1348 sync();\r
1349#endif\r
1350 }\r
1351\r
1352 PicoExit();\r
1353}\r
1354\r
1355static void skip_frame(int do_audio)\r
1356{\r
1357 PicoSkipFrame = do_audio ? 1 : 2;\r
1358 PicoFrame();\r
1359 PicoSkipFrame = 0;\r
1360}\r
1361\r
1362/* our tick here is 1 us right now */\r
1363#define ms_to_ticks(x) (unsigned int)(x * 1000)\r
1364#define get_ticks() plat_get_ticks_us()\r
1365\r
1366void emu_loop(void)\r
1367{\r
1368 int pframes_done; /* "period" frames, used for sync */\r
1369 int frames_done, frames_shown; /* actual frames for fps counter */\r
1370 int target_fps, target_frametime;\r
1371 unsigned int timestamp_base = 0, timestamp_fps;\r
1372 char *notice_msg = NULL;\r
1373 char fpsbuff[24];\r
1374 int i;\r
1375\r
1376 fpsbuff[0] = 0;\r
1377\r
1378 /* make sure we are in correct mode */\r
1379 Pico.m.dirtyPal = 1;\r
1380 rendstatus_old = -1;\r
1381\r
1382 /* number of ticks per frame */\r
1383 if (Pico.m.pal) {\r
1384 target_fps = 50;\r
1385 target_frametime = ms_to_ticks(1000) / 50;\r
1386 } else {\r
1387 target_fps = 60;\r
1388 target_frametime = ms_to_ticks(1000) / 60 + 1;\r
1389 }\r
1390\r
1391 // prepare CD buffer\r
1392 if (PicoAHW & PAHW_MCD)\r
1393 PicoCDBufferInit();\r
1394 PicoLoopPrepare();\r
1395\r
1396 pemu_loop_prep();\r
1397\r
1398 timestamp_fps = get_ticks();\r
1399 reset_timing = 1;\r
1400\r
1401 frames_done = frames_shown = pframes_done = 0;\r
1402\r
1403 plat_video_wait_vsync();\r
1404\r
1405 /* loop with resync every 1 sec. */\r
1406 while (engineState == PGS_Running)\r
1407 {\r
1408 unsigned int timestamp;\r
1409 int diff, diff_lim;\r
1410\r
1411 timestamp = get_ticks();\r
1412 if (reset_timing) {\r
1413 reset_timing = 0;\r
1414 timestamp_base = timestamp;\r
1415 pframes_done = 0;\r
1416 }\r
1417\r
1418 // show notice_msg message?\r
1419 if (notice_msg_time != 0)\r
1420 {\r
1421 static int noticeMsgSum;\r
1422 if (timestamp - ms_to_ticks(notice_msg_time) > ms_to_ticks(STATUS_MSG_TIMEOUT)) {\r
1423 notice_msg_time = 0;\r
1424 plat_status_msg_clear();\r
1425 notice_msg = NULL;\r
1426 } else {\r
1427 int sum = noticeMsg[0] + noticeMsg[1] + noticeMsg[2];\r
1428 if (sum != noticeMsgSum) {\r
1429 plat_status_msg_clear();\r
1430 noticeMsgSum = sum;\r
1431 }\r
1432 notice_msg = noticeMsg;\r
1433 }\r
1434 }\r
1435\r
1436 // second changed?\r
1437 if (timestamp - timestamp_fps >= ms_to_ticks(1000))\r
1438 {\r
1439#ifdef BENCHMARK\r
1440 static int bench = 0, bench_fps = 0, bench_fps_s = 0, bfp = 0, bf[4];\r
1441 if (++bench == 10) {\r
1442 bench = 0;\r
1443 bench_fps_s = bench_fps;\r
1444 bf[bfp++ & 3] = bench_fps;\r
1445 bench_fps = 0;\r
1446 }\r
1447 bench_fps += frames_shown;\r
1448 sprintf(fpsbuff, "%02i/%02i/%02i", frames_shown, bench_fps_s, (bf[0]+bf[1]+bf[2]+bf[3])>>2);\r
1449#else\r
1450 if (currentConfig.EmuOpt & EOPT_SHOW_FPS) {\r
1451 sprintf(fpsbuff, "%02i/%02i", frames_shown, frames_done);\r
1452 if (fpsbuff[5] == 0) { fpsbuff[5] = fpsbuff[6] = ' '; fpsbuff[7] = 0; }\r
1453 }\r
1454#endif\r
1455 frames_shown = frames_done = 0;\r
1456 timestamp_fps += ms_to_ticks(1000);\r
1457 }\r
1458#ifdef PFRAMES\r
1459 sprintf(fpsbuff, "%i", Pico.m.frame_count);\r
1460#endif\r
1461\r
1462 if (timestamp - timestamp_base >= ms_to_ticks(1000))\r
1463 {\r
1464 if ((currentConfig.EmuOpt & EOPT_NO_FRMLIMIT) && currentConfig.Frameskip >= 0)\r
1465 pframes_done = 0;\r
1466 else {\r
1467 pframes_done -= target_fps;\r
1468 /* don't allow it to drift during heavy slowdowns */\r
1469 if (pframes_done < -5) {\r
1470 reset_timing = 1;\r
1471 continue;\r
1472 }\r
1473 if (pframes_done < -2)\r
1474 pframes_done = -2;\r
1475 }\r
1476 timestamp_base += ms_to_ticks(1000);\r
1477 }\r
1478\r
1479 diff = timestamp - timestamp_base;\r
1480 diff_lim = (pframes_done + 1) * target_frametime;\r
1481\r
1482 if (currentConfig.Frameskip >= 0) // frameskip enabled\r
1483 {\r
1484 for (i = 0; i < currentConfig.Frameskip; i++) {\r
1485 emu_update_input();\r
1486 skip_frame(1);\r
1487 pframes_done++; frames_done++;\r
1488 diff_lim += target_frametime;\r
1489\r
1490 if (!(currentConfig.EmuOpt & (EOPT_NO_FRMLIMIT|EOPT_EXT_FRMLIMIT))) {\r
1491 timestamp = get_ticks();\r
1492 diff = timestamp - timestamp_base;\r
1493 if (!reset_timing && diff < diff_lim) // we are too fast\r
1494 plat_wait_till_us(timestamp_base + diff_lim);\r
1495 }\r
1496 }\r
1497 }\r
1498 else if (diff > diff_lim)\r
1499 {\r
1500 /* no time left for this frame - skip */\r
1501 if (diff - diff_lim >= ms_to_ticks(200)) {\r
1502 /* if too much behind, reset instead */\r
1503 reset_timing = 1;\r
1504 continue;\r
1505 }\r
1506 emu_update_input();\r
1507 skip_frame(diff < diff_lim + target_frametime * 2);\r
1508 pframes_done++; frames_done++;\r
1509 continue;\r
1510 }\r
1511\r
1512 emu_update_input();\r
1513 PicoFrame();\r
1514\r
1515 /* frame limiter */\r
1516 if (!reset_timing && !(currentConfig.EmuOpt & (EOPT_NO_FRMLIMIT|EOPT_EXT_FRMLIMIT)))\r
1517 {\r
1518 timestamp = get_ticks();\r
1519 diff = timestamp - timestamp_base;\r
1520\r
1521 // sleep or vsync if we are still too fast\r
1522 if (diff < diff_lim)\r
1523 {\r
1524 // we are too fast\r
1525 plat_wait_till_us(timestamp_base + diff_lim - target_frametime / 4);\r
1526 if (currentConfig.EmuOpt & EOPT_VSYNC)\r
1527 plat_video_wait_vsync();\r
1528 }\r
1529 }\r
1530\r
1531 pemu_update_display(fpsbuff, notice_msg);\r
1532\r
1533 pframes_done++; frames_done++; frames_shown++;\r
1534 }\r
1535\r
1536 emu_set_fastforward(0);\r
1537\r
1538 // save SRAM\r
1539 if ((currentConfig.EmuOpt & EOPT_EN_SRAM) && SRam.changed) {\r
1540 plat_status_msg_busy_first("Writing SRAM/BRAM...");\r
1541 emu_save_load_game(0, 1);\r
1542 SRam.changed = 0;\r
1543 }\r
1544\r
1545 pemu_loop_end();\r
1546\r
1547 // pemu_loop_end() might want to do 1 frame for bg image,\r
1548 // so free CD buffer here\r
1549 if (PicoAHW & PAHW_MCD)\r
1550 PicoCDBufferFree();\r
1551}\r
1552\r
fast MegaDrive/MegaCD/32X emulator