+1 -1

apps/filetree.c

··· 829 829 playlist_get_filename_crc32(NULL, start_index); 830 830 global_status.resume_elapsed = 0; 831 831 global_status.resume_offset = 0; 832 832 - status_save(); 832 832 + status_save(false); 833 833 rc = GO_TO_WPS; 834 834 } 835 835 else {

+2 -2

apps/gui/skin_engine/skin_display.c

··· 187 187 int maxvol = sound_max(SOUND_VOLUME); 188 188 #if defined(HAVE_PERCEPTUAL_VOLUME) || defined(HAVE_TOUCHSCREEN) 189 189 length = 1000; 190 190 - end = to_normalized_volume(global_settings.volume, minvol, maxvol, length); 190 190 + end = to_normalized_volume(global_status.volume, minvol, maxvol, length); 191 191 #else 192 192 length = maxvol - minvol; 193 193 - end = global_settings.volume - minvol; 193 193 + end = global_status.volume - minvol; 194 194 #endif 195 195 } 196 196 else if (pb->type == SKIN_TOKEN_BATTERY_PERCENTBAR)

+1 -1

apps/gui/skin_engine/skin_parser.c

··· 1910 1910 1911 1911 if (region->action == ACTION_TOUCH_MUTE) 1912 1912 { 1913 1913 - region->value = global_settings.volume; 1913 1913 + region->value = global_status.volume; 1914 1914 } 1915 1915 1916 1916

+6 -6

apps/gui/skin_engine/skin_tokens.c

··· 1173 1173 1174 1174 case SKIN_TOKEN_VOLUME: 1175 1175 format_sound_value_ex(buf, buf_size, SOUND_VOLUME, 1176 1176 - global_settings.volume, true); 1176 1176 + global_status.volume, true); 1177 1177 1178 1178 if (intval) 1179 1179 { 1180 1180 int minvol = sound_min(SOUND_VOLUME); 1181 1181 if (limit == TOKEN_VALUE_ONLY) 1182 1182 { 1183 1183 - numeric_ret = global_settings.volume; 1183 1183 + numeric_ret = global_status.volume; 1184 1184 } 1185 1185 - else if (global_settings.volume == minvol) 1185 1185 + else if (global_status.volume == minvol) 1186 1186 { 1187 1187 numeric_ret = 1; 1188 1188 } 1189 1189 - else if (global_settings.volume == 0) 1189 1189 + else if (global_status.volume == 0) 1190 1190 { 1191 1191 numeric_ret = limit - 1; 1192 1192 } 1193 1193 - else if (global_settings.volume > 0) 1193 1193 + else if (global_status.volume > 0) 1194 1194 { 1195 1195 numeric_ret = limit; 1196 1196 } 1197 1197 else 1198 1198 { 1199 1199 - numeric_ret = (limit-3) * (global_settings.volume - minvol - 1) 1199 1199 + numeric_ret = (limit-3) * (global_status.volume - minvol - 1) 1200 1200 / (-1 - minvol) + 2; 1201 1201 } 1202 1202 }

+4 -4

apps/gui/skin_engine/skin_touchsupport.c

··· 274 274 case ACTION_TOUCH_MUTE: 275 275 { 276 276 const int min_vol = sound_min(SOUND_VOLUME); 277 277 - if (global_settings.volume == min_vol) 278 278 - global_settings.volume = temp->value; 277 277 + if (global_status.volume == min_vol) 278 278 + global_status.volume = temp->value; 279 279 else 280 280 { 281 281 - temp->value = global_settings.volume; 282 282 - global_settings.volume = min_vol; 281 281 + temp->value = global_status.volume; 282 282 + global_status.volume = min_vol; 283 283 } 284 284 setvol(); 285 285 returncode = ACTION_REDRAW;

+1 -1

apps/gui/statusbar.c

··· 229 229 bar->battery_icon_switch_tick = current_tick + HZ; 230 230 } 231 231 } 232 232 - bar->info.volume = global_settings.volume; 232 232 + bar->info.volume = global_status.volume; 233 233 bar->info.shuffle = global_settings.playlist_shuffle; 234 234 #ifdef HAS_BUTTON_HOLD 235 235 bar->info.keylock = button_hold();

+2 -2

apps/gui/wps.c

··· 192 192 const int max_vol = sound_max(SOUND_VOLUME); 193 193 const int step_vol = sound_steps(SOUND_VOLUME); 194 194 195 195 - global_settings.volume = from_normalized_volume(offset, min_vol, max_vol, 1000); 196 196 - global_settings.volume -= (global_settings.volume % step_vol); 195 195 + global_status.volume = from_normalized_volume(offset, min_vol, max_vol, 1000); 196 196 + global_status.volume -= (global_status.volume % step_vol); 197 197 setvol(); 198 198 } 199 199 return ACTION_TOUCHSCREEN;

+2 -2

apps/iap/iap-core.c

··· 322 322 IAP_TX_INIT(0x03, 0x0D); 323 323 IAP_TX_PUT(0x04); 324 324 IAP_TX_PUT(0x00); 325 325 - IAP_TX_PUT(0xFF & (int)((global_settings.volume + 90) * 2.65625)); 325 325 + IAP_TX_PUT(0xFF & (int)((global_status.volume + 90) * 2.65625)); 326 326 iap_send_tx(); 327 327 } 328 328 ··· 882 882 IAP_TX_INIT(0x03, 0x09); 883 883 IAP_TX_PUT(0x04); 884 884 IAP_TX_PUT(0x00); 885 885 - IAP_TX_PUT(0xFF &(int)((global_settings.volume + 90) * 2.65625)); 885 885 + IAP_TX_PUT(0xFF &(int)((global_status.volume + 90) * 2.65625)); 886 886 device.changed_notifications |= BIT_N(4); 887 887 iap_send_tx(); 888 888 }

+6 -6

apps/iap/iap-lingo3.c

