len0rd/rockbox
1
0
Fork 1
mirror of https://github.com/Rockbox/rockbox.git synced 2025-10-13 10:07:38 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Remove NVRAM infavor of a separate cfg file

Browse source 
remove nvram and use the existing settings framework for it

add a crc check to the user_settings data to see if we need to save
the user setting file or if we can just save the status file (resume.cfg)

move volume to the system_status struct so we don't write the whole settings file
over volume changes

allow user to still export volume with save sound settings

allow the user to also export pitch and speed

name the file .resume.cfg

Rename all the SYSTEM_STATUS save file variables to TLAs to save space and
discourage tinkering

Cleanup DEBUG_AVAIL_SETTINGS output

when saving user_settings it calls status_save as well this cause the resume
file to be written twice. instead remove the callback for status_save
when setting_save is called

remove header text when saving .resume.cfg

convert status_save() to status_save(bool force)
add SYSTEM_STATUS_UPDATE_TICKS

for ATA device set this to 5 minutes
since we arlready wait for the disk to be up before saving
we don't want to miss our window

for all other every 15 minutes

that way if the battery is too low by the time shutdown comes around you
don't lose much progress

Change-Id: I27214ffd6e5d5494ee5ca83b14f04a41ba426ad7
This commit is contained in:
William Wilgus 2025-01-19 18:17:13 -05:00 • committed by William Wilgus
parent 8e293b4948
commit 7100090f99
41 changed files with 299 additions and 340 deletions
Download patch file Download diff file Expand all files Collapse all files

2
apps/filetree.c
View file

@ -829,7 +829,7 @@ int ft_enter(struct tree_context* c)
playlist_get_filename_crc32(NULL, start_index);
global_status.resume_elapsed = 0;
global_status.resume_offset = 0;
status_save();
status_save(false);
rc = GO_TO_WPS;
}
else {

4
apps/gui/skin_engine/skin_display.c
View file

@ -187,10 +187,10 @@ void draw_progressbar(struct gui_wps *gwps, struct skin_viewport* skin_viewport,
int maxvol = sound_max(SOUND_VOLUME);
#if defined(HAVE_PERCEPTUAL_VOLUME) || defined(HAVE_TOUCHSCREEN)
length = 1000;
end = to_normalized_volume(global_settings.volume, minvol, maxvol, length);
end = to_normalized_volume(global_status.volume, minvol, maxvol, length);
#else
length = maxvol - minvol;
end = global_settings.volume - minvol;
end = global_status.volume - minvol;
#endif
}
else if (pb->type == SKIN_TOKEN_BATTERY_PERCENTBAR)

2
apps/gui/skin_engine/skin_parser.c
View file

@ -1910,7 +1910,7 @@ static int parse_touchregion(struct skin_element *element,
if (region->action == ACTION_TOUCH_MUTE)
{
region->value = global_settings.volume;
region->value = global_status.volume;
}

12
apps/gui/skin_engine/skin_tokens.c
View file

@ -1173,30 +1173,30 @@ const char *get_token_value(struct gui_wps *gwps,
case SKIN_TOKEN_VOLUME:
format_sound_value_ex(buf, buf_size, SOUND_VOLUME,
global_settings.volume, true);
global_status.volume, true);
if (intval)
{
int minvol = sound_min(SOUND_VOLUME);
if (limit == TOKEN_VALUE_ONLY)
{
numeric_ret = global_settings.volume;
numeric_ret = global_status.volume;
}
else if (global_settings.volume == minvol)
else if (global_status.volume == minvol)
{
numeric_ret = 1;
}
else if (global_settings.volume == 0)
else if (global_status.volume == 0)
{
numeric_ret = limit - 1;
}
else if (global_settings.volume > 0)
else if (global_status.volume > 0)
{
numeric_ret = limit;
}
else
{
numeric_ret = (limit-3) * (global_settings.volume - minvol - 1)
numeric_ret = (limit-3) * (global_status.volume - minvol - 1)
/ (-1 - minvol) + 2;
}
}

8
apps/gui/skin_engine/skin_touchsupport.c
View file

@ -274,12 +274,12 @@ int skin_get_touchaction(struct gui_wps *gwps, int* edge_offset)
case ACTION_TOUCH_MUTE:
{
const int min_vol = sound_min(SOUND_VOLUME);
if (global_settings.volume == min_vol)
global_settings.volume = temp->value;
if (global_status.volume == min_vol)
global_status.volume = temp->value;
else
{
temp->value = global_settings.volume;
global_settings.volume = min_vol;
temp->value = global_status.volume;
global_status.volume = min_vol;
}
setvol();
returncode = ACTION_REDRAW;

2
apps/gui/statusbar.c
View file

@ -229,7 +229,7 @@ static struct screen * sb_fill_bar_info(struct gui_statusbar * bar)
bar->battery_icon_switch_tick = current_tick + HZ;
}
}
bar->info.volume = global_settings.volume;
bar->info.volume = global_status.volume;
bar->info.shuffle = global_settings.playlist_shuffle;
#ifdef HAS_BUTTON_HOLD
bar->info.keylock = button_hold();

4
apps/gui/wps.c
View file

@ -192,8 +192,8 @@ static int skintouch_to_wps(void)
const int max_vol = sound_max(SOUND_VOLUME);
const int step_vol = sound_steps(SOUND_VOLUME);
global_settings.volume = from_normalized_volume(offset, min_vol, max_vol, 1000);
global_settings.volume -= (global_settings.volume % step_vol);
global_status.volume = from_normalized_volume(offset, min_vol, max_vol, 1000);
global_status.volume -= (global_status.volume % step_vol);
setvol();
}
return ACTION_TOUCHSCREEN;

4
apps/iap/iap-core.c
View file

@ -322,7 +322,7 @@ void iap_set_remote_volume(void)
IAP_TX_INIT(0x03, 0x0D);
IAP_TX_PUT(0x04);
IAP_TX_PUT(0x00);
IAP_TX_PUT(0xFF & (int)((global_settings.volume + 90) * 2.65625));
IAP_TX_PUT(0xFF & (int)((global_status.volume + 90) * 2.65625));
iap_send_tx();
}
@ -882,7 +882,7 @@ void iap_periodic(void)
IAP_TX_INIT(0x03, 0x09);
IAP_TX_PUT(0x04);
IAP_TX_PUT(0x00);
IAP_TX_PUT(0xFF &(int)((global_settings.volume + 90) * 2.65625));
IAP_TX_PUT(0xFF &(int)((global_status.volume + 90) * 2.65625));
device.changed_notifications |= BIT_N(4);
iap_send_tx();
}

12
apps/iap/iap-lingo3.c
View file

