common/config.c

   1 /*
   2  * Human-readable config file management for PicoDrive
   3  * (c) notaz, 2008
   4  */
   5
   6 #include <stdio.h>
   7 #include <string.h>
   8 #include <stdlib.h>
   9 #ifdef __EPOC32__
  10 #include <unistd.h>
  11 #endif
  12 #include "config.h"
  13 #include "input.h"
  14 #include "lprintf.h"
  15
  16 static char *mystrip(char *str);
  17
  18 #ifndef _MSC_VER
  19
  20 #include "menu.h"
  21 #include "emu.h"
  22 #include <pico/pico.h>
  23
  24 // always output DOS endlines
  25 #ifdef _WIN32
  26 #define NL "\n"
  27 #else
  28 #define NL "\r\n"
  29 #endif
  30
  31 static int seek_sect(FILE *f, const char *section)
  32 {
  33         char line[128], *tmp;
  34         int len;
  35
  36         len = strlen(section);
  37         // seek to the section needed
  38         while (!feof(f))
  39         {
  40                 tmp = fgets(line, sizeof(line), f);
  41                 if (tmp == NULL) break;
  42
  43                 if (line[0] != '[') continue; // not section start
  44                 if (strncmp(line + 1, section, len) == 0 && line[len+1] == ']')
  45                         return 1; // found it
  46         }
  47
  48         return 0;
  49 }
  50
  51
  52 static void custom_write(FILE *f, const menu_entry *me, int no_def)
  53 {
  54         char str24[24];
  55
  56         switch (me->id)
  57         {
  58                 /* TODO: this should be rm'd when PSP menu is converted */
  59                 case MA_OPT3_SCALE:
  60                         if (no_def && defaultConfig.scale == currentConfig.scale) return;
  61                         fprintf(f, "Scale factor = %.2f", currentConfig.scale);
  62                         break;
  63                 case MA_OPT3_HSCALE32:
  64                         if (no_def && defaultConfig.hscale32 == currentConfig.hscale32) return;
  65                         fprintf(f, "Hor. scale (for low res. games) = %.2f", currentConfig.hscale32);
  66                         break;
  67                 case MA_OPT3_HSCALE40:
  68                         if (no_def && defaultConfig.hscale40 == currentConfig.hscale40) return;
  69                         fprintf(f, "Hor. scale (for hi res. games) = %.2f", currentConfig.hscale40);
  70                         break;
  71                 case MA_OPT3_FILTERING:
  72                         if (no_def && defaultConfig.scaling == currentConfig.scaling) return;
  73                         fprintf(f, "Bilinear filtering = %i", currentConfig.scaling);
  74                         break;
  75                 case MA_OPT3_GAMMAA:
  76                         if (no_def && defaultConfig.gamma == currentConfig.gamma) return;
  77                         fprintf(f, "Gamma adjustment = %i", currentConfig.gamma);
  78                         break;
  79                 case MA_OPT3_BLACKLVL:
  80                         if (no_def && defaultConfig.gamma2 == currentConfig.gamma2) return;
  81                         fprintf(f, "Black level = %i", currentConfig.gamma2);
  82                         break;
  83                 case MA_OPT3_VSYNC:
  84                         if (no_def && (defaultConfig.EmuOpt&0x12000) == (currentConfig.gamma2&0x12000)) return;
  85                         strcpy(str24, "never");
  86                         if (currentConfig.EmuOpt & 0x2000)
  87                                 strcpy(str24, (currentConfig.EmuOpt & 0x10000) ? "sometimes" : "always");
  88                         fprintf(f, "Wait for vsync = %s", str24);
  89                         break;
  90
  91                 default:
  92                         lprintf("unhandled custom_write: %i\n", me->id);
  93                         return;
  94         }
  95         fprintf(f, NL);
  96 }
  97
  98
  99 static void keys_write(FILE *fn, const char *bind_str, int dev_id, const int *binds, int no_defaults)
 100 {
 101         char act[48];
 102         int key_count, k, i;
 103         const int *def_binds;
 104
 105         key_count = in_get_dev_info(dev_id, IN_INFO_BIND_COUNT);
 106         def_binds = in_get_dev_def_binds(dev_id);
 107
 108         for (k = 0; k < key_count; k++)
 109         {
 110                 const char *name;
 111                 int t, mask;
 112                 act[0] = act[31] = 0;
 113
 114                 for (t = 0; t < IN_BINDTYPE_COUNT; t++)
 115                         if (binds[IN_BIND_OFFS(k, t)] != def_binds[IN_BIND_OFFS(k, t)])
 116                                 break;
 117
 118                 if (no_defaults && t == IN_BINDTYPE_COUNT)
 119                         continue;       /* no change from defaults */
 120
 121                 name = in_get_key_name(dev_id, k);
 122
 123                 for (t = 0; t < IN_BINDTYPE_COUNT; t++)
 124                         if (binds[IN_BIND_OFFS(k, t)] != 0 || def_binds[IN_BIND_OFFS(k, t)] == 0)
 125                                 break;
 126
 127                 if (t == IN_BINDTYPE_COUNT) {
 128                         /* key has default bind removed */
 129                         fprintf(fn, "%s %s =" NL, bind_str, name);
 130                         continue;
 131                 }
 132
 133                 for (i = 0; i < sizeof(me_ctrl_actions) / sizeof(me_ctrl_actions[0]); i++) {
 134                         mask = me_ctrl_actions[i].mask;
 135                         if (mask & binds[IN_BIND_OFFS(k, IN_BINDTYPE_PLAYER12)]) {
 136                                 strncpy(act, me_ctrl_actions[i].name, 31);
 137                                 fprintf(fn, "%s %s = player1 %s" NL, bind_str, name, mystrip(act));
 138                         }
 139                         mask = me_ctrl_actions[i].mask << 16;
 140                         if (mask & binds[IN_BIND_OFFS(k, IN_BINDTYPE_PLAYER12)]) {
 141                                 strncpy(act, me_ctrl_actions[i].name, 31);
 142                                 fprintf(fn, "%s %s = player2 %s" NL, bind_str, name, mystrip(act));
 143                         }
 144                 }
 145
 146                 for (i = 0; emuctrl_actions[i].name != NULL; i++) {
 147                         mask = emuctrl_actions[i].mask;
 148                         if (mask & binds[IN_BIND_OFFS(k, IN_BINDTYPE_EMU)]) {
 149                                 strncpy(act, emuctrl_actions[i].name, 31);
 150                                 fprintf(fn, "%s %s = %s" NL, bind_str, name, mystrip(act));
 151                         }
 152                 }
 153         }
 154 }
 155
 156 /* XXX: this should go to menu structures instead */
 157 static int default_var(const menu_entry *me)
 158 {
 159         switch (me->id)
 160         {
 161                 case MA_OPT2_ENABLE_YM2612:
 162                 case MA_OPT2_ENABLE_SN76496:
 163                 case MA_OPT2_ENABLE_Z80:
 164                 case MA_OPT_6BUTTON_PAD:
 165                 case MA_OPT_ACC_SPRITES:
 166                 case MA_OPT_ARM940_SOUND:
 167                 case MA_CDOPT_PCM:
 168                 case MA_CDOPT_CDDA:
 169                 case MA_CDOPT_SCALEROT_CHIP:
 170                 case MA_CDOPT_BETTER_SYNC:
 171                 case MA_CDOPT_SAVERAM:
 172                 case MA_OPT2_SVP_DYNAREC:
 173                 case MA_OPT2_NO_SPRITE_LIM:
 174                 case MA_OPT2_NO_IDLE_LOOPS:
 175                         return defaultConfig.s_PicoOpt;
 176
 177                 case MA_OPT_SRAM_STATES:
 178                 case MA_OPT_SHOW_FPS:
 179                 case MA_OPT_ENABLE_SOUND:
 180                 case MA_OPT2_GZIP_STATES:
 181                 case MA_OPT2_SQUIDGEHACK:
 182                 case MA_OPT2_NO_LAST_ROM:
 183                 case MA_OPT2_RAMTIMINGS:
 184                 case MA_CDOPT_LEDS:
 185                 case MA_OPT2_A_SN_GAMMA:
 186                 case MA_OPT2_VSYNC:
 187                 case MA_OPT_INTERLACED:
 188                 case MA_OPT2_DBLBUFF:
 189                 case MA_OPT2_STATUS_LINE:
 190                 case MA_OPT2_NO_FRAME_LIMIT:
 191                 case MA_OPT_TEARING_FIX:
 192                         return defaultConfig.EmuOpt;
 193
 194                 case MA_CTRL_TURBO_RATE: return defaultConfig.turbo_rate;
 195                 case MA_OPT_SCALING:     return defaultConfig.scaling;
 196                 case MA_OPT_ROTATION:    return defaultConfig.rotation;
 197                 case MA_OPT2_GAMMA:      return defaultConfig.gamma;
 198                 case MA_OPT_FRAMESKIP:   return defaultConfig.Frameskip;
 199                 case MA_OPT_CPU_CLOCKS:  return defaultConfig.CPUclock;
 200
 201                 case MA_OPT_SAVE_SLOT:
 202                 default:
 203                         return 0;
 204         }
 205 }
 206
 207 static int is_cust_val_default(const menu_entry *me)
 208 {
 209         switch (me->id)
 210         {
 211                 case MA_OPT_REGION:
 212                         return defaultConfig.s_PicoRegion == PicoRegionOverride &&
 213                                 defaultConfig.s_PicoAutoRgnOrder == PicoAutoRgnOrder;
 214                 case MA_OPT_SOUND_QUALITY:
 215                         return defaultConfig.s_PsndRate == PsndRate &&
 216                                 ((defaultConfig.s_PicoOpt ^ PicoOpt) & POPT_EN_STEREO) == 0;
 217                 case MA_OPT_CONFIRM_STATES:
 218                         return !((defaultConfig.EmuOpt ^ currentConfig.EmuOpt) &
 219                                 (EOPT_CONFIRM_LOAD|EOPT_CONFIRM_SAVE)) == 0;
 220                 case MA_OPT_RENDERER:
 221                         return ((defaultConfig.s_PicoOpt ^ PicoOpt) & POPT_ALT_RENDERER) == 0 &&
 222                                 ((defaultConfig.EmuOpt ^ currentConfig.EmuOpt) & EOPT_16BPP) == 0;
 223                 case MA_CDOPT_READAHEAD:
 224                         return defaultConfig.s_PicoCDBuffers == PicoCDBuffers;
 225                 default:break;
 226         }
 227
 228         lprintf("is_cust_val_default: unhandled id %i\n", me->id);
 229         return 0;
 230 }
 231
 232 int config_writesect(const char *fname, const char *section)
 233 {
 234         FILE *fo = NULL, *fn = NULL; // old and new
 235         int no_defaults = 0; // avoid saving defaults
 236         menu_entry *me;
 237         int t, tlen, ret;
 238         char line[128], *tmp;
 239
 240         if (section != NULL)
 241         {
 242                 no_defaults = 1;
 243
 244                 fo = fopen(fname, "r");
 245                 if (fo == NULL) {
 246                         fn = fopen(fname, "w");
 247                         goto write;
 248                 }
 249
 250                 ret = seek_sect(fo, section);
 251                 if (!ret) {
 252                         // sect not found, we can simply append
 253                         fclose(fo); fo = NULL;
 254                         fn = fopen(fname, "a");
 255                         goto write;
 256                 }
 257
 258                 // use 2 files..
 259                 fclose(fo);
 260                 rename(fname, "tmp.cfg");
 261                 fo = fopen("tmp.cfg", "r");
 262                 fn = fopen(fname, "w");
 263                 if (fo == NULL || fn == NULL) goto write;
 264
 265                 // copy everything until sect
 266                 tlen = strlen(section);
 267                 while (!feof(fo))
 268                 {
 269                         tmp = fgets(line, sizeof(line), fo);
 270                         if (tmp == NULL) break;
 271
 272                         if (line[0] == '[' && strncmp(line + 1, section, tlen) == 0 && line[tlen+1] == ']')
 273                                 break;
 274                         fputs(line, fn);
 275                 }
 276
 277                 // now skip to next sect
 278                 while (!feof(fo))
 279                 {
 280                         tmp = fgets(line, sizeof(line), fo);
 281                         if (tmp == NULL) break;
 282                         if (line[0] == '[') {
 283                                 fseek(fo, -strlen(line), SEEK_CUR);
 284                                 break;
 285                         }
 286                 }
 287                 if (feof(fo))
 288                 {
 289                         fclose(fo); fo = NULL;
 290                         remove("tmp.cfg");
 291                 }
 292         }
 293         else
 294         {
 295                 fn = fopen(fname, "w");
 296         }
 297
 298 write:
 299         if (fn == NULL) {
 300                 if (fo) fclose(fo);
 301                 return -1;
 302         }
 303         if (section != NULL)
 304                 fprintf(fn, "[%s]" NL, section);
 305
 306         me = me_list_get_first();
 307         while (me != NULL)
 308         {
 309                 int dummy;
 310                 if (!me->need_to_save)
 311                         goto next;
 312                 if (me->beh == MB_OPT_ONOFF || me->beh == MB_OPT_CUSTONOFF) {
 313                         if (!no_defaults || ((*(int *)me->var ^ default_var(me)) & me->mask))
 314                                 fprintf(fn, "%s = %i" NL, me->name, (*(int *)me->var & me->mask) ? 1 : 0);
 315                 } else if (me->beh == MB_OPT_RANGE || me->beh == MB_OPT_CUSTRANGE) {
 316                         if (!no_defaults || (*(int *)me->var ^ default_var(me)))
 317                                 fprintf(fn, "%s = %i" NL, me->name, *(int *)me->var);
 318                 } else if (me->name != NULL && me->generate_name != NULL) {
 319                         if (!no_defaults || !is_cust_val_default(me)) {
 320                                 strncpy(line, me->generate_name(0, &dummy), sizeof(line));
 321                                 line[sizeof(line) - 1] = 0;
 322                                 mystrip(line);
 323                                 fprintf(fn, "%s = %s" NL, me->name, line);
 324                         }
 325                 } else
 326                         custom_write(fn, me, no_defaults);
 327 next:
 328                 me = me_list_get_next();
 329         }
 330
 331         /* input: save device names */
 332         for (t = 0; t < IN_MAX_DEVS; t++)
 333         {
 334                 const int  *binds = in_get_dev_binds(t);
 335                 const char *name =  in_get_dev_name(t, 0, 0);
 336                 if (binds == NULL || name == NULL)
 337                         continue;
 338
 339                 fprintf(fn, "input%d = %s" NL, t, name);
 340         }
 341
 342         /* input: save binds */
 343         for (t = 0; t < IN_MAX_DEVS; t++)
 344         {
 345                 const int *binds = in_get_dev_binds(t);
 346                 const char *name = in_get_dev_name(t, 0, 0);
 347                 char strbind[16];
 348                 int count;
 349
 350                 if (binds == NULL || name == NULL)
 351                         continue;
 352
 353                 sprintf(strbind, "bind%d", t);
 354                 if (t == 0) strbind[4] = 0;
 355
 356                 count = in_get_dev_info(t, IN_INFO_BIND_COUNT);
 357                 keys_write(fn, strbind, t, binds, no_defaults);
 358         }
 359
 360 #ifndef PSP
 361         if (section == NULL)
 362                 fprintf(fn, "Sound Volume = %i" NL, currentConfig.volume);
 363 #endif
 364
 365         fprintf(fn, NL);
 366
 367         if (fo != NULL)
 368         {
 369                 // copy whatever is left
 370                 while (!feof(fo))
 371                 {
 372                         tmp = fgets(line, sizeof(line), fo);
 373                         if (tmp == NULL) break;
 374
 375                         fputs(line, fn);
 376                 }
 377                 fclose(fo);
 378                 remove("tmp.cfg");
 379         }
 380
 381         fclose(fn);
 382         return 0;
 383 }
 384
 385
 386 int config_writelrom(const char *fname)
 387 {
 388         char line[128], *tmp, *optr = NULL;
 389         char *old_data = NULL;
 390         int size;
 391         FILE *f;
 392
 393         if (strlen(rom_fname_loaded) == 0) return -1;
 394
 395         f = fopen(fname, "r");
 396         if (f != NULL)
 397         {
 398                 fseek(f, 0, SEEK_END);
 399                 size = ftell(f);
 400                 fseek(f, 0, SEEK_SET);
 401                 old_data = malloc(size + size/8);
 402                 if (old_data != NULL)
 403                 {
 404                         optr = old_data;
 405                         while (!feof(f))
 406                         {
 407                                 tmp = fgets(line, sizeof(line), f);
 408                                 if (tmp == NULL) break;
 409                                 mystrip(line);
 410                                 if (strncasecmp(line, "LastUsedROM", 11) == 0)
 411                                         continue;
 412                                 sprintf(optr, "%s", line);
 413                                 optr += strlen(optr);
 414                         }
 415                 }
 416                 fclose(f);
 417         }
 418
 419         f = fopen(fname, "w");
 420         if (f == NULL) return -1;
 421
 422         if (old_data != NULL) {
 423                 fwrite(old_data, 1, optr - old_data, f);
 424                 free(old_data);
 425         }
 426         fprintf(f, "LastUsedROM = %s" NL, rom_fname_loaded);
 427         fclose(f);
 428         return 0;
 429 }
 430
 431 /* --------------------------------------------------------------------------*/
 432
 433 int config_readlrom(const char *fname)
 434 {
 435         char line[128], *tmp;
 436         int i, len, ret = -1;
 437         FILE *f;
 438
 439         f = fopen(fname, "r");
 440         if (f == NULL) return -1;
 441
 442         // seek to the section needed
 443         while (!feof(f))
 444         {
 445                 tmp = fgets(line, sizeof(line), f);
 446                 if (tmp == NULL) break;
 447
 448                 if (strncasecmp(line, "LastUsedROM", 11) != 0) continue;
 449                 len = strlen(line);
 450                 for (i = 0; i < len; i++)
 451                         if (line[i] == '#' || line[i] == '\r' || line[i] == '\n') { line[i] = 0; break; }
 452                 tmp = strchr(line, '=');
 453                 if (tmp == NULL) break;
 454                 tmp++;
 455                 mystrip(tmp);
 456
 457                 len = sizeof(rom_fname_loaded);
 458                 strncpy(rom_fname_loaded, tmp, len);
 459                 rom_fname_loaded[len-1] = 0;
 460                 ret = 0;
 461                 break;
 462         }
 463         fclose(f);
 464         return ret;
 465 }
 466
 467
 468 static int custom_read(menu_entry *me, const char *var, const char *val)
 469 {
 470         char *tmp;
 471         int tmpi;
 472
 473         switch (me->id)
 474         {
 475                 case MA_OPT_RENDERER:
 476                         if (strcasecmp(var, "Renderer") != 0) return 0;
 477                         if      (strcasecmp(val, "8bit fast") == 0 || strcasecmp(val, "fast") == 0) {
 478                                 PicoOpt |=  POPT_ALT_RENDERER;
 479                         }
 480                         else if (strcasecmp(val, "16bit accurate") == 0 || strcasecmp(val, "accurate") == 0) {
 481                                 PicoOpt &= ~POPT_ALT_RENDERER;
 482                                 currentConfig.EmuOpt |=  0x80;
 483                         }
 484                         else if (strcasecmp(val, "8bit accurate") == 0) {
 485                                 PicoOpt &= ~POPT_ALT_RENDERER;
 486                                 currentConfig.EmuOpt &= ~0x80;
 487                         }
 488                         else
 489                                 return 0;
 490                         return 1;
 491
 492                 case MA_OPT_SCALING:
 493 #ifdef __GP2X__
 494                         if (strcasecmp(var, "Scaling") != 0) return 0;
 495                         if        (strcasecmp(val, "OFF") == 0) {
 496                                 currentConfig.scaling = EOPT_SCALE_NONE;
 497                         } else if (strcasecmp(val, "hw horizontal") == 0) {
 498                                 currentConfig.scaling = EOPT_SCALE_HW_H;
 499                         } else if (strcasecmp(val, "hw horiz. + vert.") == 0) {
 500                                 currentConfig.scaling = EOPT_SCALE_HW_HV;
 501                         } else if (strcasecmp(val, "sw horizontal") == 0) {
 502                                 currentConfig.scaling = EOPT_SCALE_SW_H;
 503                         } else
 504                                 currentConfig.scaling = atoi(val);
 505                         return 1;
 506 #else
 507                         return 0;
 508 #endif
 509
 510                 case MA_OPT_FRAMESKIP:
 511                         if (strcasecmp(var, "Frameskip") != 0) return 0;
 512                         if (strcasecmp(val, "Auto") == 0)
 513                              currentConfig.Frameskip = -1;
 514                         else currentConfig.Frameskip = atoi(val);
 515                         return 1;
 516
 517                 case MA_OPT_SOUND_QUALITY:
 518                         if (strcasecmp(var, "Sound Quality") != 0) return 0;
 519                         PsndRate = strtoul(val, &tmp, 10);
 520                         if (PsndRate < 8000 || PsndRate > 44100)
 521                                 PsndRate = 22050;
 522                         if (*tmp == 'H' || *tmp == 'h') tmp++;
 523                         if (*tmp == 'Z' || *tmp == 'z') tmp++;
 524                         while (*tmp == ' ') tmp++;
 525                         if        (strcasecmp(tmp, "stereo") == 0) {
 526                                 PicoOpt |=  POPT_EN_STEREO;
 527                         } else if (strcasecmp(tmp, "mono") == 0) {
 528                                 PicoOpt &= ~POPT_EN_STEREO;
 529                         } else
 530                                 return 0;
 531                         return 1;
 532
 533                 case MA_OPT_REGION:
 534                         if (strcasecmp(var, "Region") != 0) return 0;
 535                         if       (strncasecmp(val, "Auto: ", 6) == 0)
 536                         {
 537                                 const char *p = val + 5, *end = val + strlen(val);
 538                                 int i;
 539                                 PicoRegionOverride = PicoAutoRgnOrder = 0;
 540                                 for (i = 0; p < end && i < 3; i++)
 541                                 {
 542                                         while (*p == ' ') p++;
 543                                         if        (p[0] == 'J' && p[1] == 'P') {
 544                                                 PicoAutoRgnOrder |= 1 << (i*4);
 545                                         } else if (p[0] == 'U' && p[1] == 'S') {
 546                                                 PicoAutoRgnOrder |= 4 << (i*4);
 547                                         } else if (p[0] == 'E' && p[1] == 'U') {
 548                                                 PicoAutoRgnOrder |= 8 << (i*4);
 549                                         }
 550                                         while (*p != ' ' && *p != 0) p++;
 551                                         if (*p == 0) break;
 552                                 }
 553                         }
 554                         else   if (strcasecmp(val, "Auto") == 0) {
 555                                 PicoRegionOverride = 0;
 556                         } else if (strcasecmp(val, "Japan NTSC") == 0) {
 557                                 PicoRegionOverride = 1;
 558                         } else if (strcasecmp(val, "Japan PAL") == 0) {
 559                                 PicoRegionOverride = 2;
 560                         } else if (strcasecmp(val, "USA") == 0) {
 561                                 PicoRegionOverride = 4;
 562                         } else if (strcasecmp(val, "Europe") == 0) {
 563                                 PicoRegionOverride = 8;
 564                         } else
 565                                 return 0;
 566                         return 1;
 567
 568                 case MA_OPT_CONFIRM_STATES:
 569                         if (strcasecmp(var, "Confirm savestate") != 0) return 0;
 570                         if        (strcasecmp(val, "OFF") == 0) {
 571                                 currentConfig.EmuOpt &= ~(5<<9);
 572                         } else if (strcasecmp(val, "writes") == 0) {
 573                                 currentConfig.EmuOpt &= ~(5<<9);
 574                                 currentConfig.EmuOpt |=   1<<9;
 575                         } else if (strcasecmp(val, "loads") == 0) {
 576                                 currentConfig.EmuOpt &= ~(5<<9);
 577                                 currentConfig.EmuOpt |=   4<<9;
 578                         } else if (strcasecmp(val, "both") == 0) {
 579                                 currentConfig.EmuOpt &= ~(5<<9);
 580                                 currentConfig.EmuOpt |=   5<<9;
 581                         } else
 582                                 return 0;
 583                         return 1;
 584
 585                 case MA_OPT2_GAMMA:
 586                         if (strcasecmp(var, "Gamma correction") != 0) return 0;
 587                         currentConfig.gamma = (int) (atof(val) * 100.0);
 588                         return 1;
 589
 590                 case MA_OPT2_SQUIDGEHACK:
 591                         if (strcasecmp(var, "Squidgehack") != 0) return 0;
 592                         tmpi = atoi(val);
 593                         if (tmpi) *(int *)me->var |=  me->mask;
 594                         else      *(int *)me->var &= ~me->mask;
 595                         return 1;
 596
 597                 case MA_CDOPT_READAHEAD:
 598                         if (strcasecmp(var, "ReadAhead buffer") != 0) return 0;
 599                         PicoCDBuffers = atoi(val) / 2;
 600                         return 1;
 601
 602                 /* PSP */
 603                 case MA_OPT3_SCALE:
 604                         if (strcasecmp(var, "Scale factor") != 0) return 0;
 605                         currentConfig.scale = atof(val);
 606                         return 1;
 607                 case MA_OPT3_HSCALE32:
 608                         if (strcasecmp(var, "Hor. scale (for low res. games)") != 0) return 0;
 609                         currentConfig.hscale32 = atof(val);
 610                         return 1;
 611                 case MA_OPT3_HSCALE40:
 612                         if (strcasecmp(var, "Hor. scale (for hi res. games)") != 0) return 0;
 613                         currentConfig.hscale40 = atof(val);
 614                         return 1;
 615                 case MA_OPT3_FILTERING:
 616                         if (strcasecmp(var, "Bilinear filtering") != 0) return 0;
 617                         currentConfig.scaling = atoi(val);
 618                         return 1;
 619                 case MA_OPT3_GAMMAA:
 620                         if (strcasecmp(var, "Gamma adjustment") != 0) return 0;
 621                         currentConfig.gamma = atoi(val);
 622                         return 1;
 623                 case MA_OPT3_BLACKLVL:
 624                         if (strcasecmp(var, "Black level") != 0) return 0;
 625                         currentConfig.gamma2 = atoi(val);
 626                         return 1;
 627                 case MA_OPT3_VSYNC:
 628                         if (strcasecmp(var, "Wait for vsync") != 0) return 0;
 629                         if        (strcasecmp(val, "never") == 0) {
 630                                 currentConfig.EmuOpt &= ~0x12000;
 631                         } else if (strcasecmp(val, "sometimes") == 0) {
 632                                 currentConfig.EmuOpt |=  0x12000;
 633                         } else if (strcasecmp(val, "always") == 0) {
 634                                 currentConfig.EmuOpt &= ~0x12000;
 635                                 currentConfig.EmuOpt |=  0x02000;
 636                         } else
 637                                 return 0;
 638                         return 1;
 639
 640                 default:
 641                         lprintf("unhandled custom_read: %i\n", me->id);
 642                         return 0;
 643         }
 644 }
 645
 646
 647 static unsigned int keys_encountered = 0;
 648
 649 static int parse_bind_val(const char *val, int *type)
 650 {
 651         int i;
 652
 653         *type = IN_BINDTYPE_NONE;
 654         if (val[0] == 0)
 655                 return 0;
 656
 657         if (strncasecmp(val, "player", 6) == 0)
 658         {
 659                 int player, shift = 0;
 660                 player = atoi(val + 6) - 1;
 661
 662                 if (player > 1)
 663                         return -1;
 664                 if (player == 1)
 665                         shift = 16;
 666
 667                 *type = IN_BINDTYPE_PLAYER12;
 668                 for (i = 0; i < sizeof(me_ctrl_actions) / sizeof(me_ctrl_actions[0]); i++) {
 669                         if (strncasecmp(me_ctrl_actions[i].name, val + 8, strlen(val + 8)) == 0)
 670                                 return me_ctrl_actions[i].mask << shift;
 671                 }
 672         }
 673         for (i = 0; emuctrl_actions[i].name != NULL; i++) {
 674                 if (strncasecmp(emuctrl_actions[i].name, val, strlen(val)) == 0) {
 675                         *type = IN_BINDTYPE_EMU;
 676                         return emuctrl_actions[i].mask;
 677                 }
 678         }
 679
 680         return -1;
 681 }
 682
 683 static void keys_parse(const char *key, const char *val, int dev_id)
 684 {
 685         int acts, type;
 686
 687         acts = parse_bind_val(val, &type);
 688         if (acts == -1) {
 689                 lprintf("config: unhandled action \"%s\"\n", val);
 690                 return;
 691         }
 692
 693         in_config_bind_key(dev_id, key, acts, type);
 694 }
 695
 696 static int get_numvar_num(const char *var)
 697 {
 698         char *p = NULL;
 699         int num;
 700
 701         if (var[0] == ' ')
 702                 return 0;
 703
 704         num = strtoul(var, &p, 10);
 705         if (*p == 0 || *p == ' ')
 706                 return num;
 707
 708         return -1;
 709 }
 710
 711 /* map dev number in confing to input dev number */
 712 static unsigned char input_dev_map[IN_MAX_DEVS];
 713
 714 static void parse(const char *var, const char *val)
 715 {
 716         menu_entry *me;
 717         int tmp, ret = 0;
 718
 719         if (strcasecmp(var, "LastUsedROM") == 0)
 720                 return; /* handled elsewhere */
 721
 722         if (strcasecmp(var, "Sound Volume") == 0) {
 723                 currentConfig.volume = atoi(val);
 724                 return;
 725         }
 726
 727         /* input: device name */
 728         if (strncasecmp(var, "input", 5) == 0) {
 729                 int num = get_numvar_num(var + 5);
 730                 if (num >= 0 && num < IN_MAX_DEVS)
 731                         input_dev_map[num] = in_config_parse_dev(val);
 732                 else
 733                         lprintf("config: failed to parse: %s\n", var);
 734                 return;
 735         }
 736
 737         // key binds
 738         if (strncasecmp(var, "bind", 4) == 0) {
 739                 const char *p = var + 4;
 740                 int num = get_numvar_num(p);
 741                 if (num < 0 || num >= IN_MAX_DEVS) {
 742                         lprintf("config: failed to parse: %s\n", var);
 743                         return;
 744                 }
 745
 746                 num = input_dev_map[num];
 747                 if (num < 0 || num >= IN_MAX_DEVS) {
 748                         lprintf("config: invalid device id: %s\n", var);
 749                         return;
 750                 }
 751
 752                 while (*p && *p != ' ') p++;
 753                 while (*p && *p == ' ') p++;
 754                 keys_parse(p, val, num);
 755                 return;
 756         }
 757
 758         me = me_list_get_first();
 759         while (me != NULL && ret == 0)
 760         {
 761                 if (!me->need_to_save)
 762                         goto next;
 763                 if (me->name != NULL && me->name[0] != 0) {
 764                         if (strcasecmp(var, me->name) != 0)
 765                                 goto next; /* surely not this one */
 766                         if (me->beh == MB_OPT_ONOFF) {
 767                                 tmp = atoi(val);
 768                                 if (tmp) *(int *)me->var |=  me->mask;
 769                                 else     *(int *)me->var &= ~me->mask;
 770                                 return;
 771                         } else if (me->beh == MB_OPT_RANGE) {
 772                                 tmp = atoi(val);
 773                                 if (tmp < me->min) tmp = me->min;
 774                                 if (tmp > me->max) tmp = me->max;
 775                                 *(int *)me->var = tmp;
 776                                 return;
 777                         }
 778                 }
 779                 ret = custom_read(me, var, val);
 780 next:
 781                 me = me_list_get_next();
 782         }
 783         if (!ret) lprintf("config_readsect: unhandled var: \"%s\"\n", var);
 784 }
 785
 786
 787 int config_havesect(const char *fname, const char *section)
 788 {
 789         FILE *f;
 790         int ret;
 791
 792         f = fopen(fname, "r");
 793         if (f == NULL) return 0;
 794
 795         ret = seek_sect(f, section);
 796         fclose(f);
 797         return ret;
 798 }
 799
 800 int config_readsect(const char *fname, const char *section)
 801 {
 802         char line[128], *var, *val;
 803         FILE *f;
 804         int ret;
 805
 806         f = fopen(fname, "r");
 807         if (f == NULL) return -1;
 808
 809         if (section != NULL)
 810         {
 811                 ret = seek_sect(f, section);
 812                 if (!ret) {
 813                         lprintf("config_readsect: %s: missing section [%s]\n", fname, section);
 814                         fclose(f);
 815                         return -1;
 816                 }
 817         }
 818
 819         keys_encountered = 0;
 820         memset(input_dev_map, 0xff, sizeof(input_dev_map));
 821
 822         in_config_start();
 823         while (!feof(f))
 824         {
 825                 ret = config_get_var_val(f, line, sizeof(line), &var, &val);
 826                 if (ret ==  0) break;
 827                 if (ret == -1) continue;
 828
 829                 parse(var, val);
 830         }
 831         in_config_end();
 832
 833         fclose(f);
 834         return 0;
 835 }
 836
 837 #endif // _MSC_VER
 838
 839 static char *mystrip(char *str)
 840 {
 841         int i, len;
 842
 843         len = strlen(str);
 844         for (i = 0; i < len; i++)
 845                 if (str[i] != ' ') break;
 846         if (i > 0) memmove(str, str + i, len - i + 1);
 847
 848         len = strlen(str);
 849         for (i = len - 1; i >= 0; i--)
 850                 if (str[i] != ' ') break;
 851         str[i+1] = 0;
 852
 853         return str;
 854 }
 855
 856 /* returns:
 857  *  0 - EOF, end
 858  *  1 - parsed ok
 859  * -1 - failed to parse line
 860  */
 861 int config_get_var_val(void *file, char *line, int lsize, char **rvar, char **rval)
 862 {
 863         char *var, *val, *tmp;
 864         FILE *f = file;
 865         int len, i;
 866
 867         tmp = fgets(line, lsize, f);
 868         if (tmp == NULL) return 0;
 869
 870         if (line[0] == '[') return 0; // other section
 871
 872         // strip comments, linefeed, spaces..
 873         len = strlen(line);
 874         for (i = 0; i < len; i++)
 875                 if (line[i] == '#' || line[i] == '\r' || line[i] == '\n') { line[i] = 0; break; }
 876         mystrip(line);
 877         len = strlen(line);
 878         if (len <= 0) return -1;;
 879
 880         // get var and val
 881         for (i = 0; i < len; i++)
 882                 if (line[i] == '=') break;
 883         if (i >= len || strchr(&line[i+1], '=') != NULL) {
 884                 lprintf("config_readsect: can't parse: %s\n", line);
 885                 return -1;
 886         }
 887         line[i] = 0;
 888         var = line;
 889         val = &line[i+1];
 890         mystrip(var);
 891         mystrip(val);
 892
 893 #ifndef _MSC_VER
 894         if (strlen(var) == 0 || (strlen(val) == 0 && strncasecmp(var, "bind", 4) != 0)) {
 895                 lprintf("config_readsect: something's empty: \"%s\" = \"%s\"\n", var, val);
 896                 return -1;;
 897         }
 898 #endif
 899
 900         *rvar = var;
 901         *rval = val;
 902         return 1;
 903 }
 904