··· 265 265 device.play_status = audio_status(); 266 266 /* TODO: Fix this */ 267 267 device.mute = false; 268 268 - device.volume = global_settings.volume; 268 268 + device.volume = global_status.volume; 269 269 device.power_state = charger_input_state; 270 270 device.battery_level = battery_level(); 271 271 /* TODO: Fix this */ ··· 441 441 /* Mute status False*/ 442 442 IAP_TX_PUT(0x00); 443 443 /* Volume */ 444 444 - IAP_TX_PUT(0xFF & (int)((global_settings.volume + 90) * 2.65625)); 444 444 + IAP_TX_PUT(0xFF & (int)((global_status.volume + 90) * 2.65625)); 445 445 446 446 } else { 447 447 /* Mute status True*/ ··· 630 630 /* Mute status False*/ 631 631 IAP_TX_PUT(0x00); 632 632 /* Volume */ 633 633 - IAP_TX_PUT(0xFF & (int)((global_settings.volume + 90) * 2.65625)); 634 634 - IAP_TX_PUT(0xFF & (int)((global_settings.volume + 90) * 2.65625)); 633 633 + IAP_TX_PUT(0xFF & (int)((global_status.volume + 90) * 2.65625)); 634 634 + IAP_TX_PUT(0xFF & (int)((global_status.volume + 90) * 2.65625)); 635 635 636 636 } else { 637 637 /* Mute status True*/ ··· 766 766 CHECKLEN(5); 767 767 if (buf[0x03]==0x00){ 768 768 /* Not Muted */ 769 769 - global_settings.volume = (int) (buf[0x04]/2.65625)-90; 769 769 + global_status.volume = (int) (buf[0x04]/2.65625)-90; 770 770 device.mute = false; 771 771 } 772 772 else { ··· 940 940 CHECKLEN(7); 941 941 if (buf[0x03]==0x00){ 942 942 /* Not Muted */ 943 943 - global_settings.volume = (int) (buf[0x04]/2.65625)-90; 943 943 + global_status.volume = (int) (buf[0x04]/2.65625)-90; 944 944 device.mute = false; 945 945 } 946 946 else {

+5 -5

apps/main.c

··· 319 319 struct dircache_info info; 320 320 dircache_get_info(&info); 321 321 global_status.dircache_size = info.size; 322 322 - status_save(); 322 322 + status_save(true); 323 323 } 324 324 /* else don't wait or already enabled by load */ 325 325 } ··· 435 435 pcm_init(); 436 436 dsp_init(); 437 437 settings_reset(); 438 438 - settings_load(SETTINGS_ALL); 438 438 + settings_load(); 439 439 settings_apply(true); 440 440 #ifdef HAVE_DIRCACHE 441 441 init_dircache(true); ··· 679 679 pcm_init(); 680 680 dsp_init(); 681 681 682 682 - CHART(">settings_load(ALL)"); 683 683 - settings_load(SETTINGS_ALL); 684 684 - CHART("<settings_load(ALL)"); 682 682 + CHART(">settings_load"); 683 683 + settings_load(); 684 684 + CHART("<settings_load"); 685 685 686 686 #if defined(BUTTON_REC) || \ 687 687 (CONFIG_KEYPAD == GIGABEAT_PAD) || \

+1 -1

apps/menus/sound_menu.c

··· 87 87 88 88 /***********************************/ 89 89 /* SOUND MENU */ 90 90 - MENUITEM_SETTING(volume, &global_settings.volume, NULL); 90 90 + MENUITEM_SETTING(volume, &global_status.volume, NULL); 91 91 MENUITEM_SETTING(volume_limit, &global_settings.volume_limit, volume_limit_callback); 92 92 #ifdef AUDIOHW_HAVE_BASS 93 93 MENUITEM_SETTING(bass, &global_settings.bass,

+18 -17

apps/misc.c

··· 345 345 talk_disable(true); 346 346 } 347 347 348 348 - status_save(); 348 348 + status_save(true); 349 349 350 350 #if CONFIG_CHARGING && !defined(HAVE_POWEROFF_WHILE_CHARGING) 351 351 if(!charger_inserted()) ··· 751 751 * event data is available in the last button data */ 752 752 int volume = button_get_data(); 753 753 DEBUGF("SYS_VOLUME_CHANGED: %d\n", volume); 754 754 - if (global_settings.volume != volume) { 755 755 - global_settings.volume = volume; 754 754 + if (global_status.volume != volume) { 755 755 + global_status.volume = volume; 756 756 if (firstvolume) { 757 757 setvol(); 758 758 firstvolume = false; ··· 859 859 { 860 860 const int min_vol = sound_min(SOUND_VOLUME); 861 861 const int max_vol = sound_max(SOUND_VOLUME); 862 862 - if (global_settings.volume < min_vol) 863 863 - global_settings.volume = min_vol; 864 864 - if (global_settings.volume > max_vol) 865 865 - global_settings.volume = max_vol; 866 866 - if (global_settings.volume > global_settings.volume_limit) 867 867 - global_settings.volume = global_settings.volume_limit; 868 868 - 869 869 - sound_set_volume(global_settings.volume); 862 862 + int volume = global_status.volume; 863 863 + if (volume < min_vol) 864 864 + volume = min_vol; 865 865 + if (volume > max_vol) 866 866 + volume = max_vol; 867 867 + if (volume > global_settings.volume_limit) 868 868 + volume = global_settings.volume_limit; 869 869 + global_status.volume = volume; 870 870 + sound_set_volume(volume); 870 871 global_status.last_volume_change = current_tick; 871 871 - settings_save(); 872 872 + status_save(false); 872 873 } 873 874 874 875 #ifdef HAVE_PERCEPTUAL_VOLUME ··· 920 921 if (vol >= norm_tab_size) 921 922 vol = norm_tab_size - 1; 922 923 923 923 - global_settings.volume = norm_tab[vol]; 924 924 + global_status.volume = norm_tab[vol]; 924 925 } 925 926 926 927 int get_normalized_volume(void) ··· 931 932 while (a != b) 932 933 { 933 934 int i = (a + b + 1) / 2; 934 934 - if (global_settings.volume < norm_tab[i]) 935 935 + if (global_status.volume < norm_tab[i]) 935 936 b = i - 1; 936 937 else 937 938 a = i; ··· 942 943 #else 943 944 void set_normalized_volume(int vol) 944 945 { 945 945 - global_settings.volume = vol * sound_steps(SOUND_VOLUME); 946 946 + global_status.volume = vol * sound_steps(SOUND_VOLUME); 946 947 } 947 948 948 949 int get_normalized_volume(void) 949 950 { 950 950 - return global_settings.volume / sound_steps(SOUND_VOLUME); 951 951 + return global_status.volume / sound_steps(SOUND_VOLUME); 951 952 } 952 953 #endif 953 954 ··· 971 972 #endif 972 973 case VOLUME_ADJUST_DIRECT: 973 974 default: 974 974 - global_settings.volume += steps * sound_steps(SOUND_VOLUME); 975 975 + global_status.volume += steps * sound_steps(SOUND_VOLUME); 975 976 break; 976 977 } 977 978

+1 -1

apps/playback.c

··· 3011 3011 audio_set_output_source(AUDIO_SRC_PLAYBACK); 3012 3012 #endif 3013 3013 #ifndef PLATFORM_HAS_VOLUME_CHANGE 3014 3014 - sound_set_volume(global_settings.volume); 3014 3014 + sound_set_volume(global_status.volume); 3015 3015 #endif 3016 3016 pcmbuf_update_frequency(); 3017 3017

+2 -2

apps/playlist.c

··· 3777 3777 global_status.resume_elapsed = id3->elapsed; 3778 3778 global_status.resume_offset = id3->offset; 3779 3779 global_status.resume_modified = pl_modified; 3780 3780 - status_save(); 3780 3780 + status_save(false); 3781 3781 } 3782 3782 } 3783 3783 else ··· 3787 3787 global_status.resume_elapsed = -1; 3788 3788 global_status.resume_offset = -1; 3789 3789 global_status.resume_modified = false; 3790 3790 - status_save(); 3790 3790 + status_save(true); 3791 3791 return -1; 3792 3792 } 3793 3793

+1 -1

apps/plugin.c

··· 1029 1029 1030 1030 plugin_check_open_close__exit(); 1031 1031 1032 1032 - status_save(); 1032 1032 + status_save(false); 1033 1033 1034 1034 if (rc == PLUGIN_ERROR) 1035 1035 splash(HZ*2, str(LANG_PLUGIN_ERROR));

+4 -4

apps/plugins/beatbox/beatbox.c

