apps/settings.c

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