tsiry-sandratraina.com
A modern Music Player Daemon based on Rockbox open source high quality audio player
libadwaita
audio
rust
zig
deno
mpris
rockbox
mpd
Remove NVRAM infavor of a separate cfg file
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
authored by
William Wilgus
and committed by
William Wilgus
7100090f
8e293b49
+1
-1
apps/filetree.c
+1
-1
apps/filetree.c
+2
-2
apps/gui/skin_engine/skin_display.c
+2
-2
apps/gui/skin_engine/skin_display.c
···
187
int maxvol = sound_max(SOUND_VOLUME);
188
#if defined(HAVE_PERCEPTUAL_VOLUME) || defined(HAVE_TOUCHSCREEN)
189
length = 1000;
190
-
end = to_normalized_volume(global_settings.volume, minvol, maxvol, length);
191
#else
192
length = maxvol - minvol;
193
-
end = global_settings.volume - minvol;
194
#endif
195
}
196
else if (pb->type == SKIN_TOKEN_BATTERY_PERCENTBAR)
···
187
int maxvol = sound_max(SOUND_VOLUME);
188
#if defined(HAVE_PERCEPTUAL_VOLUME) || defined(HAVE_TOUCHSCREEN)
189
length = 1000;
190
+
end = to_normalized_volume(global_status.volume, minvol, maxvol, length);
191
#else
192
length = maxvol - minvol;
193
+
end = global_status.volume - minvol;
194
#endif
195
}
196
else if (pb->type == SKIN_TOKEN_BATTERY_PERCENTBAR)
+1
-1
apps/gui/skin_engine/skin_parser.c
+1
-1
apps/gui/skin_engine/skin_parser.c
+6
-6
apps/gui/skin_engine/skin_tokens.c
+6
-6
apps/gui/skin_engine/skin_tokens.c
···
1173
1174
case SKIN_TOKEN_VOLUME:
1175
format_sound_value_ex(buf, buf_size, SOUND_VOLUME,
1176
-
global_settings.volume, true);
1177
1178
if (intval)
1179
{
1180
int minvol = sound_min(SOUND_VOLUME);
1181
if (limit == TOKEN_VALUE_ONLY)
1182
{
1183
-
numeric_ret = global_settings.volume;
1184
}
1185
-
else if (global_settings.volume == minvol)
1186
{
1187
numeric_ret = 1;
1188
}
1189
-
else if (global_settings.volume == 0)
1190
{
1191
numeric_ret = limit - 1;
1192
}
1193
-
else if (global_settings.volume > 0)
1194
{
1195
numeric_ret = limit;
1196
}
1197
else
1198
{
1199
-
numeric_ret = (limit-3) * (global_settings.volume - minvol - 1)
1200
/ (-1 - minvol) + 2;
1201
}
1202
}
···
1173
1174
case SKIN_TOKEN_VOLUME:
1175
format_sound_value_ex(buf, buf_size, SOUND_VOLUME,
1176
+
global_status.volume, true);
1177
1178
if (intval)
1179
{
1180
int minvol = sound_min(SOUND_VOLUME);
1181
if (limit == TOKEN_VALUE_ONLY)
1182
{
1183
+
numeric_ret = global_status.volume;
1184
}
1185
+
else if (global_status.volume == minvol)
1186
{
1187
numeric_ret = 1;
1188
}
1189
+
else if (global_status.volume == 0)
1190
{
1191
numeric_ret = limit - 1;
1192
}
1193
+
else if (global_status.volume > 0)
1194
{
1195
numeric_ret = limit;
1196
}
1197
else
1198
{
1199
+
numeric_ret = (limit-3) * (global_status.volume - minvol - 1)
1200
/ (-1 - minvol) + 2;
1201
}
1202
}
+4
-4
apps/gui/skin_engine/skin_touchsupport.c
+4
-4
apps/gui/skin_engine/skin_touchsupport.c
···
274
case ACTION_TOUCH_MUTE:
275
{
276
const int min_vol = sound_min(SOUND_VOLUME);
277
-
if (global_settings.volume == min_vol)
278
-
global_settings.volume = temp->value;
279
else
280
{
281
-
temp->value = global_settings.volume;
282
-
global_settings.volume = min_vol;
283
}
284
setvol();
285
returncode = ACTION_REDRAW;
···
274
case ACTION_TOUCH_MUTE:
275
{
276
const int min_vol = sound_min(SOUND_VOLUME);
277
+
if (global_status.volume == min_vol)
278
+
global_status.volume = temp->value;
279
else
280
{
281
+
temp->value = global_status.volume;
282
+
global_status.volume = min_vol;
283
}
284
setvol();
285
returncode = ACTION_REDRAW;
+1
-1
apps/gui/statusbar.c
+1
-1
apps/gui/statusbar.c
+2
-2
apps/gui/wps.c
+2
-2
apps/gui/wps.c
···
192
const int max_vol = sound_max(SOUND_VOLUME);
193
const int step_vol = sound_steps(SOUND_VOLUME);
194
195
-
global_settings.volume = from_normalized_volume(offset, min_vol, max_vol, 1000);
196
-
global_settings.volume -= (global_settings.volume % step_vol);
197
setvol();
198
}
199
return ACTION_TOUCHSCREEN;
···
192
const int max_vol = sound_max(SOUND_VOLUME);
193
const int step_vol = sound_steps(SOUND_VOLUME);
194
195
+
global_status.volume = from_normalized_volume(offset, min_vol, max_vol, 1000);
196
+
global_status.volume -= (global_status.volume % step_vol);
197
setvol();
198
}
199
return ACTION_TOUCHSCREEN;
+2
-2
apps/iap/iap-core.c
+2
-2
apps/iap/iap-core.c
···
322
IAP_TX_INIT(0x03, 0x0D);
323
IAP_TX_PUT(0x04);
324
IAP_TX_PUT(0x00);
325
-
IAP_TX_PUT(0xFF & (int)((global_settings.volume + 90) * 2.65625));
326
iap_send_tx();
327
}
328
···
882
IAP_TX_INIT(0x03, 0x09);
883
IAP_TX_PUT(0x04);
884
IAP_TX_PUT(0x00);
885
-
IAP_TX_PUT(0xFF &(int)((global_settings.volume + 90) * 2.65625));
886
device.changed_notifications |= BIT_N(4);
887
iap_send_tx();
888
}
···
322
IAP_TX_INIT(0x03, 0x0D);
323
IAP_TX_PUT(0x04);
324
IAP_TX_PUT(0x00);
325
+
IAP_TX_PUT(0xFF & (int)((global_status.volume + 90) * 2.65625));
326
iap_send_tx();
327
}
328
···
882
IAP_TX_INIT(0x03, 0x09);
883
IAP_TX_PUT(0x04);
884
IAP_TX_PUT(0x00);
885
+
IAP_TX_PUT(0xFF &(int)((global_status.volume + 90) * 2.65625));
886
device.changed_notifications |= BIT_N(4);
887
iap_send_tx();
888
}
+6
-6
apps/iap/iap-lingo3.c
+6
-6
apps/iap/iap-lingo3.c
···
265
device.play_status = audio_status();
266
/* TODO: Fix this */
267
device.mute = false;
268
-
device.volume = global_settings.volume;
269
device.power_state = charger_input_state;
270
device.battery_level = battery_level();
271
/* TODO: Fix this */
···
441
/* Mute status False*/
442
IAP_TX_PUT(0x00);
443
/* Volume */
444
-
IAP_TX_PUT(0xFF & (int)((global_settings.volume + 90) * 2.65625));
445
446
} else {
447
/* Mute status True*/
···
630
/* Mute status False*/
631
IAP_TX_PUT(0x00);
632
/* Volume */
633
-
IAP_TX_PUT(0xFF & (int)((global_settings.volume + 90) * 2.65625));
634
-
IAP_TX_PUT(0xFF & (int)((global_settings.volume + 90) * 2.65625));
635
636
} else {
637
/* Mute status True*/
···
766
CHECKLEN(5);
767
if (buf[0x03]==0x00){
768
/* Not Muted */
769
-
global_settings.volume = (int) (buf[0x04]/2.65625)-90;
770
device.mute = false;
771
}
772
else {
···
940
CHECKLEN(7);
941
if (buf[0x03]==0x00){
942
/* Not Muted */
943
-
global_settings.volume = (int) (buf[0x04]/2.65625)-90;
944
device.mute = false;
945
}
946
else {
···
265
device.play_status = audio_status();
266
/* TODO: Fix this */
267
device.mute = false;
268
+
device.volume = global_status.volume;
269
device.power_state = charger_input_state;
270
device.battery_level = battery_level();
271
/* TODO: Fix this */
···
441
/* Mute status False*/
442
IAP_TX_PUT(0x00);
443
/* Volume */
444
+
IAP_TX_PUT(0xFF & (int)((global_status.volume + 90) * 2.65625));
445
446
} else {
447
/* Mute status True*/
···
630
/* Mute status False*/
631
IAP_TX_PUT(0x00);
632
/* Volume */
633
+
IAP_TX_PUT(0xFF & (int)((global_status.volume + 90) * 2.65625));
634
+
IAP_TX_PUT(0xFF & (int)((global_status.volume + 90) * 2.65625));
635
636
} else {
637
/* Mute status True*/
···
766
CHECKLEN(5);
767
if (buf[0x03]==0x00){
768
/* Not Muted */
769
+
global_status.volume = (int) (buf[0x04]/2.65625)-90;
770
device.mute = false;
771
}
772
else {
···
940
CHECKLEN(7);
941
if (buf[0x03]==0x00){
942
/* Not Muted */
943
+
global_status.volume = (int) (buf[0x04]/2.65625)-90;
944
device.mute = false;
945
}
946
else {
+5
-5
apps/main.c
+5
-5
apps/main.c
···
319
struct dircache_info info;
320
dircache_get_info(&info);
321
global_status.dircache_size = info.size;
322
-
status_save();
323
}
324
/* else don't wait or already enabled by load */
325
}
···
435
pcm_init();
436
dsp_init();
437
settings_reset();
438
-
settings_load(SETTINGS_ALL);
439
settings_apply(true);
440
#ifdef HAVE_DIRCACHE
441
init_dircache(true);
···
679
pcm_init();
680
dsp_init();
681
682
-
CHART(">settings_load(ALL)");
683
-
settings_load(SETTINGS_ALL);
684
-
CHART("<settings_load(ALL)");
685
686
#if defined(BUTTON_REC) || \
687
(CONFIG_KEYPAD == GIGABEAT_PAD) || \
···
319
struct dircache_info info;
320
dircache_get_info(&info);
321
global_status.dircache_size = info.size;
322
+
status_save(true);
323
}
324
/* else don't wait or already enabled by load */
325
}
···
435
pcm_init();
436
dsp_init();
437
settings_reset();
438
+
settings_load();
439
settings_apply(true);
440
#ifdef HAVE_DIRCACHE
441
init_dircache(true);
···
679
pcm_init();
680
dsp_init();
681
682
+
CHART(">settings_load");
683
+
settings_load();
684
+
CHART("<settings_load");
685
686
#if defined(BUTTON_REC) || \
687
(CONFIG_KEYPAD == GIGABEAT_PAD) || \
+18
-17
apps/misc.c
+18
-17
apps/misc.c
···
345
talk_disable(true);
346
}
347
348
-
status_save();
349
350
#if CONFIG_CHARGING && !defined(HAVE_POWEROFF_WHILE_CHARGING)
351
if(!charger_inserted())
···
751
* event data is available in the last button data */
752
int volume = button_get_data();
753
DEBUGF("SYS_VOLUME_CHANGED: %d\n", volume);
754
-
if (global_settings.volume != volume) {
755
-
global_settings.volume = volume;
756
if (firstvolume) {
757
setvol();
758
firstvolume = false;
···
859
{
860
const int min_vol = sound_min(SOUND_VOLUME);
861
const int max_vol = sound_max(SOUND_VOLUME);
862
-
if (global_settings.volume < min_vol)
863
-
global_settings.volume = min_vol;
864
-
if (global_settings.volume > max_vol)
865
-
global_settings.volume = max_vol;
866
-
if (global_settings.volume > global_settings.volume_limit)
867
-
global_settings.volume = global_settings.volume_limit;
868
-
869
-
sound_set_volume(global_settings.volume);
870
global_status.last_volume_change = current_tick;
871
-
settings_save();
872
}
873
874
#ifdef HAVE_PERCEPTUAL_VOLUME
···
920
if (vol >= norm_tab_size)
921
vol = norm_tab_size - 1;
922
923
-
global_settings.volume = norm_tab[vol];
924
}
925
926
int get_normalized_volume(void)
···
931
while (a != b)
932
{
933
int i = (a + b + 1) / 2;
934
-
if (global_settings.volume < norm_tab[i])
935
b = i - 1;
936
else
937
a = i;
···
942
#else
943
void set_normalized_volume(int vol)
944
{
945
-
global_settings.volume = vol * sound_steps(SOUND_VOLUME);
946
}
947
948
int get_normalized_volume(void)
949
{
950
-
return global_settings.volume / sound_steps(SOUND_VOLUME);
951
}
952
#endif
953
···
971
#endif
972
case VOLUME_ADJUST_DIRECT:
973
default:
974
-
global_settings.volume += steps * sound_steps(SOUND_VOLUME);
975
break;
976
}
977
···
345
talk_disable(true);
346
}
347
348
+
status_save(true);
349
350
#if CONFIG_CHARGING && !defined(HAVE_POWEROFF_WHILE_CHARGING)
351
if(!charger_inserted())
···
751
* event data is available in the last button data */
752
int volume = button_get_data();
753
DEBUGF("SYS_VOLUME_CHANGED: %d\n", volume);
754
+
if (global_status.volume != volume) {
755
+
global_status.volume = volume;
756
if (firstvolume) {
757
setvol();
758
firstvolume = false;
···
859
{
860
const int min_vol = sound_min(SOUND_VOLUME);
861
const int max_vol = sound_max(SOUND_VOLUME);
862
+
int volume = global_status.volume;
863
+
if (volume < min_vol)
864
+
volume = min_vol;
865
+
if (volume > max_vol)
866
+
volume = max_vol;
867
+
if (volume > global_settings.volume_limit)
868
+
volume = global_settings.volume_limit;
869
+
global_status.volume = volume;
870
+
sound_set_volume(volume);
871
global_status.last_volume_change = current_tick;
872
+
status_save(false);
873
}
874
875
#ifdef HAVE_PERCEPTUAL_VOLUME
···
921
if (vol >= norm_tab_size)
922
vol = norm_tab_size - 1;
923
924
+
global_status.volume = norm_tab[vol];
925
}
926
927
int get_normalized_volume(void)
···
932
while (a != b)
933
{
934
int i = (a + b + 1) / 2;
935
+
if (global_status.volume < norm_tab[i])
936
b = i - 1;
937
else
938
a = i;
···
943
#else
944
void set_normalized_volume(int vol)
945
{
946
+
global_status.volume = vol * sound_steps(SOUND_VOLUME);
947
}
948
949
int get_normalized_volume(void)
950
{
951
+
return global_status.volume / sound_steps(SOUND_VOLUME);
952
}
953
#endif
954
···
972
#endif
973
case VOLUME_ADJUST_DIRECT:
974
default:
975
+
global_status.volume += steps * sound_steps(SOUND_VOLUME);
976
break;
977
}
978
+1
-1
apps/playback.c
+1
-1
apps/playback.c
+2
-2
apps/playlist.c
+2
-2
apps/playlist.c
···
3777
global_status.resume_elapsed = id3->elapsed;
3778
global_status.resume_offset = id3->offset;
3779
global_status.resume_modified = pl_modified;
3780
-
status_save();
3781
}
3782
}
3783
else
···
3787
global_status.resume_elapsed = -1;
3788
global_status.resume_offset = -1;
3789
global_status.resume_modified = false;
3790
-
status_save();
3791
return -1;
3792
}
3793
···
3777
global_status.resume_elapsed = id3->elapsed;
3778
global_status.resume_offset = id3->offset;
3779
global_status.resume_modified = pl_modified;
3780
+
status_save(false);
3781
}
3782
}
3783
else
···
3787
global_status.resume_elapsed = -1;
3788
global_status.resume_offset = -1;
3789
global_status.resume_modified = false;
3790
+
status_save(true);
3791
return -1;
3792
}
3793
+1
-1
apps/plugin.c
+1
-1
apps/plugin.c
+4
-4
apps/plugins/beatbox/beatbox.c
+4
-4
apps/plugins/beatbox/beatbox.c
···
601
/*
602
case BTN_UP:
603
case BTN_UP | BUTTON_REPEAT:
604
-
vol = rb->global_settings->volume;
605
if (vol < rb->sound_max(SOUND_VOLUME))
606
{
607
vol++;
608
rb->sound_set(SOUND_VOLUME, vol);
609
-
rb->global_settings->volume = vol;
610
}
611
break;
612
613
case BTN_DOWN:
614
case BTN_DOWN | BUTTON_REPEAT:
615
-
vol = rb->global_settings->volume;
616
if (vol > rb->sound_min(SOUND_VOLUME))
617
{
618
vol--;
619
rb->sound_set(SOUND_VOLUME, vol);
620
-
rb->global_settings->volume = vol;
621
}
622
break;
623
···
601
/*
602
case BTN_UP:
603
case BTN_UP | BUTTON_REPEAT:
604
+
vol = rb->global_status->volume;
605
if (vol < rb->sound_max(SOUND_VOLUME))
606
{
607
vol++;
608
rb->sound_set(SOUND_VOLUME, vol);
609
+
rb->global_status->volume = vol;
610
}
611
break;
612
613
case BTN_DOWN:
614
case BTN_DOWN | BUTTON_REPEAT:
615
+
vol = rb->global_status->volume;
616
if (vol > rb->sound_min(SOUND_VOLUME))
617
{
618
vol--;
619
rb->sound_set(SOUND_VOLUME, vol);
620
+
rb->global_status->volume = vol;
621
}
622
break;
623
+2
-2
apps/plugins/doom/rockdoom.c
+2
-2
apps/plugins/doom/rockdoom.c
+1
-1
apps/plugins/fft/fft.c
+1
-1
apps/plugins/fft/fft.c
+1
-1
apps/plugins/lib/playback_control.c
+1
-1
apps/plugins/lib/playback_control.c
+6
-6
apps/plugins/metronome.c
+6
-6
apps/plugins/metronome.c
···
887
/* One line in several. */
888
rb->snprintf( buffer, sizeof(buffer), "%u/%u@%u V%d"
889
, ps->beats_per_bar, ps->base_beat
890
-
, bpm, rb->global_settings->volume );
891
display->puts(0,4, buffer);
892
893
/* Would it hurt to draw a 3rd line to 2-line display?
···
931
#endif
932
933
rb->snprintf( buffer, sizeof(buffer), "BPM: %d Vol: %d"
934
-
, bpm, rb->global_settings->volume );
935
display->puts(0,3, buffer);
936
937
display->hline(0, 111, 12);
···
962
This is for parts with associated volume. */
963
static void tweak_volume(int offset)
964
{
965
-
int vol = rb->global_settings->volume + offset;
966
int minvol = rb->sound_min(SOUND_VOLUME);
967
int maxvol = rb->sound_max(SOUND_VOLUME);
968
···
1121
{
1122
int minvol = rb->sound_min(SOUND_VOLUME);
1123
int maxvol = rb->sound_max(SOUND_VOLUME);
1124
-
int vol = rb->global_settings->volume + delta;
1125
1126
if (vol > maxvol) vol = maxvol;
1127
else if(vol < minvol) vol = minvol;
1128
-
if(vol != rb->global_settings->volume)
1129
{
1130
-
rb->global_settings->volume = vol;
1131
tweak_volume(part->volume);
1132
trigger_display(display_state);
1133
}
···
887
/* One line in several. */
888
rb->snprintf( buffer, sizeof(buffer), "%u/%u@%u V%d"
889
, ps->beats_per_bar, ps->base_beat
890
+
, bpm, rb->global_status->volume );
891
display->puts(0,4, buffer);
892
893
/* Would it hurt to draw a 3rd line to 2-line display?
···
931
#endif
932
933
rb->snprintf( buffer, sizeof(buffer), "BPM: %d Vol: %d"
934
+
, bpm, rb->global_status->volume );
935
display->puts(0,3, buffer);
936
937
display->hline(0, 111, 12);
···
962
This is for parts with associated volume. */
963
static void tweak_volume(int offset)
964
{
965
+
int vol = rb->global_status->volume + offset;
966
int minvol = rb->sound_min(SOUND_VOLUME);
967
int maxvol = rb->sound_max(SOUND_VOLUME);
968
···
1121
{
1122
int minvol = rb->sound_min(SOUND_VOLUME);
1123
int maxvol = rb->sound_max(SOUND_VOLUME);
1124
+
int vol = rb->global_status->volume + delta;
1125
1126
if (vol > maxvol) vol = maxvol;
1127
else if(vol < minvol) vol = minvol;
1128
+
if(vol != rb->global_status->volume)
1129
{
1130
+
rb->global_status->volume = vol;
1131
tweak_volume(part->volume);
1132
trigger_display(display_state);
1133
}
+4
-4
apps/plugins/midi/midiplay.c
+4
-4
apps/plugins/midi/midiplay.c
···
588
case MIDI_VOL_UP:
589
case MIDI_VOL_UP | BUTTON_REPEAT:
590
{
591
-
vol = rb->global_settings->volume;
592
if (vol < rb->sound_max(SOUND_VOLUME))
593
{
594
vol++;
595
rb->sound_set(SOUND_VOLUME, vol);
596
-
rb->global_settings->volume = vol;
597
}
598
break;
599
}
···
601
case MIDI_VOL_DOWN:
602
case MIDI_VOL_DOWN | BUTTON_REPEAT:
603
{
604
-
vol = rb->global_settings->volume;
605
if (vol > rb->sound_min(SOUND_VOLUME))
606
{
607
vol--;
608
rb->sound_set(SOUND_VOLUME, vol);
609
-
rb->global_settings->volume = vol;
610
}
611
break;
612
}
···
588
case MIDI_VOL_UP:
589
case MIDI_VOL_UP | BUTTON_REPEAT:
590
{
591
+
vol = rb->global_status->volume;
592
if (vol < rb->sound_max(SOUND_VOLUME))
593
{
594
vol++;
595
rb->sound_set(SOUND_VOLUME, vol);
596
+
rb->global_status->volume = vol;
597
}
598
break;
599
}
···
601
case MIDI_VOL_DOWN:
602
case MIDI_VOL_DOWN | BUTTON_REPEAT:
603
{
604
+
vol = rb->global_status->volume;
605
if (vol > rb->sound_min(SOUND_VOLUME))
606
{
607
vol--;
608
rb->sound_set(SOUND_VOLUME, vol);
609
+
rb->global_status->volume = vol;
610
}
611
break;
612
}
+1
-1
apps/plugins/mikmod/mikmod.c
+1
-1
apps/plugins/mikmod/mikmod.c
+4
-4
apps/plugins/mpegplayer/mpegplayer.c
+4
-4
apps/plugins/mpegplayer/mpegplayer.c
···
1462
char buf[32];
1463
int width;
1464
1465
-
int volume = rb->global_settings->volume;
1466
rb->snprintf(buf, sizeof (buf), "%d%s",
1467
rb->sound_val2phys(SOUND_VOLUME, volume),
1468
rb->sound_unit(SOUND_VOLUME));
···
1870
/* Change the current audio volume by a specified amount */
1871
static void osd_set_volume(int delta)
1872
{
1873
-
int vol = rb->global_settings->volume;
1874
int limit;
1875
1876
vol += delta;
···
1888
}
1889
1890
/* Sync the global settings */
1891
-
if (vol != rb->global_settings->volume) {
1892
rb->sound_set(SOUND_VOLUME, vol);
1893
-
rb->global_settings->volume = vol;
1894
}
1895
1896
/* Update the volume display */
···
1462
char buf[32];
1463
int width;
1464
1465
+
int volume = rb->global_status->volume;
1466
rb->snprintf(buf, sizeof (buf), "%d%s",
1467
rb->sound_val2phys(SOUND_VOLUME, volume),
1468
rb->sound_unit(SOUND_VOLUME));
···
1870
/* Change the current audio volume by a specified amount */
1871
static void osd_set_volume(int delta)
1872
{
1873
+
int vol = rb->global_status->volume;
1874
int limit;
1875
1876
vol += delta;
···
1888
}
1889
1890
/* Sync the global settings */
1891
+
if (vol != rb->global_status->volume) {
1892
rb->sound_set(SOUND_VOLUME, vol);
1893
+
rb->global_status->volume = vol;
1894
}
1895
1896
/* Update the volume display */
+4
-4
apps/plugins/oscilloscope.c
+4
-4
apps/plugins/oscilloscope.c
···
2113
case OSCILLOSCOPE_VOL_UP:
2114
case OSCILLOSCOPE_VOL_UP | BUTTON_REPEAT:
2115
{
2116
-
int vol = rb->global_settings->volume;
2117
2118
if (vol < rb->sound_max(SOUND_VOLUME))
2119
{
2120
vol++;
2121
rb->sound_set(SOUND_VOLUME, vol);
2122
-
rb->global_settings->volume = vol;
2123
}
2124
2125
osc_popupmsg(OSC_MSG_VOLUME, vol);
···
2129
case OSCILLOSCOPE_VOL_DOWN:
2130
case OSCILLOSCOPE_VOL_DOWN | BUTTON_REPEAT:
2131
{
2132
-
int vol = rb->global_settings->volume;
2133
2134
if (vol > rb->sound_min(SOUND_VOLUME))
2135
{
2136
vol--;
2137
rb->sound_set(SOUND_VOLUME, vol);
2138
-
rb->global_settings->volume = vol;
2139
}
2140
2141
osc_popupmsg(OSC_MSG_VOLUME, vol);
···
2113
case OSCILLOSCOPE_VOL_UP:
2114
case OSCILLOSCOPE_VOL_UP | BUTTON_REPEAT:
2115
{
2116
+
int vol = rb->global_status->volume;
2117
2118
if (vol < rb->sound_max(SOUND_VOLUME))
2119
{
2120
vol++;
2121
rb->sound_set(SOUND_VOLUME, vol);
2122
+
rb->global_status->volume = vol;
2123
}
2124
2125
osc_popupmsg(OSC_MSG_VOLUME, vol);
···
2129
case OSCILLOSCOPE_VOL_DOWN:
2130
case OSCILLOSCOPE_VOL_DOWN | BUTTON_REPEAT:
2131
{
2132
+
int vol = rb->global_status->volume;
2133
2134
if (vol > rb->sound_min(SOUND_VOLUME))
2135
{
2136
vol--;
2137
rb->sound_set(SOUND_VOLUME, vol);
2138
+
rb->global_status->volume = vol;
2139
}
2140
2141
osc_popupmsg(OSC_MSG_VOLUME, vol);
+2
-2
apps/plugins/test_sampr.c
+2
-2
apps/plugins/test_sampr.c
···
174
#ifndef HAVE_VOLUME_IN_LIST
175
static void set_volume(int value)
176
{
177
-
rb->global_settings->volume = value;
178
rb->sound_set(SOUND_VOLUME, value);
179
}
180
···
243
#ifndef HAVE_VOLUME_IN_LIST
244
if (volume_set)
245
{
246
-
int volume = rb->global_settings->volume;
247
248
rb->set_int("Volume", NULL, -1, &volume,
249
set_volume, 1, rb->sound_min(SOUND_VOLUME),
···
174
#ifndef HAVE_VOLUME_IN_LIST
175
static void set_volume(int value)
176
{
177
+
rb->global_status->volume = value;
178
rb->sound_set(SOUND_VOLUME, value);
179
}
180
···
243
#ifndef HAVE_VOLUME_IN_LIST
244
if (volume_set)
245
{
246
+
int volume = rb->global_status->volume;
247
248
rb->set_int("Volume", NULL, -1, &volume,
249
set_volume, 1, rb->sound_min(SOUND_VOLUME),
+3
-3
apps/plugins/vu_meter.c
+3
-3
apps/plugins/vu_meter.c
···
637
static void change_volume(int delta) {
638
int minvol = rb->sound_min(SOUND_VOLUME);
639
int maxvol = rb->sound_max(SOUND_VOLUME);
640
-
int vol = rb->global_settings->volume + delta;
641
642
if (vol > maxvol) vol = maxvol;
643
else if (vol < minvol) vol = minvol;
644
-
if (vol != rb->global_settings->volume) {
645
rb->sound_set(SOUND_VOLUME, vol);
646
-
rb->global_settings->volume = vol;
647
rb->lcd_putsxyf(0,0, "%d", vol);
648
rb->lcd_update();
649
rb->sleep(HZ/12);
···
637
static void change_volume(int delta) {
638
int minvol = rb->sound_min(SOUND_VOLUME);
639
int maxvol = rb->sound_max(SOUND_VOLUME);
640
+
int vol = rb->global_status->volume + delta;
641
642
if (vol > maxvol) vol = maxvol;
643
else if (vol < minvol) vol = minvol;
644
+
if (vol != rb->global_status->volume) {
645
rb->sound_set(SOUND_VOLUME, vol);
646
+
rb->global_status->volume = vol;
647
rb->lcd_putsxyf(0,0, "%d", vol);
648
rb->lcd_update();
649
rb->sleep(HZ/12);
+1
-1
apps/plugins/xworld/sys.c
+1
-1
apps/plugins/xworld/sys.c
+3
-3
apps/radio/radio.c
+3
-3
apps/radio/radio.c
···
296
&fm_region_data[global_settings.fm_region];
297
global_status.last_frequency = (curr_freq - fmr->freq_min)
298
/ fmr->freq_step;
299
-
status_save();
300
}
301
302
/* Step to the next or previous frequency */
···
531
532
case ACTION_SETTINGS_INC:
533
case ACTION_SETTINGS_INCREPEAT:
534
-
global_settings.volume += sound_steps(SOUND_VOLUME);
535
setvol();
536
update_type = SKIN_REFRESH_NON_STATIC;
537
break;
538
539
case ACTION_SETTINGS_DEC:
540
case ACTION_SETTINGS_DECREPEAT:
541
-
global_settings.volume -= sound_steps(SOUND_VOLUME);
542
setvol();
543
update_type = SKIN_REFRESH_NON_STATIC;
544
break;
···
296
&fm_region_data[global_settings.fm_region];
297
global_status.last_frequency = (curr_freq - fmr->freq_min)
298
/ fmr->freq_step;
299
+
status_save(true);
300
}
301
302
/* Step to the next or previous frequency */
···
531
532
case ACTION_SETTINGS_INC:
533
case ACTION_SETTINGS_INCREPEAT:
534
+
global_status.volume += sound_steps(SOUND_VOLUME);
535
setvol();
536
update_type = SKIN_REFRESH_NON_STATIC;
537
break;
538
539
case ACTION_SETTINGS_DEC:
540
case ACTION_SETTINGS_DECREPEAT:
541
+
global_status.volume -= sound_steps(SOUND_VOLUME);
542
setvol();
543
update_type = SKIN_REFRESH_NON_STATIC;
544
break;
+3
-3
apps/recorder/recording.c
+3
-3
apps/recorder/recording.c
···
773
case ITEM_VOLUME:
774
snprintf(buffer, buffer_len, "%s: %s", str(LANG_VOLUME),
775
fmt_gain(SOUND_VOLUME,
776
-
global_settings.volume,
777
buf2, sizeof(buf2)));
778
break;
779
#endif
···
896
switch(setting_id)
897
{
898
case SOUND_VOLUME:
899
-
global_settings.volume += steps;
900
setvol();
901
break;
902
#if defined(HAVE_LINE_REC) || defined(HAVE_FMRADIO_REC)
···
1020
#endif
1021
1022
audio_init_recording();
1023
-
sound_set_volume(global_settings.volume);
1024
1025
#if CONFIG_RTC == 0
1026
/* Create new filename for recording start */
···
773
case ITEM_VOLUME:
774
snprintf(buffer, buffer_len, "%s: %s", str(LANG_VOLUME),
775
fmt_gain(SOUND_VOLUME,
776
+
global_status.volume,
777
buf2, sizeof(buf2)));
778
break;
779
#endif
···
896
switch(setting_id)
897
{
898
case SOUND_VOLUME:
899
+
global_status.volume += steps;
900
setvol();
901
break;
902
#if defined(HAVE_LINE_REC) || defined(HAVE_FMRADIO_REC)
···
1020
#endif
1021
1022
audio_init_recording();
1023
+
sound_set_volume(global_status.volume);
1024
1025
#if CONFIG_RTC == 0
1026
/* Create new filename for recording start */
+1
-2
apps/screens.c
+1
-2
apps/screens.c
+156
-188
apps/settings.c
+156
-188
apps/settings.c
···
8
* $Id$
9
*
10
* Copyright (C) 2002 by Stuart Martin
11
-
* RTC config saving code (C) 2002 by hessu@hes.iki.fi
12
*
13
* This program is free software; you can redistribute it and/or
14
* modify it under the terms of the GNU General Public License
···
79
80
struct user_settings global_settings;
81
struct system_status global_status;
82
83
#include "dsp_proc_settings.h"
84
#include "playback.h"
···
87
#endif
88
#include "pcm_sampr.h"
89
90
-
#define NVRAM_DATA_START 8
91
-
#define NVRAM_BLOCK_SIZE (sizeof(struct system_status) + NVRAM_DATA_START)
92
-
93
-
#define MAX_LINES 10
94
-
95
#ifdef HAVE_REMOTE_LCD
96
#include "lcd-remote.h"
97
#endif
···
103
104
#ifdef ROCKBOX_NO_TEMP_SETTINGS_FILE /* Overwrites same file each time */
105
#define CONFIGFILE_TEMP CONFIGFILE
106
-
#define NVRAM_FILE_TEMP NVRAM_FILE
107
#define rename_temp_file(a,b,c)
108
#else /* creates temp files on save, renames next load, saves old file if desired */
109
#define CONFIGFILE_TEMP CONFIGFILE".new"
110
-
#define NVRAM_FILE_TEMP NVRAM_FILE".new"
111
112
#ifdef LOGF_ENABLE
113
static char *debug_get_flags(uint32_t flags);
114
#endif
115
static void debug_available_settings(void);
116
···
129
rename(tempfile, file);
130
}
131
}
132
-
#endif
133
-
134
-
long lasttime = 0;
135
-
136
-
/** NVRAM stuff, if the target doesnt have NVRAM it is saved in ROCKBOX_DIR /nvram.bin **/
137
-
/* NVRAM is set out as
138
-
*
139
-
* [0] 'R'
140
-
* [1] 'b'
141
-
* [2] version
142
-
* [3] stored variable count
143
-
* [4-7] crc32 checksum in host endian order
144
-
* [8+] data
145
-
*/
146
-
147
-
static unsigned int nvram_crc(char *buf, int max_len)
148
-
{
149
-
return crc_32(&buf[NVRAM_DATA_START], max_len - NVRAM_DATA_START - 1, NVRAM_BLOCK_SIZE);
150
-
}
151
-
152
-
static void read_nvram_data(void)
153
-
{
154
-
rename_temp_file(NVRAM_FILE_TEMP, NVRAM_FILE, NVRAM_FILE".old");
155
-
156
-
int fd = open(NVRAM_FILE, O_RDONLY);
157
-
if (fd < 0)
158
-
return;
159
-
160
-
char buf[NVRAM_BLOCK_SIZE];
161
-
memset(buf, 0, sizeof(buf));
162
-
163
-
ssize_t bytes = read(fd, buf, sizeof(buf));
164
-
close(fd);
165
-
166
-
if (bytes < 8) /* min is 8 bytes,magic, ver, vars, crc32 */
167
-
return;
168
-
169
-
/* check magic, version */
170
-
if (buf[0] != 'R' || buf[1] != 'b' || buf[2] != NVRAM_CONFIG_VERSION)
171
-
return;
172
-
173
-
/* check crc32 */
174
-
unsigned int crc32 = nvram_crc(buf, sizeof(buf));
175
-
if (crc32 != load_h32(&buf[4]))
176
-
return;
177
-
178
-
/* all good, so read in the settings */
179
-
int var_count = buf[3];
180
-
size_t buf_pos = NVRAM_DATA_START;
181
-
for(int i = 0; i < nb_settings; i++)
182
-
{
183
-
const struct settings_list *setting = &settings[i];
184
-
int nvram_bytes = (setting->flags & F_NVRAM_BYTES_MASK) >> F_NVRAM_MASK_SHIFT;
185
-
if (nvram_bytes)
186
-
{
187
-
if (var_count > 0 && buf_pos < (size_t)bytes)
188
-
{
189
-
memcpy(setting->setting, &buf[buf_pos], nvram_bytes);
190
-
buf_pos += nvram_bytes;
191
-
var_count--;
192
-
}
193
-
else /* should only happen when new items are added to the end */
194
-
{
195
-
memcpy(setting->setting, &setting->default_val, nvram_bytes);
196
-
}
197
-
}
198
-
}
199
-
}
200
-
201
-
static void write_nvram_data(void)
202
-
{
203
-
char buf[NVRAM_BLOCK_SIZE];
204
-
memset(buf, 0, sizeof(buf));
205
-
206
-
/* magic, version */
207
-
buf[0] = 'R';
208
-
buf[1] = 'b';
209
-
buf[2] = NVRAM_CONFIG_VERSION;
210
-
211
-
size_t buf_pos = NVRAM_DATA_START;
212
-
int var_count = 0;
213
-
for(int i = 0; i < nb_settings && buf_pos < sizeof(buf); i++)
214
-
{
215
-
const struct settings_list *setting = &settings[i];
216
-
int nvram_bytes = (setting->flags & F_NVRAM_BYTES_MASK) >> F_NVRAM_MASK_SHIFT;
217
-
if (nvram_bytes)
218
-
{
219
-
memcpy(&buf[buf_pos], setting->setting, nvram_bytes);
220
-
buf_pos += nvram_bytes;
221
-
var_count++;
222
-
}
223
-
}
224
-
225
-
/* count and crc32 */
226
-
buf[3] = var_count;
227
-
store_h32(&buf[4], nvram_crc(buf, sizeof(buf)));
228
-
229
-
int fd = open(NVRAM_FILE_TEMP,O_CREAT|O_TRUNC|O_WRONLY, 0666);
230
-
if (fd < 0)
231
-
return;
232
-
233
-
write(fd, buf, sizeof(buf));
234
-
close(fd);
235
-
}
236
237
const char* setting_get_cfgvals(const struct settings_list *setting)
238
{
···
242
return setting->choice_setting->cfg_vals;
243
else if ((setting->flags & F_BOOL_SETTING) == F_BOOL_SETTING)
244
{
245
-
DEBUGF("Setting: %s \n", setting->cfg_name);
246
return setting->bool_setting->cfg_vals;
247
}
248
else if ((setting->flags & F_HAS_CFGVALS) == F_HAS_CFGVALS)
···
252
253
/** Reading from a config file **/
254
/*
255
-
* load settings from disk or RTC RAM
256
*/
257
-
void settings_load(int which)
258
{
259
logf("\r\n%s()\r\n", __func__);
260
debug_available_settings();
261
262
-
if (which & SETTINGS_RTC)
263
-
read_nvram_data();
264
-
if (which & SETTINGS_HD)
265
-
{
266
-
rename_temp_file(CONFIGFILE_TEMP, CONFIGFILE, CONFIGFILE".old");
267
-
settings_load_config(CONFIGFILE, false);
268
-
settings_load_config(FIXEDSETTINGSFILE, false);
269
-
}
270
}
271
272
bool cfg_string_to_int(const struct settings_list *setting, int* out, const char* str)
···
533
(int)RGB_UNPACK_RED(colour),
534
(int)RGB_UNPACK_GREEN(colour),
535
(int)RGB_UNPACK_BLUE(colour));
536
}
537
else
538
#endif
539
-
if (setting_get_cfgvals(setting) == NULL)
540
-
{
541
-
snprintf(buf, buf_len, "%d", *(int*)setting->setting);
542
-
}
543
-
else
544
{
545
-
if (!cfg_int_to_string(setting, *(int*)setting->setting,
546
-
buf, buf_len))
547
-
snprintf(buf, buf_len, "%d", *(int*)setting->setting);
548
}
549
break;
550
case F_T_BOOL:
551
cfg_int_to_string(setting, *(bool*)setting->setting, buf, buf_len);
···
599
sound_default(setting->sound_setting->setting))
600
return false;
601
}
602
else if (*(int*)setting->setting == setting->default_val.int_)
603
return false;
604
break;
···
624
fd = open(filename,O_CREAT|O_TRUNC|O_WRONLY, 0666);
625
if (fd < 0)
626
return false;
627
-
fdprintf(fd, "# .cfg file created by rockbox %s - "
628
"http://www.rockbox.org\r\n\r\n", rbversion);
629
for(i=0; i<nb_settings; i++)
630
{
631
const struct settings_list *setting = &settings[i];
···
656
if (!(setting->flags & F_EQSETTING))
657
continue;
658
break;
659
}
660
cfg_to_string(setting, value, MAX_PATH);
661
logf("Written: '%s: %s'\r\n",setting->cfg_name, value);
···
668
669
static void flush_global_status_callback(void)
670
{
671
-
write_nvram_data();
672
}
673
674
static void flush_config_block_callback(void)
675
{
676
-
write_nvram_data();
677
-
settings_write_config(CONFIGFILE_TEMP, SETTINGS_SAVE_CHANGED);
678
}
679
680
void reset_runtime(void)
···
684
}
685
686
/*
687
-
* persist all runtime user settings to disk or RTC RAM
688
*/
689
-
static void update_runtime(void)
690
{
691
int elapsed_secs;
692
···
698
global_status.topruntime = global_status.runtime;
699
}
700
701
-
void status_save(void)
702
{
703
-
update_runtime();
704
-
register_storage_idle_func(flush_global_status_callback);
705
}
706
707
int settings_save(void)
708
{
709
logf("%s", __func__);
710
-
update_runtime();
711
register_storage_idle_func(flush_config_block_callback);
712
return 0;
713
}
714
715
bool settings_save_config(int options)
716
{
717
-
/* if we have outstanding temp files it would be a good idea to flush
718
-
them before the user starts saving things */
719
-
rename_temp_file(NVRAM_FILE_TEMP, NVRAM_FILE, NULL); /* dont overwrite .old */
720
-
rename_temp_file(CONFIGFILE_TEMP, CONFIGFILE, NULL); /* files from last boot */
721
-
722
char filename[MAX_PATH];
723
const char *folder, *namebase;
724
switch (options)
···
805
#endif
806
sound_set(SOUND_BALANCE, global_settings.balance);
807
#ifndef PLATFORM_HAS_VOLUME_CHANGE
808
-
sound_set(SOUND_VOLUME, global_settings.volume);
809
#endif
810
sound_set(SOUND_CHANNELS, global_settings.channel_config);
811
sound_set(SOUND_STEREO_WIDTH, global_settings.stereo_width);
···
1122
CHART("<viewportmanager_theme_changed");
1123
}
1124
1125
-
1126
/*
1127
* reset all settings to their default value
1128
*/
···
1192
const struct settings_list *setting = &settings[i];
1193
if (setting->cfg_name && !strcasecmp(setting->cfg_name, name))
1194
{
1195
-
logf("Found, flags: %s", debug_get_flags(settings[i].flags));
1196
return setting;
1197
}
1198
}
···
1356
#ifdef LOGF_ENABLE
1357
static char *debug_get_flags(uint32_t flags)
1358
{
1359
-
static char buf[256] = {0};
1360
uint32_t ftype = flags & F_T_MASK; /* the variable type for the setting */
1361
flags &= ~F_T_MASK;
1362
switch (ftype)
1363
{
1364
case F_T_CUSTOM:
1365
-
strlcpy(buf, "[Type CUSTOM] ", sizeof(buf));
1366
break;
1367
case F_T_INT:
1368
-
strlcpy(buf, "[Type INT] ", sizeof(buf));
1369
break;
1370
case F_T_UINT:
1371
-
strlcpy(buf, "[Type UINT] ", sizeof(buf));
1372
break;
1373
case F_T_BOOL:
1374
-
strlcpy(buf, "[Type BOOL] ", sizeof(buf));
1375
break;
1376
case F_T_CHARPTR:
1377
-
strlcpy(buf, "[Type CHARPTR] ", sizeof(buf));
1378
break;
1379
case F_T_UCHARPTR:
1380
-
strlcpy(buf, "[Type UCHARPTR] ", sizeof(buf));
1381
break;
1382
}
1383
1384
#define SETTINGFLAGS(n) \
1385
-
if(flags & n) { \
1386
-
flags &= ~n; \
1387
strlcat(buf, "["#n"]", sizeof(buf));}
1388
1389
-
SETTINGFLAGS(F_T_SOUND);
1390
-
SETTINGFLAGS(F_BOOL_SETTING);
1391
-
SETTINGFLAGS(F_RGB);
1392
-
SETTINGFLAGS(F_FILENAME);
1393
-
SETTINGFLAGS(F_INT_SETTING);
1394
SETTINGFLAGS(F_CHOICE_SETTING);
1395
SETTINGFLAGS(F_CHOICETALKS);
1396
SETTINGFLAGS(F_TABLE_SETTING);
1397
-
SETTINGFLAGS(F_ALLOW_ARBITRARY_VALS);
1398
-
SETTINGFLAGS(F_CB_ON_SELECT_ONLY);
1399
-
SETTINGFLAGS(F_CB_ONLY_IF_CHANGED);
1400
SETTINGFLAGS(F_MIN_ISFUNC);
1401
SETTINGFLAGS(F_MAX_ISFUNC);
1402
SETTINGFLAGS(F_DEF_ISFUNC);
1403
-
SETTINGFLAGS(F_CUSTOM_SETTING);
1404
-
SETTINGFLAGS(F_TIME_SETTING);
1405
-
SETTINGFLAGS(F_THEMESETTING);
1406
-
SETTINGFLAGS(F_RECSETTING);
1407
-
SETTINGFLAGS(F_EQSETTING);
1408
-
SETTINGFLAGS(F_SOUNDSETTING);
1409
SETTINGFLAGS(F_TEMPVAR);
1410
SETTINGFLAGS(F_PADTITLE);
1411
SETTINGFLAGS(F_NO_WRAP);
1412
SETTINGFLAGS(F_BANFROMQS);
1413
SETTINGFLAGS(F_DEPRECATED);
1414
#undef SETTINGFLAGS
1415
1416
-
if (flags & F_NVRAM_BYTES_MASK)
1417
-
{
1418
-
flags &= ~F_NVRAM_BYTES_MASK;
1419
-
strlcat(buf, "[NVRAM]", sizeof(buf));
1420
-
}
1421
/* anything left is unknown */
1422
-
if (flags)
1423
{
1424
-
strlcat(buf, "[UNKNOWN FLAGS]", sizeof(buf));
1425
size_t len = strlen(buf);
1426
if (len < sizeof(buf))
1427
-
snprintf(buf + len, sizeof(buf) - len - 1, "[%x]", flags);
1428
}
1429
return buf;
1430
}
1431
#endif
1432
static void debug_available_settings(void)
1433
{
1434
#if defined(DEBUG_AVAIL_SETTINGS) && defined(LOGF_ENABLE)
1435
logf("\r\nAvailable Settings:");
1436
for (int i=0; i<nb_settings; i++)
1437
{
1438
uint32_t flags = settings[i].flags;
1439
const char *name;
1440
if (settings[i].cfg_name)
1441
-
name = settings[i].cfg_name;
1442
else if (settings[i].RESERVED == NULL)
1443
{
1444
-
name = "SYS (NVRAM?)";
1445
-
if (flags & F_NVRAM_BYTES_MASK)
1446
-
{
1447
-
flags &= ~F_NVRAM_BYTES_MASK;
1448
-
flags |= 0x80000; /* unused by other flags */
1449
-
}
1450
}
1451
else
1452
{
1453
name = "?? UNKNOWN NAME ?? ";
1454
}
1455
-
logf("'%s' flags: %s",name, debug_get_flags(flags));
1456
}
1457
logf("End Available Settings\r\n");
1458
#endif
···
8
* $Id$
9
*
10
* Copyright (C) 2002 by Stuart Martin
11
*
12
* This program is free software; you can redistribute it and/or
13
* modify it under the terms of the GNU General Public License
···
78
79
struct user_settings global_settings;
80
struct system_status global_status;
81
+
static uint32_t user_settings_crc;
82
+
static long next_status_update_tick;
83
+
long lasttime = 0;
84
+
85
+
/* flush system_status more often for spinning harddisks as we may not be able
86
+
* to spin up at shutdown in order to save so keep the gap minimal */
87
+
#if (CONFIG_STORAGE & STORAGE_ATA)
88
+
#define SYSTEM_STATUS_UPDATE_TICKS (HZ * 60 * 5) /* flush every 5 minutes */
89
+
#else
90
+
#define SYSTEM_STATUS_UPDATE_TICKS (HZ * 60 * 15) /* flush every 15 minutes */
91
+
#endif
92
93
#include "dsp_proc_settings.h"
94
#include "playback.h"
···
97
#endif
98
#include "pcm_sampr.h"
99
100
#ifdef HAVE_REMOTE_LCD
101
#include "lcd-remote.h"
102
#endif
···
108
109
#ifdef ROCKBOX_NO_TEMP_SETTINGS_FILE /* Overwrites same file each time */
110
#define CONFIGFILE_TEMP CONFIGFILE
111
+
#define RESUMEFILE_TEMP RESUMEFILE
112
#define rename_temp_file(a,b,c)
113
#else /* creates temp files on save, renames next load, saves old file if desired */
114
#define CONFIGFILE_TEMP CONFIGFILE".new"
115
+
#define RESUMEFILE_TEMP RESUMEFILE".new"
116
117
#ifdef LOGF_ENABLE
118
static char *debug_get_flags(uint32_t flags);
119
+
#undef DEBUGF /* allow DEBUGF or logf not both */
120
+
#define DEBUGF(...) do { } while(0)
121
#endif
122
static void debug_available_settings(void);
123
···
136
rename(tempfile, file);
137
}
138
}
139
+
#endif /* ndef ROCKBOX_NO_TEMP_SETTINGS_FILE */
140
141
const char* setting_get_cfgvals(const struct settings_list *setting)
142
{
···
146
return setting->choice_setting->cfg_vals;
147
else if ((setting->flags & F_BOOL_SETTING) == F_BOOL_SETTING)
148
{
149
+
logf("Setting: %s", setting->cfg_name);
150
return setting->bool_setting->cfg_vals;
151
}
152
else if ((setting->flags & F_HAS_CFGVALS) == F_HAS_CFGVALS)
···
156
157
/** Reading from a config file **/
158
/*
159
+
* load settings from disk
160
*/
161
+
void settings_load(void)
162
{
163
logf("\r\n%s()\r\n", __func__);
164
debug_available_settings();
165
166
+
/* make temp files current make current files .old */
167
+
rename_temp_file(RESUMEFILE_TEMP, RESUMEFILE, RESUMEFILE".old");
168
+
rename_temp_file(CONFIGFILE_TEMP, CONFIGFILE, CONFIGFILE".old");
169
+
170
+
settings_load_config(CONFIGFILE, false); /* load user_settings items */
171
+
settings_load_config(RESUMEFILE, false); /* load system_status items */
172
+
173
+
/* fixed settings file has final say on user_settings AND system_status items */
174
+
settings_load_config(FIXEDSETTINGSFILE, false);
175
+
176
+
/* set initial CRC value - settings_save checks, if changed writes to disk */
177
+
user_settings_crc = crc_32(&global_settings,
178
+
sizeof(global_settings), 0xFFFFFFFF);
179
}
180
181
bool cfg_string_to_int(const struct settings_list *setting, int* out, const char* str)
···
442
(int)RGB_UNPACK_RED(colour),
443
(int)RGB_UNPACK_GREEN(colour),
444
(int)RGB_UNPACK_BLUE(colour));
445
+
break; /* we got a value */
446
}
447
else
448
#endif
449
+
if (setting_get_cfgvals(setting) != NULL && cfg_int_to_string(
450
+
setting, *(int*)setting->setting, buf, buf_len))
451
{
452
+
break; /* we got a value */
453
}
454
+
455
+
snprintf(buf, buf_len, "%d", *(int*)setting->setting);
456
break;
457
case F_T_BOOL:
458
cfg_int_to_string(setting, *(bool*)setting->setting, buf, buf_len);
···
506
sound_default(setting->sound_setting->setting))
507
return false;
508
}
509
+
else if (setting->flags & F_RESUMESETTING)
510
+
{
511
+
/* exclude resume settings they will get saved to '.resume.cfg' */
512
+
return false;
513
+
}
514
else if (*(int*)setting->setting == setting->default_val.int_)
515
return false;
516
break;
···
536
fd = open(filename,O_CREAT|O_TRUNC|O_WRONLY, 0666);
537
if (fd < 0)
538
return false;
539
+
540
+
if (options != SETTINGS_SAVE_RESUMEINFO)
541
+
{
542
+
fdprintf(fd, "# .cfg file created by rockbox %s - "
543
"http://www.rockbox.org\r\n\r\n", rbversion);
544
+
}
545
+
546
for(i=0; i<nb_settings; i++)
547
{
548
const struct settings_list *setting = &settings[i];
···
573
if (!(setting->flags & F_EQSETTING))
574
continue;
575
break;
576
+
case SETTINGS_SAVE_RESUMEINFO:
577
+
if (!(setting->flags & F_RESUMESETTING))
578
+
continue;
579
+
break;
580
+
case SETTINGS_SAVE_ALL:
581
+
{
582
+
/*only save sound settings (volume) from F_RESUMESETTING items */
583
+
uint32_t exclude_flag = (F_RESUMESETTING|F_SOUNDSETTING);
584
+
if ((setting->flags & exclude_flag) == F_RESUMESETTING)
585
+
continue;
586
+
break;
587
+
}
588
}
589
cfg_to_string(setting, value, MAX_PATH);
590
logf("Written: '%s: %s'\r\n",setting->cfg_name, value);
···
597
598
static void flush_global_status_callback(void)
599
{
600
+
if (TIME_AFTER(current_tick, next_status_update_tick))
601
+
{
602
+
next_status_update_tick = current_tick + SYSTEM_STATUS_UPDATE_TICKS;
603
+
update_runtime();
604
+
605
+
DEBUGF("Writing system_status to disk\n");
606
+
logf("Writing system_status to disk");
607
+
608
+
settings_write_config(RESUMEFILE_TEMP, SETTINGS_SAVE_RESUMEINFO);
609
+
}
610
}
611
612
static void flush_config_block_callback(void)
613
{
614
+
uint32_t crc = crc_32(&global_settings, sizeof(global_settings), 0xFFFFFFFF);
615
+
if (user_settings_crc != crc)
616
+
{
617
+
DEBUGF("Writing changed user_settings to disk\n");
618
+
logf("Writing changed user_settings to disk");
619
+
620
+
user_settings_crc = crc; /* update immediately in case we yield */
621
+
if (!settings_write_config(CONFIGFILE_TEMP, SETTINGS_SAVE_CHANGED))
622
+
{
623
+
user_settings_crc = 0;
624
+
DEBUGF("Error failed to write settings to disk\n");
625
+
logf("Error failed to write settings to disk");
626
+
}
627
+
}
628
+
#ifdef LOGF_ENABLE
629
+
else
630
+
logf("No changes to user_settings");
631
+
#endif
632
+
/* remove any outstanding status_cb and call it unconditionally */
633
+
next_status_update_tick = current_tick - 1;
634
+
unregister_storage_idle_func(flush_global_status_callback, true);
635
}
636
637
void reset_runtime(void)
···
641
}
642
643
/*
644
+
* update runtime and if greater topruntime as well
645
*/
646
+
void update_runtime(void)
647
{
648
int elapsed_secs;
649
···
655
global_status.topruntime = global_status.runtime;
656
}
657
658
+
void status_save(bool force)
659
{
660
+
if(force)
661
+
{
662
+
settings_save(); /* will force a status flush */
663
+
}
664
+
else
665
+
register_storage_idle_func(flush_global_status_callback);
666
}
667
668
int settings_save(void)
669
{
670
logf("%s", __func__);
671
+
/* remove any oustanding status_cb we will call it in the config_block_cb */
672
+
unregister_storage_idle_func(flush_global_status_callback, false);
673
register_storage_idle_func(flush_config_block_callback);
674
return 0;
675
}
676
677
bool settings_save_config(int options)
678
{
679
char filename[MAX_PATH];
680
const char *folder, *namebase;
681
switch (options)
···
762
#endif
763
sound_set(SOUND_BALANCE, global_settings.balance);
764
#ifndef PLATFORM_HAS_VOLUME_CHANGE
765
+
sound_set(SOUND_VOLUME, global_status.volume);
766
#endif
767
sound_set(SOUND_CHANNELS, global_settings.channel_config);
768
sound_set(SOUND_STEREO_WIDTH, global_settings.stereo_width);
···
1079
CHART("<viewportmanager_theme_changed");
1080
}
1081
1082
/*
1083
* reset all settings to their default value
1084
*/
···
1148
const struct settings_list *setting = &settings[i];
1149
if (setting->cfg_name && !strcasecmp(setting->cfg_name, name))
1150
{
1151
+
#ifdef LOGF_ENABLE
1152
+
name = debug_get_flags(settings[i].flags);
1153
+
logf("Found, %s", name);
1154
+
#endif
1155
return setting;
1156
}
1157
}
···
1315
#ifdef LOGF_ENABLE
1316
static char *debug_get_flags(uint32_t flags)
1317
{
1318
+
static char buf[256];
1319
uint32_t ftype = flags & F_T_MASK; /* the variable type for the setting */
1320
flags &= ~F_T_MASK;
1321
+
uint32_t flags_rem = flags;
1322
switch (ftype)
1323
{
1324
case F_T_CUSTOM:
1325
+
strlcpy(buf, "Type: [CUSTOM] Flags: ", sizeof(buf));
1326
break;
1327
case F_T_INT:
1328
+
strlcpy(buf, "Type: [INT] Flags: ", sizeof(buf));
1329
break;
1330
case F_T_UINT:
1331
+
strlcpy(buf, "Type: [UINT] Flags: ", sizeof(buf));
1332
break;
1333
case F_T_BOOL:
1334
+
strlcpy(buf, "Type: [BOOL] Flags: ", sizeof(buf));
1335
break;
1336
case F_T_CHARPTR:
1337
+
strlcpy(buf, "Type: [CHARPTR] Flags: ", sizeof(buf));
1338
break;
1339
case F_T_UCHARPTR:
1340
+
strlcpy(buf, "Type: [UCHARPTR] Flags: ", sizeof(buf));
1341
+
break;
1342
+
default:
1343
+
snprintf(buf, sizeof(buf),
1344
+
"Type: [!UNKNOWN TYPE! (0x%lx)] Flags: ", (long)ftype);
1345
break;
1346
}
1347
1348
#define SETTINGFLAGS(n) \
1349
+
if(flags_rem & n) { \
1350
+
flags_rem &= ~n; \
1351
strlcat(buf, "["#n"]", sizeof(buf));}
1352
1353
+
SETTINGFLAGS(F_RESUMESETTING);
1354
+
SETTINGFLAGS(F_THEMESETTING);
1355
+
SETTINGFLAGS(F_RECSETTING);
1356
+
SETTINGFLAGS(F_EQSETTING);
1357
+
SETTINGFLAGS(F_SOUNDSETTING);
1358
SETTINGFLAGS(F_CHOICE_SETTING);
1359
SETTINGFLAGS(F_CHOICETALKS);
1360
SETTINGFLAGS(F_TABLE_SETTING);
1361
+
SETTINGFLAGS(F_CUSTOM_SETTING);
1362
+
SETTINGFLAGS(F_TIME_SETTING);
1363
+
1364
+
SETTINGFLAGS(F_FILENAME);
1365
+
SETTINGFLAGS(F_INT_SETTING);
1366
+
SETTINGFLAGS(F_T_SOUND);
1367
+
SETTINGFLAGS(F_RGB);
1368
+
SETTINGFLAGS(F_BOOL_SETTING);
1369
+
1370
SETTINGFLAGS(F_MIN_ISFUNC);
1371
SETTINGFLAGS(F_MAX_ISFUNC);
1372
SETTINGFLAGS(F_DEF_ISFUNC);
1373
+
SETTINGFLAGS(F_ALLOW_ARBITRARY_VALS);
1374
+
SETTINGFLAGS(F_CB_ON_SELECT_ONLY);
1375
+
SETTINGFLAGS(F_CB_ONLY_IF_CHANGED);
1376
SETTINGFLAGS(F_TEMPVAR);
1377
SETTINGFLAGS(F_PADTITLE);
1378
SETTINGFLAGS(F_NO_WRAP);
1379
SETTINGFLAGS(F_BANFROMQS);
1380
SETTINGFLAGS(F_DEPRECATED);
1381
+
1382
+
SETTINGFLAGS(F_HAS_CFGVALS);
1383
#undef SETTINGFLAGS
1384
1385
/* anything left is unknown */
1386
+
if (flags_rem)
1387
{
1388
+
strlcat(buf, "[!UNKNOWN FLAGS!]", sizeof(buf));
1389
size_t len = strlen(buf);
1390
if (len < sizeof(buf))
1391
+
snprintf(buf + len, sizeof(buf) - len - 1, "[0x%lx]", flags_rem);
1392
}
1393
+
/* no flags set */
1394
+
if (flags == 0)
1395
+
strlcat(buf, "[0x0]", sizeof(buf));
1396
return buf;
1397
}
1398
#endif
1399
static void debug_available_settings(void)
1400
{
1401
#if defined(DEBUG_AVAIL_SETTINGS) && defined(LOGF_ENABLE)
1402
+
static char namebuf[128];
1403
+
1404
logf("\r\nAvailable Settings:");
1405
for (int i=0; i<nb_settings; i++)
1406
{
1407
uint32_t flags = settings[i].flags;
1408
const char *name;
1409
if (settings[i].cfg_name)
1410
+
{
1411
+
snprintf(namebuf, sizeof(namebuf), "'%s'", settings[i].cfg_name);
1412
+
name = namebuf;
1413
+
}
1414
else if (settings[i].RESERVED == NULL)
1415
{
1416
+
name = "SYS";
1417
}
1418
else
1419
{
1420
name = "?? UNKNOWN NAME ?? ";
1421
}
1422
+
1423
+
logf("%-45s %s",name, debug_get_flags(flags));
1424
}
1425
logf("End Available Settings\r\n");
1426
#endif
+5
-9
apps/settings.h
+5
-9
apps/settings.h
···
245
246
247
/** function prototypes **/
248
-
249
-
/* argument bits for settings_load() */
250
-
#define SETTINGS_RTC (BIT_N(0)) /* only the settings from the RTC nonvolatile RAM */
251
-
#define SETTINGS_HD (BIT_N(1)) /* only the settings from the disk sector */
252
-
#define SETTINGS_ALL (SETTINGS_RTC|SETTINGS_HD) /* both */
253
-
void settings_load(int which) INIT_ATTR;
254
bool settings_load_config(const char* file, bool apply);
255
256
-
void status_save(void);
257
int settings_save(void);
258
void reset_runtime(void);
259
/* defines for the options paramater */
···
266
SETTINGS_SAVE_RECPRESETS,
267
#endif
268
SETTINGS_SAVE_EQPRESET,
269
};
270
bool settings_save_config(int options);
271
···
322
323
struct system_status
324
{
325
int resume_index; /* index in playlist (-1 for no active resume) */
326
uint32_t resume_crc32; /* crc32 of the name of the file */
327
uint32_t resume_elapsed; /* elapsed time in last file */
···
350
struct user_settings
351
{
352
/* audio settings */
353
-
354
-
int volume; /* audio output volume in decibels range depends on the dac */
355
int balance; /* stereo balance: -100 - +100 -100=left 0=bal +100=right */
356
int bass; /* bass boost/cut in decibels */
357
int treble; /* treble boost/cut in decibels */
···
245
246
247
/** function prototypes **/
248
+
void update_runtime(void);
249
+
void settings_load(void) INIT_ATTR;
250
bool settings_load_config(const char* file, bool apply);
251
252
+
void status_save(bool force);
253
int settings_save(void);
254
void reset_runtime(void);
255
/* defines for the options paramater */
···
262
SETTINGS_SAVE_RECPRESETS,
263
#endif
264
SETTINGS_SAVE_EQPRESET,
265
+
SETTINGS_SAVE_RESUMEINFO,
266
};
267
bool settings_save_config(int options);
268
···
319
320
struct system_status
321
{
322
+
int volume; /* audio output volume in decibels range depends on the dac */
323
int resume_index; /* index in playlist (-1 for no active resume) */
324
uint32_t resume_crc32; /* crc32 of the name of the file */
325
uint32_t resume_elapsed; /* elapsed time in last file */
···
348
struct user_settings
349
{
350
/* audio settings */
351
int balance; /* stereo balance: -100 - +100 -100=left 0=bal +100=right */
352
int bass; /* bass boost/cut in decibels */
353
int treble; /* treble boost/cut in decibels */
+30
-26
apps/settings_list.c
+30
-26
apps/settings_list.c
···
73
#include "usb-ibasso.h"
74
#endif
75
76
-
#define NVRAM(bytes) (bytes<<F_NVRAM_MASK_SHIFT)
77
-
/** NOTE: NVRAM_CONFIG_VERSION is in settings_list.h
78
-
and you may need to update it if you edit this file */
79
-
80
#define UNUSED {.RESERVED=NULL}
81
#define INT(a) {.int_ = a}
82
#define UINT(a) {.uint_ = a}
···
122
BOOL_SETTING(flags,var,lang_id,default,name,off_on, \
123
LANG_SET_BOOL_YES,LANG_SET_BOOL_NO,cb)
124
125
-
/* int variable which is NOT saved to .cfg files,
126
-
(Use NVRAM() in the flags to save to the nvram (or nvram.bin file) */
127
-
#define SYSTEM_SETTING(flags,var,default) \
128
-
{flags|F_T_INT, &global_status.var,-1, INT(default), \
129
-
NULL, UNUSED}
130
131
/* setting which stores as a filename (or another string) in the .cfgvals
132
The string must be a char array (which all of our string settings are),
···
828
#endif
829
830
const struct settings_list settings[] = {
831
-
/* sound settings */
832
-
SOUND_SETTING(F_NO_WRAP, volume, LANG_VOLUME, "volume", SOUND_VOLUME),
833
CUSTOM_SETTING(F_NO_WRAP, volume_limit, LANG_VOLUME_LIMIT,
834
NULL, "volume limit",
835
volume_limit_load_from_cfg, volume_limit_write_to_cfg,
···
972
OFFON_SETTING(F_CB_ON_SELECT_ONLY|F_CB_ONLY_IF_CHANGED, playlist_shuffle,
973
LANG_SHUFFLE, false, "shuffle", shuffle_playlist_callback),
974
975
-
SYSTEM_SETTING(NVRAM(4), resume_index, -1),
976
-
SYSTEM_SETTING(NVRAM(4), resume_crc32, -1),
977
-
SYSTEM_SETTING(NVRAM(4), resume_elapsed, -1),
978
-
SYSTEM_SETTING(NVRAM(4), resume_offset, -1),
979
-
SYSTEM_SETTING(NVRAM(4), resume_modified, false),
980
-
#ifdef HAVE_PITCHCONTROL
981
-
SYSTEM_SETTING(NVRAM(4), resume_pitch, PITCH_SPEED_100),
982
-
SYSTEM_SETTING(NVRAM(4), resume_speed, PITCH_SPEED_100),
983
-
#endif
984
CHOICE_SETTING(F_CB_ON_SELECT_ONLY|F_CB_ONLY_IF_CHANGED, repeat_mode,
985
LANG_REPEAT, REPEAT_OFF, "repeat", "off,all,one,shuffle"
986
#ifdef AB_REPEAT_ENABLE
···
1121
"idle poweroff", UNIT_MIN, 0,60,1,
1122
formatter_time_unit_0_is_off, getlang_time_unit_0_is_off,
1123
set_poweroff_timeout),
1124
-
SYSTEM_SETTING(NVRAM(4), runtime, 0),
1125
-
SYSTEM_SETTING(NVRAM(4), topruntime, 0),
1126
INT_SETTING(F_BANFROMQS, max_files_in_playlist,
1127
LANG_MAX_FILES_IN_PLAYLIST,
1128
#if CONFIG_CPU == PP5002 || CONFIG_CPU == PP5020 || CONFIG_CPU == PP5022
···
1172
#endif /* IPOD_VIDEO */
1173
#endif
1174
#if CONFIG_CHARGING
1175
-
OFFON_SETTING(NVRAM(1), car_adapter_mode,
1176
LANG_CAR_ADAPTER_MODE, false, "car adapter mode", NULL),
1177
INT_SETTING_NOWRAP(0, car_adapter_mode_delay, LANG_CAR_ADAPTER_MODE_DELAY,
1178
5, "delay before resume", UNIT_SEC, 5, 30, 5,
···
1196
#if CONFIG_TUNER
1197
OFFON_SETTING(0, fm_force_mono, LANG_FM_MONO_MODE,
1198
false, "force fm mono", toggle_mono_mode),
1199
-
SYSTEM_SETTING(NVRAM(4), last_frequency, 0),
1200
#endif
1201
#if defined(HAVE_RDS_CAP) && defined(CONFIG_RTC)
1202
OFFON_SETTING(0, sync_rds_time, LANG_FM_SYNC_RDS_TIME, false, "sync_rds_time", NULL),
···
1827
#ifdef HAVE_DIRCACHE
1828
/*enable dircache for all targets > 2MB of RAM by default*/
1829
OFFON_SETTING(F_BANFROMQS,dircache,LANG_DIRCACHE_ENABLE,true,"dircache",NULL),
1830
-
SYSTEM_SETTING(NVRAM(4),dircache_size,0),
1831
#endif
1832
1833
#ifdef HAVE_TAGCACHE
···
2049
ID2P(LANG_BOOKMARK_MENU_RECENT_BOOKMARKS),
2050
ID2P(LANG_OPEN_PLUGIN)
2051
),
2052
-
SYSTEM_SETTING(NVRAM(1),last_screen,-1),
2053
#if defined(HAVE_RTC_ALARM) && \
2054
(defined(HAVE_RECORDING) || CONFIG_TUNER)
2055
{F_T_INT|F_HAS_CFGVALS, &global_settings.alarm_wake_up_screen, LANG_ALARM_WAKEUP_SCREEN,
···
73
#include "usb-ibasso.h"
74
#endif
75
76
#define UNUSED {.RESERVED=NULL}
77
#define INT(a) {.int_ = a}
78
#define UINT(a) {.uint_ = a}
···
118
BOOL_SETTING(flags,var,lang_id,default,name,off_on, \
119
LANG_SET_BOOL_YES,LANG_SET_BOOL_NO,cb)
120
121
+
/*system_status int variable which is saved to resume.cfg */
122
+
#define SYSTEM_STATUS(flags,var,default,name) \
123
+
{flags|F_RESUMESETTING|F_T_INT, &global_status.var,-1, \
124
+
INT(default), name, UNUSED}
125
+
/* system_status settings items will be saved to resume.cfg
126
+
Use for int which use the set_sound() function to set them
127
+
These items WILL be included in the users exported settings files
128
+
*/
129
+
#define SYSTEM_STATUS_SOUND(flags,var,lang_id,name,setting) \
130
+
{flags|F_T_INT|F_T_SOUND|F_SOUNDSETTING|F_ALLOW_ARBITRARY_VALS| \
131
+
F_RESUMESETTING, &global_status.var, lang_id, NODEFAULT,name, \
132
+
{.sound_setting=(struct sound_setting[]){{setting}}} }
133
134
/* setting which stores as a filename (or another string) in the .cfgvals
135
The string must be a char array (which all of our string settings are),
···
831
#endif
832
833
const struct settings_list settings[] = {
834
+
/* system_status settings .resume.cfg */
835
+
SYSTEM_STATUS_SOUND(F_NO_WRAP, volume, LANG_VOLUME, "volume", SOUND_VOLUME),
836
+
#ifdef HAVE_PITCHCONTROL
837
+
SYSTEM_STATUS(F_SOUNDSETTING, resume_pitch, PITCH_SPEED_100, "pitch"),
838
+
SYSTEM_STATUS(F_SOUNDSETTING, resume_speed, PITCH_SPEED_100, "speed"),
839
+
#endif
840
+
SYSTEM_STATUS(0, resume_index, -1, "IDX"),
841
+
SYSTEM_STATUS(0, resume_crc32, -1, "CRC"),
842
+
SYSTEM_STATUS(0, resume_elapsed, -1, "ELA"),
843
+
SYSTEM_STATUS(0, resume_offset, -1, "OFF"),
844
+
SYSTEM_STATUS(0, resume_modified, false, "PLM"),
845
+
SYSTEM_STATUS(0, runtime, 0, "CRT"),
846
+
SYSTEM_STATUS(0, topruntime, 0, "TRT"),
847
+
SYSTEM_STATUS(0, last_screen, -1, "PVS"),
848
+
/* sound settings */
849
CUSTOM_SETTING(F_NO_WRAP, volume_limit, LANG_VOLUME_LIMIT,
850
NULL, "volume limit",
851
volume_limit_load_from_cfg, volume_limit_write_to_cfg,
···
988
OFFON_SETTING(F_CB_ON_SELECT_ONLY|F_CB_ONLY_IF_CHANGED, playlist_shuffle,
989
LANG_SHUFFLE, false, "shuffle", shuffle_playlist_callback),
990
991
CHOICE_SETTING(F_CB_ON_SELECT_ONLY|F_CB_ONLY_IF_CHANGED, repeat_mode,
992
LANG_REPEAT, REPEAT_OFF, "repeat", "off,all,one,shuffle"
993
#ifdef AB_REPEAT_ENABLE
···
1128
"idle poweroff", UNIT_MIN, 0,60,1,
1129
formatter_time_unit_0_is_off, getlang_time_unit_0_is_off,
1130
set_poweroff_timeout),
1131
INT_SETTING(F_BANFROMQS, max_files_in_playlist,
1132
LANG_MAX_FILES_IN_PLAYLIST,
1133
#if CONFIG_CPU == PP5002 || CONFIG_CPU == PP5020 || CONFIG_CPU == PP5022
···
1177
#endif /* IPOD_VIDEO */
1178
#endif
1179
#if CONFIG_CHARGING
1180
+
OFFON_SETTING(0, car_adapter_mode,
1181
LANG_CAR_ADAPTER_MODE, false, "car adapter mode", NULL),
1182
INT_SETTING_NOWRAP(0, car_adapter_mode_delay, LANG_CAR_ADAPTER_MODE_DELAY,
1183
5, "delay before resume", UNIT_SEC, 5, 30, 5,
···
1201
#if CONFIG_TUNER
1202
OFFON_SETTING(0, fm_force_mono, LANG_FM_MONO_MODE,
1203
false, "force fm mono", toggle_mono_mode),
1204
+
SYSTEM_STATUS(0, last_frequency, 0, "PFQ"),
1205
#endif
1206
#if defined(HAVE_RDS_CAP) && defined(CONFIG_RTC)
1207
OFFON_SETTING(0, sync_rds_time, LANG_FM_SYNC_RDS_TIME, false, "sync_rds_time", NULL),
···
1832
#ifdef HAVE_DIRCACHE
1833
/*enable dircache for all targets > 2MB of RAM by default*/
1834
OFFON_SETTING(F_BANFROMQS,dircache,LANG_DIRCACHE_ENABLE,true,"dircache",NULL),
1835
+
SYSTEM_STATUS(0, dircache_size, 0, "DSZ"),
1836
#endif
1837
1838
#ifdef HAVE_TAGCACHE
···
2054
ID2P(LANG_BOOKMARK_MENU_RECENT_BOOKMARKS),
2055
ID2P(LANG_OPEN_PLUGIN)
2056
),
2057
#if defined(HAVE_RTC_ALARM) && \
2058
(defined(HAVE_RECORDING) || CONFIG_TUNER)
2059
{F_T_INT|F_HAS_CFGVALS, &global_settings.alarm_wake_up_screen, LANG_ALARM_WAKEUP_SCREEN,
+4
-13
apps/settings_list.h
+4
-13
apps/settings_list.h
···
119
Should really only be used if the value you want to store in global_settings
120
is very different to the string you want to use in the config. */
121
#define F_CUSTOM_SETTING 0x8000
122
struct custom_setting {
123
/* load the saved value from the .cfg
124
setting: pointer into global_settings
···
146
147
#define F_TIME_SETTING 0x10000 /* int,table format hh:mm:ss.mss auto ranged */
148
#define F_HAS_CFGVALS 0x20000 /* uses setting union to carry cfg_vals */
149
-
150
-
151
/* these use the _isfunc_type type for the function */
152
/* typedef int (*_isfunc_type)(void); */
153
#define F_MIN_ISFUNC 0x100000 /* min(above) is function pointer to above type */
154
#define F_MAX_ISFUNC 0x200000 /* max(above) is function pointer to above type */
155
#define F_DEF_ISFUNC 0x400000 /* default_val is function pointer to above type */
156
-
157
#define F_THEMESETTING 0x800000
158
#define F_RECSETTING 0x1000000
159
#define F_EQSETTING 0x2000000
160
#define F_SOUNDSETTING 0x4000000
161
-
162
-
#define F_NVRAM_BYTES_MASK 0xE0000 /*0-4 bytes can be stored */
163
-
#define F_NVRAM_MASK_SHIFT 17
164
-
#define NVRAM_CONFIG_VERSION 9
165
-
/* Above define should be bumped if
166
-
- a new NVRAM setting is added between 2 other NVRAM settings
167
-
- number of bytes for a NVRAM setting is changed
168
-
- a NVRAM setting is removed
169
-
*/
170
-
171
#define F_CB_ON_SELECT_ONLY 0x10000000 /* option_callback only called if selected */
172
#define F_CB_ONLY_IF_CHANGED 0x20000000 /* option_callback only called if setting changed */
173
···
119
Should really only be used if the value you want to store in global_settings
120
is very different to the string you want to use in the config. */
121
#define F_CUSTOM_SETTING 0x8000
122
+
123
struct custom_setting {
124
/* load the saved value from the .cfg
125
setting: pointer into global_settings
···
147
148
#define F_TIME_SETTING 0x10000 /* int,table format hh:mm:ss.mss auto ranged */
149
#define F_HAS_CFGVALS 0x20000 /* uses setting union to carry cfg_vals */
150
+
#define F_RESUMESETTING 0x40000 /* saved to a separate cfg file on shutdown */
151
+
/*#define _AVAILABLE_ 0x80000*/
152
/* these use the _isfunc_type type for the function */
153
/* typedef int (*_isfunc_type)(void); */
154
#define F_MIN_ISFUNC 0x100000 /* min(above) is function pointer to above type */
155
#define F_MAX_ISFUNC 0x200000 /* max(above) is function pointer to above type */
156
#define F_DEF_ISFUNC 0x400000 /* default_val is function pointer to above type */
157
#define F_THEMESETTING 0x800000
158
#define F_RECSETTING 0x1000000
159
#define F_EQSETTING 0x2000000
160
#define F_SOUNDSETTING 0x4000000
161
+
/*#define _AVAILABLE_ 0x8000000*/
162
#define F_CB_ON_SELECT_ONLY 0x10000000 /* option_callback only called if selected */
163
#define F_CB_ONLY_IF_CHANGED 0x20000000 /* option_callback only called if setting changed */
164
+1
-1
apps/tree.c
+1
-1
apps/tree.c
+1
-1
firmware/drivers/tuner/ipod_remote_tuner.c
+1
-1
firmware/drivers/tuner/ipod_remote_tuner.c
+2
-1
firmware/export/rbpaths.h
+2
-1
firmware/export/rbpaths.h
···
113
#define CODEPAGE_DIR ROCKBOX_DIR "/codepages"
114
115
#define VIEWERS_CONFIG ROCKBOX_DIR "/viewers.config"
116
#define CONFIGFILE ROCKBOX_DIR "/config.cfg"
117
#define FIXEDSETTINGSFILE ROCKBOX_DIR "/fixed.cfg"
118
119
#define PLAYLIST_CONTROL_FILE ROCKBOX_DIR "/.playlist_control"
120
-
#define NVRAM_FILE ROCKBOX_DIR "/nvram.bin"
121
#define GLYPH_CACHE_FILE ROCKBOX_DIR "/.glyphcache"
122
123
#endif /* __PATHS_H__ */
···
113
#define CODEPAGE_DIR ROCKBOX_DIR "/codepages"
114
115
#define VIEWERS_CONFIG ROCKBOX_DIR "/viewers.config"
116
+
117
+
#define RESUMEFILE ROCKBOX_DIR "/.resume.cfg"
118
#define CONFIGFILE ROCKBOX_DIR "/config.cfg"
119
#define FIXEDSETTINGSFILE ROCKBOX_DIR "/fixed.cfg"
120
121
#define PLAYLIST_CONTROL_FILE ROCKBOX_DIR "/.playlist_control"
122
#define GLYPH_CACHE_FILE ROCKBOX_DIR "/.glyphcache"
123
124
#endif /* __PATHS_H__ */
+1
-1
firmware/sound.c
+1
-1
firmware/sound.c