diff options
Diffstat (limited to 'apps/onplay.c')
-rw-r--r-- | apps/onplay.c | 320 |
1 files changed, 5 insertions, 315 deletions
diff --git a/apps/onplay.c b/apps/onplay.c index 26a2614b56..5f8af77fca 100644 --- a/apps/onplay.c +++ b/apps/onplay.c | |||
@@ -200,322 +200,7 @@ static int bookmark_menu_callback(int action, | |||
200 | return action; | 200 | return action; |
201 | } | 201 | } |
202 | 202 | ||
203 | enum ePT_SECS { | ||
204 | ePT_SECS_TTL = 0, | ||
205 | ePT_SECS_BEF, | ||
206 | ePT_SECS_AFT, | ||
207 | ePT_SECS_COUNT | ||
208 | }; | ||
209 | |||
210 | enum ePT_KBS { | ||
211 | /* Note: Order matters (voicing order of LANG_PLAYTIME_STORAGE) */ | ||
212 | ePT_KBS_TTL = 0, | ||
213 | ePT_KBS_BEF, | ||
214 | ePT_KBS_AFT, | ||
215 | ePT_KBS_COUNT | ||
216 | }; | ||
217 | |||
218 | /* playing_time screen context */ | ||
219 | struct playing_time_info { | ||
220 | int curr_playing; /* index of currently playing track in playlist */ | ||
221 | int nb_tracks; /* how many tracks in playlist */ | ||
222 | /* seconds total, before, and after current position. Datatype | ||
223 | allows for values up to 68years. If I had kept it in ms | ||
224 | though, it would have overflowed at 24days, which takes | ||
225 | something like 8.5GB at 32kbps, and so we could conceivably | ||
226 | have playlists lasting longer than that. */ | ||
227 | long secs[ePT_SECS_COUNT]; | ||
228 | long trk_secs[ePT_SECS_COUNT]; | ||
229 | /* kilobytes played total, before, and after current pos. | ||
230 | Kilobytes because bytes would overflow. Data type range is up | ||
231 | to 2TB. */ | ||
232 | long kbs[ePT_KBS_COUNT]; | ||
233 | }; | ||
234 | |||
235 | /* list callback for playing_time screen */ | ||
236 | static const char * playing_time_get_or_speak_info(int selected_item, void * data, | ||
237 | char *buf, size_t buffer_len, | ||
238 | bool say_it) | ||
239 | { | ||
240 | long elapsed_pct; /* percentage of duration elapsed */ | ||
241 | struct playing_time_info *pti = (struct playing_time_info *)data; | ||
242 | switch(selected_item) { | ||
243 | case 0: { /* elapsed and total time */ | ||
244 | char timestr1[25], timestr2[25]; | ||
245 | format_time_auto(timestr1, sizeof(timestr1), | ||
246 | pti->secs[ePT_SECS_BEF], UNIT_SEC, false); | ||
247 | |||
248 | format_time_auto(timestr2, sizeof(timestr2), | ||
249 | pti->secs[ePT_SECS_TTL], UNIT_SEC, false); | ||
250 | |||
251 | if (pti->secs[ePT_SECS_TTL] == 0) | ||
252 | elapsed_pct = 0; | ||
253 | else if (pti->secs[ePT_SECS_TTL] <= 0xFFFFFF) | ||
254 | { | ||
255 | elapsed_pct = (pti->secs[ePT_SECS_BEF] * 100 | ||
256 | / pti->secs[ePT_SECS_TTL]); | ||
257 | } | ||
258 | else /* sacrifice some precision to avoid overflow */ | ||
259 | { | ||
260 | elapsed_pct = (pti->secs[ePT_SECS_BEF] >> 7) * 100 | ||
261 | / (pti->secs[ePT_SECS_TTL] >> 7); | ||
262 | } | ||
263 | snprintf(buf, buffer_len, str(LANG_PLAYTIME_ELAPSED), | ||
264 | timestr1, timestr2, elapsed_pct); | ||
265 | |||
266 | if (say_it) | ||
267 | talk_ids(false, LANG_PLAYTIME_ELAPSED, | ||
268 | TALK_ID(pti->secs[ePT_SECS_BEF], UNIT_TIME), | ||
269 | VOICE_OF, | ||
270 | TALK_ID(pti->secs[ePT_SECS_TTL], UNIT_TIME), | ||
271 | VOICE_PAUSE, | ||
272 | TALK_ID(elapsed_pct, UNIT_PERCENT)); | ||
273 | break; | ||
274 | } | ||
275 | case 1: { /* playlist remaining time */ | ||
276 | char timestr[25]; | ||
277 | format_time_auto(timestr, sizeof(timestr), pti->secs[ePT_SECS_AFT], | ||
278 | UNIT_SEC, false); | ||
279 | snprintf(buf, buffer_len, str(LANG_PLAYTIME_REMAINING), timestr); | ||
280 | |||
281 | if (say_it) | ||
282 | talk_ids(false, LANG_PLAYTIME_REMAINING, | ||
283 | TALK_ID(pti->secs[ePT_SECS_AFT], UNIT_TIME)); | ||
284 | break; | ||
285 | } | ||
286 | case 2: { /* track elapsed and duration */ | ||
287 | char timestr1[25], timestr2[25]; | ||
288 | |||
289 | format_time_auto(timestr1, sizeof(timestr1), pti->trk_secs[ePT_SECS_BEF], | ||
290 | UNIT_SEC, false); | ||
291 | format_time_auto(timestr2, sizeof(timestr2), pti->trk_secs[ePT_SECS_TTL], | ||
292 | UNIT_SEC, false); | ||
293 | |||
294 | if (pti->trk_secs[ePT_SECS_TTL] == 0) | ||
295 | elapsed_pct = 0; | ||
296 | else if (pti->trk_secs[ePT_SECS_TTL] <= 0xFFFFFF) | ||
297 | { | ||
298 | elapsed_pct = (pti->trk_secs[ePT_SECS_BEF] * 100 | ||
299 | / pti->trk_secs[ePT_SECS_TTL]); | ||
300 | } | ||
301 | else /* sacrifice some precision to avoid overflow */ | ||
302 | { | ||
303 | elapsed_pct = (pti->trk_secs[ePT_SECS_BEF] >> 7) * 100 | ||
304 | / (pti->trk_secs[ePT_SECS_TTL] >> 7); | ||
305 | } | ||
306 | snprintf(buf, buffer_len, str(LANG_PLAYTIME_TRK_ELAPSED), | ||
307 | timestr1, timestr2, elapsed_pct); | ||
308 | |||
309 | if (say_it) | ||
310 | talk_ids(false, LANG_PLAYTIME_TRK_ELAPSED, | ||
311 | TALK_ID(pti->trk_secs[ePT_SECS_BEF], UNIT_TIME), | ||
312 | VOICE_OF, | ||
313 | TALK_ID(pti->trk_secs[ePT_SECS_TTL], UNIT_TIME), | ||
314 | VOICE_PAUSE, | ||
315 | TALK_ID(elapsed_pct, UNIT_PERCENT)); | ||
316 | break; | ||
317 | } | ||
318 | case 3: { /* track remaining time */ | ||
319 | char timestr[25]; | ||
320 | format_time_auto(timestr, sizeof(timestr), pti->trk_secs[ePT_SECS_AFT], | ||
321 | UNIT_SEC, false); | ||
322 | snprintf(buf, buffer_len, str(LANG_PLAYTIME_TRK_REMAINING), timestr); | ||
323 | |||
324 | if (say_it) | ||
325 | talk_ids(false, LANG_PLAYTIME_TRK_REMAINING, | ||
326 | TALK_ID(pti->trk_secs[ePT_SECS_AFT], UNIT_TIME)); | ||
327 | break; | ||
328 | } | ||
329 | case 4: { /* track index */ | ||
330 | int track_pct = (pti->curr_playing + 1) * 100 / pti->nb_tracks; | ||
331 | snprintf(buf, buffer_len, str(LANG_PLAYTIME_TRACK), | ||
332 | pti->curr_playing + 1, pti->nb_tracks, track_pct); | ||
333 | |||
334 | if (say_it) | ||
335 | talk_ids(false, LANG_PLAYTIME_TRACK, | ||
336 | TALK_ID(pti->curr_playing + 1, UNIT_INT), | ||
337 | VOICE_OF, | ||
338 | TALK_ID(pti->nb_tracks, UNIT_INT), | ||
339 | VOICE_PAUSE, | ||
340 | TALK_ID(track_pct, UNIT_PERCENT)); | ||
341 | break; | ||
342 | } | ||
343 | case 5: { /* storage size */ | ||
344 | int i; | ||
345 | char kbstr[ePT_KBS_COUNT][10]; | ||
346 | 203 | ||
347 | for (i = 0; i < ePT_KBS_COUNT; i++) { | ||
348 | output_dyn_value(kbstr[i], sizeof(kbstr[i]), | ||
349 | pti->kbs[i], kibyte_units, 3, true); | ||
350 | } | ||
351 | snprintf(buf, buffer_len, str(LANG_PLAYTIME_STORAGE), | ||
352 | kbstr[ePT_KBS_TTL], kbstr[ePT_KBS_BEF],kbstr[ePT_KBS_AFT]); | ||
353 | |||
354 | if (say_it) { | ||
355 | int32_t voice_ids[ePT_KBS_COUNT]; | ||
356 | voice_ids[ePT_KBS_TTL] = LANG_PLAYTIME_STORAGE; | ||
357 | voice_ids[ePT_KBS_BEF] = VOICE_PLAYTIME_DONE; | ||
358 | voice_ids[ePT_KBS_AFT] = LANG_PLAYTIME_REMAINING; | ||
359 | |||
360 | for (i = 0; i < ePT_KBS_COUNT; i++) { | ||
361 | talk_ids(i > 0, VOICE_PAUSE, voice_ids[i]); | ||
362 | output_dyn_value(NULL, 0, pti->kbs[i], kibyte_units, 3, true); | ||
363 | } | ||
364 | } | ||
365 | break; | ||
366 | } | ||
367 | case 6: { /* Average track file size */ | ||
368 | char str[10]; | ||
369 | long avg_track_size = pti->kbs[ePT_KBS_TTL] / pti->nb_tracks; | ||
370 | output_dyn_value(str, sizeof(str), avg_track_size, kibyte_units, 3, true); | ||
371 | snprintf(buf, buffer_len, str(LANG_PLAYTIME_AVG_TRACK_SIZE), str); | ||
372 | |||
373 | if (say_it) { | ||
374 | talk_id(LANG_PLAYTIME_AVG_TRACK_SIZE, false); | ||
375 | output_dyn_value(NULL, 0, avg_track_size, kibyte_units, 3, true); | ||
376 | } | ||
377 | break; | ||
378 | } | ||
379 | case 7: { /* Average bitrate */ | ||
380 | /* Convert power of 2 kilobytes to power of 10 kilobits */ | ||
381 | long avg_bitrate = (pti->kbs[ePT_KBS_TTL] / pti->secs[ePT_SECS_TTL] | ||
382 | * 1024 * 8 / 1000); | ||
383 | snprintf(buf, buffer_len, str(LANG_PLAYTIME_AVG_BITRATE), avg_bitrate); | ||
384 | |||
385 | if (say_it) | ||
386 | talk_ids(false, LANG_PLAYTIME_AVG_BITRATE, | ||
387 | TALK_ID(avg_bitrate, UNIT_KBIT)); | ||
388 | break; | ||
389 | } | ||
390 | } | ||
391 | return buf; | ||
392 | } | ||
393 | |||
394 | static const char * playing_time_get_info(int selected_item, void * data, | ||
395 | char *buffer, size_t buffer_len) | ||
396 | { | ||
397 | return playing_time_get_or_speak_info(selected_item, data, | ||
398 | buffer, buffer_len, false); | ||
399 | } | ||
400 | |||
401 | static int playing_time_speak_info(int selected_item, void * data) | ||
402 | { | ||
403 | static char buffer[MAX_PATH]; | ||
404 | playing_time_get_or_speak_info(selected_item, data, | ||
405 | buffer, MAX_PATH, true); | ||
406 | return 0; | ||
407 | } | ||
408 | |||
409 | /* playing time screen: shows total and elapsed playlist duration and | ||
410 | other stats */ | ||
411 | static bool playing_time(void) | ||
412 | { | ||
413 | int error_count = 0; | ||
414 | unsigned long talked_tick = current_tick; | ||
415 | struct playing_time_info pti; | ||
416 | struct playlist_track_info pltrack; | ||
417 | struct mp3entry id3; | ||
418 | int i, fd; | ||
419 | |||
420 | pti.nb_tracks = playlist_amount(); | ||
421 | playlist_get_resume_info(&pti.curr_playing); | ||
422 | struct mp3entry *curr_id3 = audio_current_track(); | ||
423 | if (pti.curr_playing == -1 || !curr_id3) | ||
424 | return false; | ||
425 | pti.secs[ePT_SECS_BEF] = pti.trk_secs[ePT_SECS_BEF] = curr_id3->elapsed / 1000; | ||
426 | pti.secs[ePT_SECS_AFT] = pti.trk_secs[ePT_SECS_AFT] | ||
427 | = (curr_id3->length -curr_id3->elapsed) / 1000; | ||
428 | pti.kbs[ePT_KBS_BEF] = curr_id3->offset / 1024; | ||
429 | pti.kbs[ePT_KBS_AFT] = (curr_id3->filesize -curr_id3->offset) / 1024; | ||
430 | |||
431 | splash(0, ID2P(LANG_WAIT)); | ||
432 | splash_progress_set_delay(5 * HZ); | ||
433 | /* Go through each file in the playlist and get its stats. For | ||
434 | huge playlists this can take a while... The reference position | ||
435 | is the position at the moment this function was invoked, | ||
436 | although playback continues forward. */ | ||
437 | for (i = 0; i < pti.nb_tracks; i++) { | ||
438 | /* Show a splash while we are loading. */ | ||
439 | splash_progress(i, pti.nb_tracks, | ||
440 | "%s (%s)", str(LANG_WAIT), str(LANG_OFF_ABORT)); | ||
441 | |||
442 | /* Voice equivalent */ | ||
443 | if (TIME_AFTER(current_tick, talked_tick + 5 * HZ)) { | ||
444 | talked_tick = current_tick; | ||
445 | talk_ids(false, LANG_LOADING_PERCENT, | ||
446 | TALK_ID(i * 100 / pti.nb_tracks, UNIT_PERCENT)); | ||
447 | } | ||
448 | if (action_userabort(TIMEOUT_NOBLOCK)) | ||
449 | goto exit; | ||
450 | |||
451 | if (i == pti.curr_playing) | ||
452 | continue; | ||
453 | |||
454 | if (playlist_get_track_info(NULL, i, &pltrack) >= 0) | ||
455 | { | ||
456 | bool ret = false; | ||
457 | if ((fd = open(pltrack.filename, O_RDONLY)) >= 0) | ||
458 | { | ||
459 | ret = get_metadata(&id3, fd, pltrack.filename); | ||
460 | close(fd); | ||
461 | if (ret) | ||
462 | { | ||
463 | if (i < pti.curr_playing) { | ||
464 | pti.secs[ePT_SECS_BEF] += id3.length / 1000; | ||
465 | pti.kbs[ePT_KBS_BEF] += id3.filesize / 1024; | ||
466 | } else { | ||
467 | pti.secs[ePT_SECS_AFT] += id3.length / 1000; | ||
468 | pti.kbs[ePT_KBS_AFT] += id3.filesize / 1024; | ||
469 | } | ||
470 | } | ||
471 | } | ||
472 | |||
473 | if (!ret) | ||
474 | { | ||
475 | error_count++; | ||
476 | continue; | ||
477 | } | ||
478 | } | ||
479 | else | ||
480 | { | ||
481 | error_count++; | ||
482 | break; | ||
483 | } | ||
484 | } | ||
485 | |||
486 | if (error_count > 0) | ||
487 | { | ||
488 | splash(HZ, ID2P(LANG_PLAYTIME_ERROR)); | ||
489 | } | ||
490 | |||
491 | pti.nb_tracks -= error_count; | ||
492 | pti.secs[ePT_SECS_TTL] = pti.secs[ePT_SECS_BEF] + pti.secs[ePT_SECS_AFT]; | ||
493 | pti.trk_secs[ePT_SECS_TTL] = pti.trk_secs[ePT_SECS_BEF] + pti.trk_secs[ePT_SECS_AFT]; | ||
494 | pti.kbs[ePT_KBS_TTL] = pti.kbs[ePT_KBS_BEF] + pti.kbs[ePT_KBS_AFT]; | ||
495 | |||
496 | struct gui_synclist pt_lists; | ||
497 | int key; | ||
498 | |||
499 | gui_synclist_init(&pt_lists, &playing_time_get_info, &pti, true, 1, NULL); | ||
500 | if (global_settings.talk_menu) | ||
501 | gui_synclist_set_voice_callback(&pt_lists, playing_time_speak_info); | ||
502 | gui_synclist_set_nb_items(&pt_lists, 8); | ||
503 | gui_synclist_set_title(&pt_lists, str(LANG_PLAYING_TIME), NOICON); | ||
504 | gui_synclist_draw(&pt_lists); | ||
505 | gui_synclist_speak_item(&pt_lists); | ||
506 | while (true) { | ||
507 | if (list_do_action(CONTEXT_LIST, HZ/2, &pt_lists, &key) == 0 | ||
508 | && key!=ACTION_NONE && key!=ACTION_UNKNOWN) | ||
509 | { | ||
510 | talk_force_shutup(); | ||
511 | return(default_event_handler(key) == SYS_USB_CONNECTED); | ||
512 | } | ||
513 | |||
514 | } | ||
515 | |||
516 | exit: | ||
517 | return false; | ||
518 | } | ||
519 | 204 | ||
520 | /* CONTEXT_WPS playlist options */ | 205 | /* CONTEXT_WPS playlist options */ |
521 | static bool shuffle_playlist(void) | 206 | static bool shuffle_playlist(void) |
@@ -545,6 +230,11 @@ static int wps_view_cur_playlist(void) | |||
545 | return 0; | 230 | return 0; |
546 | } | 231 | } |
547 | 232 | ||
233 | static void playing_time(void) | ||
234 | { | ||
235 | plugin_load(PLUGIN_APPS_DIR"/playing_time.rock", NULL); | ||
236 | } | ||
237 | |||
548 | MENUITEM_FUNCTION(wps_view_cur_playlist_item, 0, ID2P(LANG_VIEW_DYNAMIC_PLAYLIST), | 238 | MENUITEM_FUNCTION(wps_view_cur_playlist_item, 0, ID2P(LANG_VIEW_DYNAMIC_PLAYLIST), |
549 | wps_view_cur_playlist, NULL, Icon_NOICON); | 239 | wps_view_cur_playlist, NULL, Icon_NOICON); |
550 | MENUITEM_FUNCTION(search_playlist_item, 0, ID2P(LANG_SEARCH_IN_PLAYLIST), | 240 | MENUITEM_FUNCTION(search_playlist_item, 0, ID2P(LANG_SEARCH_IN_PLAYLIST), |