devs/foxbox
1
0
Fork 0
forked from len0rd/rockbox
Code Pull requests Activity

plugins: playing time: improve precision

Browse source 
Add up length and size of tracks in ms & Bytes,
then only convert units to s & KiB at the end.
Otherwise, the result can be noticeably off when
dealing with a large enough number of tracks.

Change-Id: I2a3e502508089830f63b24c3bbdbb0ab8f57cabe
This commit is contained in:
Christian Soffke 2024-07-24 20:50:39 +02:00
parent 23e5f77ab0
commit b52e72db36
1 changed files with 142 additions and 161 deletions
Download patch file Download diff file Expand all files Collapse all files

303
apps/plugins/playing_time.c
View file

@ -44,212 +44,190 @@ const int menu_items[] = {
const unsigned char * const * const kibyte_units = &byte_units[1]; const unsigned char * const * const kibyte_units = &byte_units[1];
enum ePT_SECS { enum ePT_SUM {
ePT_SECS_TTL = 0,
ePT_SECS_BEF,
ePT_SECS_AFT,
ePT_SECS_COUNT
};
enum ePT_KBS {
/* Note: Order matters (voicing order of LANG_PLAYTIME_STORAGE) */ /* Note: Order matters (voicing order of LANG_PLAYTIME_STORAGE) */
ePT_KBS_TTL = 0, ePT_TOTAL = 0,
ePT_KBS_BEF, ePT_ELAPSED,
ePT_KBS_AFT, ePT_REMAINING,
ePT_KBS_COUNT
ePT_COUNT
}; };
/* playing_time screen context */
struct playing_time_info { struct playing_time_info {
int curr_index; /* index of currently playing track in playlist */ int nb_tracks; /* number of tracks in playlist */
int curr_display_index; /* display index of currently playing track in playlist */ int curr_track_index; /* index of currently playing track in playlist */
int nb_tracks; /* how many tracks in playlist */ int curr_display_index; /* display index of currently playing track */
unsigned long curr_track_length[ePT_COUNT]; /* current track length */
/* seconds total, before, and after current position. Datatype unsigned long long length[ePT_COUNT]; /* length of all tracks */
allows for values up to 68years. If I had kept it in ms unsigned long long size[ePT_COUNT]; /* file size of all tracks */
though, it would have overflowed at 24days, which takes
something like 8.5GB at 32kbps, and so we could conceivably
have playlists lasting longer than that. */
long secs[ePT_SECS_COUNT];
long trk_secs[ePT_SECS_COUNT];
/* kilobytes played total, before, and after current pos.
Kilobytes because bytes would overflow. Data type range is up
to 2TB. */
long kbs[ePT_KBS_COUNT];
}; };
static char* get_percent_str(long percents) static char* get_percent_str(long percents)
{ {
static char val[10]; static char val[10];
rb->snprintf(val, 10, rb->str(LANG_PERCENT_FORMAT), percents); rb->snprintf(val, sizeof(val), rb->str(LANG_PERCENT_FORMAT), percents);
return val; return val;
} }
static inline void prepare_time_string(char *buf, size_t buffer_len, long elapsed_pct, const char *timestr1, const char *timestr2) static inline void prepare_time_string(char *buf, size_t buffer_len,
long elapsed_pct, const char *timestr1,
const char *timestr2)
{ {
if (rb->lang_is_rtl()) if (rb->lang_is_rtl())
{
rb->snprintf(buf, buffer_len, "%s %s / %s", rb->snprintf(buf, buffer_len, "%s %s / %s",
get_percent_str(elapsed_pct), timestr2, timestr1); get_percent_str(elapsed_pct), timestr2, timestr1);
}
else else
{
rb->snprintf(buf, buffer_len, "%s / %s %s", rb->snprintf(buf, buffer_len, "%s / %s %s",
timestr1, timestr2, get_percent_str(elapsed_pct)); timestr1, timestr2, get_percent_str(elapsed_pct));
}
} }
/* list callback for playing_time screen */ /* list callback for playing_time screen */
static const char * playing_time_get_or_speak_info(int selected_item, void * data, static const char * pt_get_or_speak_info(int selected_item, void * data,
char *buf, size_t buffer_len, char *buf, size_t buffer_len,
bool say_it) bool say_it)
{ {
long elapsed_pct; /* percentage of duration elapsed */ long elapsed_pct; /* percentage of duration elapsed */
struct playing_time_info *pti = (struct playing_time_info *)data; struct playing_time_info *pti = (struct playing_time_info *)data;
int info_no = selected_item/2; int info_no = selected_item/2;
const int menu_name_id = menu_items[info_no]; const int menu_name_id = menu_items[info_no];
if (!(selected_item%2)) /* header */
{/* header */ if (!(selected_item % 2))
return rb->str(menu_name_id); return rb->str(menu_name_id);
}
/* data */
switch(info_no) { switch(info_no) {
case 0: { /* elapsed and total time */ case 0: { /* elapsed and total time */
char timestr1[25], timestr2[25]; char timestr1[25], timestr2[25];
rb->format_time_auto(timestr1, sizeof(timestr1), rb->format_time_auto(timestr1, sizeof(timestr1),
pti->secs[ePT_SECS_BEF], UNIT_SEC, true); pti->length[ePT_ELAPSED], UNIT_SEC, true);
rb->format_time_auto(timestr2, sizeof(timestr2), rb->format_time_auto(timestr2, sizeof(timestr2),
pti->secs[ePT_SECS_TTL], UNIT_SEC, true); pti->length[ePT_TOTAL], UNIT_SEC, true);
if (pti->secs[ePT_SECS_TTL] == 0) if (pti->length[ePT_TOTAL] == 0)
elapsed_pct = 0; elapsed_pct = 0;
else if (pti->secs[ePT_SECS_TTL] <= 0xFFFFFF) else if (pti->length[ePT_TOTAL] <= 0xFFFFFF)
{ {
elapsed_pct = (pti->secs[ePT_SECS_BEF] * 100 elapsed_pct = (pti->length[ePT_ELAPSED] * 100
/ pti->secs[ePT_SECS_TTL]); / pti->length[ePT_TOTAL]);
} }
else /* sacrifice some precision to avoid overflow */ else /* sacrifice some precision to avoid overflow */
{ {
elapsed_pct = (pti->secs[ePT_SECS_BEF] >> 7) * 100 elapsed_pct = (pti->length[ePT_ELAPSED] >> 7) * 100
/ (pti->secs[ePT_SECS_TTL] >> 7); / (pti->length[ePT_TOTAL] >> 7);
} }
prepare_time_string(buf, buffer_len, elapsed_pct, timestr1, timestr2); prepare_time_string(buf, buffer_len, elapsed_pct, timestr1, timestr2);
if (say_it) if (say_it)
rb_talk_ids(false, menu_name_id, rb_talk_ids(false, menu_name_id,
TALK_ID(pti->secs[ePT_SECS_BEF], UNIT_TIME), TALK_ID(pti->length[ePT_ELAPSED], UNIT_TIME),
VOICE_OF, VOICE_OF,
TALK_ID(pti->secs[ePT_SECS_TTL], UNIT_TIME), TALK_ID(pti->length[ePT_TOTAL], UNIT_TIME),
VOICE_PAUSE, VOICE_PAUSE,
TALK_ID(elapsed_pct, UNIT_PERCENT)); TALK_ID(elapsed_pct, UNIT_PERCENT));
break; break;
} }
case 1: { /* playlist remaining time */ case 1: { /* playlist remaining time */
char timestr[25]; char timestr[25];
rb->format_time_auto(timestr, sizeof(timestr), pti->secs[ePT_SECS_AFT], rb->format_time_auto(timestr, sizeof(timestr),
UNIT_SEC, false); pti->length[ePT_REMAINING], UNIT_SEC, false);
rb->snprintf(buf, buffer_len, "%s", timestr); rb->snprintf(buf, buffer_len, "%s", timestr);
if (say_it) if (say_it)
rb_talk_ids(false, menu_name_id, rb_talk_ids(false, menu_name_id,
TALK_ID(pti->secs[ePT_SECS_AFT], UNIT_TIME)); TALK_ID(pti->length[ePT_REMAINING], UNIT_TIME));
break; break;
} }
case 2: { /* track elapsed and duration */ case 2: { /* track elapsed and duration */
char timestr1[25], timestr2[25]; char timestr1[25], timestr2[25];
rb->format_time_auto(timestr1, sizeof(timestr1), pti->trk_secs[ePT_SECS_BEF], rb->format_time_auto(timestr1, sizeof(timestr1),
UNIT_SEC, true); pti->curr_track_length[ePT_ELAPSED], UNIT_SEC, true);
rb->format_time_auto(timestr2, sizeof(timestr2), pti->trk_secs[ePT_SECS_TTL], rb->format_time_auto(timestr2, sizeof(timestr2),
UNIT_SEC, true); pti->curr_track_length[ePT_TOTAL], UNIT_SEC, true);
if (pti->trk_secs[ePT_SECS_TTL] == 0) if (pti->curr_track_length[ePT_TOTAL] == 0)
elapsed_pct = 0; elapsed_pct = 0;
else if (pti->trk_secs[ePT_SECS_TTL] <= 0xFFFFFF) else if (pti->curr_track_length[ePT_TOTAL] <= 0xFFFFFF)
{ {
elapsed_pct = (pti->trk_secs[ePT_SECS_BEF] * 100 elapsed_pct = (pti->curr_track_length[ePT_ELAPSED] * 100
/ pti->trk_secs[ePT_SECS_TTL]); / pti->curr_track_length[ePT_TOTAL]);
} }
else /* sacrifice some precision to avoid overflow */ else /* sacrifice some precision to avoid overflow */
{ {
elapsed_pct = (pti->trk_secs[ePT_SECS_BEF] >> 7) * 100 elapsed_pct = (pti->curr_track_length[ePT_ELAPSED] >> 7) * 100
/ (pti->trk_secs[ePT_SECS_TTL] >> 7); / (pti->curr_track_length[ePT_TOTAL] >> 7);
} }
prepare_time_string(buf, buffer_len, elapsed_pct, timestr1, timestr2); prepare_time_string(buf, buffer_len, elapsed_pct, timestr1, timestr2);
if (say_it) if (say_it)
rb_talk_ids(false, menu_name_id, rb_talk_ids(false, menu_name_id,
TALK_ID(pti->trk_secs[ePT_SECS_BEF], UNIT_TIME), TALK_ID(pti->curr_track_length[ePT_ELAPSED], UNIT_TIME),
VOICE_OF, VOICE_OF,
TALK_ID(pti->trk_secs[ePT_SECS_TTL], UNIT_TIME), TALK_ID(pti->curr_track_length[ePT_TOTAL], UNIT_TIME),
VOICE_PAUSE, VOICE_PAUSE,
TALK_ID(elapsed_pct, UNIT_PERCENT)); TALK_ID(elapsed_pct, UNIT_PERCENT));
break; break;
} }
case 3: { /* track remaining time */ case 3: { /* track remaining time */
char timestr[25]; char timestr[25];
rb->format_time_auto(timestr, sizeof(timestr), pti->trk_secs[ePT_SECS_AFT], rb->format_time_auto(timestr, sizeof(timestr),
UNIT_SEC, false); pti->curr_track_length[ePT_REMAINING], UNIT_SEC, false);
rb->snprintf(buf, buffer_len, "%s", timestr); rb->snprintf(buf, buffer_len, "%s", timestr);
if (say_it) if (say_it)
rb_talk_ids(false, menu_name_id, rb_talk_ids(false, menu_name_id,
TALK_ID(pti->trk_secs[ePT_SECS_AFT], UNIT_TIME)); TALK_ID(pti->curr_track_length[ePT_REMAINING], UNIT_TIME));
break; break;
} }
case 4: { /* track index */ case 4: { /* track index */
int track_pct = pti->curr_display_index * 100 / pti->nb_tracks; int track_pct = pti->curr_display_index * 100 / pti->nb_tracks;
if (rb->lang_is_rtl()) if (rb->lang_is_rtl())
{ rb->snprintf(buf, buffer_len, "%s %d / %d", get_percent_str(track_pct),
rb->snprintf(buf, buffer_len, "%s %d / %d", pti->nb_tracks, pti->curr_display_index);
get_percent_str(track_pct), pti->nb_tracks, pti->curr_display_index);
}
else else
{ rb->snprintf(buf, buffer_len, "%d / %d %s", pti->curr_display_index,
rb->snprintf(buf, buffer_len, "%d / %d %s", pti->nb_tracks, get_percent_str(track_pct));
pti->curr_display_index, pti->nb_tracks, get_percent_str(track_pct));
}
if (say_it) if (say_it)
rb_talk_ids(false, menu_name_id, rb_talk_ids(false, menu_name_id,
TALK_ID(pti->curr_display_index, UNIT_INT), TALK_ID(pti->curr_display_index, UNIT_INT),
VOICE_OF, VOICE_OF,
TALK_ID(pti->nb_tracks, UNIT_INT), TALK_ID(pti->nb_tracks, UNIT_INT),
VOICE_PAUSE, VOICE_PAUSE,
TALK_ID(track_pct, UNIT_PERCENT)); TALK_ID(track_pct, UNIT_PERCENT));
break; break;
} }
case 5: { /* storage size */ case 5: { /* storage size */
int i; int i;
char kbstr[ePT_KBS_COUNT][20]; char kbstr[ePT_COUNT][20];
for (i = 0; i < ePT_KBS_COUNT; i++) { for (i = 0; i < ePT_COUNT; i++) {
rb->output_dyn_value(kbstr[i], sizeof(kbstr[i]), rb->output_dyn_value(kbstr[i], sizeof(kbstr[i]),
pti->kbs[i], kibyte_units, 3, true); pti->size[i], kibyte_units, 3, true);
} }
rb->snprintf(buf, buffer_len, "%s (%s / %s)", rb->snprintf(buf, buffer_len, "%s (%s / %s)", kbstr[ePT_TOTAL],
kbstr[ePT_KBS_TTL], kbstr[ePT_KBS_BEF],kbstr[ePT_KBS_AFT]); kbstr[ePT_ELAPSED], kbstr[ePT_REMAINING]);
if (say_it) { if (say_it) {
int32_t voice_ids[ePT_KBS_COUNT]; int32_t voice_ids[ePT_COUNT];
voice_ids[ePT_KBS_TTL] = menu_name_id; voice_ids[ePT_TOTAL] = menu_name_id;
voice_ids[ePT_KBS_BEF] = VOICE_PLAYTIME_DONE; voice_ids[ePT_ELAPSED] = VOICE_PLAYTIME_DONE;
voice_ids[ePT_KBS_AFT] = LANG_PLAYTIME_REMAINING; voice_ids[ePT_REMAINING] = LANG_PLAYTIME_REMAINING;
for (i = 0; i < ePT_KBS_COUNT; i++) { for (i = 0; i < ePT_COUNT; i++)
{
rb_talk_ids(i > 0, VOICE_PAUSE, voice_ids[i]); rb_talk_ids(i > 0, VOICE_PAUSE, voice_ids[i]);
rb->output_dyn_value(NULL, 0, pti->kbs[i], kibyte_units, 3, true); rb->output_dyn_value(NULL, 0, pti->size[i], kibyte_units, 3, true);
} }
} }
break; break;
} }
case 6: { /* Average track file size */ case 6: { /* Average track file size */
char str[20]; char str[20];
long avg_track_size = pti->kbs[ePT_KBS_TTL] / pti->nb_tracks; long avg_track_size = pti->size[ePT_TOTAL] / pti->nb_tracks;
rb->output_dyn_value(str, sizeof(str), avg_track_size, kibyte_units, 3, true); rb->output_dyn_value(str, sizeof(str), avg_track_size, kibyte_units, 3, true);
rb->snprintf(buf, buffer_len, "%s", str); rb->snprintf(buf, buffer_len, "%s", str);
@ -261,31 +239,30 @@ static const char * playing_time_get_or_speak_info(int selected_item, void * dat
} }
case 7: { /* Average bitrate */ case 7: { /* Average bitrate */
/* Convert power of 2 kilobytes to power of 10 kilobits */ /* Convert power of 2 kilobytes to power of 10 kilobits */
long avg_bitrate = (pti->kbs[ePT_KBS_TTL] / pti->secs[ePT_SECS_TTL] long avg_bitrate = (pti->size[ePT_TOTAL] / pti->length[ePT_TOTAL]
* 1024 * 8 / 1000); * 1024 * 8 / 1000);
rb->snprintf(buf, buffer_len, "%ld kbps", avg_bitrate); rb->snprintf(buf, buffer_len, "%ld kbps", avg_bitrate);
if (say_it) if (say_it)
rb_talk_ids(false, menu_name_id, rb_talk_ids(false, menu_name_id,
TALK_ID(avg_bitrate, UNIT_KBIT)); TALK_ID(avg_bitrate, UNIT_KBIT));
break; break;
} }
} }
return buf; return buf;
} }
static const char * playing_time_get_info(int selected_item, void * data, static const char * pt_get_info(int selected_item, void * data,
char *buffer, size_t buffer_len) char *buffer, size_t buffer_len)
{ {
return playing_time_get_or_speak_info(selected_item, data, return pt_get_or_speak_info(selected_item, data,
buffer, buffer_len, false); buffer, buffer_len, false);
} }
static int playing_time_speak_info(int selected_item, void * data) static int pt_speak_info(int selected_item, void * data)
{ {
static char buffer[MAX_PATH]; static char buffer[MAX_PATH];
playing_time_get_or_speak_info(selected_item, data, pt_get_or_speak_info(selected_item, data, buffer, sizeof(buffer), true);
buffer, MAX_PATH, true);
return 0; return 0;
} }
@ -293,25 +270,30 @@ static int playing_time_speak_info(int selected_item, void * data)
other stats */ other stats */
static bool playing_time(void) static bool playing_time(void)
{ {
int error_count = 0;
unsigned long talked_tick = *rb->current_tick;
struct playing_time_info pti; struct playing_time_info pti;
struct playlist_track_info pltrack; struct playlist_track_info pl_track;
struct mp3entry id3; struct mp3entry id3;
int i, index; struct mp3entry *curr_id3;
struct gui_synclist pt_lists;
unsigned long talked_tick = *rb->current_tick;
int action, i, index, section, error_count = 0;
pti.nb_tracks = rb->playlist_amount(); pti.nb_tracks = rb->playlist_amount();
rb->playlist_get_resume_info(&pti.curr_index); rb->playlist_get_resume_info(&pti.curr_track_index);
struct mp3entry *curr_id3 = rb->audio_current_track(); curr_id3 = rb->audio_current_track();
if (pti.curr_index == -1 || !curr_id3)
if (pti.curr_track_index == -1 || !curr_id3)
return false; return false;
pti.curr_display_index = rb->playlist_get_display_index(); pti.curr_display_index = rb->playlist_get_display_index();
pti.secs[ePT_SECS_BEF] = pti.trk_secs[ePT_SECS_BEF] = curr_id3->elapsed / 1000; pti.length[ePT_ELAPSED] = pti.curr_track_length[ePT_ELAPSED]
pti.secs[ePT_SECS_AFT] = pti.trk_secs[ePT_SECS_AFT] = curr_id3->elapsed;
= (curr_id3->length -curr_id3->elapsed) / 1000; pti.length[ePT_REMAINING] = pti.curr_track_length[ePT_REMAINING]
pti.kbs[ePT_KBS_BEF] = curr_id3->offset / 1024; = curr_id3->length - curr_id3->elapsed;
pti.kbs[ePT_KBS_AFT] = (curr_id3->filesize -curr_id3->offset) / 1024;
pti.size[ePT_ELAPSED] = curr_id3->offset;
pti.size[ePT_REMAINING] = curr_id3->filesize - curr_id3->offset;
rb->splash_progress_set_delay(HZ/2); rb->splash_progress_set_delay(HZ/2);
@ -328,15 +310,14 @@ static bool playing_time(void)
if (index == pti.nb_tracks) if (index == pti.nb_tracks)
index = 0; index = 0;
/* Show a splash while we are loading. */
rb->splash_progress(i, pti.nb_tracks, "%s (%s)", rb->splash_progress(i, pti.nb_tracks, "%s (%s)",
rb->str(LANG_WAIT), rb->str(LANG_OFF_ABORT)); rb->str(LANG_WAIT), rb->str(LANG_OFF_ABORT));
/* Voice equivalent */ if (TIME_AFTER(*rb->current_tick, talked_tick + HZ*5))
if (TIME_AFTER(*rb->current_tick, talked_tick + 5 * HZ)) { {
talked_tick = *rb->current_tick; talked_tick = *rb->current_tick;
rb_talk_ids(false, LANG_LOADING_PERCENT, rb_talk_ids(false, LANG_LOADING_PERCENT,
TALK_ID(i * 100 / pti.nb_tracks, UNIT_PERCENT)); TALK_ID(i * 100 / pti.nb_tracks, UNIT_PERCENT));
} }
if (rb->action_userabort(TIMEOUT_NOBLOCK)) if (rb->action_userabort(TIMEOUT_NOBLOCK))
{ {
@ -346,67 +327,67 @@ static bool playing_time(void)
goto exit; goto exit;
} }
if (index == pti.curr_index) if (index == pti.curr_track_index)
continue; continue;
if (rb->playlist_get_track_info(NULL, index, &pltrack) < 0 if (rb->playlist_get_track_info(NULL, index, &pl_track) < 0
|| !rb->get_metadata(&id3, -1, pltrack.filename)) || !rb->get_metadata(&id3, -1, pl_track.filename))
{ {
error_count++; error_count++;
continue; continue;
} }
if (pltrack.display_index < pti.curr_display_index) /* preceding tracks */ section = pl_track.display_index < pti.curr_display_index ?
{ ePT_ELAPSED : ePT_REMAINING;
pti.secs[ePT_SECS_BEF] += id3.length / 1000; pti.length[section] += id3.length;
pti.kbs[ePT_KBS_BEF] += id3.filesize / 1024; pti.size[section] += id3.filesize;
}
else
{
pti.secs[ePT_SECS_AFT] += id3.length / 1000;
pti.kbs[ePT_KBS_AFT] += id3.filesize / 1024;
}
} }
#ifdef HAVE_ADJUSTABLE_CPU_FREQ #ifdef HAVE_ADJUSTABLE_CPU_FREQ
rb->cpu_boost(false); rb->cpu_boost(false);
#endif #endif
if (error_count > 0) if (error_count > 0)
{
rb->splash(HZ, ID2P(LANG_PLAYTIME_ERROR)); rb->splash(HZ, ID2P(LANG_PLAYTIME_ERROR));
}
pti.nb_tracks -= error_count; pti.nb_tracks -= error_count;
pti.secs[ePT_SECS_TTL] = pti.secs[ePT_SECS_BEF] + pti.secs[ePT_SECS_AFT];
pti.trk_secs[ePT_SECS_TTL] = pti.trk_secs[ePT_SECS_BEF] + pti.trk_secs[ePT_SECS_AFT];
pti.kbs[ePT_KBS_TTL] = pti.kbs[ePT_KBS_BEF] + pti.kbs[ePT_KBS_AFT];
struct gui_synclist pt_lists; /* convert units from ms to s */
int key; pti.length[ePT_ELAPSED] /= 1000;
pti.length[ePT_REMAINING] /= 1000;
pti.curr_track_length[ePT_ELAPSED] /= 1000;
pti.curr_track_length[ePT_REMAINING] /= 1000;
/* convert units from Bytes to KiB */
pti.size[ePT_ELAPSED] >>= 10;
pti.size[ePT_REMAINING] >>= 10;
rb->gui_synclist_init(&pt_lists, &playing_time_get_info, &pti, true, 2, NULL); /* calculate totals */
pti.length[ePT_TOTAL] = pti.length[ePT_ELAPSED] + pti.length[ePT_REMAINING];
pti.curr_track_length[ePT_TOTAL] = pti.curr_track_length[ePT_ELAPSED]
+ pti.curr_track_length[ePT_REMAINING];
pti.size[ePT_TOTAL] = pti.size[ePT_ELAPSED] + pti.size[ePT_REMAINING];
rb->gui_synclist_init(&pt_lists, &pt_get_info, &pti, true, 2, NULL);
if (rb->global_settings->talk_menu) if (rb->global_settings->talk_menu)
rb->gui_synclist_set_voice_callback(&pt_lists, playing_time_speak_info); rb->gui_synclist_set_voice_callback(&pt_lists, pt_speak_info);
rb->gui_synclist_set_nb_items(&pt_lists, 16); rb->gui_synclist_set_nb_items(&pt_lists, 16);
rb->gui_synclist_set_title(&pt_lists, rb->str(LANG_PLAYING_TIME), NOICON); rb->gui_synclist_set_title(&pt_lists, rb->str(LANG_PLAYING_TIME), NOICON);
rb->gui_synclist_draw(&pt_lists); rb->gui_synclist_draw(&pt_lists);
rb->gui_synclist_speak_item(&pt_lists); rb->gui_synclist_speak_item(&pt_lists);
while (true) { while (true)
key = rb->get_action(CONTEXT_LIST, HZ/2); {
if (rb->gui_synclist_do_button(&pt_lists, &key) == 0 action = rb->get_action(CONTEXT_LIST, HZ/2);
&& key!=ACTION_NONE && key!=ACTION_UNKNOWN) if (rb->gui_synclist_do_button(&pt_lists, &action) == 0
&& action != ACTION_NONE && action != ACTION_UNKNOWN)
{ {
bool usb = rb->default_event_handler(key) == SYS_USB_CONNECTED; bool usb = rb->default_event_handler(action) == SYS_USB_CONNECTED;
if (!usb && IS_SYSEVENT(key)) if (!usb && IS_SYSEVENT(action))
continue; continue;
rb->talk_force_shutup(); rb->talk_force_shutup();
return usb; return usb;
} }
} }
exit: exit:
return false; return false;
} }