apps/gui/wps.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 Jerome Kuptz
  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
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21 #include <stdio.h>
  22 #include <string.h>
  23 #include <stdlib.h>
  24 #include "config.h"
  25
  26 #include "system.h"
  27 #include "file.h"
  28 #include "lcd.h"
  29 #include "font.h"
  30 #include "backlight.h"
  31 #include "action.h"
  32 #include "kernel.h"
  33 #include "filetypes.h"
  34 #include "settings.h"
  35 #include "skin_engine/skin_engine.h"
  36 #include "mp3_playback.h"
  37 #include "audio.h"
  38 #include "usb.h"
  39 #include "status.h"
  40 #include "storage.h"
  41 #include "screens.h"
  42 #include "playlist.h"
  43 #ifdef HAVE_LCD_BITMAP
  44 #include "icons.h"
  45 #include "peakmeter.h"
  46 #endif
  47 #include "lang.h"
  48 #include "bookmark.h"
  49 #include "misc.h"
  50 #include "sound.h"
  51 #include "onplay.h"
  52 #include "abrepeat.h"
  53 #include "playback.h"
  54 #include "splash.h"
  55 #include "cuesheet.h"
  56 #include "ata_idle_notify.h"
  57 #include "root_menu.h"
  58 #include "backdrop.h"
  59 #include "quickscreen.h"
  60 #include "pitchscreen.h"
  61 #include "appevents.h"
  62 #include "viewport.h"
  63 #include "pcmbuf.h"
  64 #include "option_select.h"
  65 #include "dsp.h"
  66 #include "playlist_viewer.h"
  67 #include "wps.h"
  68 #include "statusbar-skinned.h"
  69
  70 #define RESTORE_WPS_INSTANTLY       0l
  71 #define RESTORE_WPS_NEXT_SECOND     ((long)(HZ+current_tick))
  72
  73 #define FF_REWIND_MAX_PERCENT 3 /* cap ff/rewind step size at max % of file */
  74                                 /* 3% of 30min file == 54s step size */
  75 #define MIN_FF_REWIND_STEP 500
  76
  77 /* currently only one wps_state is needed, initialize to 0 */
  78        struct wps_state     wps_state               = { .id3 = NULL };
  79 static struct gui_wps       gui_wps[NB_SCREENS]     = {{ .data = NULL }};
  80 static struct wps_data      wps_datas[NB_SCREENS]   = {{ .wps_loaded = 0 }};
  81 static struct wps_sync_data wps_sync_data           = { .do_full_update = false };
  82
  83 /* initial setup of wps_data  */
  84 static void wps_state_init(void);
  85 static void track_changed_callback(void *param);
  86 static void nextid3available_callback(void* param);
  87
  88 #define WPS_DEFAULTCFG WPS_DIR "/rockbox_default.wps"
  89 #ifdef HAVE_REMOTE_LCD
  90 #define RWPS_DEFAULTCFG WPS_DIR "/rockbox_default.rwps"
  91 #define DEFAULT_WPS(screen) ((screen) == SCREEN_MAIN ? \
  92                             WPS_DEFAULTCFG:RWPS_DEFAULTCFG)
  93 #else
  94 #define DEFAULT_WPS(screen) (WPS_DEFAULTCFG)
  95 #endif
  96
  97 void wps_data_load(enum screen_type screen, const char *buf, bool isfile)
  98 {
  99     bool loaded_ok;
 100
 101 #ifndef __PCTOOL__
 102     /*
 103      * Hardcode loading WPS_DEFAULTCFG to cause a reset ideally this
 104      * wants to be a virtual file.  Feel free to modify dirbrowse()
 105      * if you're feeling brave.
 106      */
 107
 108     if (buf && ! strcmp(buf, DEFAULT_WPS(screen)) )
 109     {
 110 #ifdef HAVE_REMOTE_LCD
 111         if (screen == SCREEN_REMOTE)
 112             global_settings.rwps_file[0] = '\0';
 113         else
 114 #endif
 115             global_settings.wps_file[0] = '\0';
 116         buf = NULL;
 117     }
 118
 119 #endif /* __PCTOOL__ */
 120
 121     loaded_ok = buf && skin_data_load(screen, gui_wps[screen].data, buf, isfile);
 122
 123     if (!loaded_ok) /* load the hardcoded default */
 124     {
 125         char *skin_buf[NB_SCREENS] = {
 126 #ifdef HAVE_LCD_BITMAP
 127 #if LCD_DEPTH > 1
 128             "%X(d)\n"
 129 #endif
 130             "%s%?it<%?in<%in. |>%it|%fn>\n"
 131             "%s%?ia<%ia|%?d(2)<%d(2)|%(root%)>>\n"
 132             "%s%?id<%id|%?d(1)<%d(1)|%(root%)>> %?iy<%(%iy%)|>\n\n"
 133             "%al%pc/%pt%ar[%pp:%pe]\n"
 134             "%fbkBit %?fv<avg|> %?iv<%(id3v%iv%)|%(no id3%)>\n"
 135             "%pb\n%pm\n",
 136 #else
 137             "%s%pp/%pe: %?it<%it|%fn> - %?ia<%ia|%d(2)> - %?id<%id|%d(1)>\n"
 138             "%pc%?ps<*|/>%pt\n",
 139 #endif
 140 #ifdef HAVE_REMOTE_LCD
 141 #if LCD_REMOTE_DEPTH > 1
 142             "%X(d)\n"
 143 #endif
 144             "%s%?ia<%ia|%?d(2)<%d(2)|%(root%)>>\n"
 145             "%s%?it<%?in<%in. |>%it|%fn>\n"
 146             "%al%pc/%pt%ar[%pp:%pe]\n"
 147             "%fbkBit %?fv<avg|> %?iv<%(id3v%iv%)|%(no id3%)>\n"
 148             "%pb\n",
 149 #endif
 150         };
 151         skin_data_load(screen, gui_wps[screen].data, skin_buf[screen], false);
 152     }
 153 }
 154
 155 void fade(bool fade_in, bool updatewps)
 156 {
 157     int fp_global_vol = global_settings.volume << 8;
 158     int fp_min_vol = sound_min(SOUND_VOLUME) << 8;
 159     int fp_step = (fp_global_vol - fp_min_vol) / 30;
 160     int i;
 161     wps_state.is_fading = !fade_in;
 162     if (fade_in) {
 163         /* fade in */
 164         int fp_volume = fp_min_vol;
 165
 166         /* zero out the sound */
 167         sound_set_volume(fp_min_vol >> 8);
 168
 169         sleep(HZ/10); /* let audio thread run */
 170         audio_resume();
 171
 172         while (fp_volume < fp_global_vol - fp_step) {
 173             fp_volume += fp_step;
 174             sound_set_volume(fp_volume >> 8);
 175             if (updatewps)
 176             {
 177                 FOR_NB_SCREENS(i)
 178                     skin_update(&gui_wps[i], WPS_REFRESH_NON_STATIC);
 179             }
 180             sleep(1);
 181         }
 182         sound_set_volume(global_settings.volume);
 183     }
 184     else {
 185         /* fade out */
 186         int fp_volume = fp_global_vol;
 187
 188         while (fp_volume > fp_min_vol + fp_step) {
 189             fp_volume -= fp_step;
 190             sound_set_volume(fp_volume >> 8);
 191             if (updatewps)
 192             {
 193                 FOR_NB_SCREENS(i)
 194                     skin_update(&gui_wps[i], WPS_REFRESH_NON_STATIC);
 195             }
 196             sleep(1);
 197         }
 198         audio_pause();
 199         wps_state.is_fading = false;
 200 #if CONFIG_CODEC != SWCODEC
 201 #ifndef SIMULATOR
 202         /* let audio thread run and wait for the mas to run out of data */
 203         while (!mp3_pause_done())
 204 #endif
 205             sleep(HZ/10);
 206 #endif
 207
 208         /* reset volume to what it was before the fade */
 209         sound_set_volume(global_settings.volume);
 210     }
 211 }
 212
 213 static bool update_onvol_change(struct gui_wps * gwps)
 214 {
 215     skin_update(gwps, WPS_REFRESH_NON_STATIC);
 216
 217 #ifdef HAVE_LCD_CHARCELLS
 218     splashf(0, "Vol: %3d dB",
 219                sound_val2phys(SOUND_VOLUME, global_settings.volume));
 220     return true;
 221 #endif
 222     return false;
 223 }
 224
 225
 226 #ifdef HAVE_TOUCHSCREEN
 227 int skintouch_to_wps(struct wps_data *data)
 228 {
 229     int offset = 0;
 230     int button = skin_get_touchaction(data, &offset);
 231     switch (button)
 232     {
 233         case ACTION_STD_PREV:
 234             return ACTION_WPS_SKIPPREV;
 235         case ACTION_STD_PREVREPEAT:
 236             return ACTION_WPS_SEEKBACK;
 237         case ACTION_STD_NEXT:
 238             return ACTION_WPS_SKIPNEXT;
 239         case ACTION_STD_NEXTREPEAT:
 240             return ACTION_WPS_SEEKFWD;
 241         case ACTION_STD_MENU:
 242             return ACTION_WPS_MENU;
 243         case ACTION_STD_CONTEXT:
 244             return ACTION_WPS_CONTEXT;
 245         case ACTION_STD_QUICKSCREEN:
 246             return ACTION_WPS_QUICKSCREEN;
 247 #ifdef HAVE_HOTKEY
 248         case ACTION_STD_HOTKEY:
 249             return ACTION_WPS_HOTKEY;
 250 #endif
 251         case WPS_TOUCHREGION_SCROLLBAR:
 252             wps_state.id3->elapsed = wps_state.id3->length*offset/100;
 253             if (!wps_state.paused)
 254 #if (CONFIG_CODEC == SWCODEC)
 255                 audio_pre_ff_rewind();
 256 #else
 257                 audio_pause();
 258 #endif
 259             audio_ff_rewind(wps_state.id3->elapsed);
 260 #if (CONFIG_CODEC != SWCODEC)
 261             if (!wps_state.paused)
 262                 audio_resume();
 263 #endif
 264             return ACTION_TOUCHSCREEN;
 265         case WPS_TOUCHREGION_VOLUME:
 266         {
 267             const int min_vol = sound_min(SOUND_VOLUME);
 268             const int max_vol = sound_max(SOUND_VOLUME);
 269             global_settings.volume = (offset * (max_vol - min_vol)) / 100;
 270             global_settings.volume += min_vol;
 271             setvol();
 272         }
 273         return ACTION_TOUCHSCREEN;
 274     }
 275     return button;
 276 }
 277 #endif
 278
 279 bool ffwd_rew(int button)
 280 {
 281     unsigned int step = 0;     /* current ff/rewind step */
 282     unsigned int max_step = 0; /* maximum ff/rewind step */
 283     int ff_rewind_count = 0;   /* current ff/rewind count (in ticks) */
 284     int direction = -1;         /* forward=1 or backward=-1 */
 285     bool exit = false;
 286     bool usb = false;
 287     int i = 0;
 288     const long ff_rw_accel = (global_settings.ff_rewind_accel + 3);
 289
 290     if (button == ACTION_NONE)
 291     {
 292         status_set_ffmode(0);
 293         return usb;
 294     }
 295     while (!exit)
 296     {
 297         switch ( button )
 298         {
 299             case ACTION_WPS_SEEKFWD:
 300                  direction = 1;
 301             case ACTION_WPS_SEEKBACK:
 302                 if (wps_state.ff_rewind)
 303                 {
 304                     if (direction == 1)
 305                     {
 306                         /* fast forwarding, calc max step relative to end */
 307                         max_step = (wps_state.id3->length -
 308                                     (wps_state.id3->elapsed +
 309                                      ff_rewind_count)) *
 310                                      FF_REWIND_MAX_PERCENT / 100;
 311                     }
 312                     else
 313                     {
 314                         /* rewinding, calc max step relative to start */
 315                         max_step = (wps_state.id3->elapsed + ff_rewind_count) *
 316                                     FF_REWIND_MAX_PERCENT / 100;
 317                     }
 318
 319                     max_step = MAX(max_step, MIN_FF_REWIND_STEP);
 320
 321                     if (step > max_step)
 322                         step = max_step;
 323
 324                     ff_rewind_count += step * direction;
 325
 326                     /* smooth seeking by multiplying step by: 1 + (2 ^ -accel) */
 327                     step += step >> ff_rw_accel;
 328                 }
 329                 else
 330                 {
 331                     if ( (audio_status() & AUDIO_STATUS_PLAY) &&
 332                           wps_state.id3 && wps_state.id3->length )
 333                     {
 334                         if (!wps_state.paused)
 335 #if (CONFIG_CODEC == SWCODEC)
 336                             audio_pre_ff_rewind();
 337 #else
 338                             audio_pause();
 339 #endif
 340 #if CONFIG_KEYPAD == PLAYER_PAD
 341                         FOR_NB_SCREENS(i)
 342                             gui_wps[i].display->stop_scroll();
 343 #endif
 344                         if (direction > 0)
 345                             status_set_ffmode(STATUS_FASTFORWARD);
 346                         else
 347                             status_set_ffmode(STATUS_FASTBACKWARD);
 348
 349                         wps_state.ff_rewind = true;
 350
 351                         step = 1000 * global_settings.ff_rewind_min_step;
 352                     }
 353                     else
 354                         break;
 355                 }
 356
 357                 if (direction > 0) {
 358                     if ((wps_state.id3->elapsed + ff_rewind_count) >
 359                         wps_state.id3->length)
 360                         ff_rewind_count = wps_state.id3->length -
 361                             wps_state.id3->elapsed;
 362                 }
 363                 else {
 364                     if ((int)(wps_state.id3->elapsed + ff_rewind_count) < 0)
 365                         ff_rewind_count = -wps_state.id3->elapsed;
 366                 }
 367
 368                 /* set the wps state ff_rewind_count so the progess info
 369                    displays corectly */
 370                 wps_state.ff_rewind_count = (wps_state.wps_time_countup == false)?
 371                                             ff_rewind_count:-ff_rewind_count;
 372                 FOR_NB_SCREENS(i)
 373                 {
 374                     skin_update(&gui_wps[i],
 375                                 WPS_REFRESH_PLAYER_PROGRESS |
 376                                 WPS_REFRESH_DYNAMIC);
 377                 }
 378
 379                 break;
 380
 381             case ACTION_WPS_STOPSEEK:
 382                 wps_state.id3->elapsed = wps_state.id3->elapsed+ff_rewind_count;
 383                 audio_ff_rewind(wps_state.id3->elapsed);
 384                 wps_state.ff_rewind_count = 0;
 385                 wps_state.ff_rewind = false;
 386                 status_set_ffmode(0);
 387 #if (CONFIG_CODEC != SWCODEC)
 388                 if (!wps_state.paused)
 389                     audio_resume();
 390 #endif
 391 #ifdef HAVE_LCD_CHARCELLS
 392                 FOR_NB_SCREENS(i)
 393                     skin_update(&gui_wps[i], WPS_REFRESH_ALL);
 394 #endif
 395                 exit = true;
 396                 break;
 397
 398             default:
 399                 if(default_event_handler(button) == SYS_USB_CONNECTED) {
 400                     status_set_ffmode(0);
 401                     usb = true;
 402                     exit = true;
 403                 }
 404                 break;
 405         }
 406         if (!exit)
 407         {
 408             button = get_action(CONTEXT_WPS|ALLOW_SOFTLOCK,TIMEOUT_BLOCK);
 409 #ifdef HAVE_TOUCHSCREEN
 410             if (button == ACTION_TOUCHSCREEN)
 411                 button = skintouch_to_wps(gui_wps[SCREEN_MAIN].data);
 412             if (button != ACTION_WPS_SEEKFWD &&
 413                 button != ACTION_WPS_SEEKBACK)
 414                 button = ACTION_WPS_STOPSEEK;
 415 #endif
 416         }
 417     }
 418     return usb;
 419 }
 420
 421
 422 void display_keylock_text(bool locked)
 423 {
 424     int i;
 425     FOR_NB_SCREENS(i)
 426         gui_wps[i].display->stop_scroll();
 427
 428     splash(HZ, locked ? ID2P(LANG_KEYLOCK_ON) : ID2P(LANG_KEYLOCK_OFF));
 429 }
 430
 431
 432
 433
 434 #if defined(HAVE_BACKLIGHT) || defined(HAVE_REMOTE_LCD)
 435 static void gwps_caption_backlight(struct wps_state *state)
 436 {
 437     if (state && state->id3)
 438     {
 439 #ifdef HAVE_BACKLIGHT
 440         if (global_settings.caption_backlight)
 441         {
 442             /* turn on backlight n seconds before track ends, and turn it off n
 443                seconds into the new track. n == backlight_timeout, or 5s */
 444             int n = global_settings.backlight_timeout * 1000;
 445
 446             if ( n < 1000 )
 447                 n = 5000; /* use 5s if backlight is always on or off */
 448
 449             if (((state->id3->elapsed < 1000) ||
 450                  ((state->id3->length - state->id3->elapsed) < (unsigned)n)) &&
 451                 (state->paused == false))
 452                 backlight_on();
 453         }
 454 #endif
 455 #ifdef HAVE_REMOTE_LCD
 456         if (global_settings.remote_caption_backlight)
 457         {
 458             /* turn on remote backlight n seconds before track ends, and turn it
 459                off n seconds into the new track. n == remote_backlight_timeout,
 460                or 5s */
 461             int n = global_settings.remote_backlight_timeout * 1000;
 462
 463             if ( n < 1000 )
 464                 n = 5000; /* use 5s if backlight is always on or off */
 465
 466             if (((state->id3->elapsed < 1000) ||
 467                  ((state->id3->length - state->id3->elapsed) < (unsigned)n)) &&
 468                 (state->paused == false))
 469                 remote_backlight_on();
 470         }
 471 #endif
 472     }
 473 }
 474 #endif
 475
 476
 477 static void change_dir(int direction)
 478 {
 479     if (global_settings.prevent_skip)
 480         return;
 481
 482     if (direction < 0)
 483         audio_prev_dir();
 484     else if (direction > 0)
 485         audio_next_dir();
 486     /* prevent the next dir to immediatly start being ffw'd */
 487     action_wait_for_release();
 488 }
 489
 490 static void prev_track(unsigned long skip_thresh)
 491 {
 492     if (wps_state.id3->elapsed < skip_thresh)
 493     {
 494         audio_prev();
 495         return;
 496     }
 497     else
 498     {
 499         if (wps_state.id3->cuesheet)
 500         {
 501             curr_cuesheet_skip(wps_state.id3->cuesheet, -1, wps_state.id3->elapsed);
 502             return;
 503         }
 504
 505         if (!wps_state.paused)
 506 #if (CONFIG_CODEC == SWCODEC)
 507             audio_pre_ff_rewind();
 508 #else
 509         audio_pause();
 510 #endif
 511
 512         audio_ff_rewind(0);
 513
 514 #if (CONFIG_CODEC != SWCODEC)
 515         if (!wps_state.paused)
 516             audio_resume();
 517 #endif
 518     }
 519 }
 520
 521 static void next_track(void)
 522 {
 523     /* take care of if we're playing a cuesheet */
 524     if (wps_state.id3->cuesheet)
 525     {
 526         if (curr_cuesheet_skip(wps_state.id3->cuesheet, 1, wps_state.id3->elapsed))
 527         {
 528             /* if the result was false, then we really want
 529                to skip to the next track */
 530             return;
 531         }
 532     }
 533
 534     audio_next();
 535 }
 536
 537 static void play_hop(int direction)
 538 {
 539     long step = global_settings.skip_length*1000;
 540     long elapsed = wps_state.id3->elapsed;
 541     long remaining = wps_state.id3->length - elapsed;
 542
 543     if (step < 0)
 544     {
 545         if (direction < 0)
 546         {
 547             prev_track(DEFAULT_SKIP_TRESH);
 548             return;
 549         }
 550         else if (remaining < DEFAULT_SKIP_TRESH*2)
 551         {
 552             next_track();
 553             return;
 554         }
 555         else
 556             elapsed += (remaining - DEFAULT_SKIP_TRESH*2);
 557     }
 558     else if (!global_settings.prevent_skip &&
 559            (!step ||
 560             (direction > 0 && step >= remaining) ||
 561             (direction < 0 && elapsed < DEFAULT_SKIP_TRESH)))
 562     {   /* Do normal track skipping */
 563         if (direction > 0)
 564             next_track();
 565         else if (direction < 0)
 566             prev_track(DEFAULT_SKIP_TRESH);
 567         return;
 568     }
 569     else if (direction == 1 && step >= remaining)
 570     {
 571 #if CONFIG_CODEC == SWCODEC
 572         if(global_settings.beep)
 573             pcmbuf_beep(1000, 150, 1500*global_settings.beep);
 574 #endif
 575         return;
 576     }
 577     else if ((direction == -1 && elapsed < step))
 578     {
 579         elapsed = 0;
 580     }
 581     else
 582     {
 583         elapsed += step * direction;
 584     }
 585     if((audio_status() & AUDIO_STATUS_PLAY) && !wps_state.paused)
 586     {
 587 #if (CONFIG_CODEC == SWCODEC)
 588         audio_pre_ff_rewind();
 589 #else
 590         audio_pause();
 591 #endif
 592     }
 593     audio_ff_rewind(wps_state.id3->elapsed = elapsed);
 594 #if (CONFIG_CODEC != SWCODEC)
 595     if (!wps_state.paused)
 596         audio_resume();
 597 #endif
 598 }
 599
 600
 601 #if defined(HAVE_LCD_ENABLE) || defined(HAVE_LCD_SLEEP)
 602 /*
 603  * If the user is unable to see the wps, because the display is deactivated,
 604  * we suppress updates until the wps is activated again (the lcd driver will
 605  * call this hook to issue an instant update)
 606  * */
 607 static void wps_lcd_activation_hook(void *param)
 608 {
 609     (void)param;
 610     wps_sync_data.do_full_update = true;
 611     /* force timeout in wps main loop, so that the update is instantly */
 612     queue_post(&button_queue, BUTTON_NONE, 0);
 613 }
 614 #endif
 615
 616 static void gwps_leave_wps(void)
 617 {
 618     int i;
 619
 620     FOR_NB_SCREENS(i)
 621     {
 622         gui_wps[i].display->stop_scroll();
 623 #if LCD_DEPTH > 1 || defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1
 624         gui_wps[i].display->backdrop_show(sb_get_backdrop(i));
 625 #endif
 626         viewportmanager_theme_undo(i, skin_has_sbs(i, gui_wps[i].data));
 627
 628     }
 629
 630 #if defined(HAVE_LCD_ENABLE) || defined(HAVE_LCD_SLEEP)
 631     /* Play safe and unregister the hook */
 632     remove_event(LCD_EVENT_ACTIVATION, wps_lcd_activation_hook);
 633 #endif
 634     /* unhandle statusbar update delay */
 635     sb_skin_set_update_delay(DEFAULT_UPDATE_DELAY);
 636 }
 637
 638 /*
 639  * display the wps on entering or restoring */
 640 static void gwps_enter_wps(void)
 641 {
 642     int i;
 643     FOR_NB_SCREENS(i)
 644     {
 645         struct gui_wps *gwps = &gui_wps[i];
 646         struct screen *display = gwps->display;
 647         display->stop_scroll();
 648         viewportmanager_theme_enable(i, skin_has_sbs(i, gui_wps[i].data), NULL);
 649
 650         /* Update the values in the first (default) viewport - in case the user
 651            has modified the statusbar or colour settings */
 652 #if LCD_DEPTH > 1
 653         if (display->depth > 1)
 654         {
 655             struct viewport *vp = &find_viewport(VP_DEFAULT_LABEL, gwps->data)->vp;
 656             vp->fg_pattern = display->get_foreground();
 657             vp->bg_pattern = display->get_background();
 658         }
 659 #endif
 660         /* make the backdrop actually take effect */
 661 #if LCD_DEPTH > 1 || defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1
 662         display->backdrop_show(gwps->data->backdrop);
 663 #endif
 664         display->clear_display();
 665         skin_update(gwps, WPS_REFRESH_ALL);
 666
 667 #ifdef HAVE_TOUCHSCREEN
 668         skin_disarm_touchregions(gui_wps[i].data);
 669 #endif
 670     }
 671     /* force statusbar/skin update since we just cleared the whole screen */
 672     send_event(GUI_EVENT_ACTIONUPDATE, (void*)1);
 673 }
 674
 675 /* The WPS can be left in two ways:
 676  *      a)  call a function, which draws over the wps. In this case, the wps
 677  *          will be still active (i.e. the below function didn't return)
 678  *      b)  return with a value evaluated by root_menu.c, in this case the wps
 679  *          is really left, and root_menu will handle the next screen
 680  *
 681  * In either way, call gwps_leave_wps(), in order to restore the correct
 682  * "main screen" backdrops and statusbars
 683  */
 684 long gui_wps_show(void)
 685 {
 686     long button = 0;
 687     bool restore = true;
 688     long restoretimer = RESTORE_WPS_INSTANTLY; /* timer to delay screen redraw temporarily */
 689     bool exit = false;
 690     bool bookmark = false;
 691     bool update = false;
 692     bool vol_changed = false;
 693     int i;
 694     long last_left = 0, last_right = 0;
 695
 696 #ifdef HAVE_LCD_CHARCELLS
 697     status_set_audio(true);
 698     status_set_param(false);
 699 #endif
 700
 701 #ifdef AB_REPEAT_ENABLE
 702     ab_repeat_init();
 703     ab_reset_markers();
 704 #endif
 705     wps_state_init();
 706
 707     while ( 1 )
 708     {
 709         bool audio_paused = (audio_status() & AUDIO_STATUS_PAUSE)?true:false;
 710
 711         /* did someone else (i.e power thread) change audio pause mode? */
 712         if (wps_state.paused != audio_paused) {
 713             wps_state.paused = audio_paused;
 714
 715             /* if another thread paused audio, we are probably in car mode,
 716                about to shut down. lets save the settings. */
 717             if (wps_state.paused) {
 718                 settings_save();
 719 #if !defined(HAVE_RTC_RAM) && !defined(HAVE_SW_POWEROFF)
 720                 call_storage_idle_notifys(true);
 721 #endif
 722             }
 723         }
 724         button = skin_wait_for_action(gui_wps, CONTEXT_WPS|ALLOW_SOFTLOCK,
 725                                       restore ? 1 : HZ/5);
 726
 727         /* Exit if audio has stopped playing. This happens e.g. at end of
 728            playlist or if using the sleep timer. */
 729         if (!(audio_status() & AUDIO_STATUS_PLAY))
 730             exit = true;
 731 #ifdef HAVE_TOUCHSCREEN
 732         if (button == ACTION_TOUCHSCREEN)
 733             button = skintouch_to_wps(gui_wps[SCREEN_MAIN].data);
 734 #endif
 735 /* The iPods/X5/M5 use a single button for the A-B mode markers,
 736    defined as ACTION_WPSAB_SINGLE in their config files. */
 737 #ifdef ACTION_WPSAB_SINGLE
 738         if (!global_settings.party_mode && ab_repeat_mode_enabled())
 739         {
 740             static int wps_ab_state = 0;
 741             if (button == ACTION_WPSAB_SINGLE)
 742             {
 743                 switch (wps_ab_state)
 744                 {
 745                     case 0: /* set the A spot */
 746                         button = ACTION_WPS_ABSETA_PREVDIR;
 747                         break;
 748                     case 1: /* set the B spot */
 749                         button = ACTION_WPS_ABSETB_NEXTDIR;
 750                         break;
 751                     case 2:
 752                         button = ACTION_WPS_ABRESET;
 753                         break;
 754                 }
 755                 wps_ab_state = (wps_ab_state+1) % 3;
 756             }
 757         }
 758 #endif
 759         switch(button)
 760         {
 761 #ifdef HAVE_HOTKEY
 762             case ACTION_WPS_HOTKEY:
 763                 if (!global_settings.hotkey_wps)
 764                     break;
 765                 /* fall through */
 766 #endif
 767             case ACTION_WPS_CONTEXT:
 768             {
 769                 bool hotkey = button == ACTION_WPS_HOTKEY;
 770                 gwps_leave_wps();
 771                 int retval = onplay(wps_state.id3->path,
 772                            FILE_ATTR_AUDIO, CONTEXT_WPS, hotkey);
 773                 /* if music is stopped in the context menu we want to exit the wps */
 774                 if (retval == ONPLAY_MAINMENU
 775                     || !audio_status())
 776                     return GO_TO_ROOT;
 777                 else if (retval == ONPLAY_PLAYLIST)
 778                     return GO_TO_PLAYLIST_VIEWER;
 779 #ifdef HAVE_PICTUREFLOW_INTEGRATION
 780                 else if (retval == ONPLAY_PICTUREFLOW)
 781                     return GO_TO_PICTUREFLOW;
 782 #endif
 783                 restore = true;
 784             }
 785             break;
 786
 787             case ACTION_WPS_BROWSE:
 788 #ifdef HAVE_LCD_CHARCELLS
 789                 status_set_record(false);
 790                 status_set_audio(false);
 791 #endif
 792                 gwps_leave_wps();
 793                 return GO_TO_PREVIOUS_BROWSER;
 794                 break;
 795
 796                 /* play/pause */
 797             case ACTION_WPS_PLAY:
 798                 if (global_settings.party_mode)
 799                     break;
 800                 if ( wps_state.paused )
 801                 {
 802                     wps_state.paused = false;
 803                     if ( global_settings.fade_on_stop )
 804                         fade(true, true);
 805                     else
 806                         audio_resume();
 807                 }
 808                 else
 809                 {
 810                     wps_state.paused = true;
 811                     if ( global_settings.fade_on_stop )
 812                         fade(false, true);
 813                     else
 814                         audio_pause();
 815                     settings_save();
 816 #if !defined(HAVE_RTC_RAM) && !defined(HAVE_SW_POWEROFF)
 817                     call_storage_idle_notifys(true);   /* make sure resume info is saved */
 818 #endif
 819                 }
 820                 break;
 821
 822             case ACTION_WPS_VOLUP:
 823                 global_settings.volume++;
 824                 vol_changed = true;
 825                 break;
 826             case ACTION_WPS_VOLDOWN:
 827                 global_settings.volume--;
 828                 vol_changed = true;
 829                 break;
 830             /* fast forward
 831                 OR next dir if this is straight after ACTION_WPS_SKIPNEXT */
 832             case ACTION_WPS_SEEKFWD:
 833                 if (global_settings.party_mode)
 834                     break;
 835                 if (current_tick -last_right < HZ)
 836                 {
 837                     if (wps_state.id3->cuesheet)
 838                     {
 839                         audio_next();
 840                     }
 841                     else
 842                     {
 843                         change_dir(1);
 844                     }
 845                 }
 846                 else
 847                     ffwd_rew(ACTION_WPS_SEEKFWD);
 848                 last_right = last_left = 0;
 849                 break;
 850             /* fast rewind
 851                 OR prev dir if this is straight after ACTION_WPS_SKIPPREV,*/
 852             case ACTION_WPS_SEEKBACK:
 853                 if (global_settings.party_mode)
 854                     break;
 855                 if (current_tick -last_left < HZ)
 856                 {
 857                     if (wps_state.id3->cuesheet)
 858                     {
 859                         if (!wps_state.paused)
 860 #if (CONFIG_CODEC == SWCODEC)
 861                             audio_pre_ff_rewind();
 862 #else
 863                             audio_pause();
 864 #endif
 865                         audio_ff_rewind(0);
 866                     }
 867                     else
 868                     {
 869                         change_dir(-1);
 870                     }
 871                 }
 872                 else
 873                     ffwd_rew(ACTION_WPS_SEEKBACK);
 874                 last_left = last_right = 0;
 875                 break;
 876
 877                 /* prev / restart */
 878             case ACTION_WPS_SKIPPREV:
 879                 if (global_settings.party_mode)
 880                     break;
 881                 last_left = current_tick;
 882 #ifdef AB_REPEAT_ENABLE
 883                 /* if we're in A/B repeat mode and the current position
 884                    is past the A marker, jump back to the A marker... */
 885                 if ( ab_repeat_mode_enabled() )
 886                 {
 887                     if ( ab_after_A_marker(wps_state.id3->elapsed) )
 888                     {
 889                         ab_jump_to_A_marker();
 890                         break;
 891 #if (AB_REPEAT_ENABLE == 2)
 892                     } else {
 893                         ab_reset_markers();
 894 #endif
 895                     }
 896                 }
 897                 else
 898                 /* ...otherwise, do it normally */
 899 #endif
 900                     play_hop(-1);
 901                 break;
 902
 903                 /* next
 904                    OR if skip length set, hop by predetermined amount. */
 905             case ACTION_WPS_SKIPNEXT:
 906                 if (global_settings.party_mode)
 907                     break;
 908                 last_right = current_tick;
 909 #ifdef AB_REPEAT_ENABLE
 910                 /* if we're in A/B repeat mode and the current position is
 911                    before the A marker, jump to the A marker... */
 912                 if ( ab_repeat_mode_enabled() )
 913                 {
 914                     if ( ab_before_A_marker(wps_state.id3->elapsed) )
 915                     {
 916                         ab_jump_to_A_marker();
 917                         break;
 918 #if (AB_REPEAT_ENABLE == 2)
 919                     } else {
 920                         ab_reset_markers();
 921 #endif
 922                     }
 923                 }
 924                 else
 925                 /* ...otherwise, do it normally */
 926 #endif
 927                     play_hop(1);
 928                 break;
 929                 /* next / prev directories */
 930                 /* and set A-B markers if in a-b mode */
 931             case ACTION_WPS_ABSETB_NEXTDIR:
 932                 if (global_settings.party_mode)
 933                     break;
 934 #if defined(AB_REPEAT_ENABLE)
 935                 if (ab_repeat_mode_enabled())
 936                 {
 937                     ab_set_B_marker(wps_state.id3->elapsed);
 938                     ab_jump_to_A_marker();
 939                 }
 940                 else
 941 #endif
 942                 {
 943                     change_dir(1);
 944                 }
 945                 break;
 946             case ACTION_WPS_ABSETA_PREVDIR:
 947                 if (global_settings.party_mode)
 948                     break;
 949 #if defined(AB_REPEAT_ENABLE)
 950                 if (ab_repeat_mode_enabled())
 951                     ab_set_A_marker(wps_state.id3->elapsed);
 952                 else
 953 #endif
 954                 {
 955                     change_dir(-1);
 956                 }
 957                 break;
 958             /* menu key functions */
 959             case ACTION_WPS_MENU:
 960                 gwps_leave_wps();
 961                 return GO_TO_ROOT;
 962                 break;
 963
 964
 965 #ifdef HAVE_QUICKSCREEN
 966             case ACTION_WPS_QUICKSCREEN:
 967             {
 968                 gwps_leave_wps();
 969                 if (quick_screen_quick(button))
 970                     return GO_TO_ROOT;
 971                 restore = true;
 972             }
 973             break;
 974 #endif /* HAVE_QUICKSCREEN */
 975
 976                 /* screen settings */
 977 #ifdef BUTTON_F3
 978             case ACTION_F3:
 979             {
 980                 gwps_leave_wps();
 981                 if (quick_screen_f3(BUTTON_F3))
 982                     return GO_TO_ROOT;
 983                 restore = true;
 984             }
 985             break;
 986 #endif /* BUTTON_F3 */
 987
 988                 /* pitch screen */
 989 #ifdef HAVE_PITCHSCREEN
 990             case ACTION_WPS_PITCHSCREEN:
 991             {
 992                 gwps_leave_wps();
 993                 if (1 == gui_syncpitchscreen_run())
 994                     return GO_TO_ROOT;
 995                 restore = true;
 996             }
 997             break;
 998 #endif /* HAVE_PITCHSCREEN */
 999
1000 #ifdef AB_REPEAT_ENABLE
1001             /* reset A&B markers */
1002             case ACTION_WPS_ABRESET:
1003                 if (ab_repeat_mode_enabled())
1004                 {
1005                     ab_reset_markers();
1006                     update = true;
1007                 }
1008                 break;
1009 #endif /* AB_REPEAT_ENABLE */
1010
1011                 /* stop and exit wps */
1012             case ACTION_WPS_STOP:
1013                 if (global_settings.party_mode)
1014                     break;
1015                 bookmark = true;
1016                 exit = true;
1017                 break;
1018
1019             case ACTION_WPS_ID3SCREEN:
1020             {
1021                 gwps_leave_wps();
1022                 if (browse_id3())
1023                     return GO_TO_ROOT;
1024                 restore = true;
1025             }
1026             break;
1027 #ifdef HAVE_TOUCHSCREEN
1028             case ACTION_TOUCH_SHUFFLE: /* toggle shuffle mode */
1029             {
1030                 global_settings.playlist_shuffle =
1031                                                 !global_settings.playlist_shuffle;
1032 #if CONFIG_CODEC == SWCODEC
1033                 dsp_set_replaygain();
1034 #endif
1035                 if (global_settings.playlist_shuffle)
1036                     playlist_randomise(NULL, current_tick, true);
1037                 else
1038                     playlist_sort(NULL, true);
1039             }
1040             break;
1041             case ACTION_TOUCH_REPMODE: /* cycle the repeat mode setting */
1042             {
1043                 const struct settings_list *rep_setting =
1044                                 find_setting(&global_settings.repeat_mode, NULL);
1045                 option_select_next_val(rep_setting, false, true);
1046                 audio_flush_and_reload_tracks();
1047             }
1048             break;
1049 #endif /* HAVE_TOUCHSCREEN */
1050              /* this case is used by the softlock feature
1051               * it requests a full update here */
1052             case ACTION_REDRAW:
1053                 wps_sync_data.do_full_update = true;
1054                 break;
1055             case ACTION_NONE: /* Timeout, do a partial update */
1056                 update = true;
1057                 ffwd_rew(button); /* hopefully fix the ffw/rwd bug */
1058                 break;
1059 #ifdef HAVE_RECORDING
1060             case ACTION_WPS_REC:
1061                 exit = true;
1062                 break;
1063 #endif
1064             case SYS_POWEROFF:
1065                 default_event_handler(SYS_POWEROFF);
1066                 break;
1067             case ACTION_WPS_VIEW_PLAYLIST:
1068                 gwps_leave_wps();
1069                 return GO_TO_PLAYLIST_VIEWER;
1070                 break;
1071             default:
1072                 if(default_event_handler(button) == SYS_USB_CONNECTED)
1073                 {
1074                     gwps_leave_wps();
1075                     return GO_TO_ROOT;
1076                 }
1077                 update = true;
1078                 break;
1079         }
1080
1081         if (vol_changed)
1082         {
1083             bool res = false;
1084             vol_changed = false;
1085             setvol();
1086             FOR_NB_SCREENS(i)
1087             {
1088                 if(update_onvol_change(&gui_wps[i]))
1089                     res = true;
1090             }
1091             if (res) {
1092                 restore = true;
1093                 restoretimer = RESTORE_WPS_NEXT_SECOND;
1094             }
1095         }
1096
1097
1098         if (restore &&
1099             ((restoretimer == RESTORE_WPS_INSTANTLY) ||
1100              TIME_AFTER(current_tick, restoretimer)))
1101         {
1102             restore = false;
1103             restoretimer = RESTORE_WPS_INSTANTLY;
1104 #if defined(HAVE_LCD_ENABLE) || defined(HAVE_LCD_SLEEP)
1105             add_event(LCD_EVENT_ACTIVATION, false, wps_lcd_activation_hook);
1106 #endif
1107         /* we remove the update delay since it's not very usable in the wps,
1108          * e.g. during volume changing or ffwd/rewind */
1109             sb_skin_set_update_delay(0);
1110             wps_sync_data.do_full_update = update = false;
1111             gwps_enter_wps();
1112         }
1113         else if (wps_sync_data.do_full_update || update)
1114         {
1115 #if defined(HAVE_BACKLIGHT) || defined(HAVE_REMOTE_LCD)
1116             gwps_caption_backlight(&wps_state);
1117 #endif
1118             FOR_NB_SCREENS(i)
1119             {
1120 #if defined(HAVE_LCD_ENABLE) || defined(HAVE_LCD_SLEEP)
1121                 /* currently, all remotes are readable without backlight
1122                  * so still update those */
1123                 if (lcd_active() || (i != SCREEN_MAIN))
1124 #endif
1125                 {
1126                     skin_update(&gui_wps[i], wps_sync_data.do_full_update ?
1127                                             WPS_REFRESH_ALL : WPS_REFRESH_NON_STATIC);
1128                 }
1129             }
1130             wps_sync_data.do_full_update = false;
1131             update = false;
1132         }
1133
1134         if (exit) {
1135 #ifdef HAVE_LCD_CHARCELLS
1136             status_set_record(false);
1137             status_set_audio(false);
1138 #endif
1139             if (global_settings.fade_on_stop)
1140                 fade(false, true);
1141
1142             if (bookmark)
1143                 bookmark_autobookmark(true);
1144             audio_stop();
1145 #ifdef AB_REPEAT_ENABLE
1146             ab_reset_markers();
1147 #endif
1148             gwps_leave_wps();
1149 #ifdef HAVE_RECORDING
1150             if (button == ACTION_WPS_REC)
1151                 return GO_TO_RECSCREEN;
1152 #endif
1153             if (global_settings.browse_current)
1154                 return GO_TO_PREVIOUS_BROWSER;
1155             return GO_TO_PREVIOUS;
1156         }
1157
1158         if (button && !IS_SYSEVENT(button) )
1159             storage_spin();
1160     }
1161     return GO_TO_ROOT; /* unreachable - just to reduce compiler warnings */
1162 }
1163
1164 /* this is called from the playback thread so NO DRAWING! */
1165 static void track_changed_callback(void *param)
1166 {
1167     wps_state.id3 = (struct mp3entry*)param;
1168     wps_state.nid3 = audio_next_track();
1169     if (wps_state.id3->cuesheet)
1170     {
1171         cue_find_current_track(wps_state.id3->cuesheet, wps_state.id3->elapsed);
1172     }
1173     wps_sync_data.do_full_update = true;
1174 }
1175 static void nextid3available_callback(void* param)
1176 {
1177     (void)param;
1178     wps_state.nid3 = audio_next_track();
1179     wps_sync_data.do_full_update = true;
1180 }
1181
1182
1183 static void wps_state_init(void)
1184 {
1185     wps_state.ff_rewind = false;
1186     wps_state.paused = false;
1187     if(audio_status() & AUDIO_STATUS_PLAY)
1188     {
1189         wps_state.id3 = audio_current_track();
1190         wps_state.nid3 = audio_next_track();
1191     }
1192     else
1193     {
1194         wps_state.id3 = NULL;
1195         wps_state.nid3 = NULL;
1196     }
1197     /* We'll be updating due to restore initialized with true */
1198     wps_sync_data.do_full_update = false;
1199     /* add the WPS track event callbacks */
1200     add_event(PLAYBACK_EVENT_TRACK_CHANGE, false, track_changed_callback);
1201     add_event(PLAYBACK_EVENT_NEXTTRACKID3_AVAILABLE, false, nextid3available_callback);
1202 }
1203
1204
1205 void gui_sync_wps_init(void)
1206 {
1207     int i;
1208     FOR_NB_SCREENS(i)
1209     {
1210 #ifdef HAVE_ALBUMART
1211         wps_datas[i].albumart = NULL;
1212         wps_datas[i].playback_aa_slot = -1;
1213 #endif
1214         gui_wps[i].data = &wps_datas[i];
1215         gui_wps[i].display = &screens[i];
1216         /* Currently no seperate wps_state needed/possible
1217            so use the only available ( "global" ) one */
1218         gui_wps[i].state = &wps_state;
1219         /* must point to the same struct for both screens */
1220         gui_wps[i].sync_data = &wps_sync_data;
1221     }
1222 }
1223
1224
1225 #ifdef IPOD_ACCESSORY_PROTOCOL
1226 bool is_wps_fading(void)
1227 {
1228     return wps_state.is_fading;
1229 }
1230
1231 int wps_get_ff_rewind_count(void)
1232 {
1233     return wps_state.ff_rewind_count;
1234 }
1235 #endif