@ -265,7 +265,7 @@ void iap_handlepkt_mode3(const unsigned int len, const unsigned char *buf)
device.play_status = audio_status();
/* TODO: Fix this */
device.mute = false;
device.volume = global_settings.volume;
device.volume = global_status.volume;
device.power_state = charger_input_state;
device.battery_level = battery_level();
/* TODO: Fix this */
@ -441,7 +441,7 @@ void iap_handlepkt_mode3(const unsigned int len, const unsigned char *buf)
/* Mute status False*/
IAP_TX_PUT(0x00);
/* Volume */
IAP_TX_PUT(0xFF & (int)((global_settings.volume + 90) * 2.65625));
IAP_TX_PUT(0xFF & (int)((global_status.volume + 90) * 2.65625));
} else {
/* Mute status True*/
@ -630,8 +630,8 @@ void iap_handlepkt_mode3(const unsigned int len, const unsigned char *buf)
/* Mute status False*/
IAP_TX_PUT(0x00);
/* Volume */
IAP_TX_PUT(0xFF & (int)((global_settings.volume + 90) * 2.65625));
IAP_TX_PUT(0xFF & (int)((global_settings.volume + 90) * 2.65625));
IAP_TX_PUT(0xFF & (int)((global_status.volume + 90) * 2.65625));
IAP_TX_PUT(0xFF & (int)((global_status.volume + 90) * 2.65625));
} else {
/* Mute status True*/
@ -766,7 +766,7 @@ void iap_handlepkt_mode3(const unsigned int len, const unsigned char *buf)
CHECKLEN(5);
if (buf[0x03]==0x00){
/* Not Muted */
global_settings.volume = (int) (buf[0x04]/2.65625)-90;
global_status.volume = (int) (buf[0x04]/2.65625)-90;
device.mute = false;
}
else {
@ -940,7 +940,7 @@ void iap_handlepkt_mode3(const unsigned int len, const unsigned char *buf)
CHECKLEN(7);
if (buf[0x03]==0x00){
/* Not Muted */
global_settings.volume = (int) (buf[0x04]/2.65625)-90;
global_status.volume = (int) (buf[0x04]/2.65625)-90;
device.mute = false;
}
else {

10
apps/main.c
View file

@ -319,7 +319,7 @@ static int INIT_ATTR init_dircache(bool preinit)
struct dircache_info info;
dircache_get_info(&info);
global_status.dircache_size = info.size;
status_save();
status_save(true);
}
/* else don't wait or already enabled by load */
}
@ -435,7 +435,7 @@ static void init(void)
pcm_init();
dsp_init();
settings_reset();
settings_load(SETTINGS_ALL);
settings_load();
settings_apply(true);
#ifdef HAVE_DIRCACHE
init_dircache(true);
@ -679,9 +679,9 @@ static void init(void)
pcm_init();
dsp_init();
CHART(">settings_load(ALL)");
settings_load(SETTINGS_ALL);
CHART("<settings_load(ALL)");
CHART(">settings_load");
settings_load();
CHART("<settings_load");
#if defined(BUTTON_REC) || \
(CONFIG_KEYPAD == GIGABEAT_PAD) || \

2
apps/menus/sound_menu.c
View file

@ -87,7 +87,7 @@ static int volume_limit_callback(int action,
/***********************************/
/* SOUND MENU */
MENUITEM_SETTING(volume, &global_settings.volume, NULL);
MENUITEM_SETTING(volume, &global_status.volume, NULL);
MENUITEM_SETTING(volume_limit, &global_settings.volume_limit, volume_limit_callback);
#ifdef AUDIOHW_HAVE_BASS
MENUITEM_SETTING(bass, &global_settings.bass,

35
apps/misc.c
View file

@ -345,7 +345,7 @@ static bool clean_shutdown(enum shutdown_type sd_type,
talk_disable(true);
}
status_save();
status_save(true);
#if CONFIG_CHARGING && !defined(HAVE_POWEROFF_WHILE_CHARGING)
if(!charger_inserted())
@ -751,8 +751,8 @@ long default_event_handler_ex(long event, void (*callback)(void *), void *parame
* event data is available in the last button data */
int volume = button_get_data();
DEBUGF("SYS_VOLUME_CHANGED: %d\n", volume);
if (global_settings.volume != volume) {
global_settings.volume = volume;
if (global_status.volume != volume) {
global_status.volume = volume;
if (firstvolume) {
setvol();
firstvolume = false;
@ -859,16 +859,17 @@ void setvol(void)
{
const int min_vol = sound_min(SOUND_VOLUME);
const int max_vol = sound_max(SOUND_VOLUME);
if (global_settings.volume < min_vol)
global_settings.volume = min_vol;
if (global_settings.volume > max_vol)
global_settings.volume = max_vol;
if (global_settings.volume > global_settings.volume_limit)
global_settings.volume = global_settings.volume_limit;
sound_set_volume(global_settings.volume);
int volume = global_status.volume;
if (volume < min_vol)
volume = min_vol;
if (volume > max_vol)
volume = max_vol;
if (volume > global_settings.volume_limit)
volume = global_settings.volume_limit;
global_status.volume = volume;
sound_set_volume(volume);
global_status.last_volume_change = current_tick;
settings_save();
status_save(false);
}
#ifdef HAVE_PERCEPTUAL_VOLUME
@ -920,7 +921,7 @@ void set_normalized_volume(int vol)
if (vol >= norm_tab_size)
vol = norm_tab_size - 1;
global_settings.volume = norm_tab[vol];
global_status.volume = norm_tab[vol];
}
int get_normalized_volume(void)
@ -931,7 +932,7 @@ int get_normalized_volume(void)
while (a != b)
{
int i = (a + b + 1) / 2;
if (global_settings.volume < norm_tab[i])
if (global_status.volume < norm_tab[i])
b = i - 1;
else
a = i;
@ -942,12 +943,12 @@ int get_normalized_volume(void)
#else
void set_normalized_volume(int vol)
{
global_settings.volume = vol * sound_steps(SOUND_VOLUME);
global_status.volume = vol * sound_steps(SOUND_VOLUME);
}
int get_normalized_volume(void)
{
return global_settings.volume / sound_steps(SOUND_VOLUME);
return global_status.volume / sound_steps(SOUND_VOLUME);
}
#endif
@ -971,7 +972,7 @@ void adjust_volume_ex(int steps, enum volume_adjust_mode mode)
#endif
case VOLUME_ADJUST_DIRECT:
default:
global_settings.volume += steps * sound_steps(SOUND_VOLUME);
global_status.volume += steps * sound_steps(SOUND_VOLUME);
break;
}

2
apps/playback.c
View file

@ -3011,7 +3011,7 @@ static void audio_start_playback(const struct audio_resume_info *resume_info,
audio_set_output_source(AUDIO_SRC_PLAYBACK);
#endif
#ifndef PLATFORM_HAS_VOLUME_CHANGE
sound_set_volume(global_settings.volume);
sound_set_volume(global_status.volume);
#endif
pcmbuf_update_frequency();

4
apps/playlist.c
View file

@ -3777,7 +3777,7 @@ int playlist_update_resume_info(const struct mp3entry* id3)
global_status.resume_elapsed = id3->elapsed;
global_status.resume_offset = id3->offset;
global_status.resume_modified = pl_modified;
status_save();
status_save(false);
}
}
else
@ -3787,7 +3787,7 @@ int playlist_update_resume_info(const struct mp3entry* id3)
global_status.resume_elapsed = -1;
global_status.resume_offset = -1;
global_status.resume_modified = false;
status_save();
status_save(true);
return -1;
}

2
apps/plugin.c
View file

@ -1029,7 +1029,7 @@ int plugin_load(const char* plugin, const void* parameter)
plugin_check_open_close__exit();
status_save();
status_save(false);
if (rc == PLUGIN_ERROR)
splash(HZ*2, str(LANG_PLUGIN_ERROR));

8
apps/plugins/beatbox/beatbox.c
View file

@ -601,23 +601,23 @@ int beatboxmain()
/*
case BTN_UP:
case BTN_UP | BUTTON_REPEAT:
vol = rb->global_settings->volume;
vol = rb->global_status->volume;
if (vol < rb->sound_max(SOUND_VOLUME))
{
vol++;
rb->sound_set(SOUND_VOLUME, vol);
rb->global_settings->volume = vol;
rb->global_status->volume = vol;
}
break;
case BTN_DOWN:
case BTN_DOWN | BUTTON_REPEAT:
vol = rb->global_settings->volume;
vol = rb->global_status->volume;
if (vol > rb->sound_min(SOUND_VOLUME))
{
vol--;
rb->sound_set(SOUND_VOLUME, vol);
rb->global_settings->volume = vol;
rb->global_status->volume = vol;
}
break;

4
apps/plugins/doom/m_menu.c
View file

@ -878,7 +878,7 @@ void M_SystemVol(int choice)
{
systemvol-=5;
rb->sound_set(SOUND_VOLUME, systemvol);
rb->global_settings->volume = systemvol;
rb->global_status->volume = systemvol;
}
break;
case 1:
@ -886,7 +886,7 @@ void M_SystemVol(int choice)
{
systemvol+=5;
rb->sound_set(SOUND_VOLUME, systemvol);
rb->global_settings->volume = systemvol;
rb->global_status->volume = systemvol;
}
break;
}

4
apps/plugins/doom/rockdoom.c
View file

@ -718,8 +718,8 @@ enum plugin_status plugin_start(const void* parameter)
int mod = (rb->sound_max(SOUND_VOLUME)-rb->sound_min(SOUND_VOLUME))/15;
if(mod == 0)
mod = rb->global_settings->volume;
systemvol= rb->global_settings->volume-rb->global_settings->volume%mod;
mod = rb->global_status->volume;
systemvol= rb->global_status->volume-rb->global_status->volume%mod;
general_translucency = default_translucency; // phares

2
apps/plugins/fft/fft.c
View file

@ -978,7 +978,7 @@ static void fft_osd_format_message(enum fft_setting_flags id)
case FFT_SETF_VOLUME:
rb->snprintf(fft_osd_message, sizeof (fft_osd_message),
"Volume: %d%s",
rb->sound_val2phys(SOUND_VOLUME, global_settings.volume),
rb->sound_val2phys(SOUND_VOLUME, global_status.volume),
rb->sound_unit(SOUND_VOLUME));
return;
#endif

2
apps/plugins/lib/playback_control.c
View file

@ -65,7 +65,7 @@ static bool nexttrack(void)
static bool volume(void)
{
const struct settings_list* vol =
rb->find_setting(&rb->global_settings->volume);
rb->find_setting(&rb->global_status->volume);
return rb->option_screen((struct settings_list*)vol, parentvp, false, "Volume");
}

12
apps/plugins/metronome.c
View file

@ -887,7 +887,7 @@ static void metronome_draw(struct screen* display, int state)
/* One line in several. */
rb->snprintf( buffer, sizeof(buffer), "%u/%u@%u V%d"
, ps->beats_per_bar, ps->base_beat
, bpm, rb->global_settings->volume );
, bpm, rb->global_status->volume );
display->puts(0,4, buffer);
/* Would it hurt to draw a 3rd line to 2-line display?
@ -931,7 +931,7 @@ static void metronome_draw(struct screen* display, int state)
#endif
rb->snprintf( buffer, sizeof(buffer), "BPM: %d Vol: %d"
, bpm, rb->global_settings->volume );
, bpm, rb->global_status->volume );
display->puts(0,3, buffer);
display->hline(0, 111, 12);
@ -962,7 +962,7 @@ static void draw_display(void)
This is for parts with associated volume. */
static void tweak_volume(int offset)
{
int vol = rb->global_settings->volume + offset;
int vol = rb->global_status->volume + offset;
int minvol = rb->sound_min(SOUND_VOLUME);
int maxvol = rb->sound_max(SOUND_VOLUME);
@ -1121,13 +1121,13 @@ static void change_volume(int delta)
{
int minvol = rb->sound_min(SOUND_VOLUME);
int maxvol = rb->sound_max(SOUND_VOLUME);
int vol = rb->global_settings->volume + delta;
int vol = rb->global_status->volume + delta;
if (vol > maxvol) vol = maxvol;
else if(vol < minvol) vol = minvol;
if(vol != rb->global_settings->volume)
if(vol != rb->global_status->volume)
{
rb->global_settings->volume = vol;
rb->global_status->volume = vol;
tweak_volume(part->volume);
trigger_display(display_state);
}

8
apps/plugins/midi/midiplay.c
View file

@ -588,12 +588,12 @@ static int midimain(const void * filename)
case MIDI_VOL_UP:
case MIDI_VOL_UP | BUTTON_REPEAT:
{
vol = rb->global_settings->volume;
vol = rb->global_status->volume;
if (vol < rb->sound_max(SOUND_VOLUME))
{
vol++;
rb->sound_set(SOUND_VOLUME, vol);
rb->global_settings->volume = vol;
rb->global_status->volume = vol;
}
break;
}
@ -601,12 +601,12 @@ static int midimain(const void * filename)
case MIDI_VOL_DOWN:
case MIDI_VOL_DOWN | BUTTON_REPEAT:
{
vol = rb->global_settings->volume;
vol = rb->global_status->volume;
if (vol > rb->sound_min(SOUND_VOLUME))
{
vol--;
rb->sound_set(SOUND_VOLUME, vol);
rb->global_settings->volume = vol;
rb->global_status->volume = vol;
}
break;
}

2
apps/plugins/mikmod/mikmod.c
View file

@ -326,7 +326,7 @@ static void showinfo(void)
module->sngspd, module->bpm);
rb->lcd_putsxy(1, 1 + 6 * font_h, statustext);
sprintf(statustext, "vol: %ddB", rb->global_settings->volume);
sprintf(statustext, "vol: %ddB", rb->global_status->volume);
rb->lcd_putsxy(1, 1 + 7 * font_h, statustext);
sprintf(statustext, "time: %d:%02d",

8
apps/plugins/mpegplayer/mpegplayer.c
View file

@ -1462,7 +1462,7 @@ static void osd_refresh_volume(void)
char buf[32];
int width;
int volume = rb->global_settings->volume;
int volume = rb->global_status->volume;
rb->snprintf(buf, sizeof (buf), "%d%s",
rb->sound_val2phys(SOUND_VOLUME, volume),
rb->sound_unit(SOUND_VOLUME));
@ -1870,7 +1870,7 @@ static int osd_stream_status(void)
/* Change the current audio volume by a specified amount */
static void osd_set_volume(int delta)
{
int vol = rb->global_settings->volume;
int vol = rb->global_status->volume;
int limit;
vol += delta;
@ -1888,9 +1888,9 @@ static void osd_set_volume(int delta)
}
/* Sync the global settings */
if (vol != rb->global_settings->volume) {
if (vol != rb->global_status->volume) {
rb->sound_set(SOUND_VOLUME, vol);
rb->global_settings->volume = vol;
rb->global_status->volume = vol;
}
/* Update the volume display */

8
apps/plugins/oscilloscope.c
View file

@ -2113,13 +2113,13 @@ enum plugin_status plugin_start(const void* parameter)
case OSCILLOSCOPE_VOL_UP:
case OSCILLOSCOPE_VOL_UP | BUTTON_REPEAT:
{
int vol = rb->global_settings->volume;
int vol = rb->global_status->volume;
if (vol < rb->sound_max(SOUND_VOLUME))
{
vol++;
rb->sound_set(SOUND_VOLUME, vol);
rb->global_settings->volume = vol;
rb->global_status->volume = vol;
}
osc_popupmsg(OSC_MSG_VOLUME, vol);
@ -2129,13 +2129,13 @@ enum plugin_status plugin_start(const void* parameter)
case OSCILLOSCOPE_VOL_DOWN:
case OSCILLOSCOPE_VOL_DOWN | BUTTON_REPEAT:
{
int vol = rb->global_settings->volume;
int vol = rb->global_status->volume;
if (vol > rb->sound_min(SOUND_VOLUME))
{
vol--;
rb->sound_set(SOUND_VOLUME, vol);
rb->global_settings->volume = vol;
rb->global_status->volume = vol;
}
osc_popupmsg(OSC_MSG_VOLUME, vol);

2
apps/plugins/rockboy/menu.c
View file

@ -428,7 +428,7 @@ static void do_opt_menu(void)
options.dirty=1; /* Assume that the settings have been changed */
struct viewport *parentvp = NULL;
const struct settings_list* vol = rb->find_setting(&rb->global_settings->volume);
const struct settings_list* vol = rb->find_setting(&rb->global_status->volume);
while(!done)
{

4
apps/plugins/test_sampr.c
View file

@ -174,7 +174,7 @@ static void set_frequency(int index)
#ifndef HAVE_VOLUME_IN_LIST
static void set_volume(int value)
{
rb->global_settings->volume = value;
rb->global_status->volume = value;
rb->sound_set(SOUND_VOLUME, value);
}
@ -243,7 +243,7 @@ static void play_tone(bool volume_set)
#ifndef HAVE_VOLUME_IN_LIST
if (volume_set)
{
int volume = rb->global_settings->volume;
int volume = rb->global_status->volume;
rb->set_int("Volume", NULL, -1, &volume,
set_volume, 1, rb->sound_min(SOUND_VOLUME),

6
apps/plugins/vu_meter.c
View file

@ -637,13 +637,13 @@ static void save_settings(void) {
static void change_volume(int delta) {
int minvol = rb->sound_min(SOUND_VOLUME);
int maxvol = rb->sound_max(SOUND_VOLUME);
int vol = rb->global_settings->volume + delta;
int vol = rb->global_status->volume + delta;
if (vol > maxvol) vol = maxvol;
else if (vol < minvol) vol = minvol;
if (vol != rb->global_settings->volume) {
if (vol != rb->global_status->volume) {
rb->sound_set(SOUND_VOLUME, vol);
rb->global_settings->volume = vol;
rb->global_status->volume = vol;
rb->lcd_putsxyf(0,0, "%d", vol);
rb->lcd_update();
rb->sleep(HZ/12);

2
apps/plugins/xworld/sys.c
View file

@ -286,7 +286,7 @@ static void do_sound_settings(struct System* sys)
case 2:
{
const struct settings_list* vol =
rb->find_setting(&rb->global_settings->volume);
rb->find_setting(&rb->global_status->volume);
rb->option_screen((struct settings_list*)vol, NULL, false, "Volume");
break;
}

6
apps/radio/radio.c
View file

@ -296,7 +296,7 @@ void remember_frequency(void)
&fm_region_data[global_settings.fm_region];
global_status.last_frequency = (curr_freq - fmr->freq_min)
/ fmr->freq_step;
status_save();
status_save(true);
}
/* Step to the next or previous frequency */
@ -531,14 +531,14 @@ void radio_screen(void)
case ACTION_SETTINGS_INC:
case ACTION_SETTINGS_INCREPEAT:
global_settings.volume += sound_steps(SOUND_VOLUME);
global_status.volume += sound_steps(SOUND_VOLUME);
setvol();
update_type = SKIN_REFRESH_NON_STATIC;
break;
case ACTION_SETTINGS_DEC:
case ACTION_SETTINGS_DECREPEAT:
global_settings.volume -= sound_steps(SOUND_VOLUME);
global_status.volume -= sound_steps(SOUND_VOLUME);
setvol();
update_type = SKIN_REFRESH_NON_STATIC;
break;

6
apps/recorder/recording.c
View file

@ -773,7 +773,7 @@ static const char* reclist_get_name(int selected_item, void * data,
case ITEM_VOLUME:
snprintf(buffer, buffer_len, "%s: %s", str(LANG_VOLUME),
fmt_gain(SOUND_VOLUME,
global_settings.volume,
global_status.volume,
buf2, sizeof(buf2)));
break;
#endif
@ -896,7 +896,7 @@ static void recording_step_levels(int setting_id, int steps)
switch(setting_id)
{
case SOUND_VOLUME:
global_settings.volume += steps;
global_status.volume += steps;
setvol();
break;
#if defined(HAVE_LINE_REC) || defined(HAVE_FMRADIO_REC)
@ -1020,7 +1020,7 @@ bool recording_screen(bool no_source)
#endif
audio_init_recording();
sound_set_volume(global_settings.volume);
sound_set_volume(global_status.volume);
#if CONFIG_RTC == 0
/* Create new filename for recording start */

3
apps/root_menu.c
View file

@ -710,7 +710,7 @@ static inline int load_screen(int screen)
if (screen == old_previous)
old_previous = GO_TO_ROOT;
global_status.last_screen = (char)screen;
status_save();
status_save(false);
if (screen == GO_TO_BROWSEPLUGINS)
activity = ACTIVITY_PLUGINBROWSER;
@ -774,7 +774,6 @@ static int load_plugin_screen(char *key)
int old_global = global_status.last_screen;
last_screen = next_screen;
global_status.last_screen = (char)next_screen;
/*status_save(); //only needed if we crash */
while(loops-- > 0) /* just to keep things from getting out of hand */
{

3
apps/screens.c
View file

@ -889,8 +889,7 @@ static const char* runtime_get_data(int selected_item, void* data,
{
case 0:return str(LANG_RUNNING_TIME);
case 1: {
global_status.runtime += ((current_tick - lasttime) / HZ);
lasttime = current_tick;
update_runtime();
t = global_status.runtime;
break;
}

348
apps/settings.c
View file

@ -8,7 +8,6 @@
* $Id$
*
* Copyright (C) 2002 by Stuart Martin
* RTC config saving code (C) 2002 by hessu@hes.iki.fi
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
@ -79,6 +78,17 @@
struct user_settings global_settings;
struct system_status global_status;
static uint32_t user_settings_crc;
static long next_status_update_tick;
long lasttime = 0;
/* flush system_status more often for spinning harddisks as we may not be able
* to spin up at shutdown in order to save so keep the gap minimal */
#if (CONFIG_STORAGE & STORAGE_ATA)
#define SYSTEM_STATUS_UPDATE_TICKS (HZ * 60 * 5) /* flush every 5 minutes */
#else
#define SYSTEM_STATUS_UPDATE_TICKS (HZ * 60 * 15) /* flush every 15 minutes */
#endif
#include "dsp_proc_settings.h"
#include "playback.h"
@ -87,11 +97,6 @@ struct system_status global_status;
#endif
#include "pcm_sampr.h"
#define NVRAM_DATA_START 8
#define NVRAM_BLOCK_SIZE (sizeof(struct system_status) + NVRAM_DATA_START)
#define MAX_LINES 10
#ifdef HAVE_REMOTE_LCD
#include "lcd-remote.h"
#endif
@ -103,14 +108,16 @@ struct system_status global_status;
#ifdef ROCKBOX_NO_TEMP_SETTINGS_FILE /* Overwrites same file each time */
#define CONFIGFILE_TEMP CONFIGFILE
#define NVRAM_FILE_TEMP NVRAM_FILE
#define RESUMEFILE_TEMP RESUMEFILE
#define rename_temp_file(a,b,c)
#else /* creates temp files on save, renames next load, saves old file if desired */
#define CONFIGFILE_TEMP CONFIGFILE".new"
#define NVRAM_FILE_TEMP NVRAM_FILE".new"
#define RESUMEFILE_TEMP RESUMEFILE".new"
#ifdef LOGF_ENABLE
static char *debug_get_flags(uint32_t flags);
#undef DEBUGF /* allow DEBUGF or logf not both */
#define DEBUGF(...) do { } while(0)
#endif
static void debug_available_settings(void);
@ -129,110 +136,7 @@ static void rename_temp_file(const char *tempfile,
rename(tempfile, file);
}
}
#endif
long lasttime = 0;
/** NVRAM stuff, if the target doesnt have NVRAM it is saved in ROCKBOX_DIR /nvram.bin **/
/* NVRAM is set out as
*
* [0] 'R'
* [1] 'b'
* [2] version
* [3] stored variable count
* [4-7] crc32 checksum in host endian order
* [8+] data
*/
static unsigned int nvram_crc(char *buf, int max_len)
{
return crc_32(&buf[NVRAM_DATA_START], max_len - NVRAM_DATA_START - 1, NVRAM_BLOCK_SIZE);
}
static void read_nvram_data(void)
{
rename_temp_file(NVRAM_FILE_TEMP, NVRAM_FILE, NVRAM_FILE".old");
int fd = open(NVRAM_FILE, O_RDONLY);
if (fd < 0)
return;
char buf[NVRAM_BLOCK_SIZE];
memset(buf, 0, sizeof(buf));
ssize_t bytes = read(fd, buf, sizeof(buf));
close(fd);
if (bytes < 8) /* min is 8 bytes,magic, ver, vars, crc32 */
return;
/* check magic, version */
if (buf[0] != 'R' || buf[1] != 'b' || buf[2] != NVRAM_CONFIG_VERSION)
return;
/* check crc32 */
unsigned int crc32 = nvram_crc(buf, sizeof(buf));
if (crc32 != load_h32(&buf[4]))
return;
/* all good, so read in the settings */
int var_count = buf[3];
size_t buf_pos = NVRAM_DATA_START;
for(int i = 0; i < nb_settings; i++)
{
const struct settings_list *setting = &settings[i];
int nvram_bytes = (setting->flags & F_NVRAM_BYTES_MASK) >> F_NVRAM_MASK_SHIFT;
if (nvram_bytes)
{
if (var_count > 0 && buf_pos < (size_t)bytes)
{
memcpy(setting->setting, &buf[buf_pos], nvram_bytes);
buf_pos += nvram_bytes;
var_count--;
}
else /* should only happen when new items are added to the end */
{
memcpy(setting->setting, &setting->default_val, nvram_bytes);
}
}
}
}
static void write_nvram_data(void)
{
char buf[NVRAM_BLOCK_SIZE];
memset(buf, 0, sizeof(buf));
/* magic, version */
buf[0] = 'R';
buf[1] = 'b';
buf[2] = NVRAM_CONFIG_VERSION;
size_t buf_pos = NVRAM_DATA_START;
int var_count = 0;
for(int i = 0; i < nb_settings && buf_pos < sizeof(buf); i++)
{
const struct settings_list *setting = &settings[i];
int nvram_bytes = (setting->flags & F_NVRAM_BYTES_MASK) >> F_NVRAM_MASK_SHIFT;
if (nvram_bytes)
{
memcpy(&buf[buf_pos], setting->setting, nvram_bytes);
buf_pos += nvram_bytes;
var_count++;
}
}
/* count and crc32 */
buf[3] = var_count;
store_h32(&buf[4], nvram_crc(buf, sizeof(buf)));
int fd = open(NVRAM_FILE_TEMP,O_CREAT|O_TRUNC|O_WRONLY, 0666);
if (fd < 0)
return;
write(fd, buf, sizeof(buf));
close(fd);
}
#endif /* ndef ROCKBOX_NO_TEMP_SETTINGS_FILE */
const char* setting_get_cfgvals(const struct settings_list *setting)
{
@ -242,7 +146,7 @@ const char* setting_get_cfgvals(const struct settings_list *setting)
return setting->choice_setting->cfg_vals;
else if ((setting->flags & F_BOOL_SETTING) == F_BOOL_SETTING)
{
DEBUGF("Setting: %s \n", setting->cfg_name);
logf("Setting: %s", setting->cfg_name);
return setting->bool_setting->cfg_vals;
}
else if ((setting->flags & F_HAS_CFGVALS) == F_HAS_CFGVALS)
@ -252,21 +156,26 @@ const char* setting_get_cfgvals(const struct settings_list *setting)
/** Reading from a config file **/
/*
* load settings from disk or RTC RAM
* load settings from disk
*/
void settings_load(int which)
void settings_load(void)
{
logf("\r\n%s()\r\n", __func__);
debug_available_settings();
if (which & SETTINGS_RTC)
read_nvram_data();
if (which & SETTINGS_HD)
{
rename_temp_file(CONFIGFILE_TEMP, CONFIGFILE, CONFIGFILE".old");
settings_load_config(CONFIGFILE, false);
settings_load_config(FIXEDSETTINGSFILE, false);
}
/* make temp files current make current files .old */
rename_temp_file(RESUMEFILE_TEMP, RESUMEFILE, RESUMEFILE".old");
rename_temp_file(CONFIGFILE_TEMP, CONFIGFILE, CONFIGFILE".old");
settings_load_config(CONFIGFILE, false); /* load user_settings items */
settings_load_config(RESUMEFILE, false); /* load system_status items */
/* fixed settings file has final say on user_settings AND system_status items */
settings_load_config(FIXEDSETTINGSFILE, false);
/* set initial CRC value - settings_save checks, if changed writes to disk */
user_settings_crc = crc_32(&global_settings,
sizeof(global_settings), 0xFFFFFFFF);
}
bool cfg_string_to_int(const struct settings_list *setting, int* out, const char* str)
@ -533,19 +442,17 @@ void cfg_to_string(const struct settings_list *setting, char* buf, int buf_len)
(int)RGB_UNPACK_RED(colour),
(int)RGB_UNPACK_GREEN(colour),
(int)RGB_UNPACK_BLUE(colour));
break; /* we got a value */
}
else
#endif
if (setting_get_cfgvals(setting) == NULL)
if (setting_get_cfgvals(setting) != NULL && cfg_int_to_string(
setting, *(int*)setting->setting, buf, buf_len))
{
snprintf(buf, buf_len, "%d", *(int*)setting->setting);
}
else
{
if (!cfg_int_to_string(setting, *(int*)setting->setting,
buf, buf_len))
snprintf(buf, buf_len, "%d", *(int*)setting->setting);
break; /* we got a value */
}
snprintf(buf, buf_len, "%d", *(int*)setting->setting);
break;
case F_T_BOOL:
cfg_int_to_string(setting, *(bool*)setting->setting, buf, buf_len);
@ -599,6 +506,11 @@ static bool is_changed(const struct settings_list *setting)
sound_default(setting->sound_setting->setting))
return false;
}
else if (setting->flags & F_RESUMESETTING)
{
/* exclude resume settings they will get saved to '.resume.cfg' */
return false;
}
else if (*(int*)setting->setting == setting->default_val.int_)
return false;
break;
@ -624,8 +536,13 @@ static bool settings_write_config(const char* filename, int options)
fd = open(filename,O_CREAT|O_TRUNC|O_WRONLY, 0666);
if (fd < 0)
return false;
fdprintf(fd, "# .cfg file created by rockbox %s - "
if (options != SETTINGS_SAVE_RESUMEINFO)
{
fdprintf(fd, "# .cfg file created by rockbox %s - "
"http://www.rockbox.org\r\n\r\n", rbversion);
}
for(i=0; i<nb_settings; i++)
{
const struct settings_list *setting = &settings[i];
@ -656,6 +573,18 @@ static bool settings_write_config(const char* filename, int options)
if (!(setting->flags & F_EQSETTING))
continue;
break;
case SETTINGS_SAVE_RESUMEINFO:
if (!(setting->flags & F_RESUMESETTING))
continue;
break;
case SETTINGS_SAVE_ALL:
{
/*only save sound settings (volume) from F_RESUMESETTING items */
uint32_t exclude_flag = (F_RESUMESETTING|F_SOUNDSETTING);
if ((setting->flags & exclude_flag) == F_RESUMESETTING)
continue;
break;
}
}
cfg_to_string(setting, value, MAX_PATH);
logf("Written: '%s: %s'\r\n",setting->cfg_name, value);
@ -668,13 +597,41 @@ static bool settings_write_config(const char* filename, int options)
static void flush_global_status_callback(void)
{
write_nvram_data();
if (TIME_AFTER(current_tick, next_status_update_tick))
{
next_status_update_tick = current_tick + SYSTEM_STATUS_UPDATE_TICKS;
update_runtime();
DEBUGF("Writing system_status to disk\n");
logf("Writing system_status to disk");
settings_write_config(RESUMEFILE_TEMP, SETTINGS_SAVE_RESUMEINFO);
}
}
static void flush_config_block_callback(void)
{
write_nvram_data();
settings_write_config(CONFIGFILE_TEMP, SETTINGS_SAVE_CHANGED);
uint32_t crc = crc_32(&global_settings, sizeof(global_settings), 0xFFFFFFFF);
if (user_settings_crc != crc)
{
DEBUGF("Writing changed user_settings to disk\n");
logf("Writing changed user_settings to disk");
user_settings_crc = crc; /* update immediately in case we yield */
if (!settings_write_config(CONFIGFILE_TEMP, SETTINGS_SAVE_CHANGED))
{
user_settings_crc = 0;
DEBUGF("Error failed to write settings to disk\n");
logf("Error failed to write settings to disk");
}
}
#ifdef LOGF_ENABLE
else
logf("No changes to user_settings");
#endif
/* remove any outstanding status_cb and call it unconditionally */
next_status_update_tick = current_tick - 1;
unregister_storage_idle_func(flush_global_status_callback, true);
}
void reset_runtime(void)
@ -684,9 +641,9 @@ void reset_runtime(void)
}
/*
* persist all runtime user settings to disk or RTC RAM
* update runtime and if greater topruntime as well
*/
static void update_runtime(void)
void update_runtime(void)
{
int elapsed_secs;
@ -698,27 +655,27 @@ static void update_runtime(void)
global_status.topruntime = global_status.runtime;
}
void status_save(void)
void status_save(bool force)
{
update_runtime();
register_storage_idle_func(flush_global_status_callback);
if(force)
{
settings_save(); /* will force a status flush */
}
else
register_storage_idle_func(flush_global_status_callback);
}
int settings_save(void)
{
logf("%s", __func__);
update_runtime();
/* remove any oustanding status_cb we will call it in the config_block_cb */
unregister_storage_idle_func(flush_global_status_callback, false);
register_storage_idle_func(flush_config_block_callback);
return 0;
}
bool settings_save_config(int options)
{
/* if we have outstanding temp files it would be a good idea to flush
them before the user starts saving things */
rename_temp_file(NVRAM_FILE_TEMP, NVRAM_FILE, NULL); /* dont overwrite .old */
rename_temp_file(CONFIGFILE_TEMP, CONFIGFILE, NULL); /* files from last boot */
char filename[MAX_PATH];
const char *folder, *namebase;
switch (options)
@ -805,7 +762,7 @@ void sound_settings_apply(void)
#endif
sound_set(SOUND_BALANCE, global_settings.balance);
#ifndef PLATFORM_HAS_VOLUME_CHANGE
sound_set(SOUND_VOLUME, global_settings.volume);
sound_set(SOUND_VOLUME, global_status.volume);
#endif
sound_set(SOUND_CHANNELS, global_settings.channel_config);
sound_set(SOUND_STEREO_WIDTH, global_settings.stereo_width);
@ -1122,7 +1079,6 @@ void settings_apply(bool read_disk)
CHART("<viewportmanager_theme_changed");
}
/*
* reset all settings to their default value
*/
@ -1192,7 +1148,10 @@ const struct settings_list* find_setting_by_cfgname(const char* name)
const struct settings_list *setting = &settings[i];
if (setting->cfg_name && !strcasecmp(setting->cfg_name, name))
{
logf("Found, flags: %s", debug_get_flags(settings[i].flags));
#ifdef LOGF_ENABLE
name = debug_get_flags(settings[i].flags);
logf("Found, %s", name);
#endif
return setting;
}
}
@ -1356,103 +1315,112 @@ void set_file(const char* filename, char* setting, const int maxlen)
#ifdef LOGF_ENABLE
static char *debug_get_flags(uint32_t flags)
{
static char buf[256] = {0};
static char buf[256];
uint32_t ftype = flags & F_T_MASK; /* the variable type for the setting */
flags &= ~F_T_MASK;
uint32_t flags_rem = flags;
switch (ftype)
{
case F_T_CUSTOM:
strlcpy(buf, "[Type CUSTOM] ", sizeof(buf));
strlcpy(buf, "Type: [CUSTOM] Flags: ", sizeof(buf));
break;
case F_T_INT:
strlcpy(buf, "[Type INT] ", sizeof(buf));
strlcpy(buf, "Type: [INT] Flags: ", sizeof(buf));
break;
case F_T_UINT:
strlcpy(buf, "[Type UINT] ", sizeof(buf));
strlcpy(buf, "Type: [UINT] Flags: ", sizeof(buf));
break;
case F_T_BOOL:
strlcpy(buf, "[Type BOOL] ", sizeof(buf));
strlcpy(buf, "Type: [BOOL] Flags: ", sizeof(buf));
break;
case F_T_CHARPTR:
strlcpy(buf, "[Type CHARPTR] ", sizeof(buf));
strlcpy(buf, "Type: [CHARPTR] Flags: ", sizeof(buf));
break;
case F_T_UCHARPTR:
strlcpy(buf, "[Type UCHARPTR] ", sizeof(buf));
strlcpy(buf, "Type: [UCHARPTR] Flags: ", sizeof(buf));
break;
default:
snprintf(buf, sizeof(buf),
"Type: [!UNKNOWN TYPE! (0x%lx)] Flags: ", (long)ftype);
break;
}
#define SETTINGFLAGS(n) \
if(flags & n) { \
flags &= ~n; \
if(flags_rem & n) { \
flags_rem &= ~n; \
strlcat(buf, "["#n"]", sizeof(buf));}
SETTINGFLAGS(F_T_SOUND);
SETTINGFLAGS(F_BOOL_SETTING);
SETTINGFLAGS(F_RGB);
SETTINGFLAGS(F_FILENAME);
SETTINGFLAGS(F_INT_SETTING);
SETTINGFLAGS(F_CHOICE_SETTING);
SETTINGFLAGS(F_CHOICETALKS);
SETTINGFLAGS(F_TABLE_SETTING);
SETTINGFLAGS(F_ALLOW_ARBITRARY_VALS);
SETTINGFLAGS(F_CB_ON_SELECT_ONLY);
SETTINGFLAGS(F_CB_ONLY_IF_CHANGED);
SETTINGFLAGS(F_MIN_ISFUNC);
SETTINGFLAGS(F_MAX_ISFUNC);
SETTINGFLAGS(F_DEF_ISFUNC);
SETTINGFLAGS(F_CUSTOM_SETTING);
SETTINGFLAGS(F_TIME_SETTING);
SETTINGFLAGS(F_RESUMESETTING);
SETTINGFLAGS(F_THEMESETTING);
SETTINGFLAGS(F_RECSETTING);
SETTINGFLAGS(F_EQSETTING);
SETTINGFLAGS(F_SOUNDSETTING);
SETTINGFLAGS(F_CHOICE_SETTING);
SETTINGFLAGS(F_CHOICETALKS);
SETTINGFLAGS(F_TABLE_SETTING);
SETTINGFLAGS(F_CUSTOM_SETTING);
SETTINGFLAGS(F_TIME_SETTING);
SETTINGFLAGS(F_FILENAME);
SETTINGFLAGS(F_INT_SETTING);
SETTINGFLAGS(F_T_SOUND);
SETTINGFLAGS(F_RGB);
SETTINGFLAGS(F_BOOL_SETTING);
SETTINGFLAGS(F_MIN_ISFUNC);
SETTINGFLAGS(F_MAX_ISFUNC);
SETTINGFLAGS(F_DEF_ISFUNC);
SETTINGFLAGS(F_ALLOW_ARBITRARY_VALS);
SETTINGFLAGS(F_CB_ON_SELECT_ONLY);
SETTINGFLAGS(F_CB_ONLY_IF_CHANGED);
SETTINGFLAGS(F_TEMPVAR);
SETTINGFLAGS(F_PADTITLE);
SETTINGFLAGS(F_NO_WRAP);
SETTINGFLAGS(F_BANFROMQS);
SETTINGFLAGS(F_DEPRECATED);
SETTINGFLAGS(F_HAS_CFGVALS);
#undef SETTINGFLAGS
if (flags & F_NVRAM_BYTES_MASK)
{
flags &= ~F_NVRAM_BYTES_MASK;
strlcat(buf, "[NVRAM]", sizeof(buf));
}
/* anything left is unknown */
if (flags)
if (flags_rem)
{
strlcat(buf, "[UNKNOWN FLAGS]", sizeof(buf));
strlcat(buf, "[!UNKNOWN FLAGS!]", sizeof(buf));
size_t len = strlen(buf);
if (len < sizeof(buf))
snprintf(buf + len, sizeof(buf) - len - 1, "[%x]", flags);
snprintf(buf + len, sizeof(buf) - len - 1, "[0x%lx]", flags_rem);
}
/* no flags set */
if (flags == 0)
strlcat(buf, "[0x0]", sizeof(buf));
return buf;
}
#endif
static void debug_available_settings(void)
{
#if defined(DEBUG_AVAIL_SETTINGS) && defined(LOGF_ENABLE)
static char namebuf[128];
logf("\r\nAvailable Settings:");
for (int i=0; i<nb_settings; i++)
{
uint32_t flags = settings[i].flags;
const char *name;
if (settings[i].cfg_name)
name = settings[i].cfg_name;
{
snprintf(namebuf, sizeof(namebuf), "'%s'", settings[i].cfg_name);
name = namebuf;
}
else if (settings[i].RESERVED == NULL)
{
name = "SYS (NVRAM?)";
if (flags & F_NVRAM_BYTES_MASK)
{
flags &= ~F_NVRAM_BYTES_MASK;
flags |= 0x80000; /* unused by other flags */
}
name = "SYS";
}
else
{
name = "?? UNKNOWN NAME ?? ";
}
logf("'%s' flags: %s",name, debug_get_flags(flags));
logf("%-45s %s",name, debug_get_flags(flags));
}
logf("End Available Settings\r\n");
#endif

14
apps/settings.h
View file

@ -245,15 +245,11 @@ enum { ALARM_START_WPS = 0,
/** function prototypes **/
/* argument bits for settings_load() */
#define SETTINGS_RTC (BIT_N(0)) /* only the settings from the RTC nonvolatile RAM */
#define SETTINGS_HD (BIT_N(1)) /* only the settings from the disk sector */
#define SETTINGS_ALL (SETTINGS_RTC|SETTINGS_HD) /* both */
void settings_load(int which) INIT_ATTR;
void update_runtime(void);
void settings_load(void) INIT_ATTR;
bool settings_load_config(const char* file, bool apply);
void status_save(void);
void status_save(bool force);
int settings_save(void);
void reset_runtime(void);
/* defines for the options paramater */
@ -266,6 +262,7 @@ enum {
SETTINGS_SAVE_RECPRESETS,
#endif
SETTINGS_SAVE_EQPRESET,
SETTINGS_SAVE_RESUMEINFO,
};
bool settings_save_config(int options);
@ -322,6 +319,7 @@ const char* setting_get_cfgvals(const struct settings_list *setting);
struct system_status
{
int volume; /* audio output volume in decibels range depends on the dac */
int resume_index; /* index in playlist (-1 for no active resume) */
uint32_t resume_crc32; /* crc32 of the name of the file */
uint32_t resume_elapsed; /* elapsed time in last file */
@ -350,8 +348,6 @@ struct system_status
struct user_settings
{
/* audio settings */
int volume; /* audio output volume in decibels range depends on the dac */
int balance; /* stereo balance: -100 - +100 -100=left 0=bal +100=right */
int bass; /* bass boost/cut in decibels */
int treble; /* treble boost/cut in decibels */

56
apps/settings_list.c
View file

@ -73,10 +73,6 @@
#include "usb-ibasso.h"
#endif
#define NVRAM(bytes) (bytes<<F_NVRAM_MASK_SHIFT)
/** NOTE: NVRAM_CONFIG_VERSION is in settings_list.h
and you may need to update it if you edit this file */
#define UNUSED {.RESERVED=NULL}
#define INT(a) {.int_ = a}
#define UINT(a) {.uint_ = a}
@ -122,11 +118,18 @@
BOOL_SETTING(flags,var,lang_id,default,name,off_on, \
LANG_SET_BOOL_YES,LANG_SET_BOOL_NO,cb)
/* int variable which is NOT saved to .cfg files,
(Use NVRAM() in the flags to save to the nvram (or nvram.bin file) */
#define SYSTEM_SETTING(flags,var,default) \
{flags|F_T_INT, &global_status.var,-1, INT(default), \
NULL, UNUSED}
/*system_status int variable which is saved to resume.cfg */
#define SYSTEM_STATUS(flags,var,default,name) \
{flags|F_RESUMESETTING|F_T_INT, &global_status.var,-1, \
INT(default), name, UNUSED}
/* system_status settings items will be saved to resume.cfg
Use for int which use the set_sound() function to set them
These items WILL be included in the users exported settings files
*/
#define SYSTEM_STATUS_SOUND(flags,var,lang_id,name,setting) \
{flags|F_T_INT|F_T_SOUND|F_SOUNDSETTING|F_ALLOW_ARBITRARY_VALS| \
F_RESUMESETTING, &global_status.var, lang_id, NODEFAULT,name, \
{.sound_setting=(struct sound_setting[]){{setting}}} }
/* setting which stores as a filename (or another string) in the .cfgvals
The string must be a char array (which all of our string settings are),
@ -828,8 +831,21 @@ static void hp_lo_select_apply(int arg)
#endif
const struct settings_list settings[] = {
/* sound settings */
SOUND_SETTING(F_NO_WRAP, volume, LANG_VOLUME, "volume", SOUND_VOLUME),
/* system_status settings .resume.cfg */
SYSTEM_STATUS_SOUND(F_NO_WRAP, volume, LANG_VOLUME, "volume", SOUND_VOLUME),
#ifdef HAVE_PITCHCONTROL
SYSTEM_STATUS(F_SOUNDSETTING, resume_pitch, PITCH_SPEED_100, "pitch"),
SYSTEM_STATUS(F_SOUNDSETTING, resume_speed, PITCH_SPEED_100, "speed"),
#endif
SYSTEM_STATUS(0, resume_index, -1, "IDX"),
SYSTEM_STATUS(0, resume_crc32, -1, "CRC"),
SYSTEM_STATUS(0, resume_elapsed, -1, "ELA"),
SYSTEM_STATUS(0, resume_offset, -1, "OFF"),
SYSTEM_STATUS(0, resume_modified, false, "PLM"),
SYSTEM_STATUS(0, runtime, 0, "CRT"),
SYSTEM_STATUS(0, topruntime, 0, "TRT"),
SYSTEM_STATUS(0, last_screen, -1, "PVS"),
/* sound settings */
CUSTOM_SETTING(F_NO_WRAP, volume_limit, LANG_VOLUME_LIMIT,
NULL, "volume limit",
volume_limit_load_from_cfg, volume_limit_write_to_cfg,
@ -972,15 +988,6 @@ const struct settings_list settings[] = {
OFFON_SETTING(F_CB_ON_SELECT_ONLY|F_CB_ONLY_IF_CHANGED, playlist_shuffle,
LANG_SHUFFLE, false, "shuffle", shuffle_playlist_callback),
SYSTEM_SETTING(NVRAM(4), resume_index, -1),
SYSTEM_SETTING(NVRAM(4), resume_crc32, -1),
SYSTEM_SETTING(NVRAM(4), resume_elapsed, -1),
SYSTEM_SETTING(NVRAM(4), resume_offset, -1),
SYSTEM_SETTING(NVRAM(4), resume_modified, false),
#ifdef HAVE_PITCHCONTROL
SYSTEM_SETTING(NVRAM(4), resume_pitch, PITCH_SPEED_100),
SYSTEM_SETTING(NVRAM(4), resume_speed, PITCH_SPEED_100),
#endif
CHOICE_SETTING(F_CB_ON_SELECT_ONLY|F_CB_ONLY_IF_CHANGED, repeat_mode,
LANG_REPEAT, REPEAT_OFF, "repeat", "off,all,one,shuffle"
#ifdef AB_REPEAT_ENABLE
@ -1121,8 +1128,6 @@ const struct settings_list settings[] = {
"idle poweroff", UNIT_MIN, 0,60,1,
formatter_time_unit_0_is_off, getlang_time_unit_0_is_off,
set_poweroff_timeout),
SYSTEM_SETTING(NVRAM(4), runtime, 0),
SYSTEM_SETTING(NVRAM(4), topruntime, 0),
INT_SETTING(F_BANFROMQS, max_files_in_playlist,
LANG_MAX_FILES_IN_PLAYLIST,
#if CONFIG_CPU == PP5002 || CONFIG_CPU == PP5020 || CONFIG_CPU == PP5022
@ -1172,7 +1177,7 @@ const struct settings_list settings[] = {
#endif /* IPOD_VIDEO */
#endif
#if CONFIG_CHARGING
OFFON_SETTING(NVRAM(1), car_adapter_mode,
OFFON_SETTING(0, car_adapter_mode,
LANG_CAR_ADAPTER_MODE, false, "car adapter mode", NULL),
INT_SETTING_NOWRAP(0, car_adapter_mode_delay, LANG_CAR_ADAPTER_MODE_DELAY,
5, "delay before resume", UNIT_SEC, 5, 30, 5,
@ -1196,7 +1201,7 @@ const struct settings_list settings[] = {
#if CONFIG_TUNER
OFFON_SETTING(0, fm_force_mono, LANG_FM_MONO_MODE,
false, "force fm mono", toggle_mono_mode),
SYSTEM_SETTING(NVRAM(4), last_frequency, 0),
SYSTEM_STATUS(0, last_frequency, 0, "PFQ"),
#endif
#if defined(HAVE_RDS_CAP) && defined(CONFIG_RTC)
OFFON_SETTING(0, sync_rds_time, LANG_FM_SYNC_RDS_TIME, false, "sync_rds_time", NULL),
@ -1827,7 +1832,7 @@ const struct settings_list settings[] = {
#ifdef HAVE_DIRCACHE
/*enable dircache for all targets > 2MB of RAM by default*/
OFFON_SETTING(F_BANFROMQS,dircache,LANG_DIRCACHE_ENABLE,true,"dircache",NULL),
SYSTEM_SETTING(NVRAM(4),dircache_size,0),
SYSTEM_STATUS(0, dircache_size, 0, "DSZ"),
#endif
#ifdef HAVE_TAGCACHE
@ -2049,7 +2054,6 @@ const struct settings_list settings[] = {
ID2P(LANG_BOOKMARK_MENU_RECENT_BOOKMARKS),
ID2P(LANG_OPEN_PLUGIN)
),
SYSTEM_SETTING(NVRAM(1),last_screen,-1),
#if defined(HAVE_RTC_ALARM) && \
(defined(HAVE_RECORDING) || CONFIG_TUNER)
{F_T_INT|F_HAS_CFGVALS, &global_settings.alarm_wake_up_screen, LANG_ALARM_WAKEUP_SCREEN,

17
apps/settings_list.h
View file

@ -119,6 +119,7 @@ struct table_setting {
Should really only be used if the value you want to store in global_settings
is very different to the string you want to use in the config. */
#define F_CUSTOM_SETTING 0x8000
struct custom_setting {
/* load the saved value from the .cfg
setting: pointer into global_settings
@ -146,28 +147,18 @@ struct custom_setting {
#define F_TIME_SETTING 0x10000 /* int,table format hh:mm:ss.mss auto ranged */
#define F_HAS_CFGVALS 0x20000 /* uses setting union to carry cfg_vals */
#define F_RESUMESETTING 0x40000 /* saved to a separate cfg file on shutdown */
/*#define _AVAILABLE_ 0x80000*/
/* these use the _isfunc_type type for the function */
/* typedef int (*_isfunc_type)(void); */
#define F_MIN_ISFUNC 0x100000 /* min(above) is function pointer to above type */
#define F_MAX_ISFUNC 0x200000 /* max(above) is function pointer to above type */
#define F_DEF_ISFUNC 0x400000 /* default_val is function pointer to above type */
#define F_THEMESETTING 0x800000
#define F_RECSETTING 0x1000000
#define F_EQSETTING 0x2000000
#define F_SOUNDSETTING 0x4000000
#define F_NVRAM_BYTES_MASK 0xE0000 /*0-4 bytes can be stored */
#define F_NVRAM_MASK_SHIFT 17
#define NVRAM_CONFIG_VERSION 9
/* Above define should be bumped if
- a new NVRAM setting is added between 2 other NVRAM settings
- number of bytes for a NVRAM setting is changed
- a NVRAM setting is removed
*/
/*#define _AVAILABLE_ 0x8000000*/
#define F_CB_ON_SELECT_ONLY 0x10000000 /* option_callback only called if selected */
#define F_CB_ONLY_IF_CHANGED 0x20000000 /* option_callback only called if setting changed */

2
apps/tree.c
View file

@ -1321,7 +1321,7 @@ void tree_flush(void)
}
if (old_val != global_status.dircache_size)
status_save();
status_save(true);
#ifdef HAVE_EEPROM_SETTINGS
if (savecache)

2
firmware/drivers/tuner/ipod_remote_tuner.c
View file

@ -108,7 +108,7 @@ static void rmt_tuner_sleep(int state)
iap_send_pkt(data4, sizeof(data3));
/* set volume */
unsigned char data2[] = {0x03, 0x09, 0x04, 0x00, 0x00 };
data2[4] = (char)((global_settings.volume+58) * 4);
data2[4] = (char)((global_status.volume+58) * 4);
iap_send_pkt(data2, sizeof(data2));
}
else

3
firmware/export/rbpaths.h
View file

@ -113,11 +113,12 @@
#define CODEPAGE_DIR ROCKBOX_DIR "/codepages"
#define VIEWERS_CONFIG ROCKBOX_DIR "/viewers.config"
#define RESUMEFILE ROCKBOX_DIR "/.resume.cfg"
#define CONFIGFILE ROCKBOX_DIR "/config.cfg"
#define FIXEDSETTINGSFILE ROCKBOX_DIR "/fixed.cfg"
#define PLAYLIST_CONTROL_FILE ROCKBOX_DIR "/.playlist_control"
#define NVRAM_FILE ROCKBOX_DIR "/nvram.bin"
#define GLYPH_CACHE_FILE ROCKBOX_DIR "/.glyphcache"
#endif /* __PATHS_H__ */

2
firmware/sound.c
View file

@ -117,7 +117,7 @@ int sound_current(int setting)
{
#ifndef BOOTLOADER
#ifndef PLATFORM_HAS_VOLUME_CHANGE
SOUND_CUR_SET(VOLUME, global_settings.volume)
SOUND_CUR_SET(VOLUME, global_status.volume)
#endif
#if defined(AUDIOHW_HAVE_BASS)
SOUND_CUR_SET(BASS, global_settings.bass)