apps/plugins/mpegplayer/mpegplayer.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * mpegplayer main entrypoint and UI implementation
  11  *
  12  * Copyright (c) 2007 Michael Sevakis
  13  *
  14  * This program is free software; you can redistribute it and/or
  15  * modify it under the terms of the GNU General Public License
  16  * as published by the Free Software Foundation; either version 2
  17  * of the License, or (at your option) any later version.
  18  *
  19  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  20  * KIND, either express or implied.
  21  *
  22  ****************************************************************************/
  23
  24 /****************************************************************************
  25  * NOTES:
  26  *
  27  * mpegplayer is structured as follows:
  28  *
  29  *                       +-->Video Thread-->Video Output-->LCD
  30  *                       |
  31  * UI-->Stream Manager-->+-->Audio Thread-->PCM buffer--Audio Device
  32  *         |       |     |                        |     (ref. clock)
  33  *         |       |     +-->Buffer Thread        |
  34  *    Stream Data  |             |          (clock intf./
  35  *     Requests    |         File Cache      drift adj.)
  36  *                 |          Disk I/O
  37  *         Stream services
  38  *          (timing, etc.)
  39  *
  40  * Thread list:
  41  *  1) The main thread - Handles user input, settings, basic playback control
  42  *     and USB connect.
  43  *
  44  *  2) Stream Manager thread - Handles playback state, events from streams
  45  *     such as when a stream is finished, stream commands, PCM state. The
  46  *     layer in which this thread run also handles arbitration of data
  47  *     requests between the streams and the disk buffer. The actual specific
  48  *     transport layer code may get moved out to support multiple container
  49  *     formats.
  50  *
  51  *  3) Buffer thread - Buffers data in the background, generates notifications
  52  *     to streams when their data has been buffered, and watches streams'
  53  *     progress to keep data available during playback. Handles synchronous
  54  *     random access requests when the file cache is missed.
  55  *
  56  *  4) Video thread (running on the COP for PortalPlayer targets) - Decodes
  57  *     the video stream and renders video frames to the LCD. Handles
  58  *     miscellaneous video tasks like frame and thumbnail printing.
  59  *
  60  *  5) Audio thread (running on the main CPU to maintain consistency with the
  61  *     audio FIQ hander on PP) - Decodes audio frames and places them into
  62  *     the PCM buffer for rendering by the audio device.
  63  *
  64  * Streams are neither aware of one another nor care about one another. All
  65  * streams shall have their own thread (unless it is _really_ efficient to
  66  * have a single thread handle a couple minor streams). All coordination of
  67  * the streams is done through the stream manager. The clocking is controlled
  68  * by and exposed by the stream manager to other streams and implemented at
  69  * the PCM level.
  70  *
  71  * Notes about MPEG files:
  72  *
  73  * MPEG System Clock is 27MHz - i.e. 27000000 ticks/second.
  74  *
  75  * FPS is represented in terms of a frame period - this is always an
  76  * integer number of 27MHz ticks.
  77  *
  78  * e.g. 29.97fps (30000/1001) NTSC video has an exact frame period of
  79  * 900900 27MHz ticks.
  80  *
  81  * In libmpeg2, info->sequence->frame_period contains the frame_period.
  82  *
  83  * Working with Rockbox's 100Hz tick, the common frame rates would need
  84  * to be as follows (1):
  85  *
  86  * FPS     | 27Mhz   | 100Hz          | 44.1KHz   | 48KHz
  87  * --------|-----------------------------------------------------------
  88  * 10*     | 2700000 | 10             | 4410      | 4800
  89  * 12*     | 2250000 |  8.3333        | 3675      | 4000
  90  * 15*     | 1800000 |  6.6667        | 2940      | 3200
  91  * 23.9760 | 1126125 |  4.170833333   | 1839.3375 | 2002
  92  * 24      | 1125000 |  4.166667      | 1837.5    | 2000
  93  * 25      | 1080000 |  4             | 1764      | 1920
  94  * 29.9700 |  900900 |  3.336667      | 1471,47   | 1601.6
  95  * 30      |  900000 |  3.333333      | 1470      | 1600
  96  *
  97  * *Unofficial framerates
  98  *
  99  * (1) But we don't really care since the audio clock is used anyway and has
 100  *     very fine resolution ;-)
 101  *****************************************************************************/
 102 #include "plugin.h"
 103 #include "mpegplayer.h"
 104 #include "lib/helper.h"
 105 #include "mpeg_settings.h"
 106 #include "mpeg2.h"
 107 #include "video_out.h"
 108 #include "stream_thread.h"
 109 #include "stream_mgr.h"
 110
 111 PLUGIN_HEADER
 112 PLUGIN_IRAM_DECLARE
 113
 114 /* button definitions */
 115 #if (CONFIG_KEYPAD == IRIVER_H100_PAD) || (CONFIG_KEYPAD == IRIVER_H300_PAD)
 116 #define MPEG_MENU       BUTTON_MODE
 117 #define MPEG_STOP       BUTTON_OFF
 118 #define MPEG_PAUSE      BUTTON_ON
 119 #define MPEG_VOLDOWN    BUTTON_DOWN
 120 #define MPEG_VOLUP      BUTTON_UP
 121 #define MPEG_RW         BUTTON_LEFT
 122 #define MPEG_FF         BUTTON_RIGHT
 123
 124 #elif (CONFIG_KEYPAD == IPOD_4G_PAD) || (CONFIG_KEYPAD == IPOD_3G_PAD) || \
 125       (CONFIG_KEYPAD == IPOD_1G2G_PAD)
 126 #define MPEG_MENU       BUTTON_MENU
 127 #define MPEG_PAUSE      (BUTTON_PLAY | BUTTON_REL)
 128 #define MPEG_STOP       (BUTTON_PLAY | BUTTON_REPEAT)
 129 #define MPEG_VOLDOWN    BUTTON_SCROLL_BACK
 130 #define MPEG_VOLUP      BUTTON_SCROLL_FWD
 131 #define MPEG_RW         BUTTON_LEFT
 132 #define MPEG_FF         BUTTON_RIGHT
 133
 134 #elif CONFIG_KEYPAD == IAUDIO_X5M5_PAD
 135 #define MPEG_MENU       (BUTTON_REC | BUTTON_REL)
 136 #define MPEG_STOP       BUTTON_POWER
 137 #define MPEG_PAUSE      BUTTON_PLAY
 138 #define MPEG_VOLDOWN    BUTTON_DOWN
 139 #define MPEG_VOLUP      BUTTON_UP
 140 #define MPEG_RW         BUTTON_LEFT
 141 #define MPEG_FF         BUTTON_RIGHT
 142
 143 #elif CONFIG_KEYPAD == GIGABEAT_PAD
 144 #define MPEG_MENU       BUTTON_MENU
 145 #define MPEG_STOP       BUTTON_POWER
 146 #define MPEG_PAUSE      BUTTON_SELECT
 147 #define MPEG_PAUSE2     BUTTON_A
 148 #define MPEG_VOLDOWN    BUTTON_LEFT
 149 #define MPEG_VOLUP      BUTTON_RIGHT
 150 #define MPEG_VOLDOWN2   BUTTON_VOL_DOWN
 151 #define MPEG_VOLUP2     BUTTON_VOL_UP
 152 #define MPEG_RW         BUTTON_UP
 153 #define MPEG_FF         BUTTON_DOWN
 154
 155 #define MPEG_RC_MENU    BUTTON_RC_DSP
 156 #define MPEG_RC_STOP    (BUTTON_RC_PLAY | BUTTON_REPEAT)
 157 #define MPEG_RC_PAUSE   (BUTTON_RC_PLAY | BUTTON_REL)
 158 #define MPEG_RC_VOLDOWN BUTTON_RC_VOL_DOWN
 159 #define MPEG_RC_VOLUP   BUTTON_RC_VOL_UP
 160 #define MPEG_RC_RW      BUTTON_RC_REW
 161 #define MPEG_RC_FF      BUTTON_RC_FF
 162
 163 #elif CONFIG_KEYPAD == GIGABEAT_S_PAD
 164 #define MPEG_MENU       BUTTON_MENU
 165 #define MPEG_STOP       BUTTON_POWER
 166 #define MPEG_PAUSE      BUTTON_SELECT
 167 #define MPEG_PAUSE2     BUTTON_PLAY
 168 #define MPEG_VOLDOWN    BUTTON_LEFT
 169 #define MPEG_VOLUP      BUTTON_RIGHT
 170 #define MPEG_VOLDOWN2   BUTTON_VOL_DOWN
 171 #define MPEG_VOLUP2     BUTTON_VOL_UP
 172 #define MPEG_RW         BUTTON_UP
 173 #define MPEG_RW2        BUTTON_PREV
 174 #define MPEG_FF         BUTTON_DOWN
 175 #define MPEG_FF2        BUTTON_NEXT
 176 #define MPEG_SHOW_OSD   BUTTON_BACK
 177
 178 #define MPEG_RC_MENU    BUTTON_RC_DSP
 179 #define MPEG_RC_STOP    (BUTTON_RC_PLAY | BUTTON_REPEAT)
 180 #define MPEG_RC_PAUSE   (BUTTON_RC_PLAY | BUTTON_REL)
 181 #define MPEG_RC_VOLDOWN BUTTON_RC_VOL_DOWN
 182 #define MPEG_RC_VOLUP   BUTTON_RC_VOL_UP
 183 #define MPEG_RC_RW      BUTTON_RC_REW
 184 #define MPEG_RC_FF      BUTTON_RC_FF
 185
 186 #elif CONFIG_KEYPAD == IRIVER_H10_PAD
 187 #define MPEG_MENU       BUTTON_LEFT
 188 #define MPEG_STOP       BUTTON_POWER
 189 #define MPEG_PAUSE      BUTTON_PLAY
 190 #define MPEG_VOLDOWN    BUTTON_SCROLL_DOWN
 191 #define MPEG_VOLUP      BUTTON_SCROLL_UP
 192 #define MPEG_RW         BUTTON_REW
 193 #define MPEG_FF         BUTTON_FF
 194
 195 #elif CONFIG_KEYPAD == SANSA_E200_PAD
 196 #define MPEG_MENU       BUTTON_SELECT
 197 #define MPEG_STOP       BUTTON_POWER
 198 #define MPEG_PAUSE      BUTTON_RIGHT
 199 #define MPEG_VOLDOWN    BUTTON_SCROLL_BACK
 200 #define MPEG_VOLUP      BUTTON_SCROLL_FWD
 201 #define MPEG_RW         BUTTON_UP
 202 #define MPEG_FF         BUTTON_DOWN
 203
 204 #elif CONFIG_KEYPAD == SANSA_FUZE_PAD
 205 #define MPEG_MENU       BUTTON_SELECT
 206 #define MPEG_STOP       (BUTTON_HOME|BUTTON_REPEAT)
 207 #define MPEG_PAUSE      BUTTON_UP
 208 #define MPEG_VOLDOWN    BUTTON_SCROLL_BACK
 209 #define MPEG_VOLUP      BUTTON_SCROLL_FWD
 210 #define MPEG_RW         BUTTON_LEFT
 211 #define MPEG_FF         BUTTON_RIGHT
 212
 213
 214 #elif CONFIG_KEYPAD == SANSA_C200_PAD || \
 215 CONFIG_KEYPAD == SANSA_CLIP_PAD || \
 216 CONFIG_KEYPAD == SANSA_M200_PAD
 217 #define MPEG_MENU       BUTTON_SELECT
 218 #define MPEG_STOP       BUTTON_POWER
 219 #define MPEG_PAUSE      BUTTON_UP
 220 #define MPEG_VOLDOWN    BUTTON_VOL_DOWN
 221 #define MPEG_VOLUP      BUTTON_VOL_UP
 222 #define MPEG_RW         BUTTON_LEFT
 223 #define MPEG_FF         BUTTON_RIGHT
 224
 225 #elif CONFIG_KEYPAD == MROBE500_PAD
 226 #define MPEG_STOP       BUTTON_POWER
 227
 228 #define MPEG_RC_MENU    BUTTON_RC_HEART
 229 #define MPEG_RC_STOP    BUTTON_RC_DOWN
 230 #define MPEG_RC_PAUSE   BUTTON_RC_PLAY
 231 #define MPEG_RC_VOLDOWN BUTTON_RC_VOL_DOWN
 232 #define MPEG_RC_VOLUP   BUTTON_RC_VOL_UP
 233 #define MPEG_RC_RW      BUTTON_RC_REW
 234 #define MPEG_RC_FF      BUTTON_RC_FF
 235
 236 #elif CONFIG_KEYPAD == MROBE100_PAD
 237 #define MPEG_MENU       BUTTON_MENU
 238 #define MPEG_STOP       BUTTON_POWER
 239 #define MPEG_PAUSE      BUTTON_PLAY
 240 #define MPEG_VOLDOWN    BUTTON_DOWN
 241 #define MPEG_VOLUP      BUTTON_UP
 242 #define MPEG_RW         BUTTON_LEFT
 243 #define MPEG_FF         BUTTON_RIGHT
 244
 245 #elif CONFIG_KEYPAD == IAUDIO_M3_PAD
 246 #define MPEG_MENU       BUTTON_RC_MENU
 247 #define MPEG_STOP       BUTTON_RC_REC
 248 #define MPEG_PAUSE      BUTTON_RC_PLAY
 249 #define MPEG_VOLDOWN    BUTTON_RC_VOL_DOWN
 250 #define MPEG_VOLUP      BUTTON_RC_VOL_UP
 251 #define MPEG_RW         BUTTON_RC_REW
 252 #define MPEG_FF         BUTTON_RC_FF
 253
 254 #elif CONFIG_KEYPAD == COWON_D2_PAD
 255 #define MPEG_MENU       (BUTTON_MENU|BUTTON_REL)
 256 //#define MPEG_STOP       BUTTON_POWER
 257 #define MPEG_VOLDOWN    BUTTON_MINUS
 258 #define MPEG_VOLUP      BUTTON_PLUS
 259
 260 #elif CONFIG_KEYPAD == IAUDIO67_PAD
 261 #define MPEG_MENU       BUTTON_MENU
 262 #define MPEG_STOP       BUTTON_STOP
 263 #define MPEG_PAUSE      BUTTON_PLAY
 264 #define MPEG_VOLDOWN    BUTTON_VOLDOWN
 265 #define MPEG_VOLUP      BUTTON_VOLUP
 266 #define MPEG_RW         BUTTON_LEFT
 267 #define MPEG_FF         BUTTON_RIGHT
 268
 269 #elif CONFIG_KEYPAD == CREATIVEZVM_PAD
 270 #define MPEG_MENU       BUTTON_MENU
 271 #define MPEG_STOP       BUTTON_BACK
 272 #define MPEG_PAUSE      BUTTON_PLAY
 273 #define MPEG_VOLDOWN    BUTTON_UP
 274 #define MPEG_VOLUP      BUTTON_DOWN
 275 #define MPEG_RW         BUTTON_LEFT
 276 #define MPEG_FF         BUTTON_RIGHT
 277
 278 #elif CONFIG_KEYPAD == PHILIPS_HDD1630_PAD
 279 #define MPEG_MENU       BUTTON_MENU
 280 #define MPEG_STOP       BUTTON_POWER
 281 #define MPEG_PAUSE      BUTTON_SELECT
 282 #define MPEG_VOLDOWN    BUTTON_VOL_DOWN
 283 #define MPEG_VOLUP      BUTTON_VOL_UP
 284 #define MPEG_RW         BUTTON_LEFT
 285 #define MPEG_FF         BUTTON_RIGHT
 286
 287 #elif CONFIG_KEYPAD == PHILIPS_SA9200_PAD
 288 #define MPEG_MENU       BUTTON_MENU
 289 #define MPEG_STOP       BUTTON_POWER
 290 #define MPEG_PAUSE      BUTTON_PLAY
 291 #define MPEG_VOLDOWN    BUTTON_VOL_DOWN
 292 #define MPEG_VOLUP      BUTTON_VOL_UP
 293 #define MPEG_RW         BUTTON_UP
 294 #define MPEG_FF         BUTTON_DOWN
 295
 296 #elif CONFIG_KEYPAD == ONDAVX747_PAD
 297 #define MPEG_MENU       (BUTTON_MENU|BUTTON_REL)
 298 //#define MPEG_STOP       BUTTON_POWER
 299 #define MPEG_VOLDOWN    BUTTON_VOL_DOWN
 300 #define MPEG_VOLUP      BUTTON_VOL_UP
 301
 302 #elif CONFIG_KEYPAD == ONDAVX777_PAD
 303 #define MPEG_MENU       BUTTON_POWER
 304
 305 #elif CONFIG_KEYPAD == SAMSUNG_YH_PAD
 306 #define MPEG_MENU       BUTTON_LEFT
 307 #define MPEG_STOP       BUTTON_RIGHT
 308 #define MPEG_PAUSE      BUTTON_PLAY
 309 #define MPEG_VOLDOWN    BUTTON_DOWN
 310 #define MPEG_VOLUP      BUTTON_UP
 311 #define MPEG_RW         BUTTON_REW
 312 #define MPEG_FF         BUTTON_FFWD
 313
 314 #elif CONFIG_KEYPAD == PBELL_VIBE500_PAD
 315 #define MPEG_MENU       BUTTON_MENU
 316 #define MPEG_STOP       BUTTON_REC
 317 #define MPEG_PAUSE      BUTTON_PLAY
 318 #define MPEG_VOLDOWN    BUTTON_DOWN
 319 #define MPEG_VOLUP      BUTTON_UP
 320 #define MPEG_RW         BUTTON_PREV
 321 #define MPEG_FF         BUTTON_NEXT
 322
 323 #elif CONFIG_KEYPAD == MPIO_HD200_PAD
 324 #define MPEG_MENU       BUTTON_SELECT
 325 #define MPEG_PAUSE      (BUTTON_PLAY | BUTTON_REL)
 326 #define MPEG_STOP       (BUTTON_PLAY | BUTTON_REPEAT)
 327 #define MPEG_VOLDOWN    BUTTON_VOL_DOWN
 328 #define MPEG_VOLUP      BUTTON_VOL_UP
 329 #define MPEG_RW         BUTTON_PREV
 330 #define MPEG_FF         BUTTON_NEXT
 331
 332 #else
 333 #error No keymap defined!
 334 #endif
 335
 336 #ifdef HAVE_TOUCHSCREEN
 337 #ifndef MPEG_MENU
 338 #define MPEG_MENU      (BUTTON_TOPRIGHT|BUTTON_REL)
 339 #endif
 340 #ifndef MPEG_STOP
 341 #define MPEG_STOP       BUTTON_TOPLEFT
 342 #endif
 343 #ifndef MPEG_PAUSE
 344 #define MPEG_PAUSE      BUTTON_CENTER
 345 #endif
 346 #ifndef MPEG_VOLDOWN
 347 #define MPEG_VOLDOWN    BUTTON_BOTTOMMIDDLE
 348 #endif
 349 #ifndef MPEG_VOLUP
 350 #define MPEG_VOLUP      BUTTON_TOPMIDDLE
 351 #endif
 352 #ifndef MPEG_RW
 353 #define MPEG_RW         BUTTON_MIDLEFT
 354 #endif
 355 #ifndef MPEG_FF
 356 #define MPEG_FF         BUTTON_MIDRIGHT
 357 #endif
 358 #endif
 359
 360 /* One thing we can do here for targets with remotes is having a display
 361  * always on the remote instead of always forcing a popup on the main display */
 362
 363 #define FF_REWIND_MAX_PERCENT 3 /* cap ff/rewind step size at max % of file */
 364                                 /* 3% of 30min file == 54s step size */
 365 #define MIN_FF_REWIND_STEP (TS_SECOND/2)
 366 #define OSD_MIN_UPDATE_INTERVAL (HZ/2)
 367
 368 /* OSD status - same order as icon array */
 369 enum osd_status_enum
 370 {
 371     OSD_STATUS_STOPPED = 0,
 372     OSD_STATUS_PAUSED,
 373     OSD_STATUS_PLAYING,
 374     OSD_STATUS_FF,
 375     OSD_STATUS_RW,
 376     OSD_STATUS_COUNT,
 377     OSD_STATUS_MASK = 0x7
 378 };
 379
 380 enum osd_bits
 381 {
 382     OSD_REFRESH_DEFAULT    = 0x0000, /* Only refresh elements when due */
 383                                      /* Refresh the... */
 384     OSD_REFRESH_VOLUME     = 0x0001, /* ...volume display */
 385     OSD_REFRESH_TIME       = 0x0002, /* ...time display+progress */
 386     OSD_REFRESH_STATUS     = 0x0004, /* ...playback status icon */
 387     OSD_REFRESH_BACKGROUND = 0x0008, /* ...background (implies ALL) */
 388     OSD_REFRESH_VIDEO      = 0x0010, /* ...video image upon timeout */
 389     OSD_REFRESH_RESUME     = 0x0020, /* Resume playback upon timeout */
 390     OSD_NODRAW             = 0x8000, /* OR bitflag - don't draw anything */
 391     OSD_SHOW               = 0x4000, /* OR bitflag - show the OSD */
 392     OSD_HP_PAUSE           = 0x2000,
 393     OSD_HIDE               = 0x0000, /* hide the OSD (aid readability) */
 394     OSD_REFRESH_ALL        = 0x000f, /* Only immediate graphical elements */
 395 };
 396
 397 /* Status icons selected according to font height */
 398 extern const unsigned char mpegplayer_status_icons_8x8x1[];
 399 extern const unsigned char mpegplayer_status_icons_12x12x1[];
 400 extern const unsigned char mpegplayer_status_icons_16x16x1[];
 401
 402 /* Main border areas that contain OSD elements */
 403 #define OSD_BDR_L 2
 404 #define OSD_BDR_T 2
 405 #define OSD_BDR_R 2
 406 #define OSD_BDR_B 2
 407
 408 struct osd
 409 {
 410     long hide_tick;
 411     long show_for;
 412     long print_tick;
 413     long print_delay;
 414     long resume_tick;
 415     long resume_delay;
 416     long next_auto_refresh;
 417     int x;
 418     int y;
 419     int width;
 420     int height;
 421     unsigned fgcolor;
 422     unsigned bgcolor;
 423     unsigned prog_fillcolor;
 424     struct vo_rect update_rect;
 425     struct vo_rect prog_rect;
 426     struct vo_rect time_rect;
 427     struct vo_rect dur_rect;
 428     struct vo_rect vol_rect;
 429     const unsigned char *icons;
 430     struct vo_rect stat_rect;
 431     int status;
 432     uint32_t curr_time;
 433     unsigned auto_refresh;
 434     unsigned flags;
 435 };
 436
 437 static struct osd osd;
 438
 439 static void osd_show(unsigned show);
 440
 441 #ifdef LCD_LANDSCAPE
 442     #define _X (x + osd.x)
 443     #define _Y (y + osd.y)
 444     #define _W width
 445     #define _H height
 446 #else
 447     #define _X (LCD_WIDTH - (y + osd.y) - height)
 448     #define _Y (x + osd.x)
 449     #define _W height
 450     #define _H width
 451 #endif
 452
 453 #ifdef HAVE_LCD_COLOR
 454 /* Blend two colors in 0-100% (0-255) mix of c2 into c1 */
 455 static unsigned draw_blendcolor(unsigned c1, unsigned c2, unsigned char amount)
 456 {
 457     int r1 = RGB_UNPACK_RED(c1);
 458     int g1 = RGB_UNPACK_GREEN(c1);
 459     int b1 = RGB_UNPACK_BLUE(c1);
 460
 461     int r2 = RGB_UNPACK_RED(c2);
 462     int g2 = RGB_UNPACK_GREEN(c2);
 463     int b2 = RGB_UNPACK_BLUE(c2);
 464
 465     return LCD_RGBPACK(amount*(r2 - r1) / 255 + r1,
 466                        amount*(g2 - g1) / 255 + g1,
 467                        amount*(b2 - b1) / 255 + b1);
 468 }
 469 #endif
 470
 471 /* Drawing functions that operate rotated on LCD_PORTRAIT displays -
 472  * most are just wrappers of lcd_* functions with transforms applied.
 473  * The origin is the upper-left corner of the OSD area */
 474 static void draw_update_rect(int x, int y, int width, int height)
 475 {
 476     mylcd_update_rect(_X, _Y, _W, _H);
 477 }
 478
 479 static void draw_clear_area(int x, int y, int width, int height)
 480 {
 481 #ifdef HAVE_LCD_COLOR
 482     rb->screen_clear_area(rb->screens[SCREEN_MAIN], _X, _Y, _W, _H);
 483 #else
 484     int oldmode = grey_get_drawmode();
 485     grey_set_drawmode(DRMODE_SOLID | DRMODE_INVERSEVID);
 486     grey_fillrect(_X, _Y, _W, _H);
 487     grey_set_drawmode(oldmode);
 488 #endif
 489 }
 490
 491 static void draw_clear_area_rect(const struct vo_rect *rc)
 492 {
 493     draw_clear_area(rc->l, rc->t, rc->r - rc->l, rc->b - rc->t);
 494 }
 495
 496 static void draw_fillrect(int x, int y, int width, int height)
 497 {
 498     mylcd_fillrect(_X, _Y, _W, _H);
 499 }
 500
 501 static void draw_hline(int x1, int x2, int y)
 502 {
 503 #ifdef LCD_LANDSCAPE
 504     mylcd_hline(x1 + osd.x, x2 + osd.x, y + osd.y);
 505 #else
 506     y = LCD_WIDTH - (y + osd.y) - 1;
 507     mylcd_vline(y, x1 + osd.x, x2 + osd.x);
 508 #endif
 509 }
 510
 511 static void draw_vline(int x, int y1, int y2)
 512 {
 513 #ifdef LCD_LANDSCAPE
 514     mylcd_vline(x + osd.x, y1 + osd.y, y2 + osd.y);
 515 #else
 516     y1 = LCD_WIDTH - (y1 + osd.y) - 1;
 517     y2 = LCD_WIDTH - (y2 + osd.y) - 1;
 518     mylcd_hline(y1, y2, x + osd.x);
 519 #endif
 520 }
 521
 522 static void draw_scrollbar_draw(int x, int y, int width, int height,
 523                                 uint32_t min, uint32_t max, uint32_t val)
 524 {
 525     unsigned oldfg = mylcd_get_foreground();
 526
 527     draw_hline(x + 1, x + width - 2, y);
 528     draw_hline(x + 1, x + width - 2, y + height - 1);
 529     draw_vline(x, y + 1, y + height - 2);
 530     draw_vline(x + width - 1, y + 1, y + height - 2);
 531
 532     val = muldiv_uint32(width - 2, val, max - min);
 533     val = MIN(val, (uint32_t)(width - 2));
 534
 535     draw_fillrect(x + 1, y + 1, val, height - 2);
 536
 537     mylcd_set_foreground(osd.prog_fillcolor);
 538
 539     draw_fillrect(x + 1 + val, y + 1, width - 2 - val, height - 2);
 540
 541     mylcd_set_foreground(oldfg);
 542 }
 543
 544 static void draw_scrollbar_draw_rect(const struct vo_rect *rc, int min,
 545                                      int max, int val)
 546 {
 547     draw_scrollbar_draw(rc->l, rc->t, rc->r - rc->l, rc->b - rc->t,
 548                         min, max, val);
 549 }
 550
 551 #ifdef LCD_PORTRAIT
 552 /* Portrait displays need rotated text rendering */
 553
 554 /* Limited function that only renders in DRMODE_FG and uses absolute screen
 555  * coordinates */
 556 static void draw_oriented_mono_bitmap_part(const unsigned char *src,
 557                                            int src_x, int src_y,
 558                                            int stride, int x, int y,
 559                                            int width, int height)
 560 {
 561     const unsigned char *src_end;
 562     fb_data *dst, *dst_end;
 563     unsigned fg_pattern, bg_pattern;
 564
 565     if (x + width > SCREEN_WIDTH)
 566         width = SCREEN_WIDTH - x; /* Clip right */
 567     if (x < 0)
 568         width += x, x = 0; /* Clip left */
 569     if (width <= 0)
 570         return; /* nothing left to do */
 571
 572     if (y + height > SCREEN_HEIGHT)
 573         height = SCREEN_HEIGHT - y; /* Clip bottom */
 574     if (y < 0)
 575         height += y, y = 0; /* Clip top */
 576     if (height <= 0)
 577         return; /* nothing left to do */
 578
 579     fg_pattern = rb->lcd_get_foreground();
 580     bg_pattern = rb->lcd_get_background();
 581
 582     src += stride * (src_y >> 3) + src_x; /* move starting point */
 583     src_y  &= 7;
 584     src_end = src + width;
 585
 586     dst = rb->lcd_framebuffer + (LCD_WIDTH - y) + x*LCD_WIDTH;
 587     do
 588     {
 589         const unsigned char *src_col = src++;
 590         unsigned data = *src_col >> src_y;
 591         int numbits = 8 - src_y;
 592
 593         fb_data *dst_col = dst;
 594         dst_end = dst_col - height;
 595         dst += LCD_WIDTH;
 596
 597         do
 598         {
 599             dst_col--;
 600
 601             if (data & 1)
 602                 *dst_col = fg_pattern;
 603 #if 0
 604             else
 605                 *dst_col = bg_pattern;
 606 #endif
 607             data >>= 1;
 608             if (--numbits == 0) {
 609                 src_col += stride;
 610                 data = *src_col;
 611                 numbits = 8;
 612             }
 613         }
 614         while (dst_col > dst_end);
 615     }
 616     while (src < src_end);
 617 }
 618
 619 static void draw_putsxy_oriented(int x, int y, const char *str)
 620 {
 621     unsigned short ch;
 622     unsigned short *ucs;
 623     int ofs = MIN(x, 0);
 624     struct font* pf = rb->font_get(FONT_UI);
 625
 626     ucs = rb->bidi_l2v(str, 1);
 627
 628     x += osd.x;
 629     y += osd.y;
 630
 631     while ((ch = *ucs++) != 0 && x < SCREEN_WIDTH)
 632     {
 633         int width;
 634         const unsigned char *bits;
 635
 636         /* get proportional width and glyph bits */
 637         width = rb->font_get_width(pf, ch);
 638
 639         if (ofs > width) {
 640             ofs -= width;
 641             continue;
 642         }
 643
 644         bits = rb->font_get_bits(pf, ch);
 645
 646         draw_oriented_mono_bitmap_part(bits, ofs, 0, width, x, y,
 647                                        width - ofs, pf->height);
 648
 649         x += width - ofs;
 650         ofs = 0;
 651     }
 652 }
 653 #else
 654 static void draw_oriented_mono_bitmap_part(const unsigned char *src,
 655                                            int src_x, int src_y,
 656                                            int stride, int x, int y,
 657                                            int width, int height)
 658 {
 659     int mode = mylcd_get_drawmode();
 660     mylcd_set_drawmode(DRMODE_FG);
 661     mylcd_mono_bitmap_part(src, src_x, src_y, stride, x, y, width, height);
 662     mylcd_set_drawmode(mode);
 663 }
 664
 665 static void draw_putsxy_oriented(int x, int y, const char *str)
 666 {
 667     int mode = mylcd_get_drawmode();
 668     mylcd_set_drawmode(DRMODE_FG);
 669     mylcd_putsxy(x + osd.x, y + osd.y, str);
 670     mylcd_set_drawmode(mode);
 671 }
 672 #endif /* LCD_PORTRAIT */
 673
 674 #if defined(HAVE_LCD_ENABLE) || defined(HAVE_LCD_SLEEP)
 675 /* So we can refresh the overlay */
 676 static void osd_lcd_enable_hook(void* param)
 677 {
 678     (void)param;
 679     rb->queue_post(rb->button_queue, LCD_ENABLE_EVENT_1, 0);
 680 }
 681 #endif
 682
 683 static void osd_backlight_on_video_mode(bool video_on)
 684 {
 685     if (video_on) {
 686         /* Turn off backlight timeout */
 687         /* backlight control in lib/helper.c */
 688         backlight_force_on();
 689 #if defined(HAVE_LCD_ENABLE) || defined(HAVE_LCD_SLEEP)
 690         rb->remove_event(LCD_EVENT_ACTIVATION, osd_lcd_enable_hook);
 691 #endif
 692     } else {
 693 #if defined(HAVE_LCD_ENABLE) || defined(HAVE_LCD_SLEEP)
 694         rb->add_event(LCD_EVENT_ACTIVATION, false, osd_lcd_enable_hook);
 695 #endif
 696         /* Revert to user's backlight settings */
 697         backlight_use_settings();
 698     }
 699 }
 700
 701 #ifdef HAVE_BACKLIGHT_BRIGHTNESS
 702 static void osd_backlight_brightness_video_mode(bool video_on)
 703 {
 704     if (settings.backlight_brightness < 0)
 705         return;
 706
 707     mpeg_backlight_update_brightness(
 708         video_on ? settings.backlight_brightness : -1);
 709 }
 710 #else
 711 #define osd_backlight_brightness_video_mode(video_on)
 712 #endif /* HAVE_BACKLIGHT_BRIGHTNESS */
 713
 714 static void osd_text_init(void)
 715 {
 716     struct hms hms;
 717     char buf[32];
 718     int phys;
 719     int spc_width;
 720
 721     mylcd_setfont(FONT_UI);
 722
 723     osd.x = 0;
 724     osd.width = SCREEN_WIDTH;
 725
 726     vo_rect_clear(&osd.time_rect);
 727     vo_rect_clear(&osd.stat_rect);
 728     vo_rect_clear(&osd.prog_rect);
 729     vo_rect_clear(&osd.vol_rect);
 730
 731     ts_to_hms(stream_get_duration(), &hms);
 732     hms_format(buf, sizeof (buf), &hms);
 733     mylcd_getstringsize(buf, &osd.time_rect.r, &osd.time_rect.b);
 734
 735     /* Choose well-sized bitmap images relative to font height */
 736     if (osd.time_rect.b < 12) {
 737         osd.icons = mpegplayer_status_icons_8x8x1;
 738         osd.stat_rect.r = osd.stat_rect.b = 8;
 739     } else if (osd.time_rect.b < 16) {
 740         osd.icons = mpegplayer_status_icons_12x12x1;
 741         osd.stat_rect.r = osd.stat_rect.b = 12;
 742     } else {
 743         osd.icons = mpegplayer_status_icons_16x16x1;
 744         osd.stat_rect.r = osd.stat_rect.b = 16;
 745     }
 746
 747     if (osd.stat_rect.b < osd.time_rect.b) {
 748         vo_rect_offset(&osd.stat_rect, 0,
 749                        (osd.time_rect.b - osd.stat_rect.b) / 2 + OSD_BDR_T);
 750         vo_rect_offset(&osd.time_rect, OSD_BDR_L, OSD_BDR_T);
 751     } else {
 752         vo_rect_offset(&osd.time_rect, OSD_BDR_L,
 753                        osd.stat_rect.b - osd.time_rect.b + OSD_BDR_T);
 754         vo_rect_offset(&osd.stat_rect, 0, OSD_BDR_T);
 755     }
 756
 757     osd.dur_rect = osd.time_rect;
 758
 759     phys = rb->sound_val2phys(SOUND_VOLUME, rb->sound_min(SOUND_VOLUME));
 760     rb->snprintf(buf, sizeof(buf), "%d%s", phys,
 761                  rb->sound_unit(SOUND_VOLUME));
 762
 763     mylcd_getstringsize(" ", &spc_width, NULL);
 764     mylcd_getstringsize(buf, &osd.vol_rect.r, &osd.vol_rect.b);
 765
 766     osd.prog_rect.r = SCREEN_WIDTH - OSD_BDR_L - spc_width -
 767                            osd.vol_rect.r - OSD_BDR_R;
 768     osd.prog_rect.b = 3*osd.stat_rect.b / 4;
 769     vo_rect_offset(&osd.prog_rect, osd.time_rect.l,
 770                    osd.time_rect.b);
 771
 772     vo_rect_offset(&osd.stat_rect,
 773                    (osd.prog_rect.r + osd.prog_rect.l - osd.stat_rect.r) / 2,
 774                    0);
 775
 776     vo_rect_offset(&osd.dur_rect,
 777                    osd.prog_rect.r - osd.dur_rect.r, 0);
 778
 779     vo_rect_offset(&osd.vol_rect, osd.prog_rect.r + spc_width,
 780                    (osd.prog_rect.b + osd.prog_rect.t - osd.vol_rect.b) / 2);
 781
 782     osd.height = OSD_BDR_T + MAX(osd.prog_rect.b, osd.vol_rect.b) -
 783                     MIN(osd.time_rect.t, osd.stat_rect.t) + OSD_BDR_B;
 784
 785 #ifdef HAVE_LCD_COLOR
 786     osd.height = ALIGN_UP(osd.height, 2);
 787 #endif
 788     osd.y = SCREEN_HEIGHT - osd.height;
 789
 790     mylcd_setfont(FONT_SYSFIXED);
 791 }
 792
 793 static void osd_init(void)
 794 {
 795     osd.flags = 0;
 796     osd.show_for = HZ*4;
 797     osd.print_delay = 75*HZ/100;
 798     osd.resume_delay = HZ/2;
 799 #ifdef HAVE_LCD_COLOR
 800     osd.bgcolor = LCD_RGBPACK(0x73, 0x75, 0xbd);
 801     osd.fgcolor = LCD_WHITE;
 802     osd.prog_fillcolor = LCD_BLACK;
 803 #else
 804     osd.bgcolor = GREY_LIGHTGRAY;
 805     osd.fgcolor = GREY_BLACK;
 806     osd.prog_fillcolor = GREY_WHITE;
 807 #endif
 808     osd.curr_time = 0;
 809     osd.status = OSD_STATUS_STOPPED;
 810     osd.auto_refresh = OSD_REFRESH_TIME;
 811     osd.next_auto_refresh = *rb->current_tick;
 812     osd_text_init();
 813 }
 814
 815 static void osd_schedule_refresh(unsigned refresh)
 816 {
 817     long tick = *rb->current_tick;
 818
 819     if (refresh & OSD_REFRESH_VIDEO)
 820         osd.print_tick = tick + osd.print_delay;
 821
 822     if (refresh & OSD_REFRESH_RESUME)
 823         osd.resume_tick = tick + osd.resume_delay;
 824
 825     osd.auto_refresh |= refresh;
 826 }
 827
 828 static void osd_cancel_refresh(unsigned refresh)
 829 {
 830     osd.auto_refresh &= ~refresh;
 831 }
 832
 833 /* Refresh the background area */
 834 static void osd_refresh_background(void)
 835 {
 836     char buf[32];
 837     struct hms hms;
 838
 839     unsigned bg = mylcd_get_background();
 840     mylcd_set_drawmode(DRMODE_SOLID | DRMODE_INVERSEVID);
 841
 842 #ifdef HAVE_LCD_COLOR
 843     /* Draw a "raised" area for our graphics */
 844     mylcd_set_background(draw_blendcolor(bg, MYLCD_WHITE, 192));
 845     draw_hline(0, osd.width, 0);
 846
 847     mylcd_set_background(draw_blendcolor(bg, MYLCD_WHITE, 80));
 848     draw_hline(0, osd.width, 1);
 849
 850     mylcd_set_background(draw_blendcolor(bg, MYLCD_BLACK, 48));
 851     draw_hline(0, osd.width, osd.height-2);
 852
 853     mylcd_set_background(draw_blendcolor(bg, MYLCD_BLACK, 128));
 854     draw_hline(0, osd.width, osd.height-1);
 855
 856     mylcd_set_background(bg);
 857     draw_clear_area(0, 2, osd.width, osd.height - 4);
 858 #else
 859     /* Give contrast with the main background */
 860     mylcd_set_background(MYLCD_WHITE);
 861     draw_hline(0, osd.width, 0);
 862
 863     mylcd_set_background(MYLCD_DARKGRAY);
 864     draw_hline(0, osd.width, osd.height-1);
 865
 866     mylcd_set_background(bg);
 867     draw_clear_area(0, 1, osd.width, osd.height - 2);
 868 #endif
 869
 870     vo_rect_set_ext(&osd.update_rect, 0, 0, osd.width, osd.height);
 871     mylcd_set_drawmode(DRMODE_SOLID);
 872
 873     if (stream_get_duration() != INVALID_TIMESTAMP) {
 874         /* Draw the movie duration */
 875         ts_to_hms(stream_get_duration(), &hms);
 876         hms_format(buf, sizeof (buf), &hms);
 877         draw_putsxy_oriented(osd.dur_rect.l, osd.dur_rect.t, buf);
 878     }
 879     /* else don't know the duration */
 880 }
 881
 882 /* Refresh the current time display + the progress bar */
 883 static void osd_refresh_time(void)
 884 {
 885     char buf[32];
 886     struct hms hms;
 887
 888     uint32_t duration = stream_get_duration();
 889
 890     draw_scrollbar_draw_rect(&osd.prog_rect, 0, duration,
 891                              osd.curr_time);
 892
 893     ts_to_hms(osd.curr_time, &hms);
 894     hms_format(buf, sizeof (buf), &hms);
 895
 896     draw_clear_area_rect(&osd.time_rect);
 897     draw_putsxy_oriented(osd.time_rect.l, osd.time_rect.t, buf);
 898
 899     vo_rect_union(&osd.update_rect, &osd.update_rect,
 900                   &osd.prog_rect);
 901     vo_rect_union(&osd.update_rect, &osd.update_rect,
 902                   &osd.time_rect);
 903 }
 904
 905 /* Refresh the volume display area */
 906 static void osd_refresh_volume(void)
 907 {
 908     char buf[32];
 909     int width;
 910
 911     int volume = rb->global_settings->volume;
 912     rb->snprintf(buf, sizeof (buf), "%d%s",
 913                  rb->sound_val2phys(SOUND_VOLUME, volume),
 914                  rb->sound_unit(SOUND_VOLUME));
 915     mylcd_getstringsize(buf, &width, NULL);
 916
 917     /* Right-justified */
 918     draw_clear_area_rect(&osd.vol_rect);
 919     draw_putsxy_oriented(osd.vol_rect.r - width, osd.vol_rect.t, buf);
 920
 921     vo_rect_union(&osd.update_rect, &osd.update_rect, &osd.vol_rect);
 922 }
 923
 924 /* Refresh the status icon */
 925 static void osd_refresh_status(void)
 926 {
 927     int icon_size = osd.stat_rect.r - osd.stat_rect.l;
 928
 929     draw_clear_area_rect(&osd.stat_rect);
 930
 931 #ifdef HAVE_LCD_COLOR
 932     /* Draw status icon with a drop shadow */
 933     unsigned oldfg = mylcd_get_foreground();
 934     int i = 1;
 935
 936     mylcd_set_foreground(draw_blendcolor(mylcd_get_background(),
 937                         MYLCD_BLACK, 96));
 938
 939     while (1)
 940     {
 941         draw_oriented_mono_bitmap_part(osd.icons,
 942                                        icon_size*osd.status,
 943                                        0,
 944                                        icon_size*OSD_STATUS_COUNT,
 945                                        osd.stat_rect.l + osd.x + i,
 946                                        osd.stat_rect.t + osd.y + i,
 947                                        icon_size, icon_size);
 948
 949         if (--i < 0)
 950             break;
 951
 952         mylcd_set_foreground(oldfg);
 953     }
 954
 955     vo_rect_union(&osd.update_rect, &osd.update_rect, &osd.stat_rect);
 956 #else
 957     draw_oriented_mono_bitmap_part(osd.icons,
 958                                    icon_size*osd.status,
 959                                    0,
 960                                    icon_size*OSD_STATUS_COUNT,
 961                                    osd.stat_rect.l + osd.x,
 962                                    osd.stat_rect.t + osd.y,
 963                                    icon_size, icon_size);
 964     vo_rect_union(&osd.update_rect, &osd.update_rect, &osd.stat_rect);
 965 #endif
 966 }
 967
 968 /* Update the current status which determines which icon is displayed */
 969 static bool osd_update_status(void)
 970 {
 971     int status;
 972
 973     switch (stream_status())
 974     {
 975     default:
 976         status = OSD_STATUS_STOPPED;
 977         break;
 978     case STREAM_PAUSED:
 979         /* If paused with a pending resume, coerce it to OSD_STATUS_PLAYING */
 980         status = (osd.auto_refresh & OSD_REFRESH_RESUME) ?
 981             OSD_STATUS_PLAYING : OSD_STATUS_PAUSED;
 982         break;
 983     case STREAM_PLAYING:
 984         status = OSD_STATUS_PLAYING;
 985         break;
 986     }
 987
 988     if (status != osd.status) {
 989         /* A refresh is needed */
 990         osd.status = status;
 991         return true;
 992     }
 993
 994     return false;
 995 }
 996
 997 /* Update the current time that will be displayed */
 998 static void osd_update_time(void)
 999 {
1000     uint32_t start;
1001     osd.curr_time = stream_get_seek_time(&start);
1002     osd.curr_time -= start;
1003 }
1004
1005 /* Refresh various parts of the OSD - showing it if it is hidden */
1006 static void osd_refresh(int hint)
1007 {
1008     long tick;
1009     unsigned oldbg, oldfg;
1010
1011     tick = *rb->current_tick;
1012
1013     if (hint == OSD_REFRESH_DEFAULT) {
1014         /* The default which forces no updates */
1015
1016         /* Make sure Rockbox doesn't turn off the player because of
1017            too little activity */
1018         if (osd.status == OSD_STATUS_PLAYING)
1019             rb->reset_poweroff_timer();
1020
1021         /* Redraw the current or possibly extract a new video frame */
1022         if ((osd.auto_refresh & OSD_REFRESH_VIDEO) &&
1023             TIME_AFTER(tick, osd.print_tick)) {
1024             osd.auto_refresh &= ~OSD_REFRESH_VIDEO;
1025             stream_draw_frame(false);
1026         }
1027
1028         /* Restart playback if the timout was reached */
1029         if ((osd.auto_refresh & OSD_REFRESH_RESUME) &&
1030             TIME_AFTER(tick, osd.resume_tick)) {
1031             osd.auto_refresh &= ~(OSD_REFRESH_RESUME | OSD_REFRESH_VIDEO);
1032             stream_resume();
1033         }
1034
1035         /* If not visible, return */
1036         if (!(osd.flags & OSD_SHOW))
1037             return;
1038
1039         /* Hide if the visibility duration was reached */
1040         if (TIME_AFTER(tick, osd.hide_tick)) {
1041             osd_show(OSD_HIDE);
1042             return;
1043         }
1044     } else {
1045         /* A forced update of some region */
1046
1047         /* Show if currently invisible */
1048         if (!(osd.flags & OSD_SHOW)) {
1049             /* Avoid call back into this function - it will be drawn */
1050             osd_show(OSD_SHOW | OSD_NODRAW);
1051             hint = OSD_REFRESH_ALL;
1052         }
1053
1054         /* Move back timeouts for frame print and hide */
1055         osd.print_tick = tick + osd.print_delay;
1056         osd.hide_tick = tick + osd.show_for;
1057     }
1058
1059     if (TIME_AFTER(tick, osd.next_auto_refresh)) {
1060         /* Refresh whatever graphical elements are due automatically */
1061         osd.next_auto_refresh = tick + OSD_MIN_UPDATE_INTERVAL;
1062
1063         if (osd.auto_refresh & OSD_REFRESH_STATUS) {
1064             if (osd_update_status())
1065                 hint |= OSD_REFRESH_STATUS;
1066         }
1067
1068         if (osd.auto_refresh & OSD_REFRESH_TIME) {
1069             osd_update_time();
1070             hint |= OSD_REFRESH_TIME;
1071         }
1072     }
1073
1074     if (hint == 0)
1075         return; /* No drawing needed */
1076
1077     /* Set basic drawing params that are used. Elements that perform variations
1078      * will restore them. */
1079     oldfg = mylcd_get_foreground();
1080     oldbg = mylcd_get_background();
1081
1082     mylcd_setfont(FONT_UI);
1083     mylcd_set_foreground(osd.fgcolor);
1084     mylcd_set_background(osd.bgcolor);
1085
1086     vo_rect_clear(&osd.update_rect);
1087
1088     if (hint & OSD_REFRESH_BACKGROUND) {
1089         osd_refresh_background();
1090         hint |= OSD_REFRESH_ALL; /* Requires a redraw of everything */
1091     }
1092
1093     if (hint & OSD_REFRESH_TIME) {
1094         osd_refresh_time();
1095     }
1096
1097     if (hint & OSD_REFRESH_VOLUME) {
1098         osd_refresh_volume();
1099     }
1100
1101     if (hint & OSD_REFRESH_STATUS) {
1102         osd_refresh_status();
1103     }
1104
1105     /* Go back to defaults */
1106     mylcd_setfont(FONT_SYSFIXED);
1107     mylcd_set_foreground(oldfg);
1108     mylcd_set_background(oldbg);
1109
1110     /* Update the dirty rectangle */
1111     vo_lock();
1112
1113     draw_update_rect(osd.update_rect.l,
1114                      osd.update_rect.t,
1115                      osd.update_rect.r - osd.update_rect.l,
1116                      osd.update_rect.b - osd.update_rect.t);
1117
1118     vo_unlock();
1119 }
1120
1121 /* Show/Hide the OSD */
1122 static void osd_show(unsigned show)
1123 {
1124     if (((show ^ osd.flags) & OSD_SHOW) == 0)
1125     {
1126         if (show & OSD_SHOW) {
1127             osd.hide_tick = *rb->current_tick + osd.show_for;
1128         }
1129         return;
1130     }
1131
1132     if (show & OSD_SHOW) {
1133         /* Clip away the part of video that is covered */
1134         struct vo_rect rc = { 0, 0, SCREEN_WIDTH, osd.y };
1135
1136         osd.flags |= OSD_SHOW;
1137
1138         if (osd.status != OSD_STATUS_PLAYING) {
1139             /* Not playing - set brightness to mpegplayer setting */
1140             osd_backlight_brightness_video_mode(true);
1141         }
1142
1143         stream_vo_set_clip(&rc);
1144
1145         if (!(show & OSD_NODRAW))
1146             osd_refresh(OSD_REFRESH_ALL);
1147     } else {
1148         /* Uncover clipped video area and redraw it */
1149         osd.flags &= ~OSD_SHOW;
1150
1151         draw_clear_area(0, 0, osd.width, osd.height);
1152
1153         if (!(show & OSD_NODRAW)) {
1154             vo_lock();
1155             draw_update_rect(0, 0, osd.width, osd.height);
1156             vo_unlock();
1157
1158             stream_vo_set_clip(NULL);
1159             stream_draw_frame(false);
1160         } else {
1161             stream_vo_set_clip(NULL);
1162         }
1163
1164         if (osd.status != OSD_STATUS_PLAYING) {
1165             /* Not playing - restore backlight brightness */
1166             osd_backlight_brightness_video_mode(false);
1167         }
1168     }
1169 }
1170
1171 /* Set the current status - update screen if specified */
1172 static void osd_set_status(int status)
1173 {
1174     bool draw = (status & OSD_NODRAW) == 0;
1175
1176     status &= OSD_STATUS_MASK;
1177
1178     if (osd.status != status) {
1179
1180         osd.status = status;
1181
1182         if (draw)
1183             osd_refresh(OSD_REFRESH_STATUS);
1184     }
1185 }
1186
1187 /* Get the current status value */
1188 static int osd_get_status(void)
1189 {
1190     return osd.status & OSD_STATUS_MASK;
1191 }
1192
1193 /* Handle Fast-forward/Rewind keys using WPS settings (and some nicked code ;) */
1194 static uint32_t osd_ff_rw(int btn, unsigned refresh)
1195 {
1196     unsigned int step = TS_SECOND*rb->global_settings->ff_rewind_min_step;
1197     const long ff_rw_accel = (rb->global_settings->ff_rewind_accel + 3);
1198     uint32_t start;
1199     uint32_t time = stream_get_seek_time(&start);
1200     const uint32_t duration = stream_get_duration();
1201     unsigned int max_step = 0;
1202     uint32_t ff_rw_count = 0;
1203     unsigned status = osd.status;
1204
1205     osd_cancel_refresh(OSD_REFRESH_VIDEO | OSD_REFRESH_RESUME |
1206                        OSD_REFRESH_TIME);
1207
1208     time -= start; /* Absolute clock => stream-relative */
1209
1210     switch (btn)
1211     {
1212     case MPEG_FF:
1213 #ifdef MPEG_FF2
1214     case MPEG_FF2:
1215 #endif
1216 #ifdef MPEG_RC_FF
1217     case MPEG_RC_FF:
1218 #endif
1219         if (!(btn & BUTTON_REPEAT))
1220             osd_set_status(OSD_STATUS_FF);
1221         btn = MPEG_FF | BUTTON_REPEAT; /* simplify code below */
1222         break;
1223     case MPEG_RW:
1224 #ifdef MPEG_RW2
1225     case MPEG_RW2:
1226 #endif
1227 #ifdef MPEG_RC_RW
1228     case MPEG_RC_RW:
1229 #endif
1230         if (!(btn & BUTTON_REPEAT))
1231             osd_set_status(OSD_STATUS_RW);
1232         btn = MPEG_RW | BUTTON_REPEAT; /* simplify code below */
1233         break;
1234     default:
1235         btn = -1;
1236     }
1237
1238     while (1)
1239     {
1240         stream_keep_disk_active();
1241
1242         switch (btn)
1243         {
1244         case BUTTON_NONE:
1245             osd_refresh(OSD_REFRESH_DEFAULT);
1246             break;
1247
1248         case MPEG_FF | BUTTON_REPEAT:
1249         case MPEG_RW | BUTTON_REPEAT:
1250 #ifdef MPEG_FF2
1251         case MPEG_FF2 | BUTTON_REPEAT:
1252 #endif
1253 #ifdef MPEG_RW2
1254         case MPEG_RW2 | BUTTON_REPEAT:
1255 #endif
1256 #ifdef MPEG_RC_FF
1257         case MPEG_RC_FF | BUTTON_REPEAT:
1258         case MPEG_RC_RW | BUTTON_REPEAT:
1259 #endif
1260             break;
1261
1262         case MPEG_FF | BUTTON_REL:
1263         case MPEG_RW | BUTTON_REL:
1264 #ifdef MPEG_FF2
1265         case MPEG_FF2 | BUTTON_REL:
1266 #endif
1267 #ifdef MPEG_RW2
1268         case MPEG_RW2 | BUTTON_REL:
1269 #endif
1270 #ifdef MPEG_RC_FF
1271         case MPEG_RC_FF | BUTTON_REL:
1272         case MPEG_RC_RW | BUTTON_REL:
1273 #endif
1274             if (osd.status == OSD_STATUS_FF)
1275                 time += ff_rw_count;
1276             else if (osd.status == OSD_STATUS_RW)
1277                 time -= ff_rw_count;
1278
1279             /* Fall-through */
1280         case -1:
1281         default:
1282             osd_schedule_refresh(refresh);
1283             osd_set_status(status);
1284             osd_schedule_refresh(OSD_REFRESH_TIME);
1285             return time;
1286         }
1287
1288         if (osd.status == OSD_STATUS_FF) {
1289             /* fast forwarding, calc max step relative to end */
1290             max_step = muldiv_uint32(duration - (time + ff_rw_count),
1291                                      FF_REWIND_MAX_PERCENT, 100);
1292         } else {
1293             /* rewinding, calc max step relative to start */
1294             max_step = muldiv_uint32(time - ff_rw_count,
1295                                      FF_REWIND_MAX_PERCENT, 100);
1296         }
1297
1298         max_step = MAX(max_step, MIN_FF_REWIND_STEP);
1299
1300         if (step > max_step)
1301             step = max_step;
1302
1303         ff_rw_count += step;
1304
1305         /* smooth seeking by multiplying step by: 1 + (2 ^ -accel) */
1306         step += step >> ff_rw_accel;
1307
1308         if (osd.status == OSD_STATUS_FF) {
1309             if (duration - time <= ff_rw_count)
1310                 ff_rw_count = duration - time;
1311
1312             osd.curr_time = time + ff_rw_count;
1313         } else {
1314             if (time <= ff_rw_count)
1315                 ff_rw_count = time;
1316
1317             osd.curr_time = time - ff_rw_count;
1318         }
1319
1320         osd_refresh(OSD_REFRESH_TIME);
1321
1322         btn = rb->button_get_w_tmo(OSD_MIN_UPDATE_INTERVAL);
1323     }
1324 }
1325
1326 static int osd_status(void)
1327 {
1328     int status = stream_status();
1329
1330     /* Coerce to STREAM_PLAYING if paused with a pending resume */
1331     if (status == STREAM_PAUSED) {
1332         if (osd.auto_refresh & OSD_REFRESH_RESUME)
1333             status = STREAM_PLAYING;
1334     }
1335
1336     return status;
1337 }
1338
1339 /* Change the current audio volume by a specified amount */
1340 static void osd_set_volume(int delta)
1341 {
1342     int vol = rb->global_settings->volume;
1343     int limit;
1344
1345     vol += delta;
1346
1347     if (delta < 0) {
1348         /* Volume down - clip to lower limit */
1349         limit = rb->sound_min(SOUND_VOLUME);
1350         if (vol < limit)
1351             vol = limit;
1352     } else {
1353         /* Volume up - clip to upper limit */
1354         limit = rb->sound_max(SOUND_VOLUME);
1355         if (vol > limit)
1356             vol = limit;
1357     }
1358
1359     /* Sync the global settings */
1360     if (vol != rb->global_settings->volume) {
1361         rb->sound_set(SOUND_VOLUME, vol);
1362         rb->global_settings->volume = vol;
1363     }
1364
1365     /* Update the volume display */
1366     osd_refresh(OSD_REFRESH_VOLUME);
1367 }
1368
1369 /* Begin playback at the specified time */
1370 static int osd_play(uint32_t time)
1371 {
1372     int retval;
1373
1374     osd_cancel_refresh(OSD_REFRESH_VIDEO | OSD_REFRESH_RESUME);
1375
1376     retval = stream_seek(time, SEEK_SET);
1377
1378     if (retval >= STREAM_OK) {
1379         osd_backlight_on_video_mode(true);
1380         osd_backlight_brightness_video_mode(true);
1381         stream_show_vo(true);
1382         retval = stream_play();
1383
1384         if (retval >= STREAM_OK)
1385             osd_set_status(OSD_STATUS_PLAYING | OSD_NODRAW);
1386     }
1387
1388     return retval;
1389 }
1390
1391 /* Halt playback - pause engine and return logical state */
1392 static int osd_halt(void)
1393 {
1394     int status = stream_pause();
1395
1396     /* Coerce to STREAM_PLAYING if paused with a pending resume */
1397     if (status == STREAM_PAUSED) {
1398         if (osd_get_status() == OSD_STATUS_PLAYING)
1399             status = STREAM_PLAYING;
1400     }
1401
1402     /* Cancel some auto refreshes - caller will restart them if desired */
1403     osd_cancel_refresh(OSD_REFRESH_VIDEO | OSD_REFRESH_RESUME);
1404
1405     /* No backlight fiddling here - callers does the right thing */
1406
1407     return status;
1408 }
1409
1410 /* Pause playback if playing */
1411 static int osd_pause(void)
1412 {
1413     unsigned refresh = osd.auto_refresh;
1414     int status = osd_halt();
1415
1416     if (status == STREAM_PLAYING && (refresh & OSD_REFRESH_RESUME)) {
1417         /* Resume pending - change to a still video frame update */
1418         osd_schedule_refresh(OSD_REFRESH_VIDEO);
1419     }
1420
1421     osd_set_status(OSD_STATUS_PAUSED);
1422
1423     osd_backlight_on_video_mode(false);
1424     /* Leave brightness alone and restore it when OSD is hidden */
1425
1426     return status;
1427 }
1428
1429 /* Resume playback if halted or paused */
1430 static void osd_resume(void)
1431 {
1432     /* Cancel video and resume auto refresh - the resyc when starting
1433      * playback will perform those tasks */
1434     osd_backlight_on_video_mode(true);
1435     osd_backlight_brightness_video_mode(true);
1436     osd_cancel_refresh(OSD_REFRESH_VIDEO | OSD_REFRESH_RESUME);
1437     osd_set_status(OSD_STATUS_PLAYING);
1438     stream_resume();
1439 }
1440
1441 /* Stop playback - remember the resume point if not closed */
1442 static void osd_stop(void)
1443 {
1444     uint32_t resume_time;
1445
1446     osd_cancel_refresh(OSD_REFRESH_VIDEO | OSD_REFRESH_RESUME);
1447     osd_set_status(OSD_STATUS_STOPPED | OSD_NODRAW);
1448     osd_show(OSD_HIDE | OSD_NODRAW);
1449
1450     stream_stop();
1451
1452     resume_time = stream_get_resume_time();
1453
1454     if (resume_time != INVALID_TIMESTAMP)
1455         settings.resume_time = resume_time;
1456
1457     osd_backlight_on_video_mode(false);
1458     osd_backlight_brightness_video_mode(false);
1459 }
1460
1461 /* Perform a seek if seeking is possible for this stream - if playing, a delay
1462  * will be inserted before restarting in case the user decides to seek again */
1463 static void osd_seek(int btn)
1464 {
1465     int status;
1466     unsigned refresh;
1467     uint32_t time;
1468
1469     if (!stream_can_seek())
1470         return;
1471
1472     /* Halt playback - not strictly nescessary but nice */
1473     status = osd_halt();
1474
1475     if (status == STREAM_STOPPED)
1476         return;
1477
1478     osd_show(OSD_SHOW);
1479
1480     if (status == STREAM_PLAYING)
1481         refresh = OSD_REFRESH_RESUME; /* delay resume if playing */
1482     else
1483         refresh = OSD_REFRESH_VIDEO;  /* refresh if paused */
1484
1485     /* Obtain a new playback point */
1486     time = osd_ff_rw(btn, refresh);
1487
1488     /* Tell engine to resume at that time */
1489     stream_seek(time, SEEK_SET);
1490 }
1491
1492 #ifdef HAVE_HEADPHONE_DETECTION
1493 /* Handle SYS_PHONE_PLUGGED/UNPLUGGED */
1494 static void osd_handle_phone_plug(bool inserted)
1495 {
1496     if (rb->global_settings->unplug_mode == 0)
1497         return;
1498
1499     /* Wait for any incomplete state transition to complete first */
1500     stream_wait_status();
1501
1502     int status = osd_status();
1503
1504     if (inserted) {
1505         if (rb->global_settings->unplug_mode > 1) {
1506             if (status == STREAM_PAUSED) {
1507                 osd_resume();
1508             }
1509         }
1510     } else {
1511         if (status == STREAM_PLAYING) {
1512             osd_pause();
1513
1514             if (stream_can_seek() && rb->global_settings->unplug_rw) {
1515                 stream_seek(-rb->global_settings->unplug_rw*TS_SECOND,
1516                             SEEK_CUR);
1517                 osd_schedule_refresh(OSD_REFRESH_VIDEO);
1518                 /* Update time display now */
1519                 osd_update_time();
1520                 osd_refresh(OSD_REFRESH_TIME);
1521             }
1522         }
1523     }
1524 }
1525 #endif
1526
1527 static void button_loop(void)
1528 {
1529     rb->lcd_setfont(FONT_SYSFIXED);
1530 #ifdef HAVE_LCD_COLOR
1531     rb->lcd_set_foreground(LCD_WHITE);
1532     rb->lcd_set_background(LCD_BLACK);
1533 #endif
1534     rb->lcd_clear_display();
1535     rb->lcd_update();
1536
1537 #if defined(HAVE_LCD_MODES) && (HAVE_LCD_MODES & LCD_MODE_YUV)
1538     rb->lcd_set_mode(LCD_MODE_YUV);
1539 #endif
1540
1541     osd_init();
1542
1543     /* Start playback at the specified starting time */
1544     if (osd_play(settings.resume_time) < STREAM_OK) {
1545         rb->splash(HZ*2, "Playback failed");
1546         return;
1547     }
1548
1549     /* Gently poll the video player for EOS and handle UI */
1550     while (stream_status() != STREAM_STOPPED)
1551     {
1552         int button;
1553
1554         mpeg_menu_sysevent_clear();
1555         button = rb->button_get_w_tmo(OSD_MIN_UPDATE_INTERVAL/2);
1556
1557         button = mpeg_menu_sysevent_callback(button, NULL);
1558
1559         switch (button)
1560         {
1561         case BUTTON_NONE:
1562         {
1563             osd_refresh(OSD_REFRESH_DEFAULT);
1564             continue;
1565             } /* BUTTON_NONE: */
1566
1567 #if defined(HAVE_LCD_ENABLE) || defined(HAVE_LCD_SLEEP)
1568         case LCD_ENABLE_EVENT_1:
1569         {
1570             /* Draw the current frame if prepared already */
1571             stream_draw_frame(true);
1572             break;
1573             } /* LCD_ENABLE_EVENT_1: */
1574 #endif
1575
1576         case MPEG_VOLUP:
1577         case MPEG_VOLUP|BUTTON_REPEAT:
1578 #ifdef MPEG_VOLUP2
1579         case MPEG_VOLUP2:
1580         case MPEG_VOLUP2|BUTTON_REPEAT:
1581 #endif
1582 #ifdef MPEG_RC_VOLUP
1583         case MPEG_RC_VOLUP:
1584         case MPEG_RC_VOLUP|BUTTON_REPEAT:
1585 #endif
1586         {
1587             osd_set_volume(+1);
1588             break;
1589             } /* MPEG_VOLUP*: */
1590
1591         case MPEG_VOLDOWN:
1592         case MPEG_VOLDOWN|BUTTON_REPEAT:
1593 #ifdef MPEG_VOLDOWN2
1594         case MPEG_VOLDOWN2:
1595         case MPEG_VOLDOWN2|BUTTON_REPEAT:
1596 #endif
1597 #ifdef MPEG_RC_VOLDOWN
1598         case MPEG_RC_VOLDOWN:
1599         case MPEG_RC_VOLDOWN|BUTTON_REPEAT:
1600 #endif
1601         {
1602             osd_set_volume(-1);
1603             break;
1604             } /* MPEG_VOLDOWN*: */
1605
1606         case MPEG_MENU:
1607 #ifdef MPEG_RC_MENU
1608         case MPEG_RC_MENU:
1609 #endif
1610         {
1611             int state = osd_halt(); /* save previous state */
1612             int result;
1613
1614             /* Hide video output */
1615             osd_show(OSD_HIDE | OSD_NODRAW);
1616             stream_show_vo(false);
1617             osd_backlight_brightness_video_mode(false);
1618
1619 #if defined(HAVE_LCD_MODES) && (HAVE_LCD_MODES & LCD_MODE_YUV)
1620             rb->lcd_set_mode(LCD_MODE_RGB565);
1621 #endif
1622
1623             result = mpeg_menu();
1624
1625             /* The menu can change the font, so restore */
1626             rb->lcd_setfont(FONT_SYSFIXED);
1627 #ifdef HAVE_LCD_COLOR
1628             rb->lcd_set_foreground(LCD_WHITE);
1629             rb->lcd_set_background(LCD_BLACK);
1630 #endif
1631             rb->lcd_clear_display();
1632             rb->lcd_update();
1633
1634             switch (result)
1635             {
1636             case MPEG_MENU_QUIT:
1637                 osd_stop();
1638                 break;
1639
1640             default:
1641 #if defined(HAVE_LCD_MODES) && (HAVE_LCD_MODES & LCD_MODE_YUV)
1642                 rb->lcd_set_mode(LCD_MODE_YUV);
1643 #endif
1644                 /* If not stopped, show video again */
1645                 if (state != STREAM_STOPPED) {
1646                     osd_show(OSD_SHOW);
1647                     stream_show_vo(true);
1648                 }
1649
1650                 /* If stream was playing, restart it */
1651                 if (state == STREAM_PLAYING) {
1652                     osd_resume();
1653                 }
1654                 break;
1655             }
1656             break;
1657             } /* MPEG_MENU: */
1658
1659 #ifdef MPEG_SHOW_OSD
1660         case MPEG_SHOW_OSD:
1661         case MPEG_SHOW_OSD | BUTTON_REPEAT:
1662             /* Show if not visible */
1663             osd_show(OSD_SHOW);
1664             /* Make sure it refreshes */
1665             osd_refresh(OSD_REFRESH_DEFAULT);
1666             break;
1667 #endif
1668
1669         case MPEG_STOP:
1670 #ifdef MPEG_RC_STOP
1671         case MPEG_RC_STOP:
1672 #endif
1673         case ACTION_STD_CANCEL:
1674         {
1675             osd_stop();
1676             break;
1677             } /* MPEG_STOP: */
1678
1679         case MPEG_PAUSE:
1680 #ifdef MPEG_PAUSE2
1681         case MPEG_PAUSE2:
1682 #endif
1683 #ifdef MPEG_RC_PAUSE
1684         case MPEG_RC_PAUSE:
1685 #endif
1686         {
1687             int status = osd_status();
1688
1689             if (status == STREAM_PLAYING) {
1690                 /* Playing => Paused */
1691                 osd_pause();
1692             }
1693             else if (status == STREAM_PAUSED) {
1694                 /* Paused => Playing */
1695                 osd_resume();
1696             }
1697
1698             break;
1699             } /* MPEG_PAUSE*: */
1700
1701         case MPEG_RW:
1702         case MPEG_FF:
1703 #ifdef MPEG_RW2
1704         case MPEG_RW2:
1705 #endif
1706 #ifdef MPEG_FF2
1707         case MPEG_FF2:
1708 #endif
1709 #ifdef MPEG_RC_RW
1710         case MPEG_RC_RW:
1711         case MPEG_RC_FF:
1712 #endif
1713         {
1714             osd_seek(button);
1715             break;
1716             } /* MPEG_RW: MPEG_FF: */
1717
1718 #ifdef HAVE_HEADPHONE_DETECTION
1719         case SYS_PHONE_PLUGGED:
1720         case SYS_PHONE_UNPLUGGED:
1721         {
1722             osd_handle_phone_plug(button == SYS_PHONE_PLUGGED);
1723             break;
1724             } /* SYS_PHONE_*: */
1725 #endif
1726
1727         default:
1728         {
1729             rb->default_event_handler(button);
1730             break;
1731             } /* default: */
1732         }
1733
1734         rb->yield();
1735     } /* end while */
1736
1737     osd_stop();
1738
1739 #if defined(HAVE_LCD_ENABLE) || defined(HAVE_LCD_SLEEP)
1740     /* Be sure hook is removed before exiting since the stop will put it
1741      * back because of the backlight restore. */
1742     rb->remove_event(LCD_EVENT_ACTIVATION, osd_lcd_enable_hook);
1743 #endif
1744
1745     rb->lcd_setfont(FONT_UI);
1746 }
1747
1748 enum plugin_status plugin_start(const void* parameter)
1749 {
1750     int status = PLUGIN_ERROR; /* assume failure */
1751     int result;
1752     int err;
1753     const char *errstring;
1754
1755     if (parameter == NULL) {
1756         /* No file = GTFO */
1757         rb->splash(HZ*2, "No File");
1758         return PLUGIN_ERROR;
1759     }
1760
1761     /* Disable all talking before initializing IRAM */
1762     rb->talk_disable(true);
1763
1764     /* Initialize IRAM - stops audio and voice as well */
1765     PLUGIN_IRAM_INIT(rb)
1766
1767 #ifdef HAVE_LCD_COLOR
1768     rb->lcd_set_backdrop(NULL);
1769     rb->lcd_set_foreground(LCD_WHITE);
1770     rb->lcd_set_background(LCD_BLACK);
1771 #endif
1772
1773     rb->lcd_clear_display();
1774     rb->lcd_update();
1775
1776     if (stream_init() < STREAM_OK) {
1777         DEBUGF("Could not initialize streams\n");
1778     } else {
1779         rb->splash(0, "Loading...");
1780         init_settings((char*)parameter);
1781
1782         err = stream_open((char *)parameter);
1783
1784         if (err >= STREAM_OK) {
1785             /* start menu */
1786             rb->lcd_clear_display();
1787             rb->lcd_update();
1788             result = mpeg_start_menu(stream_get_duration());
1789
1790             if (result != MPEG_START_QUIT) {
1791                 /* Enter button loop and process UI */
1792                 button_loop();
1793             }
1794
1795             stream_close();
1796
1797             rb->lcd_clear_display();
1798             rb->lcd_update();
1799
1800             save_settings();
1801             status = PLUGIN_OK;
1802
1803             mpeg_menu_sysevent_handle();
1804         } else {
1805             DEBUGF("Could not open %s\n", (char*)parameter);
1806             switch (err)
1807             {
1808             case STREAM_UNSUPPORTED:
1809                 errstring = "Unsupported format";
1810                 break;
1811             default:
1812                 errstring = "Error opening file: %d";
1813             }
1814
1815             rb->splashf(HZ*2, errstring, err);
1816         }
1817     }
1818
1819 #if defined(HAVE_LCD_MODES) && (HAVE_LCD_MODES & LCD_MODE_YUV)
1820     rb->lcd_set_mode(LCD_MODE_RGB565);
1821 #endif
1822
1823     stream_exit();
1824
1825     rb->talk_disable(false);
1826     return status;
1827 }