··· 601 601 /* 602 602 case BTN_UP: 603 603 case BTN_UP | BUTTON_REPEAT: 604 604 - vol = rb->global_settings->volume; 604 604 + vol = rb->global_status->volume; 605 605 if (vol < rb->sound_max(SOUND_VOLUME)) 606 606 { 607 607 vol++; 608 608 rb->sound_set(SOUND_VOLUME, vol); 609 609 - rb->global_settings->volume = vol; 609 609 + rb->global_status->volume = vol; 610 610 } 611 611 break; 612 612 613 613 case BTN_DOWN: 614 614 case BTN_DOWN | BUTTON_REPEAT: 615 615 - vol = rb->global_settings->volume; 615 615 + vol = rb->global_status->volume; 616 616 if (vol > rb->sound_min(SOUND_VOLUME)) 617 617 { 618 618 vol--; 619 619 rb->sound_set(SOUND_VOLUME, vol); 620 620 - rb->global_settings->volume = vol; 620 620 + rb->global_status->volume = vol; 621 621 } 622 622 break; 623 623

+2 -2

apps/plugins/doom/m_menu.c

··· 878 878 { 879 879 systemvol-=5; 880 880 rb->sound_set(SOUND_VOLUME, systemvol); 881 881 - rb->global_settings->volume = systemvol; 881 881 + rb->global_status->volume = systemvol; 882 882 } 883 883 break; 884 884 case 1: ··· 886 886 { 887 887 systemvol+=5; 888 888 rb->sound_set(SOUND_VOLUME, systemvol); 889 889 - rb->global_settings->volume = systemvol; 889 889 + rb->global_status->volume = systemvol; 890 890 } 891 891 break; 892 892 }

+2 -2

apps/plugins/doom/rockdoom.c

··· 718 718 719 719 int mod = (rb->sound_max(SOUND_VOLUME)-rb->sound_min(SOUND_VOLUME))/15; 720 720 if(mod == 0) 721 721 - mod = rb->global_settings->volume; 722 722 - systemvol= rb->global_settings->volume-rb->global_settings->volume%mod; 721 721 + mod = rb->global_status->volume; 722 722 + systemvol= rb->global_status->volume-rb->global_status->volume%mod; 723 723 general_translucency = default_translucency; // phares 724 724 725 725

+1 -1

apps/plugins/fft/fft.c

··· 978 978 case FFT_SETF_VOLUME: 979 979 rb->snprintf(fft_osd_message, sizeof (fft_osd_message), 980 980 "Volume: %d%s", 981 981 - rb->sound_val2phys(SOUND_VOLUME, global_settings.volume), 981 981 + rb->sound_val2phys(SOUND_VOLUME, global_status.volume), 982 982 rb->sound_unit(SOUND_VOLUME)); 983 983 return; 984 984 #endif

+1 -1

apps/plugins/lib/playback_control.c

··· 65 65 static bool volume(void) 66 66 { 67 67 const struct settings_list* vol = 68 68 - rb->find_setting(&rb->global_settings->volume); 68 68 + rb->find_setting(&rb->global_status->volume); 69 69 return rb->option_screen((struct settings_list*)vol, parentvp, false, "Volume"); 70 70 } 71 71

+6 -6

apps/plugins/metronome.c

··· 887 887 /* One line in several. */ 888 888 rb->snprintf( buffer, sizeof(buffer), "%u/%u@%u V%d" 889 889 , ps->beats_per_bar, ps->base_beat 890 890 - , bpm, rb->global_settings->volume ); 890 890 + , bpm, rb->global_status->volume ); 891 891 display->puts(0,4, buffer); 892 892 893 893 /* Would it hurt to draw a 3rd line to 2-line display? ··· 931 931 #endif 932 932 933 933 rb->snprintf( buffer, sizeof(buffer), "BPM: %d Vol: %d" 934 934 - , bpm, rb->global_settings->volume ); 934 934 + , bpm, rb->global_status->volume ); 935 935 display->puts(0,3, buffer); 936 936 937 937 display->hline(0, 111, 12); ··· 962 962 This is for parts with associated volume. */ 963 963 static void tweak_volume(int offset) 964 964 { 965 965 - int vol = rb->global_settings->volume + offset; 965 965 + int vol = rb->global_status->volume + offset; 966 966 int minvol = rb->sound_min(SOUND_VOLUME); 967 967 int maxvol = rb->sound_max(SOUND_VOLUME); 968 968 ··· 1121 1121 { 1122 1122 int minvol = rb->sound_min(SOUND_VOLUME); 1123 1123 int maxvol = rb->sound_max(SOUND_VOLUME); 1124 1124 - int vol = rb->global_settings->volume + delta; 1124 1124 + int vol = rb->global_status->volume + delta; 1125 1125 1126 1126 if (vol > maxvol) vol = maxvol; 1127 1127 else if(vol < minvol) vol = minvol; 1128 1128 - if(vol != rb->global_settings->volume) 1128 1128 + if(vol != rb->global_status->volume) 1129 1129 { 1130 1130 - rb->global_settings->volume = vol; 1130 1130 + rb->global_status->volume = vol; 1131 1131 tweak_volume(part->volume); 1132 1132 trigger_display(display_state); 1133 1133 }

+4 -4

apps/plugins/midi/midiplay.c

··· 588 588 case MIDI_VOL_UP: 589 589 case MIDI_VOL_UP | BUTTON_REPEAT: 590 590 { 591 591 - vol = rb->global_settings->volume; 591 591 + vol = rb->global_status->volume; 592 592 if (vol < rb->sound_max(SOUND_VOLUME)) 593 593 { 594 594 vol++; 595 595 rb->sound_set(SOUND_VOLUME, vol); 596 596 - rb->global_settings->volume = vol; 596 596 + rb->global_status->volume = vol; 597 597 } 598 598 break; 599 599 } ··· 601 601 case MIDI_VOL_DOWN: 602 602 case MIDI_VOL_DOWN | BUTTON_REPEAT: 603 603 { 604 604 - vol = rb->global_settings->volume; 604 604 + vol = rb->global_status->volume; 605 605 if (vol > rb->sound_min(SOUND_VOLUME)) 606 606 { 607 607 vol--; 608 608 rb->sound_set(SOUND_VOLUME, vol); 609 609 - rb->global_settings->volume = vol; 609 609 + rb->global_status->volume = vol; 610 610 } 611 611 break; 612 612 }

+1 -1

apps/plugins/mikmod/mikmod.c

··· 326 326 module->sngspd, module->bpm); 327 327 rb->lcd_putsxy(1, 1 + 6 * font_h, statustext); 328 328 329 329 - sprintf(statustext, "vol: %ddB", rb->global_settings->volume); 329 329 + sprintf(statustext, "vol: %ddB", rb->global_status->volume); 330 330 rb->lcd_putsxy(1, 1 + 7 * font_h, statustext); 331 331 332 332 sprintf(statustext, "time: %d:%02d",

+4 -4

apps/plugins/mpegplayer/mpegplayer.c

··· 1462 1462 char buf[32]; 1463 1463 int width; 1464 1464 1465 1465 - int volume = rb->global_settings->volume; 1465 1465 + int volume = rb->global_status->volume; 1466 1466 rb->snprintf(buf, sizeof (buf), "%d%s", 1467 1467 rb->sound_val2phys(SOUND_VOLUME, volume), 1468 1468 rb->sound_unit(SOUND_VOLUME)); ··· 1870 1870 /* Change the current audio volume by a specified amount */ 1871 1871 static void osd_set_volume(int delta) 1872 1872 { 1873 1873 - int vol = rb->global_settings->volume; 1873 1873 + int vol = rb->global_status->volume; 1874 1874 int limit; 1875 1875 1876 1876 vol += delta; ··· 1888 1888 } 1889 1889 1890 1890 /* Sync the global settings */ 1891 1891 - if (vol != rb->global_settings->volume) { 1891 1891 + if (vol != rb->global_status->volume) { 1892 1892 rb->sound_set(SOUND_VOLUME, vol); 1893 1893 - rb->global_settings->volume = vol; 1893 1893 + rb->global_status->volume = vol; 1894 1894 } 1895 1895 1896 1896 /* Update the volume display */

+4 -4

apps/plugins/oscilloscope.c

··· 2113 2113 case OSCILLOSCOPE_VOL_UP: 2114 2114 case OSCILLOSCOPE_VOL_UP | BUTTON_REPEAT: 2115 2115 { 2116 2116 - int vol = rb->global_settings->volume; 2116 2116 + int vol = rb->global_status->volume; 2117 2117 2118 2118 if (vol < rb->sound_max(SOUND_VOLUME)) 2119 2119 { 2120 2120 vol++; 2121 2121 rb->sound_set(SOUND_VOLUME, vol); 2122 2122 - rb->global_settings->volume = vol; 2122 2122 + rb->global_status->volume = vol; 2123 2123 } 2124 2124 2125 2125 osc_popupmsg(OSC_MSG_VOLUME, vol); ··· 2129 2129 case OSCILLOSCOPE_VOL_DOWN: 2130 2130 case OSCILLOSCOPE_VOL_DOWN | BUTTON_REPEAT: 2131 2131 { 2132 2132 - int vol = rb->global_settings->volume; 2132 2132 + int vol = rb->global_status->volume; 2133 2133 2134 2134 if (vol > rb->sound_min(SOUND_VOLUME)) 2135 2135 { 2136 2136 vol--; 2137 2137 rb->sound_set(SOUND_VOLUME, vol); 2138 2138 - rb->global_settings->volume = vol; 2138 2138 + rb->global_status->volume = vol; 2139 2139 } 2140 2140 2141 2141 osc_popupmsg(OSC_MSG_VOLUME, vol);

+1 -1

apps/plugins/rockboy/menu.c

··· 428 428 options.dirty=1; /* Assume that the settings have been changed */ 429 429 430 430 struct viewport *parentvp = NULL; 431 431 - const struct settings_list* vol = rb->find_setting(&rb->global_settings->volume); 431 431 + const struct settings_list* vol = rb->find_setting(&rb->global_status->volume); 432 432 433 433 while(!done) 434 434 {

+2 -2

apps/plugins/test_sampr.c

··· 174 174 #ifndef HAVE_VOLUME_IN_LIST 175 175 static void set_volume(int value) 176 176 { 177 177 - rb->global_settings->volume = value; 177 177 + rb->global_status->volume = value; 178 178 rb->sound_set(SOUND_VOLUME, value); 179 179 } 180 180 ··· 243 243 #ifndef HAVE_VOLUME_IN_LIST 244 244 if (volume_set) 245 245 { 246 246 - int volume = rb->global_settings->volume; 246 246 + int volume = rb->global_status->volume; 247 247 248 248 rb->set_int("Volume", NULL, -1, &volume, 249 249 set_volume, 1, rb->sound_min(SOUND_VOLUME),

+3 -3

apps/plugins/vu_meter.c

··· 637 637 static void change_volume(int delta) { 638 638 int minvol = rb->sound_min(SOUND_VOLUME); 639 639 int maxvol = rb->sound_max(SOUND_VOLUME); 640 640 - int vol = rb->global_settings->volume + delta; 640 640 + int vol = rb->global_status->volume + delta; 641 641 642 642 if (vol > maxvol) vol = maxvol; 643 643 else if (vol < minvol) vol = minvol; 644 644 - if (vol != rb->global_settings->volume) { 644 644 + if (vol != rb->global_status->volume) { 645 645 rb->sound_set(SOUND_VOLUME, vol); 646 646 - rb->global_settings->volume = vol; 646 646 + rb->global_status->volume = vol; 647 647 rb->lcd_putsxyf(0,0, "%d", vol); 648 648 rb->lcd_update(); 649 649 rb->sleep(HZ/12);

+1 -1

apps/plugins/xworld/sys.c

··· 286 286 case 2: 287 287 { 288 288 const struct settings_list* vol = 289 289 - rb->find_setting(&rb->global_settings->volume); 289 289 + rb->find_setting(&rb->global_status->volume); 290 290 rb->option_screen((struct settings_list*)vol, NULL, false, "Volume"); 291 291 break; 292 292 }

+3 -3

apps/radio/radio.c

··· 296 296 &fm_region_data[global_settings.fm_region]; 297 297 global_status.last_frequency = (curr_freq - fmr->freq_min) 298 298 / fmr->freq_step; 299 299 - status_save(); 299 299 + status_save(true); 300 300 } 301 301 302 302 /* Step to the next or previous frequency */ ··· 531 531 532 532 case ACTION_SETTINGS_INC: 533 533 case ACTION_SETTINGS_INCREPEAT: 534 534 - global_settings.volume += sound_steps(SOUND_VOLUME); 534 534 + global_status.volume += sound_steps(SOUND_VOLUME); 535 535 setvol(); 536 536 update_type = SKIN_REFRESH_NON_STATIC; 537 537 break; 538 538 539 539 case ACTION_SETTINGS_DEC: 540 540 case ACTION_SETTINGS_DECREPEAT: 541 541 - global_settings.volume -= sound_steps(SOUND_VOLUME); 541 541 + global_status.volume -= sound_steps(SOUND_VOLUME); 542 542 setvol(); 543 543 update_type = SKIN_REFRESH_NON_STATIC; 544 544 break;

+3 -3

apps/recorder/recording.c

··· 773 773 case ITEM_VOLUME: 774 774 snprintf(buffer, buffer_len, "%s: %s", str(LANG_VOLUME), 775 775 fmt_gain(SOUND_VOLUME, 776 776 - global_settings.volume, 776 776 + global_status.volume, 777 777 buf2, sizeof(buf2))); 778 778 break; 779 779 #endif ··· 896 896 switch(setting_id) 897 897 { 898 898 case SOUND_VOLUME: 899 899 - global_settings.volume += steps; 899 899 + global_status.volume += steps; 900 900 setvol(); 901 901 break; 902 902 #if defined(HAVE_LINE_REC) || defined(HAVE_FMRADIO_REC) ··· 1020 1020 #endif 1021 1021 1022 1022 audio_init_recording(); 1023 1023 - sound_set_volume(global_settings.volume); 1023 1023 + sound_set_volume(global_status.volume); 1024 1024 1025 1025 #if CONFIG_RTC == 0 1026 1026 /* Create new filename for recording start */

+1 -2

apps/root_menu.c

··· 710 710 if (screen == old_previous) 711 711 old_previous = GO_TO_ROOT; 712 712 global_status.last_screen = (char)screen; 713 713 - status_save(); 713 713 + status_save(false); 714 714 715 715 if (screen == GO_TO_BROWSEPLUGINS) 716 716 activity = ACTIVITY_PLUGINBROWSER; ··· 774 774 int old_global = global_status.last_screen; 775 775 last_screen = next_screen; 776 776 global_status.last_screen = (char)next_screen; 777 777 - /*status_save(); //only needed if we crash */ 778 777 779 778 while(loops-- > 0) /* just to keep things from getting out of hand */ 780 779 {

+1 -2

apps/screens.c

··· 889 889 { 890 890 case 0:return str(LANG_RUNNING_TIME); 891 891 case 1: { 892 892 - global_status.runtime += ((current_tick - lasttime) / HZ); 893 893 - lasttime = current_tick; 892 892 + update_runtime(); 894 893 t = global_status.runtime; 895 894 break; 896 895 }

+156 -188

apps/settings.c

··· 8 8 * $Id$ 9 9 * 10 10 * Copyright (C) 2002 by Stuart Martin 11 11 - * RTC config saving code (C) 2002 by hessu@hes.iki.fi 12 11 * 13 12 * This program is free software; you can redistribute it and/or 14 13 * modify it under the terms of the GNU General Public License ··· 79 78 80 79 struct user_settings global_settings; 81 80 struct system_status global_status; 81 81 + static uint32_t user_settings_crc; 82 82 + static long next_status_update_tick; 83 83 + long lasttime = 0; 84 84 + 85 85 + /* flush system_status more often for spinning harddisks as we may not be able 86 86 + * to spin up at shutdown in order to save so keep the gap minimal */ 87 87 + #if (CONFIG_STORAGE & STORAGE_ATA) 88 88 + #define SYSTEM_STATUS_UPDATE_TICKS (HZ * 60 * 5) /* flush every 5 minutes */ 89 89 + #else 90 90 + #define SYSTEM_STATUS_UPDATE_TICKS (HZ * 60 * 15) /* flush every 15 minutes */ 91 91 + #endif 82 92 83 93 #include "dsp_proc_settings.h" 84 94 #include "playback.h" ··· 87 97 #endif 88 98 #include "pcm_sampr.h" 89 99 90 90 - #define NVRAM_DATA_START 8 91 91 - #define NVRAM_BLOCK_SIZE (sizeof(struct system_status) + NVRAM_DATA_START) 92 92 - 93 93 - #define MAX_LINES 10 94 94 - 95 100 #ifdef HAVE_REMOTE_LCD 96 101 #include "lcd-remote.h" 97 102 #endif ··· 103 108 104 109 #ifdef ROCKBOX_NO_TEMP_SETTINGS_FILE /* Overwrites same file each time */ 105 110 #define CONFIGFILE_TEMP CONFIGFILE 106 106 - #define NVRAM_FILE_TEMP NVRAM_FILE 111 111 + #define RESUMEFILE_TEMP RESUMEFILE 107 112 #define rename_temp_file(a,b,c) 108 113 #else /* creates temp files on save, renames next load, saves old file if desired */ 109 114 #define CONFIGFILE_TEMP CONFIGFILE".new" 110 110 - #define NVRAM_FILE_TEMP NVRAM_FILE".new" 115 115 + #define RESUMEFILE_TEMP RESUMEFILE".new" 111 116 112 117 #ifdef LOGF_ENABLE 113 118 static char *debug_get_flags(uint32_t flags); 119 119 + #undef DEBUGF /* allow DEBUGF or logf not both */ 120 120 + #define DEBUGF(...) do { } while(0) 114 121 #endif 115 122 static void debug_available_settings(void); 116 123 ··· 129 136 rename(tempfile, file); 130 137 } 131 138 } 132 132 - #endif 133 133 - 134 134 - long lasttime = 0; 135 135 - 136 136 - /** NVRAM stuff, if the target doesnt have NVRAM it is saved in ROCKBOX_DIR /nvram.bin **/ 137 137 - /* NVRAM is set out as 138 138 - * 139 139 - * [0] 'R' 140 140 - * [1] 'b' 141 141 - * [2] version 142 142 - * [3] stored variable count 143 143 - * [4-7] crc32 checksum in host endian order 144 144 - * [8+] data 145 145 - */ 146 146 - 147 147 - static unsigned int nvram_crc(char *buf, int max_len) 148 148 - { 149 149 - return crc_32(&buf[NVRAM_DATA_START], max_len - NVRAM_DATA_START - 1, NVRAM_BLOCK_SIZE); 150 150 - } 151 151 - 152 152 - static void read_nvram_data(void) 153 153 - { 154 154 - rename_temp_file(NVRAM_FILE_TEMP, NVRAM_FILE, NVRAM_FILE".old"); 155 155 - 156 156 - int fd = open(NVRAM_FILE, O_RDONLY); 157 157 - if (fd < 0) 158 158 - return; 159 159 - 160 160 - char buf[NVRAM_BLOCK_SIZE]; 161 161 - memset(buf, 0, sizeof(buf)); 162 162 - 163 163 - ssize_t bytes = read(fd, buf, sizeof(buf)); 164 164 - close(fd); 165 165 - 166 166 - if (bytes < 8) /* min is 8 bytes,magic, ver, vars, crc32 */ 167 167 - return; 168 168 - 169 169 - /* check magic, version */ 170 170 - if (buf[0] != 'R' || buf[1] != 'b' || buf[2] != NVRAM_CONFIG_VERSION) 171 171 - return; 172 172 - 173 173 - /* check crc32 */ 174 174 - unsigned int crc32 = nvram_crc(buf, sizeof(buf)); 175 175 - if (crc32 != load_h32(&buf[4])) 176 176 - return; 177 177 - 178 178 - /* all good, so read in the settings */ 179 179 - int var_count = buf[3]; 180 180 - size_t buf_pos = NVRAM_DATA_START; 181 181 - for(int i = 0; i < nb_settings; i++) 182 182 - { 183 183 - const struct settings_list *setting = &settings[i]; 184 184 - int nvram_bytes = (setting->flags & F_NVRAM_BYTES_MASK) >> F_NVRAM_MASK_SHIFT; 185 185 - if (nvram_bytes) 186 186 - { 187 187 - if (var_count > 0 && buf_pos < (size_t)bytes) 188 188 - { 189 189 - memcpy(setting->setting, &buf[buf_pos], nvram_bytes); 190 190 - buf_pos += nvram_bytes; 191 191 - var_count--; 192 192 - } 193 193 - else /* should only happen when new items are added to the end */ 194 194 - { 195 195 - memcpy(setting->setting, &setting->default_val, nvram_bytes); 196 196 - } 197 197 - } 198 198 - } 199 199 - } 200 200 - 201 201 - static void write_nvram_data(void) 202 202 - { 203 203 - char buf[NVRAM_BLOCK_SIZE]; 204 204 - memset(buf, 0, sizeof(buf)); 205 205 - 206 206 - /* magic, version */ 207 207 - buf[0] = 'R'; 208 208 - buf[1] = 'b'; 209 209 - buf[2] = NVRAM_CONFIG_VERSION; 210 210 - 211 211 - size_t buf_pos = NVRAM_DATA_START; 212 212 - int var_count = 0; 213 213 - for(int i = 0; i < nb_settings && buf_pos < sizeof(buf); i++) 214 214 - { 215 215 - const struct settings_list *setting = &settings[i]; 216 216 - int nvram_bytes = (setting->flags & F_NVRAM_BYTES_MASK) >> F_NVRAM_MASK_SHIFT; 217 217 - if (nvram_bytes) 218 218 - { 219 219 - memcpy(&buf[buf_pos], setting->setting, nvram_bytes); 220 220 - buf_pos += nvram_bytes; 221 221 - var_count++; 222 222 - } 223 223 - } 224 224 - 225 225 - /* count and crc32 */ 226 226 - buf[3] = var_count; 227 227 - store_h32(&buf[4], nvram_crc(buf, sizeof(buf))); 228 228 - 229 229 - int fd = open(NVRAM_FILE_TEMP,O_CREAT|O_TRUNC|O_WRONLY, 0666); 230 230 - if (fd < 0) 231 231 - return; 232 232 - 233 233 - write(fd, buf, sizeof(buf)); 234 234 - close(fd); 235 235 - } 139 139 + #endif /* ndef ROCKBOX_NO_TEMP_SETTINGS_FILE */ 236 140 237 141 const char* setting_get_cfgvals(const struct settings_list *setting) 238 142 { ··· 242 146 return setting->choice_setting->cfg_vals; 243 147 else if ((setting->flags & F_BOOL_SETTING) == F_BOOL_SETTING) 244 148 { 245 245 - DEBUGF("Setting: %s \n", setting->cfg_name); 149 149 + logf("Setting: %s", setting->cfg_name); 246 150 return setting->bool_setting->cfg_vals; 247 151 } 248 152 else if ((setting->flags & F_HAS_CFGVALS) == F_HAS_CFGVALS) ··· 252 156 253 157 /** Reading from a config file **/ 254 158 /* 255 255 - * load settings from disk or RTC RAM 159 159 + * load settings from disk 256 160 */ 257 257 - void settings_load(int which) 161 161 + void settings_load(void) 258 162 { 259 163 logf("\r\n%s()\r\n", __func__); 260 164 debug_available_settings(); 261 165 262 262 - if (which & SETTINGS_RTC) 263 263 - read_nvram_data(); 264 264 - if (which & SETTINGS_HD) 265 265 - { 266 266 - rename_temp_file(CONFIGFILE_TEMP, CONFIGFILE, CONFIGFILE".old"); 267 267 - settings_load_config(CONFIGFILE, false); 268 268 - settings_load_config(FIXEDSETTINGSFILE, false); 269 269 - } 166 166 + /* make temp files current make current files .old */ 167 167 + rename_temp_file(RESUMEFILE_TEMP, RESUMEFILE, RESUMEFILE".old"); 168 168 + rename_temp_file(CONFIGFILE_TEMP, CONFIGFILE, CONFIGFILE".old"); 169 169 + 170 170 + settings_load_config(CONFIGFILE, false); /* load user_settings items */ 171 171 + settings_load_config(RESUMEFILE, false); /* load system_status items */ 172 172 + 173 173 + /* fixed settings file has final say on user_settings AND system_status items */ 174 174 + settings_load_config(FIXEDSETTINGSFILE, false); 175 175 + 176 176 + /* set initial CRC value - settings_save checks, if changed writes to disk */ 177 177 + user_settings_crc = crc_32(&global_settings, 178 178 + sizeof(global_settings), 0xFFFFFFFF); 270 179 } 271 180 272 181 bool cfg_string_to_int(const struct settings_list *setting, int* out, const char* str) ··· 533 442 (int)RGB_UNPACK_RED(colour), 534 443 (int)RGB_UNPACK_GREEN(colour), 535 444 (int)RGB_UNPACK_BLUE(colour)); 445 445 + break; /* we got a value */ 536 446 } 537 447 else 538 448 #endif 539 539 - if (setting_get_cfgvals(setting) == NULL) 540 540 - { 541 541 - snprintf(buf, buf_len, "%d", *(int*)setting->setting); 542 542 - } 543 543 - else 449 449 + if (setting_get_cfgvals(setting) != NULL && cfg_int_to_string( 450 450 + setting, *(int*)setting->setting, buf, buf_len)) 544 451 { 545 545 - if (!cfg_int_to_string(setting, *(int*)setting->setting, 546 546 - buf, buf_len)) 547 547 - snprintf(buf, buf_len, "%d", *(int*)setting->setting); 452 452 + break; /* we got a value */ 548 453 } 454 454 + 455 455 + snprintf(buf, buf_len, "%d", *(int*)setting->setting); 549 456 break; 550 457 case F_T_BOOL: 551 458 cfg_int_to_string(setting, *(bool*)setting->setting, buf, buf_len); ··· 599 506 sound_default(setting->sound_setting->setting)) 600 507 return false; 601 508 } 509 509 + else if (setting->flags & F_RESUMESETTING) 510 510 + { 511 511 + /* exclude resume settings they will get saved to '.resume.cfg' */ 512 512 + return false; 513 513 + } 602 514 else if (*(int*)setting->setting == setting->default_val.int_) 603 515 return false; 604 516 break; ··· 624 536 fd = open(filename,O_CREAT|O_TRUNC|O_WRONLY, 0666); 625 537 if (fd < 0) 626 538 return false; 627 627 - fdprintf(fd, "# .cfg file created by rockbox %s - " 539 539 + 540 540 + if (options != SETTINGS_SAVE_RESUMEINFO) 541 541 + { 542 542 + fdprintf(fd, "# .cfg file created by rockbox %s - " 628 543 "http://www.rockbox.org\r\n\r\n", rbversion); 544 544 + } 545 545 + 629 546 for(i=0; i<nb_settings; i++) 630 547 { 631 548 const struct settings_list *setting = &settings[i]; ··· 656 573 if (!(setting->flags & F_EQSETTING)) 657 574 continue; 658 575 break; 576 576 + case SETTINGS_SAVE_RESUMEINFO: 577 577 + if (!(setting->flags & F_RESUMESETTING)) 578 578 + continue; 579 579 + break; 580 580 + case SETTINGS_SAVE_ALL: 581 581 + { 582 582 + /*only save sound settings (volume) from F_RESUMESETTING items */ 583 583 + uint32_t exclude_flag = (F_RESUMESETTING|F_SOUNDSETTING); 584 584 + if ((setting->flags & exclude_flag) == F_RESUMESETTING) 585 585 + continue; 586 586 + break; 587 587 + } 659 588 } 660 589 cfg_to_string(setting, value, MAX_PATH); 661 590 logf("Written: '%s: %s'\r\n",setting->cfg_name, value); ··· 668 597 669 598 static void flush_global_status_callback(void) 670 599 { 671 671 - write_nvram_data(); 600 600 + if (TIME_AFTER(current_tick, next_status_update_tick)) 601 601 + { 602 602 + next_status_update_tick = current_tick + SYSTEM_STATUS_UPDATE_TICKS; 603 603 + update_runtime(); 604 604 + 605 605 + DEBUGF("Writing system_status to disk\n"); 606 606 + logf("Writing system_status to disk"); 607 607 + 608 608 + settings_write_config(RESUMEFILE_TEMP, SETTINGS_SAVE_RESUMEINFO); 609 609 + } 672 610 } 673 611 674 612 static void flush_config_block_callback(void) 675 613 { 676 676 - write_nvram_data(); 677 677 - settings_write_config(CONFIGFILE_TEMP, SETTINGS_SAVE_CHANGED); 614 614 + uint32_t crc = crc_32(&global_settings, sizeof(global_settings), 0xFFFFFFFF); 615 615 + if (user_settings_crc != crc) 616 616 + { 617 617 + DEBUGF("Writing changed user_settings to disk\n"); 618 618 + logf("Writing changed user_settings to disk"); 619 619 + 620 620 + user_settings_crc = crc; /* update immediately in case we yield */ 621 621 + if (!settings_write_config(CONFIGFILE_TEMP, SETTINGS_SAVE_CHANGED)) 622 622 + { 623 623 + user_settings_crc = 0; 624 624 + DEBUGF("Error failed to write settings to disk\n"); 625 625 + logf("Error failed to write settings to disk"); 626 626 + } 627 627 + } 628 628 + #ifdef LOGF_ENABLE 629 629 + else 630 630 + logf("No changes to user_settings"); 631 631 + #endif 632 632 + /* remove any outstanding status_cb and call it unconditionally */ 633 633 + next_status_update_tick = current_tick - 1; 634 634 + unregister_storage_idle_func(flush_global_status_callback, true); 678 635 } 679 636 680 637 void reset_runtime(void) ··· 684 641 } 685 642 686 643 /* 687 687 - * persist all runtime user settings to disk or RTC RAM 644 644 + * update runtime and if greater topruntime as well 688 645 */ 689 689 - static void update_runtime(void) 646 646 + void update_runtime(void) 690 647 { 691 648 int elapsed_secs; 692 649 ··· 698 655 global_status.topruntime = global_status.runtime; 699 656 } 700 657 701 701 - void status_save(void) 658 658 + void status_save(bool force) 702 659 { 703 703 - update_runtime(); 704 704 - register_storage_idle_func(flush_global_status_callback); 660 660 + if(force) 661 661 + { 662 662 + settings_save(); /* will force a status flush */ 663 663 + } 664 664 + else 665 665 + register_storage_idle_func(flush_global_status_callback); 705 666 } 706 667 707 668 int settings_save(void) 708 669 { 709 670 logf("%s", __func__); 710 710 - update_runtime(); 671 671 + /* remove any oustanding status_cb we will call it in the config_block_cb */ 672 672 + unregister_storage_idle_func(flush_global_status_callback, false); 711 673 register_storage_idle_func(flush_config_block_callback); 712 674 return 0; 713 675 } 714 676 715 677 bool settings_save_config(int options) 716 678 { 717 717 - /* if we have outstanding temp files it would be a good idea to flush 718 718 - them before the user starts saving things */ 719 719 - rename_temp_file(NVRAM_FILE_TEMP, NVRAM_FILE, NULL); /* dont overwrite .old */ 720 720 - rename_temp_file(CONFIGFILE_TEMP, CONFIGFILE, NULL); /* files from last boot */ 721 721 - 722 679 char filename[MAX_PATH]; 723 680 const char *folder, *namebase; 724 681 switch (options) ··· 805 762 #endif 806 763 sound_set(SOUND_BALANCE, global_settings.balance); 807 764 #ifndef PLATFORM_HAS_VOLUME_CHANGE 808 808 - sound_set(SOUND_VOLUME, global_settings.volume); 765 765 + sound_set(SOUND_VOLUME, global_status.volume); 809 766 #endif 810 767 sound_set(SOUND_CHANNELS, global_settings.channel_config); 811 768 sound_set(SOUND_STEREO_WIDTH, global_settings.stereo_width); ··· 1122 1079 CHART("<viewportmanager_theme_changed"); 1123 1080 } 1124 1081 1125 1125 - 1126 1082 /* 1127 1083 * reset all settings to their default value 1128 1084 */ ··· 1192 1148 const struct settings_list *setting = &settings[i]; 1193 1149 if (setting->cfg_name && !strcasecmp(setting->cfg_name, name)) 1194 1150 { 1195 1195 - logf("Found, flags: %s", debug_get_flags(settings[i].flags)); 1151 1151 + #ifdef LOGF_ENABLE 1152 1152 + name = debug_get_flags(settings[i].flags); 1153 1153 + logf("Found, %s", name); 1154 1154 + #endif 1196 1155 return setting; 1197 1156 } 1198 1157 } ··· 1356 1315 #ifdef LOGF_ENABLE 1357 1316 static char *debug_get_flags(uint32_t flags) 1358 1317 { 1359 1359 - static char buf[256] = {0}; 1318 1318 + static char buf[256]; 1360 1319 uint32_t ftype = flags & F_T_MASK; /* the variable type for the setting */ 1361 1320 flags &= ~F_T_MASK; 1321 1321 + uint32_t flags_rem = flags; 1362 1322 switch (ftype) 1363 1323 { 1364 1324 case F_T_CUSTOM: 1365 1365 - strlcpy(buf, "[Type CUSTOM] ", sizeof(buf)); 1325 1325 + strlcpy(buf, "Type: [CUSTOM] Flags: ", sizeof(buf)); 1366 1326 break; 1367 1327 case F_T_INT: 1368 1368 - strlcpy(buf, "[Type INT] ", sizeof(buf)); 1328 1328 + strlcpy(buf, "Type: [INT] Flags: ", sizeof(buf)); 1369 1329 break; 1370 1330 case F_T_UINT: 1371 1371 - strlcpy(buf, "[Type UINT] ", sizeof(buf)); 1331 1331 + strlcpy(buf, "Type: [UINT] Flags: ", sizeof(buf)); 1372 1332 break; 1373 1333 case F_T_BOOL: 1374 1374 - strlcpy(buf, "[Type BOOL] ", sizeof(buf)); 1334 1334 + strlcpy(buf, "Type: [BOOL] Flags: ", sizeof(buf)); 1375 1335 break; 1376 1336 case F_T_CHARPTR: 1377 1377 - strlcpy(buf, "[Type CHARPTR] ", sizeof(buf)); 1337 1337 + strlcpy(buf, "Type: [CHARPTR] Flags: ", sizeof(buf)); 1378 1338 break; 1379 1339 case F_T_UCHARPTR: 1380 1380 - strlcpy(buf, "[Type UCHARPTR] ", sizeof(buf)); 1340 1340 + strlcpy(buf, "Type: [UCHARPTR] Flags: ", sizeof(buf)); 1341 1341 + break; 1342 1342 + default: 1343 1343 + snprintf(buf, sizeof(buf), 1344 1344 + "Type: [!UNKNOWN TYPE! (0x%lx)] Flags: ", (long)ftype); 1381 1345 break; 1382 1346 } 1383 1347 1384 1348 #define SETTINGFLAGS(n) \ 1385 1385 - if(flags & n) { \ 1386 1386 - flags &= ~n; \ 1349 1349 + if(flags_rem & n) { \ 1350 1350 + flags_rem &= ~n; \ 1387 1351 strlcat(buf, "["#n"]", sizeof(buf));} 1388 1352 1389 1389 - SETTINGFLAGS(F_T_SOUND); 1390 1390 - SETTINGFLAGS(F_BOOL_SETTING); 1391 1391 - SETTINGFLAGS(F_RGB); 1392 1392 - SETTINGFLAGS(F_FILENAME); 1393 1393 - SETTINGFLAGS(F_INT_SETTING); 1353 1353 + SETTINGFLAGS(F_RESUMESETTING); 1354 1354 + SETTINGFLAGS(F_THEMESETTING); 1355 1355 + SETTINGFLAGS(F_RECSETTING); 1356 1356 + SETTINGFLAGS(F_EQSETTING); 1357 1357 + SETTINGFLAGS(F_SOUNDSETTING); 1394 1358 SETTINGFLAGS(F_CHOICE_SETTING); 1395 1359 SETTINGFLAGS(F_CHOICETALKS); 1396 1360 SETTINGFLAGS(F_TABLE_SETTING); 1397 1397 - SETTINGFLAGS(F_ALLOW_ARBITRARY_VALS); 1398 1398 - SETTINGFLAGS(F_CB_ON_SELECT_ONLY); 1399 1399 - SETTINGFLAGS(F_CB_ONLY_IF_CHANGED); 1361 1361 + SETTINGFLAGS(F_CUSTOM_SETTING); 1362 1362 + SETTINGFLAGS(F_TIME_SETTING); 1363 1363 + 1364 1364 + SETTINGFLAGS(F_FILENAME); 1365 1365 + SETTINGFLAGS(F_INT_SETTING); 1366 1366 + SETTINGFLAGS(F_T_SOUND); 1367 1367 + SETTINGFLAGS(F_RGB); 1368 1368 + SETTINGFLAGS(F_BOOL_SETTING); 1369 1369 + 1400 1370 SETTINGFLAGS(F_MIN_ISFUNC); 1401 1371 SETTINGFLAGS(F_MAX_ISFUNC); 1402 1372 SETTINGFLAGS(F_DEF_ISFUNC); 1403 1403 - SETTINGFLAGS(F_CUSTOM_SETTING); 1404 1404 - SETTINGFLAGS(F_TIME_SETTING); 1405 1405 - SETTINGFLAGS(F_THEMESETTING); 1406 1406 - SETTINGFLAGS(F_RECSETTING); 1407 1407 - SETTINGFLAGS(F_EQSETTING); 1408 1408 - SETTINGFLAGS(F_SOUNDSETTING); 1373 1373 + SETTINGFLAGS(F_ALLOW_ARBITRARY_VALS); 1374 1374 + SETTINGFLAGS(F_CB_ON_SELECT_ONLY); 1375 1375 + SETTINGFLAGS(F_CB_ONLY_IF_CHANGED); 1409 1376 SETTINGFLAGS(F_TEMPVAR); 1410 1377 SETTINGFLAGS(F_PADTITLE); 1411 1378 SETTINGFLAGS(F_NO_WRAP); 1412 1379 SETTINGFLAGS(F_BANFROMQS); 1413 1380 SETTINGFLAGS(F_DEPRECATED); 1381 1381 + 1382 1382 + SETTINGFLAGS(F_HAS_CFGVALS); 1414 1383 #undef SETTINGFLAGS 1415 1384 1416 1416 - if (flags & F_NVRAM_BYTES_MASK) 1417 1417 - { 1418 1418 - flags &= ~F_NVRAM_BYTES_MASK; 1419 1419 - strlcat(buf, "[NVRAM]", sizeof(buf)); 1420 1420 - } 1421 1385 /* anything left is unknown */ 1422 1422 - if (flags) 1386 1386 + if (flags_rem) 1423 1387 { 1424 1424 - strlcat(buf, "[UNKNOWN FLAGS]", sizeof(buf)); 1388 1388 + strlcat(buf, "[!UNKNOWN FLAGS!]", sizeof(buf)); 1425 1389 size_t len = strlen(buf); 1426 1390 if (len < sizeof(buf)) 1427 1427 - snprintf(buf + len, sizeof(buf) - len - 1, "[%x]", flags); 1391 1391 + snprintf(buf + len, sizeof(buf) - len - 1, "[0x%lx]", flags_rem); 1428 1392 } 1393 1393 + /* no flags set */ 1394 1394 + if (flags == 0) 1395 1395 + strlcat(buf, "[0x0]", sizeof(buf)); 1429 1396 return buf; 1430 1397 } 1431 1398 #endif 1432 1399 static void debug_available_settings(void) 1433 1400 { 1434 1401 #if defined(DEBUG_AVAIL_SETTINGS) && defined(LOGF_ENABLE) 1402 1402 + static char namebuf[128]; 1403 1403 + 1435 1404 logf("\r\nAvailable Settings:"); 1436 1405 for (int i=0; i<nb_settings; i++) 1437 1406 { 1438 1407 uint32_t flags = settings[i].flags; 1439 1408 const char *name; 1440 1409 if (settings[i].cfg_name) 1441 1441 - name = settings[i].cfg_name; 1410 1410 + { 1411 1411 + snprintf(namebuf, sizeof(namebuf), "'%s'", settings[i].cfg_name); 1412 1412 + name = namebuf; 1413 1413 + } 1442 1414 else if (settings[i].RESERVED == NULL) 1443 1415 { 1444 1444 - name = "SYS (NVRAM?)"; 1445 1445 - if (flags & F_NVRAM_BYTES_MASK) 1446 1446 - { 1447 1447 - flags &= ~F_NVRAM_BYTES_MASK; 1448 1448 - flags |= 0x80000; /* unused by other flags */ 1449 1449 - } 1416 1416 + name = "SYS"; 1450 1417 } 1451 1418 else 1452 1419 { 1453 1420 name = "?? UNKNOWN NAME ?? "; 1454 1421 } 1455 1455 - logf("'%s' flags: %s",name, debug_get_flags(flags)); 1422 1422 + 1423 1423 + logf("%-45s %s",name, debug_get_flags(flags)); 1456 1424 } 1457 1425 logf("End Available Settings\r\n"); 1458 1426 #endif

+5 -9

apps/settings.h

··· 245 245 246 246 247 247 /** function prototypes **/ 248 248 - 249 249 - /* argument bits for settings_load() */ 250 250 - #define SETTINGS_RTC (BIT_N(0)) /* only the settings from the RTC nonvolatile RAM */ 251 251 - #define SETTINGS_HD (BIT_N(1)) /* only the settings from the disk sector */ 252 252 - #define SETTINGS_ALL (SETTINGS_RTC|SETTINGS_HD) /* both */ 253 253 - void settings_load(int which) INIT_ATTR; 248 248 + void update_runtime(void); 249 249 + void settings_load(void) INIT_ATTR; 254 250 bool settings_load_config(const char* file, bool apply); 255 251 256 256 - void status_save(void); 252 252 + void status_save(bool force); 257 253 int settings_save(void); 258 254 void reset_runtime(void); 259 255 /* defines for the options paramater */ ··· 266 262 SETTINGS_SAVE_RECPRESETS, 267 263 #endif 268 264 SETTINGS_SAVE_EQPRESET, 265 265 + SETTINGS_SAVE_RESUMEINFO, 269 266 }; 270 267 bool settings_save_config(int options); 271 268 ··· 322 319 323 320 struct system_status 324 321 { 322 322 + int volume; /* audio output volume in decibels range depends on the dac */ 325 323 int resume_index; /* index in playlist (-1 for no active resume) */ 326 324 uint32_t resume_crc32; /* crc32 of the name of the file */ 327 325 uint32_t resume_elapsed; /* elapsed time in last file */ ··· 350 348 struct user_settings 351 349 { 352 350 /* audio settings */ 353 353 - 354 354 - int volume; /* audio output volume in decibels range depends on the dac */ 355 351 int balance; /* stereo balance: -100 - +100 -100=left 0=bal +100=right */ 356 352 int bass; /* bass boost/cut in decibels */ 357 353 int treble; /* treble boost/cut in decibels */

+30 -26

apps/settings_list.c

··· 73 73 #include "usb-ibasso.h" 74 74 #endif 75 75 76 76 - #define NVRAM(bytes) (bytes<<F_NVRAM_MASK_SHIFT) 77 77 - /** NOTE: NVRAM_CONFIG_VERSION is in settings_list.h 78 78 - and you may need to update it if you edit this file */ 79 79 - 80 76 #define UNUSED {.RESERVED=NULL} 81 77 #define INT(a) {.int_ = a} 82 78 #define UINT(a) {.uint_ = a} ··· 122 118 BOOL_SETTING(flags,var,lang_id,default,name,off_on, \ 123 119 LANG_SET_BOOL_YES,LANG_SET_BOOL_NO,cb) 124 120 125 125 - /* int variable which is NOT saved to .cfg files, 126 126 - (Use NVRAM() in the flags to save to the nvram (or nvram.bin file) */ 127 127 - #define SYSTEM_SETTING(flags,var,default) \ 128 128 - {flags|F_T_INT, &global_status.var,-1, INT(default), \ 129 129 - NULL, UNUSED} 121 121 + /*system_status int variable which is saved to resume.cfg */ 122 122 + #define SYSTEM_STATUS(flags,var,default,name) \ 123 123 + {flags|F_RESUMESETTING|F_T_INT, &global_status.var,-1, \ 124 124 + INT(default), name, UNUSED} 125 125 + /* system_status settings items will be saved to resume.cfg 126 126 + Use for int which use the set_sound() function to set them 127 127 + These items WILL be included in the users exported settings files 128 128 + */ 129 129 + #define SYSTEM_STATUS_SOUND(flags,var,lang_id,name,setting) \ 130 130 + {flags|F_T_INT|F_T_SOUND|F_SOUNDSETTING|F_ALLOW_ARBITRARY_VALS| \ 131 131 + F_RESUMESETTING, &global_status.var, lang_id, NODEFAULT,name, \ 132 132 + {.sound_setting=(struct sound_setting[]){{setting}}} } 130 133 131 134 /* setting which stores as a filename (or another string) in the .cfgvals 132 135 The string must be a char array (which all of our string settings are), ··· 828 831 #endif 829 832 830 833 const struct settings_list settings[] = { 831 831 - /* sound settings */ 832 832 - SOUND_SETTING(F_NO_WRAP, volume, LANG_VOLUME, "volume", SOUND_VOLUME), 834 834 + /* system_status settings .resume.cfg */ 835 835 + SYSTEM_STATUS_SOUND(F_NO_WRAP, volume, LANG_VOLUME, "volume", SOUND_VOLUME), 836 836 + #ifdef HAVE_PITCHCONTROL 837 837 + SYSTEM_STATUS(F_SOUNDSETTING, resume_pitch, PITCH_SPEED_100, "pitch"), 838 838 + SYSTEM_STATUS(F_SOUNDSETTING, resume_speed, PITCH_SPEED_100, "speed"), 839 839 + #endif 840 840 + SYSTEM_STATUS(0, resume_index, -1, "IDX"), 841 841 + SYSTEM_STATUS(0, resume_crc32, -1, "CRC"), 842 842 + SYSTEM_STATUS(0, resume_elapsed, -1, "ELA"), 843 843 + SYSTEM_STATUS(0, resume_offset, -1, "OFF"), 844 844 + SYSTEM_STATUS(0, resume_modified, false, "PLM"), 845 845 + SYSTEM_STATUS(0, runtime, 0, "CRT"), 846 846 + SYSTEM_STATUS(0, topruntime, 0, "TRT"), 847 847 + SYSTEM_STATUS(0, last_screen, -1, "PVS"), 848 848 + /* sound settings */ 833 849 CUSTOM_SETTING(F_NO_WRAP, volume_limit, LANG_VOLUME_LIMIT, 834 850 NULL, "volume limit", 835 851 volume_limit_load_from_cfg, volume_limit_write_to_cfg, ··· 972 988 OFFON_SETTING(F_CB_ON_SELECT_ONLY|F_CB_ONLY_IF_CHANGED, playlist_shuffle, 973 989 LANG_SHUFFLE, false, "shuffle", shuffle_playlist_callback), 974 990 975 975 - SYSTEM_SETTING(NVRAM(4), resume_index, -1), 976 976 - SYSTEM_SETTING(NVRAM(4), resume_crc32, -1), 977 977 - SYSTEM_SETTING(NVRAM(4), resume_elapsed, -1), 978 978 - SYSTEM_SETTING(NVRAM(4), resume_offset, -1), 979 979 - SYSTEM_SETTING(NVRAM(4), resume_modified, false), 980 980 - #ifdef HAVE_PITCHCONTROL 981 981 - SYSTEM_SETTING(NVRAM(4), resume_pitch, PITCH_SPEED_100), 982 982 - SYSTEM_SETTING(NVRAM(4), resume_speed, PITCH_SPEED_100), 983 983 - #endif 984 991 CHOICE_SETTING(F_CB_ON_SELECT_ONLY|F_CB_ONLY_IF_CHANGED, repeat_mode, 985 992 LANG_REPEAT, REPEAT_OFF, "repeat", "off,all,one,shuffle" 986 993 #ifdef AB_REPEAT_ENABLE ··· 1121 1128 "idle poweroff", UNIT_MIN, 0,60,1, 1122 1129 formatter_time_unit_0_is_off, getlang_time_unit_0_is_off, 1123 1130 set_poweroff_timeout), 1124 1124 - SYSTEM_SETTING(NVRAM(4), runtime, 0), 1125 1125 - SYSTEM_SETTING(NVRAM(4), topruntime, 0), 1126 1131 INT_SETTING(F_BANFROMQS, max_files_in_playlist, 1127 1132 LANG_MAX_FILES_IN_PLAYLIST, 1128 1133 #if CONFIG_CPU == PP5002 || CONFIG_CPU == PP5020 || CONFIG_CPU == PP5022 ··· 1172 1177 #endif /* IPOD_VIDEO */ 1173 1178 #endif 1174 1179 #if CONFIG_CHARGING 1175 1175 - OFFON_SETTING(NVRAM(1), car_adapter_mode, 1180 1180 + OFFON_SETTING(0, car_adapter_mode, 1176 1181 LANG_CAR_ADAPTER_MODE, false, "car adapter mode", NULL), 1177 1182 INT_SETTING_NOWRAP(0, car_adapter_mode_delay, LANG_CAR_ADAPTER_MODE_DELAY, 1178 1183 5, "delay before resume", UNIT_SEC, 5, 30, 5, ··· 1196 1201 #if CONFIG_TUNER 1197 1202 OFFON_SETTING(0, fm_force_mono, LANG_FM_MONO_MODE, 1198 1203 false, "force fm mono", toggle_mono_mode), 1199 1199 - SYSTEM_SETTING(NVRAM(4), last_frequency, 0), 1204 1204 + SYSTEM_STATUS(0, last_frequency, 0, "PFQ"), 1200 1205 #endif 1201 1206 #if defined(HAVE_RDS_CAP) && defined(CONFIG_RTC) 1202 1207 OFFON_SETTING(0, sync_rds_time, LANG_FM_SYNC_RDS_TIME, false, "sync_rds_time", NULL), ··· 1827 1832 #ifdef HAVE_DIRCACHE 1828 1833 /*enable dircache for all targets > 2MB of RAM by default*/ 1829 1834 OFFON_SETTING(F_BANFROMQS,dircache,LANG_DIRCACHE_ENABLE,true,"dircache",NULL), 1830 1830 - SYSTEM_SETTING(NVRAM(4),dircache_size,0), 1835 1835 + SYSTEM_STATUS(0, dircache_size, 0, "DSZ"), 1831 1836 #endif 1832 1837 1833 1838 #ifdef HAVE_TAGCACHE ··· 2049 2054 ID2P(LANG_BOOKMARK_MENU_RECENT_BOOKMARKS), 2050 2055 ID2P(LANG_OPEN_PLUGIN) 2051 2056 ), 2052 2052 - SYSTEM_SETTING(NVRAM(1),last_screen,-1), 2053 2057 #if defined(HAVE_RTC_ALARM) && \ 2054 2058 (defined(HAVE_RECORDING) || CONFIG_TUNER) 2055 2059 {F_T_INT|F_HAS_CFGVALS, &global_settings.alarm_wake_up_screen, LANG_ALARM_WAKEUP_SCREEN,

+4 -13

apps/settings_list.h

··· 119 119 Should really only be used if the value you want to store in global_settings 120 120 is very different to the string you want to use in the config. */ 121 121 #define F_CUSTOM_SETTING 0x8000 122 122 + 122 123 struct custom_setting { 123 124 /* load the saved value from the .cfg 124 125 setting: pointer into global_settings ··· 146 147 147 148 #define F_TIME_SETTING 0x10000 /* int,table format hh:mm:ss.mss auto ranged */ 148 149 #define F_HAS_CFGVALS 0x20000 /* uses setting union to carry cfg_vals */ 149 149 - 150 150 - 150 150 + #define F_RESUMESETTING 0x40000 /* saved to a separate cfg file on shutdown */ 151 151 + /*#define _AVAILABLE_ 0x80000*/ 151 152 /* these use the _isfunc_type type for the function */ 152 153 /* typedef int (*_isfunc_type)(void); */ 153 154 #define F_MIN_ISFUNC 0x100000 /* min(above) is function pointer to above type */ 154 155 #define F_MAX_ISFUNC 0x200000 /* max(above) is function pointer to above type */ 155 156 #define F_DEF_ISFUNC 0x400000 /* default_val is function pointer to above type */ 156 156 - 157 157 #define F_THEMESETTING 0x800000 158 158 #define F_RECSETTING 0x1000000 159 159 #define F_EQSETTING 0x2000000 160 160 #define F_SOUNDSETTING 0x4000000 161 161 - 162 162 - #define F_NVRAM_BYTES_MASK 0xE0000 /*0-4 bytes can be stored */ 163 163 - #define F_NVRAM_MASK_SHIFT 17 164 164 - #define NVRAM_CONFIG_VERSION 9 165 165 - /* Above define should be bumped if 166 166 - - a new NVRAM setting is added between 2 other NVRAM settings 167 167 - - number of bytes for a NVRAM setting is changed 168 168 - - a NVRAM setting is removed 169 169 - */ 170 170 - 161 161 + /*#define _AVAILABLE_ 0x8000000*/ 171 162 #define F_CB_ON_SELECT_ONLY 0x10000000 /* option_callback only called if selected */ 172 163 #define F_CB_ONLY_IF_CHANGED 0x20000000 /* option_callback only called if setting changed */ 173 164

+1 -1

apps/tree.c

··· 1321 1321 } 1322 1322 1323 1323 if (old_val != global_status.dircache_size) 1324 1324 - status_save(); 1324 1324 + status_save(true); 1325 1325 1326 1326 #ifdef HAVE_EEPROM_SETTINGS 1327 1327 if (savecache)

+1 -1

firmware/drivers/tuner/ipod_remote_tuner.c

··· 108 108 iap_send_pkt(data4, sizeof(data3)); 109 109 /* set volume */ 110 110 unsigned char data2[] = {0x03, 0x09, 0x04, 0x00, 0x00 }; 111 111 - data2[4] = (char)((global_settings.volume+58) * 4); 111 111 + data2[4] = (char)((global_status.volume+58) * 4); 112 112 iap_send_pkt(data2, sizeof(data2)); 113 113 } 114 114 else

+2 -1

firmware/export/rbpaths.h

··· 113 113 #define CODEPAGE_DIR ROCKBOX_DIR "/codepages" 114 114 115 115 #define VIEWERS_CONFIG ROCKBOX_DIR "/viewers.config" 116 116 + 117 117 + #define RESUMEFILE ROCKBOX_DIR "/.resume.cfg" 116 118 #define CONFIGFILE ROCKBOX_DIR "/config.cfg" 117 119 #define FIXEDSETTINGSFILE ROCKBOX_DIR "/fixed.cfg" 118 120 119 121 #define PLAYLIST_CONTROL_FILE ROCKBOX_DIR "/.playlist_control" 120 120 - #define NVRAM_FILE ROCKBOX_DIR "/nvram.bin" 121 122 #define GLYPH_CACHE_FILE ROCKBOX_DIR "/.glyphcache" 122 123 123 124 #endif /* __PATHS_H__ */

+1 -1

firmware/sound.c

··· 117 117 { 118 118 #ifndef BOOTLOADER 119 119 #ifndef PLATFORM_HAS_VOLUME_CHANGE 120 120 - SOUND_CUR_SET(VOLUME, global_settings.volume) 120 120 + SOUND_CUR_SET(VOLUME, global_status.volume) 121 121 #endif 122 122 #if defined(AUDIOHW_HAVE_BASS) 123 123 SOUND_CUR_SET(BASS, global_settings.bass)