apps/settings.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 by Stuart Martin
  11  * RTC config saving code (C) 2002 by hessu@hes.iki.fi
  12  *
  13  * This program is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU General Public License
  15  * as published by the Free Software Foundation; either version 2
  16  * of the License, or (at your option) any later version.
  17  *
  18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19  * KIND, either express or implied.
  20  *
  21  ****************************************************************************/
  22 #include <stdio.h>
  23 #include <stddef.h>
  24 #include <stdlib.h>
  25 #include <limits.h>
  26 #include "inttypes.h"
  27 #include "config.h"
  28 #include "action.h"
  29 #include "crc32.h"
  30 #include "settings.h"
  31 #include "debug.h"
  32 #include "usb.h"
  33 #include "backlight.h"
  34 #include "audio.h"
  35 #include "talk.h"
  36 #include "string.h"
  37 #include "rtc.h"
  38 #include "power.h"
  39 #include "ata_idle_notify.h"
  40 #include "storage.h"
  41 #include "screens.h"
  42 #include "ctype.h"
  43 #include "file.h"
  44 #include "system.h"
  45 #include "general.h"
  46 #include "misc.h"
  47 #ifdef HAVE_LCD_BITMAP
  48 #include "icons.h"
  49 #include "font.h"
  50 #include "peakmeter.h"
  51 #endif
  52 #include "lang.h"
  53 #include "language.h"
  54 #include "powermgmt.h"
  55 #include "sprintf.h"
  56 #include "keyboard.h"
  57 #include "version.h"
  58 #include "sound.h"
  59 #include "rbunicode.h"
  60 #include "dircache.h"
  61 #include "splash.h"
  62 #include "list.h"
  63 #include "settings_list.h"
  64 #include "filetypes.h"
  65 #include "option_select.h"
  66 #if CONFIG_TUNER
  67 #include "radio.h"
  68 #endif
  69 #include "wps.h"
  70 #include "skin_engine/skin_engine.h"
  71 #include "skin_engine/skin_fonts.h"
  72 #include "viewport.h"
  73 #include "statusbar-skinned.h"
  74
  75 #if CONFIG_CODEC == MAS3507D
  76 void dac_line_in(bool enable);
  77 #endif
  78 struct user_settings global_settings;
  79 struct system_status global_status;
  80
  81 #if CONFIG_CODEC == SWCODEC
  82 #include "dsp.h"
  83 #include "playback.h"
  84 #ifdef HAVE_RECORDING
  85 #include "enc_config.h"
  86 #endif
  87 #endif /* CONFIG_CODEC == SWCODEC */
  88
  89 #define NVRAM_BLOCK_SIZE 44
  90
  91 #ifdef HAVE_LCD_BITMAP
  92 #define MAX_LINES 10
  93 #else
  94 #define MAX_LINES 2
  95 #endif
  96
  97 #ifdef HAVE_REMOTE_LCD
  98 #include "lcd-remote.h"
  99 #endif
 100
 101 long lasttime = 0;
 102
 103 /** NVRAM stuff, if the target doesnt have NVRAM it is saved in ROCKBOX_DIR /nvram.bin **/
 104 /* NVRAM is set out as
 105 [0] 'R'
 106 [1] 'b'
 107 [2] version
 108 [3] stored variable count
 109 [4-7] crc32 checksum
 110 [8-NVRAM_BLOCK_SIZE] data
 111 */
 112 #define NVRAM_DATA_START 8
 113 #define NVRAM_FILE ROCKBOX_DIR "/nvram.bin"
 114 static char nvram_buffer[NVRAM_BLOCK_SIZE];
 115
 116 static bool read_nvram_data(char* buf, int max_len)
 117 {
 118     unsigned crc32 = 0xffffffff;
 119     int var_count = 0, i = 0, buf_pos = 0;
 120 #ifndef HAVE_RTC_RAM
 121     int fd = open(NVRAM_FILE,O_RDONLY);
 122     if (fd < 0)
 123         return false;
 124     memset(buf,0,max_len);
 125     if (read(fd,buf,max_len) < 8) /* min is 8 bytes,magic, ver, vars, crc32 */
 126         return false;
 127     close(fd);
 128 #else
 129     memset(buf,0,max_len);
 130     /* read rtc block */
 131     for (i=0; i < max_len; i++ )
 132         buf[i] = rtc_read(0x14+i);
 133 #endif
 134     /* check magic, version */
 135     if ((buf[0] != 'R') || (buf[1] != 'b')
 136         || (buf[2] != NVRAM_CONFIG_VERSION))
 137         return false;
 138     /* check crc32 */
 139     crc32 = crc_32(&buf[NVRAM_DATA_START],
 140                     max_len-NVRAM_DATA_START-1,0xffffffff);
 141     if (memcmp(&crc32,&buf[4],4))
 142         return false;
 143     /* all good, so read in the settings */
 144     var_count = buf[3];
 145     buf_pos = NVRAM_DATA_START;
 146     for(i=0; i<nb_settings; i++)
 147     {
 148         int nvram_bytes = (settings[i].flags&F_NVRAM_BYTES_MASK)
 149                                 >>F_NVRAM_MASK_SHIFT;
 150         if (nvram_bytes)
 151         {
 152             if ((var_count>0) && (buf_pos<max_len))
 153             {
 154                 memcpy(settings[i].setting,&buf[buf_pos],nvram_bytes);
 155                 buf_pos += nvram_bytes;
 156                 var_count--;
 157             }
 158             else /* should only happen when new items are added to the end */
 159             {
 160                 memcpy(settings[i].setting, &settings[i].default_val, nvram_bytes);
 161             }
 162         }
 163     }
 164     return true;
 165 }
 166 static bool write_nvram_data(char* buf, int max_len)
 167 {
 168     unsigned crc32 = 0xffffffff;
 169     int i = 0, buf_pos = 0;
 170     char var_count = 0;
 171 #ifndef HAVE_RTC_RAM
 172     int fd;
 173 #endif
 174     memset(buf,0,max_len);
 175     /* magic, version */
 176     buf[0] = 'R'; buf[1] = 'b';
 177     buf[2] = NVRAM_CONFIG_VERSION;
 178     buf_pos = NVRAM_DATA_START;
 179     for(i=0; (i<nb_settings) && (buf_pos<max_len); i++)
 180     {
 181         int nvram_bytes = (settings[i].flags&F_NVRAM_BYTES_MASK)
 182                                 >>F_NVRAM_MASK_SHIFT;
 183         if (nvram_bytes)
 184         {
 185             memcpy(&buf[buf_pos],settings[i].setting,nvram_bytes);
 186             buf_pos += nvram_bytes;
 187             var_count++;
 188         }
 189     }
 190     /* count and crc32 */
 191     buf[3] = var_count;
 192     crc32 = crc_32(&buf[NVRAM_DATA_START],
 193                     max_len-NVRAM_DATA_START-1,0xffffffff);
 194     memcpy(&buf[4],&crc32,4);
 195 #ifndef HAVE_RTC_RAM
 196     fd = open(NVRAM_FILE,O_CREAT|O_TRUNC|O_WRONLY);
 197     if (fd >= 0)
 198     {
 199         int len = write(fd,buf,max_len);
 200         close(fd);
 201         if (len < 8)
 202             return false;
 203     }
 204 #else
 205     /* FIXME: okay, it _would_ be cleaner and faster to implement rtc_write so
 206        that it would write a number of bytes at a time since the RTC chip
 207        supports that, but this will have to do for now 8-) */
 208     for (i=0; i < NVRAM_BLOCK_SIZE; i++ ) {
 209         int r = rtc_write(0x14+i, buf[i]);
 210         if (r)
 211             return false;
 212     }
 213 #endif
 214     return true;
 215 }
 216
 217 /** Reading from a config file **/
 218 /*
 219  * load settings from disk or RTC RAM
 220  */
 221 void settings_load(int which)
 222 {
 223     if (which&SETTINGS_RTC)
 224         read_nvram_data(nvram_buffer,NVRAM_BLOCK_SIZE);
 225     if (which&SETTINGS_HD)
 226     {
 227         settings_load_config(CONFIGFILE,false);
 228         settings_load_config(FIXEDSETTINGSFILE,false);
 229     }
 230 }
 231
 232 static bool cfg_string_to_int(int setting_id, int* out, const char* str)
 233 {
 234     const char* start = settings[setting_id].cfg_vals;
 235     char* end = NULL;
 236     char temp[MAX_PATH];
 237     int count = 0;
 238     while (1)
 239     {
 240         end = strchr(start, ',');
 241         if (!end)
 242         {
 243             if (!strcmp(str, start))
 244             {
 245                 *out = count;
 246                 return true;
 247             }
 248             else return false;
 249         }
 250         strlcpy(temp, start, end-start+1);
 251         if (!strcmp(str, temp))
 252         {
 253             *out = count;
 254             return true;
 255         }
 256         start = end +1;
 257         count++;
 258     }
 259     return false;
 260 }
 261
 262 bool settings_load_config(const char* file, bool apply)
 263 {
 264     int fd;
 265     char line[128];
 266     char* name;
 267     char* value;
 268     int i;
 269     fd = open_utf8(file, O_RDONLY);
 270     if (fd < 0)
 271         return false;
 272
 273     while (read_line(fd, line, sizeof line) > 0)
 274     {
 275         if (!settings_parseline(line, &name, &value))
 276             continue;
 277         for(i=0; i<nb_settings; i++)
 278         {
 279             if (settings[i].cfg_name == NULL)
 280                 continue;
 281             if (!strcasecmp(name,settings[i].cfg_name))
 282             {
 283                 switch (settings[i].flags&F_T_MASK)
 284                 {
 285                     case F_T_CUSTOM:
 286                         settings[i].custom_setting->load_from_cfg(settings[i].setting, value);
 287                         break;
 288                     case F_T_INT:
 289                     case F_T_UINT:
 290 #ifdef HAVE_LCD_COLOR
 291                         if (settings[i].flags&F_RGB)
 292                             hex_to_rgb(value, (int*)settings[i].setting);
 293                         else
 294 #endif
 295                             if (settings[i].cfg_vals == NULL)
 296                         {
 297                             *(int*)settings[i].setting = atoi(value);
 298                         }
 299                         else
 300                         {
 301                             int temp, *v = (int*)settings[i].setting;
 302                             bool found = cfg_string_to_int(i, &temp, value);
 303                             if (found)
 304                             {
 305                                 if (settings[i].flags&F_TABLE_SETTING)
 306                                     *v = settings[i].table_setting->values[temp];
 307                                 else
 308                                     *v = temp;
 309                             }
 310                             else
 311                             {   /* atoi breaks choice settings because they
 312                                  * don't have int-like values, and would
 313                                  * fall back to the first value (i.e. 0)
 314                                  * due to atoi */
 315                                 if (!(settings[i].flags&F_CHOICE_SETTING))
 316                                     *v = atoi(value);
 317                             }
 318                         }
 319                         break;
 320                     case F_T_BOOL:
 321                     {
 322                         int temp;
 323                         if (cfg_string_to_int(i,&temp,value))
 324                             *(bool*)settings[i].setting = (temp!=0);
 325                         if (settings[i].bool_setting->option_callback)
 326                             settings[i].bool_setting->option_callback(temp!=0);
 327                         break;
 328                     }
 329                     case F_T_CHARPTR:
 330                     case F_T_UCHARPTR:
 331                     {
 332                         char storage[MAX_PATH];
 333                         if (settings[i].filename_setting->prefix)
 334                         {
 335                             int len = strlen(settings[i].filename_setting->prefix);
 336                             if (!strncasecmp(value,
 337                                              settings[i].filename_setting->prefix,
 338                                              len))
 339                             {
 340                                 strlcpy(storage, &value[len], MAX_PATH);
 341                             }
 342                             else strlcpy(storage, value, MAX_PATH);
 343                         }
 344                         else strlcpy(storage, value, MAX_PATH);
 345                         if (settings[i].filename_setting->suffix)
 346                         {
 347                             char *s = strcasestr(storage,settings[i].filename_setting->suffix);
 348                             if (s) *s = '\0';
 349                         }
 350                         strlcpy((char*)settings[i].setting, storage,
 351                                 settings[i].filename_setting->max_len);
 352                         break;
 353                     }
 354                 }
 355                 break;
 356             } /* if (!strcmp(name,settings[i].cfg_name)) */
 357         } /* for(...) */
 358     } /* while(...) */
 359
 360     close(fd);
 361     settings_save();
 362     if (apply)
 363         settings_apply(true);
 364     return true;
 365 }
 366
 367 /** Writing to a config file and saving settings **/
 368
 369 bool cfg_int_to_string(int setting_id, int val, char* buf, int buf_len)
 370 {
 371     int flags = settings[setting_id].flags;
 372     const char* start = settings[setting_id].cfg_vals;
 373     char* end = NULL;
 374     int count = 0;
 375
 376     if ((flags&F_T_MASK)==F_T_INT &&
 377         flags&F_TABLE_SETTING)
 378     {
 379         const int *value = settings[setting_id].table_setting->values;
 380         while (start)
 381         {
 382             end = strchr(start,',');
 383             if (value[count] == val)
 384             {
 385                 if (end == NULL)
 386                     strlcpy(buf, start, buf_len);
 387                 else
 388                 {
 389                     int len = (buf_len > (end-start))? end-start: buf_len;
 390                     strlcpy(buf, start, len+1);
 391                 }
 392                 return true;
 393             }
 394             count++;
 395
 396             if (end)
 397                 start = end+1;
 398             else
 399                 break;
 400         }
 401         return false;
 402     }
 403
 404     while (count < val)
 405     {
 406         start = strchr(start,',');
 407         if (!start)
 408             return false;
 409         count++;
 410         start++;
 411     }
 412     end = strchr(start,',');
 413     if (end == NULL)
 414         strlcpy(buf, start, buf_len);
 415     else
 416     {
 417         int len = (buf_len > (end-start))? end-start: buf_len;
 418         strlcpy(buf, start, len+1);
 419     }
 420     return true;
 421 }
 422
 423 bool cfg_to_string(int i/*setting_id*/, char* buf, int buf_len)
 424 {
 425     switch (settings[i].flags&F_T_MASK)
 426     {
 427         case F_T_CUSTOM:
 428             settings[i].custom_setting->write_to_cfg(settings[i].setting,
 429                                                      buf, buf_len);
 430             break;
 431         case F_T_INT:
 432         case F_T_UINT:
 433 #ifdef HAVE_LCD_COLOR
 434             if (settings[i].flags&F_RGB)
 435             {
 436                 int colour = *(int*)settings[i].setting;
 437                 snprintf(buf,buf_len,"%02x%02x%02x",
 438                             (int)RGB_UNPACK_RED(colour),
 439                             (int)RGB_UNPACK_GREEN(colour),
 440                             (int)RGB_UNPACK_BLUE(colour));
 441             }
 442             else
 443 #endif
 444             if (settings[i].cfg_vals == NULL)
 445             {
 446                 snprintf(buf,buf_len,"%d",*(int*)settings[i].setting);
 447             }
 448             else
 449             {
 450                 if (cfg_int_to_string(i, *(int*)settings[i].setting,
 451                                     buf, buf_len) == false)
 452                 {
 453                     snprintf(buf,buf_len,"%d",*(int*)settings[i].setting);
 454                 }
 455                 else
 456                     return false;
 457             }
 458             break;
 459         case F_T_BOOL:
 460             cfg_int_to_string(i,
 461                     *(bool*)settings[i].setting==false?0:1, buf, buf_len);
 462             break;
 463         case F_T_CHARPTR:
 464         case F_T_UCHARPTR:
 465             if (((char*)settings[i].setting)[0]
 466                 && settings[i].filename_setting->prefix)
 467             {
 468                 if (((char*)settings[i].setting)[0] == '-')
 469                 {
 470                     buf[0] = '-';
 471                     buf[1] = '\0';
 472                 }
 473                 else
 474                 {
 475                     snprintf(buf,buf_len,"%s%s%s",
 476                             settings[i].filename_setting->prefix,
 477                             (char*)settings[i].setting,
 478                             settings[i].filename_setting->suffix);
 479                 }
 480             }
 481             else strlcpy(buf,(char*)settings[i].setting,
 482                          settings[i].filename_setting->max_len);
 483             break;
 484     } /* switch () */
 485     return true;
 486 }
 487
 488
 489 static bool is_changed(int setting_id)
 490 {
 491     const struct settings_list *setting = &settings[setting_id];
 492     switch (setting->flags&F_T_MASK)
 493     {
 494     case F_T_CUSTOM:
 495         return setting->custom_setting->is_changed(setting->setting,
 496                                             setting->default_val.custom);
 497         break;
 498     case F_T_INT:
 499     case F_T_UINT:
 500         if (setting->flags&F_DEF_ISFUNC)
 501         {
 502             if (*(int*)setting->setting == setting->default_val.func())
 503                 return false;
 504         }
 505         else if (setting->flags&F_T_SOUND)
 506         {
 507             if (*(int*)setting->setting ==
 508                 sound_default(setting->sound_setting->setting))
 509                 return false;
 510         }
 511         else if (*(int*)setting->setting == setting->default_val.int_)
 512             return false;
 513         break;
 514     case F_T_BOOL:
 515         if (*(bool*)setting->setting == setting->default_val.bool_)
 516             return false;
 517         break;
 518     case F_T_CHARPTR:
 519     case F_T_UCHARPTR:
 520         if (!strcmp((char*)setting->setting, setting->default_val.charptr))
 521             return false;
 522         break;
 523     }
 524     return true;
 525 }
 526
 527 static bool settings_write_config(const char* filename, int options)
 528 {
 529     int i;
 530     int fd;
 531     char value[MAX_PATH];
 532     fd = open(filename,O_CREAT|O_TRUNC|O_WRONLY);
 533     if (fd < 0)
 534         return false;
 535     fdprintf(fd, "# .cfg file created by rockbox %s - "
 536                  "http://www.rockbox.org\r\n\r\n", appsversion);
 537     for(i=0; i<nb_settings; i++)
 538     {
 539         if (settings[i].cfg_name == NULL)
 540             continue;
 541         value[0] = '\0';
 542
 543         switch (options)
 544         {
 545             case SETTINGS_SAVE_CHANGED:
 546                 if (!is_changed(i))
 547                     continue;
 548                 break;
 549             case SETTINGS_SAVE_SOUND:
 550                 if ((settings[i].flags&F_SOUNDSETTING) == 0)
 551                     continue;
 552                 break;
 553             case SETTINGS_SAVE_THEME:
 554                 if ((settings[i].flags&F_THEMESETTING) == 0)
 555                     continue;
 556                 break;
 557 #ifdef HAVE_RECORDING
 558             case SETTINGS_SAVE_RECPRESETS:
 559                 if ((settings[i].flags&F_RECSETTING) == 0)
 560                     continue;
 561                 break;
 562 #endif
 563 #if CONFIG_CODEC == SWCODEC
 564             case SETTINGS_SAVE_EQPRESET:
 565                 if ((settings[i].flags&F_EQSETTING) == 0)
 566                     continue;
 567                 break;
 568 #endif
 569         }
 570
 571         cfg_to_string(i, value, MAX_PATH);
 572         fdprintf(fd,"%s: %s\r\n",settings[i].cfg_name,value);
 573     } /* for(...) */
 574     close(fd);
 575     return true;
 576 }
 577 #ifndef HAVE_RTC_RAM
 578 static void flush_global_status_callback(void *data)
 579 {
 580     (void)data;
 581     write_nvram_data(nvram_buffer,NVRAM_BLOCK_SIZE);
 582 }
 583 #endif
 584 static void flush_config_block_callback(void *data)
 585 {
 586     (void)data;
 587     write_nvram_data(nvram_buffer,NVRAM_BLOCK_SIZE);
 588     settings_write_config(CONFIGFILE, SETTINGS_SAVE_CHANGED);
 589 }
 590
 591 /*
 592  * persist all runtime user settings to disk or RTC RAM
 593  */
 594 static void update_runtime(void)
 595 {
 596     int elapsed_secs;
 597
 598     elapsed_secs = (current_tick - lasttime) / HZ;
 599     global_status.runtime += elapsed_secs;
 600     lasttime += (elapsed_secs * HZ);
 601
 602     if ( global_status.runtime > global_status.topruntime )
 603         global_status.topruntime = global_status.runtime;
 604 }
 605
 606 void status_save(void)
 607 {
 608     update_runtime();
 609 #ifdef HAVE_RTC_RAM
 610     /* this will be done in the storage_callback if
 611        target doesnt have rtc ram */
 612     write_nvram_data(nvram_buffer,NVRAM_BLOCK_SIZE);
 613 #else
 614     register_storage_idle_func(flush_global_status_callback);
 615 #endif
 616 }
 617
 618 int settings_save(void)
 619 {
 620     update_runtime();
 621 #ifdef HAVE_RTC_RAM
 622     /* this will be done in the storage_callback if
 623        target doesnt have rtc ram */
 624     write_nvram_data(nvram_buffer,NVRAM_BLOCK_SIZE);
 625 #endif
 626     register_storage_idle_func(flush_config_block_callback);
 627     return 0;
 628 }
 629
 630 bool settings_save_config(int options)
 631 {
 632     char filename[MAX_PATH];
 633     char *folder, *namebase;
 634     switch (options)
 635     {
 636         case SETTINGS_SAVE_THEME:
 637             folder = THEME_DIR;
 638             namebase = "theme";
 639             break;
 640 #ifdef HAVE_RECORDING
 641         case SETTINGS_SAVE_RECPRESETS:
 642             folder = RECPRESETS_DIR;
 643             namebase = "recording";
 644             break;
 645 #endif
 646 #if CONFIG_CODEC == SWCODEC
 647         case SETTINGS_SAVE_EQPRESET:
 648             folder = EQS_DIR;
 649             namebase = "eq";
 650             break;
 651 #endif
 652         case SETTINGS_SAVE_SOUND:
 653             folder = ROCKBOX_DIR;
 654             namebase = "sound";
 655             break;
 656         default:
 657             folder = ROCKBOX_DIR;
 658             namebase = "config";
 659             break;
 660     }
 661     create_numbered_filename(filename, folder, namebase, ".cfg", 2
 662                              IF_CNFN_NUM_(, NULL));
 663
 664     /* allow user to modify filename */
 665     while (true) {
 666         if (!kbd_input(filename, sizeof filename)) {
 667             break;
 668         }
 669         else {
 670             return false;
 671         }
 672     }
 673
 674     if (settings_write_config(filename, options))
 675         splash(HZ, ID2P(LANG_SETTINGS_SAVED));
 676     else
 677         splash(HZ, ID2P(LANG_FAILED));
 678     return true;
 679 }
 680
 681 /** Apply and Reset settings **/
 682
 683
 684 #ifdef HAVE_LCD_BITMAP
 685 /*
 686  * Applies the range infos stored in global_settings to
 687  * the peak meter.
 688  */
 689 void settings_apply_pm_range(void)
 690 {
 691     int pm_min, pm_max;
 692
 693     /* depending on the scale mode (dBfs or percent) the values
 694        of global_settings.peak_meter_dbfs have different meanings */
 695     if (global_settings.peak_meter_dbfs)
 696     {
 697         /* convert to dBfs * 100          */
 698         pm_min = -(((int)global_settings.peak_meter_min) * 100);
 699         pm_max = -(((int)global_settings.peak_meter_max) * 100);
 700     }
 701     else
 702     {
 703         /* percent is stored directly -> no conversion */
 704         pm_min = global_settings.peak_meter_min;
 705         pm_max = global_settings.peak_meter_max;
 706     }
 707
 708     /* apply the range */
 709     peak_meter_init_range(global_settings.peak_meter_dbfs, pm_min, pm_max);
 710 }
 711 #endif /* HAVE_LCD_BITMAP */
 712
 713 void sound_settings_apply(void)
 714 {
 715 #if CONFIG_CODEC == SWCODEC
 716     sound_set_dsp_callback(dsp_callback);
 717 #endif
 718     sound_set(SOUND_BASS, global_settings.bass);
 719     sound_set(SOUND_TREBLE, global_settings.treble);
 720     sound_set(SOUND_BALANCE, global_settings.balance);
 721     sound_set(SOUND_VOLUME, global_settings.volume);
 722     sound_set(SOUND_CHANNELS, global_settings.channel_config);
 723     sound_set(SOUND_STEREO_WIDTH, global_settings.stereo_width);
 724 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
 725     sound_set(SOUND_LOUDNESS, global_settings.loudness);
 726     sound_set(SOUND_AVC, global_settings.avc);
 727     sound_set(SOUND_MDB_STRENGTH, global_settings.mdb_strength);
 728     sound_set(SOUND_MDB_HARMONICS, global_settings.mdb_harmonics);
 729     sound_set(SOUND_MDB_CENTER, global_settings.mdb_center);
 730     sound_set(SOUND_MDB_SHAPE, global_settings.mdb_shape);
 731     sound_set(SOUND_MDB_ENABLE, global_settings.mdb_enable);
 732     sound_set(SOUND_SUPERBASS, global_settings.superbass);
 733 #endif
 734
 735 #ifdef HAVE_WM8758
 736     sound_set(SOUND_BASS_CUTOFF, global_settings.bass_cutoff);
 737     sound_set(SOUND_TREBLE_CUTOFF, global_settings.treble_cutoff);
 738 #endif
 739 }
 740
 741
 742
 743 /* call this after loading a .wps/.rwps pr other skin files, so that the
 744  * skin buffer is reset properly
 745  */
 746 void settings_apply_skins(void)
 747 {
 748     char buf[MAX_PATH];
 749     /* re-initialize the skin buffer before we start reloading skins */
 750     skin_buffer_init();
 751 #ifdef HAVE_LCD_BITMAP
 752     skin_backdrop_init();
 753     skin_font_init();
 754     if ( global_settings.sbs_file[0] &&
 755         global_settings.sbs_file[0] != 0xff )
 756     {
 757         snprintf(buf, sizeof buf, SBS_DIR "/%s.sbs",
 758                 global_settings.sbs_file);
 759         sb_skin_data_load(SCREEN_MAIN, buf, true);
 760     }
 761     else
 762     {
 763         sb_skin_data_load(SCREEN_MAIN, NULL, true);
 764     }
 765 #endif
 766     if ( global_settings.wps_file[0] &&
 767         global_settings.wps_file[0] != 0xff )
 768     {
 769         snprintf(buf, sizeof buf, WPS_DIR "/%s.wps",
 770                 global_settings.wps_file);
 771         wps_data_load(SCREEN_MAIN, buf, true);
 772     }
 773     else
 774     {
 775         wps_data_load(SCREEN_MAIN, NULL, true);
 776     }
 777 #if defined(HAVE_REMOTE_LCD) && (NB_SCREENS > 1)
 778     if ( global_settings.rsbs_file[0] &&
 779         global_settings.rsbs_file[0] != 0xff ) {
 780         snprintf(buf, sizeof buf, SBS_DIR "/%s.rsbs",
 781                 global_settings.rsbs_file);
 782         sb_skin_data_load(SCREEN_REMOTE, buf, true);
 783     }
 784     else
 785     {
 786         sb_skin_data_load(SCREEN_REMOTE, NULL, true);
 787     }
 788     if ( global_settings.rwps_file[0])
 789     {
 790         snprintf(buf, sizeof buf, WPS_DIR "/%s.rwps",
 791                 global_settings.rwps_file);
 792         wps_data_load(SCREEN_REMOTE, buf, true);
 793     }
 794     else
 795     {
 796         wps_data_load(SCREEN_REMOTE, NULL, true);
 797     }
 798 #endif
 799     viewportmanager_theme_changed(THEME_STATUSBAR);
 800 #if LCD_DEPTH > 1 || defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1
 801     int i;
 802     FOR_NB_SCREENS(i)
 803         screens[i].backdrop_show(sb_get_backdrop(i));
 804 #endif
 805 }
 806
 807 void settings_apply(bool read_disk)
 808 {
 809
 810     char buf[64];
 811 #if CONFIG_CODEC == SWCODEC
 812     int i;
 813 #endif
 814     sound_settings_apply();
 815
 816 #ifdef HAVE_DISK_STORAGE
 817     audio_set_buffer_margin(global_settings.buffer_margin);
 818 #endif
 819
 820 #ifdef HAVE_LCD_CONTRAST
 821     lcd_set_contrast(global_settings.contrast);
 822 #endif
 823     lcd_scroll_speed(global_settings.scroll_speed);
 824 #ifdef HAVE_REMOTE_LCD
 825     lcd_remote_set_contrast(global_settings.remote_contrast);
 826     lcd_remote_set_invert_display(global_settings.remote_invert);
 827
 828 #ifdef HAVE_LCD_FLIP
 829     lcd_remote_set_flip(global_settings.remote_flip_display);
 830 #endif
 831
 832     lcd_remote_scroll_speed(global_settings.remote_scroll_speed);
 833     lcd_remote_scroll_step(global_settings.remote_scroll_step);
 834     lcd_remote_scroll_delay(global_settings.remote_scroll_delay);
 835     lcd_remote_bidir_scroll(global_settings.remote_bidir_limit);
 836 #ifdef HAVE_REMOTE_LCD_TICKING
 837     lcd_remote_emireduce(global_settings.remote_reduce_ticking);
 838 #endif
 839     remote_backlight_set_timeout(global_settings.remote_backlight_timeout);
 840 #if CONFIG_CHARGING
 841     remote_backlight_set_timeout_plugged(global_settings.remote_backlight_timeout_plugged);
 842 #endif
 843 #ifdef HAS_REMOTE_BUTTON_HOLD
 844     remote_backlight_set_on_button_hold(global_settings.remote_backlight_on_button_hold);
 845 #endif
 846 #endif /* HAVE_REMOTE_LCD */
 847 #ifdef HAVE_BACKLIGHT_BRIGHTNESS
 848     backlight_set_brightness(global_settings.brightness);
 849 #endif
 850 #ifdef HAVE_BACKLIGHT
 851     backlight_set_timeout(global_settings.backlight_timeout);
 852 #if CONFIG_CHARGING
 853     backlight_set_timeout_plugged(global_settings.backlight_timeout_plugged);
 854 #endif
 855 #if    defined(HAVE_BACKLIGHT_FADING_INT_SETTING) \
 856     || defined(HAVE_BACKLIGHT_FADING_BOOL_SETTING)
 857     backlight_set_fade_in(global_settings.backlight_fade_in);
 858     backlight_set_fade_out(global_settings.backlight_fade_out);
 859 #endif
 860 #endif
 861 #ifdef HAVE_BUTTONLIGHT_BRIGHTNESS
 862     buttonlight_set_brightness(global_settings.buttonlight_brightness);
 863 #endif
 864 #ifdef HAVE_BUTTON_LIGHT
 865     buttonlight_set_timeout(global_settings.buttonlight_timeout);
 866 #endif
 867 #ifdef HAVE_DISK_STORAGE
 868     storage_spindown(global_settings.disk_spindown);
 869 #endif
 870 #if (CONFIG_CODEC == MAS3507D) && !defined(SIMULATOR)
 871     dac_line_in(global_settings.line_in);
 872 #endif
 873     set_poweroff_timeout(global_settings.poweroff);
 874
 875     set_battery_capacity(global_settings.battery_capacity);
 876 #if BATTERY_TYPES_COUNT > 1
 877     set_battery_type(global_settings.battery_type);
 878 #endif
 879
 880 #ifdef HAVE_LCD_BITMAP
 881 #ifdef HAVE_LCD_INVERT
 882     lcd_set_invert_display(global_settings.invert);
 883 #endif
 884 #ifdef HAVE_LCD_FLIP
 885     lcd_set_flip(global_settings.flip_display);
 886     button_set_flip(global_settings.flip_display);
 887 #endif
 888     lcd_update(); /* refresh after flipping the screen */
 889     settings_apply_pm_range();
 890     peak_meter_init_times(
 891         global_settings.peak_meter_release, global_settings.peak_meter_hold,
 892         global_settings.peak_meter_clip_hold);
 893 #endif
 894
 895 #ifdef HAVE_SPEAKER
 896     audiohw_enable_speaker(global_settings.speaker_enabled);
 897 #endif
 898
 899     if (read_disk)
 900     {
 901 #ifdef HAVE_LCD_BITMAP
 902         /* fonts need to be loaded before the WPS */
 903         if ( global_settings.font_file[0]) {
 904             snprintf(buf, sizeof buf, FONT_DIR "/%s.fnt",
 905                      global_settings.font_file);
 906             if (font_load(NULL, buf) < 0)
 907                 font_reset(NULL);
 908         }
 909         else
 910             font_reset(NULL);
 911 #ifdef HAVE_REMOTE_LCD
 912         if ( global_settings.remote_font_file[0]) {
 913             snprintf(buf, sizeof buf, FONT_DIR "/%s.fnt",
 914                      global_settings.remote_font_file);
 915             if (font_load_remoteui(buf) < 0)
 916                 font_load_remoteui(NULL);
 917         }
 918         else
 919             font_load_remoteui(NULL);
 920 #endif
 921         if ( global_settings.kbd_file[0]) {
 922             snprintf(buf, sizeof buf, ROCKBOX_DIR "/%s.kbd",
 923                      global_settings.kbd_file);
 924             load_kbd(buf);
 925         }
 926         else
 927             load_kbd(NULL);
 928 #endif
 929
 930         if ( global_settings.lang_file[0]) {
 931             snprintf(buf, sizeof buf, LANG_DIR "/%s.lng",
 932                      global_settings.lang_file);
 933             lang_core_load(buf);
 934             talk_init(); /* use voice of same language */
 935         }
 936
 937         /* reload wpses */
 938         settings_apply_skins();
 939
 940         /* load the icon set */
 941         icons_init();
 942
 943 #ifdef HAVE_LCD_COLOR
 944         if (global_settings.colors_file[0])
 945             read_color_theme_file();
 946 #endif
 947     }
 948
 949 #ifdef HAVE_LCD_COLOR
 950     screens[SCREEN_MAIN].set_foreground(global_settings.fg_color);
 951     screens[SCREEN_MAIN].set_background(global_settings.bg_color);
 952     screens[SCREEN_MAIN].set_selector_start(global_settings.lss_color);
 953     screens[SCREEN_MAIN].set_selector_end(global_settings.lse_color);
 954     screens[SCREEN_MAIN].set_selector_text(global_settings.lst_color);
 955 #endif
 956
 957 #ifdef HAVE_LCD_BITMAP
 958     lcd_scroll_step(global_settings.scroll_step);
 959     gui_list_screen_scroll_step(global_settings.screen_scroll_step);
 960     gui_list_screen_scroll_out_of_view(global_settings.offset_out_of_view);
 961 #else
 962     lcd_jump_scroll(global_settings.jump_scroll);
 963     lcd_jump_scroll_delay(global_settings.jump_scroll_delay);
 964 #endif
 965     lcd_bidir_scroll(global_settings.bidir_limit);
 966     lcd_scroll_delay(global_settings.scroll_delay);
 967
 968
 969     set_codepage(global_settings.default_codepage);
 970
 971 #if CONFIG_CODEC == SWCODEC
 972 #ifdef HAVE_CROSSFADE
 973     audio_set_crossfade(global_settings.crossfade);
 974 #endif
 975     dsp_set_replaygain();
 976     dsp_set_crossfeed(global_settings.crossfeed);
 977     dsp_set_crossfeed_direct_gain(global_settings.crossfeed_direct_gain);
 978     dsp_set_crossfeed_cross_params(global_settings.crossfeed_cross_gain,
 979                                    global_settings.crossfeed_hf_attenuation,
 980                                    global_settings.crossfeed_hf_cutoff);
 981
 982     /* Configure software equalizer, hardware eq is handled in audio_init() */
 983     dsp_set_eq(global_settings.eq_enabled);
 984     dsp_set_eq_precut(global_settings.eq_precut);
 985     for(i = 0; i < 5; i++) {
 986         dsp_set_eq_coefs(i);
 987     }
 988
 989     dsp_dither_enable(global_settings.dithering_enabled);
 990     dsp_timestretch_enable(global_settings.timestretch_enabled);
 991     dsp_set_compressor(global_settings.compressor_threshold,
 992                        global_settings.compressor_makeup_gain,
 993                        global_settings.compressor_ratio,
 994                        global_settings.compressor_knee,
 995                        global_settings.compressor_release_time);
 996 #endif
 997
 998 #ifdef HAVE_SPDIF_POWER
 999     spdif_power_enable(global_settings.spdif_enable);
1000 #endif
1001
1002 #ifdef HAVE_BACKLIGHT
1003     set_backlight_filter_keypress(global_settings.bl_filter_first_keypress);
1004 #ifdef HAVE_REMOTE_LCD
1005     set_remote_backlight_filter_keypress(global_settings.remote_bl_filter_first_keypress);
1006 #endif
1007 #ifdef HAS_BUTTON_HOLD
1008     backlight_set_on_button_hold(global_settings.backlight_on_button_hold);
1009 #endif
1010 #ifdef HAVE_LCD_SLEEP_SETTING
1011     lcd_set_sleep_after_backlight_off(global_settings.lcd_sleep_after_backlight_off);
1012 #endif
1013 #endif /* HAVE_BACKLIGHT */
1014
1015 #ifdef HAVE_TOUCHPAD_SENSITIVITY_SETTING
1016     touchpad_set_sensitivity(global_settings.touchpad_sensitivity);
1017 #endif
1018
1019 #ifdef HAVE_USB_CHARGING_ENABLE
1020     usb_charging_enable(global_settings.usb_charging);
1021 #endif
1022
1023 #ifdef HAVE_TOUCHSCREEN
1024     touchscreen_set_mode(global_settings.touch_mode);
1025     memcpy(&calibration_parameters, &global_settings.ts_calibration_data, sizeof(struct touchscreen_parameter));
1026 #endif
1027
1028     /* This should stay last */
1029 #if defined(HAVE_RECORDING) && CONFIG_CODEC == SWCODEC
1030     enc_global_settings_apply();
1031 #endif
1032 #ifdef HAVE_LCD_BITMAP
1033     /* already called with THEME_STATUSBAR in settings_apply_skins() */
1034     viewportmanager_theme_changed(THEME_UI_VIEWPORT|THEME_LANGUAGE);
1035 #endif
1036 }
1037
1038
1039 /*
1040  * reset all settings to their default value
1041  */
1042 void reset_setting(const struct settings_list *setting, void *var)
1043 {
1044     switch (setting->flags&F_T_MASK)
1045     {
1046     case F_T_CUSTOM:
1047         setting->custom_setting->set_default(setting->setting,
1048                                              setting->default_val.custom);
1049         break;
1050     case F_T_INT:
1051     case F_T_UINT:
1052         if (setting->flags&F_DEF_ISFUNC)
1053             *(int*)var = setting->default_val.func();
1054         else if (setting->flags&F_T_SOUND)
1055             *(int*)var = sound_default(setting->sound_setting->setting);
1056         else *(int*)var = setting->default_val.int_;
1057         break;
1058     case F_T_BOOL:
1059         *(bool*)var = setting->default_val.bool_;
1060         break;
1061     case F_T_CHARPTR:
1062     case F_T_UCHARPTR:
1063         strlcpy((char*)var, setting->default_val.charptr,
1064                 setting->filename_setting->max_len);
1065         break;
1066     }
1067 }
1068
1069 void settings_reset(void)
1070 {
1071     int i;
1072
1073     for(i=0; i<nb_settings; i++)
1074         reset_setting(&settings[i], settings[i].setting);
1075 #if defined (HAVE_RECORDING) && CONFIG_CODEC == SWCODEC
1076     enc_global_settings_reset();
1077 #endif
1078 }
1079
1080 /** Changing setting values **/
1081 const struct settings_list* find_setting(const void* variable, int *id)
1082 {
1083     int i;
1084     for(i=0;i<nb_settings;i++)
1085     {
1086         if (settings[i].setting == variable)
1087         {
1088             if (id)
1089                 *id = i;
1090             return &settings[i];
1091         }
1092     }
1093     return NULL;
1094 }
1095
1096 bool set_bool(const char* string, const bool* variable )
1097 {
1098     return set_bool_options(string, variable,
1099                             (char *)STR(LANG_SET_BOOL_YES),
1100                             (char *)STR(LANG_SET_BOOL_NO),
1101                             NULL);
1102 }
1103
1104
1105 bool set_bool_options(const char* string, const bool* variable,
1106                       const char* yes_str, int yes_voice,
1107                       const char* no_str, int no_voice,
1108                       void (*function)(bool))
1109 {
1110     struct opt_items names[] = {
1111         {(unsigned const char *)no_str, no_voice},
1112         {(unsigned const char *)yes_str, yes_voice}
1113     };
1114     bool result;
1115
1116     result = set_option(string, variable, BOOL, names, 2,
1117                         (void (*)(int))function);
1118     return result;
1119 }
1120
1121 bool set_int(const unsigned char* string,
1122              const char* unit,
1123              int voice_unit,
1124              const int* variable,
1125              void (*function)(int),
1126              int step,
1127              int min,
1128              int max,
1129              const char* (*formatter)(char*, size_t, int, const char*) )
1130 {
1131     return set_int_ex(string, unit, voice_unit, variable, function,
1132                       step, min, max, formatter, NULL);
1133 }
1134
1135 bool set_int_ex(const unsigned char* string,
1136                 const char* unit,
1137                 int voice_unit,
1138                 const int* variable,
1139                 void (*function)(int),
1140                 int step,
1141                 int min,
1142                 int max,
1143                 const char* (*formatter)(char*, size_t, int, const char*),
1144                 int32_t (*get_talk_id)(int, int))
1145 {
1146     (void)unit;
1147     struct settings_list item;
1148     struct int_setting data = {
1149         function, voice_unit, min, max, step,
1150         formatter, get_talk_id
1151     };
1152     item.int_setting = &data;
1153     item.flags = F_INT_SETTING|F_T_INT;
1154     item.lang_id = -1;
1155     item.cfg_vals = (char*)string;
1156     item.setting = (void *)variable;
1157     return option_screen(&item, NULL, false, NULL);
1158 }
1159
1160
1161 static const struct opt_items *set_option_options;
1162 static const char* set_option_formatter(char* buf, size_t size, int item, const char* unit)
1163 {
1164     (void)buf, (void)unit, (void)size;
1165     return P2STR(set_option_options[item].string);
1166 }
1167
1168 static int32_t set_option_get_talk_id(int value, int unit)
1169 {
1170     (void)unit;
1171     return set_option_options[value].voice_id;
1172 }
1173
1174 bool set_option(const char* string, const void* variable, enum optiontype type,
1175                 const struct opt_items* options,
1176                 int numoptions, void (*function)(int))
1177 {
1178     int temp;
1179     struct settings_list item;
1180     struct int_setting data = {
1181         function, UNIT_INT, 0, numoptions-1, 1,
1182         set_option_formatter, set_option_get_talk_id
1183     };
1184     set_option_options = options;
1185     item.int_setting = &data;
1186     item.flags = F_INT_SETTING|F_T_INT;
1187     item.lang_id = -1;
1188     item.cfg_vals = (char*)string;
1189     item.setting = &temp;
1190     if (type == BOOL)
1191         temp = *(bool*)variable? 1: 0;
1192     else
1193         temp = *(int*)variable;
1194     if (!option_screen(&item, NULL, false, NULL))
1195     {
1196         if (type == BOOL)
1197             *(bool*)variable = (temp == 1);
1198         else
1199             *(int*)variable = temp;
1200         return false;
1201     }
1202     return true;
1203 }
1204
1205
1206 void set_file(const char* filename, char* setting, int maxlen)
1207 {
1208     const char* fptr = strrchr(filename,'/');
1209     int len;
1210     int extlen = 0;
1211     const char* ptr;
1212
1213     if (!fptr)
1214         return;
1215
1216     fptr++;
1217
1218     len = strlen(fptr);
1219     ptr = fptr + len;
1220     while ((*ptr != '.') && (ptr != fptr)) {
1221         extlen++;
1222         ptr--;
1223     }
1224     if(ptr == fptr) extlen = 0;
1225
1226     if (strncasecmp(ROCKBOX_DIR, filename, strlen(ROCKBOX_DIR)) ||
1227         (len-extlen > maxlen))
1228         return;
1229
1230     strlcpy(setting, fptr, len-extlen+1);
1231
1232     settings_save();
1233 }
1234