apps/plugins/mpegplayer/mpeg_settings.c

   1 #include "plugin.h"
   2 #include "lib/helper.h"
   3 #include "lib/configfile.h"
   4
   5 #include "mpegplayer.h"
   6 #include "mpeg_settings.h"
   7
   8 struct mpeg_settings settings;
   9
  10 #define THUMB_DELAY (75*HZ/100)
  11
  12 /* button definitions */
  13 #if (CONFIG_KEYPAD == IRIVER_H100_PAD) || \
  14     (CONFIG_KEYPAD == IRIVER_H300_PAD)
  15 #define MPEG_START_TIME_SELECT      BUTTON_ON
  16 #define MPEG_START_TIME_LEFT        BUTTON_LEFT
  17 #define MPEG_START_TIME_RIGHT       BUTTON_RIGHT
  18 #define MPEG_START_TIME_UP          BUTTON_UP
  19 #define MPEG_START_TIME_DOWN        BUTTON_DOWN
  20 #define MPEG_START_TIME_EXIT        BUTTON_OFF
  21
  22 #elif (CONFIG_KEYPAD == IAUDIO_X5M5_PAD)
  23 #define MPEG_START_TIME_SELECT      BUTTON_PLAY
  24 #define MPEG_START_TIME_LEFT        BUTTON_LEFT
  25 #define MPEG_START_TIME_RIGHT       BUTTON_RIGHT
  26 #define MPEG_START_TIME_UP          BUTTON_UP
  27 #define MPEG_START_TIME_DOWN        BUTTON_DOWN
  28 #define MPEG_START_TIME_EXIT        BUTTON_POWER
  29
  30 #elif (CONFIG_KEYPAD == IPOD_4G_PAD) || \
  31       (CONFIG_KEYPAD == IPOD_3G_PAD) || \
  32       (CONFIG_KEYPAD == IPOD_1G2G_PAD)
  33 #define MPEG_START_TIME_SELECT      BUTTON_SELECT
  34 #define MPEG_START_TIME_LEFT        BUTTON_LEFT
  35 #define MPEG_START_TIME_RIGHT       BUTTON_RIGHT
  36 #define MPEG_START_TIME_UP          BUTTON_SCROLL_FWD
  37 #define MPEG_START_TIME_DOWN        BUTTON_SCROLL_BACK
  38 #define MPEG_START_TIME_EXIT        BUTTON_MENU
  39
  40 #elif CONFIG_KEYPAD == GIGABEAT_PAD
  41 #define MPEG_START_TIME_SELECT      BUTTON_SELECT
  42 #define MPEG_START_TIME_LEFT        BUTTON_LEFT
  43 #define MPEG_START_TIME_RIGHT       BUTTON_RIGHT
  44 #define MPEG_START_TIME_UP          BUTTON_UP
  45 #define MPEG_START_TIME_DOWN        BUTTON_DOWN
  46 #define MPEG_START_TIME_LEFT2       BUTTON_VOL_UP
  47 #define MPEG_START_TIME_RIGHT2      BUTTON_VOL_DOWN
  48 #define MPEG_START_TIME_EXIT        BUTTON_POWER
  49
  50 #define MPEG_START_TIME_RC_SELECT   (BUTTON_RC_PLAY | BUTTON_REL)
  51 #define MPEG_START_TIME_RC_LEFT     BUTTON_RC_REW
  52 #define MPEG_START_TIME_RC_RIGHT    BUTTON_RC_FF
  53 #define MPEG_START_TIME_RC_UP       BUTTON_RC_VOL_UP
  54 #define MPEG_START_TIME_RC_DOWN     BUTTON_RC_VOL_DOWN
  55 #define MPEG_START_TIME_RC_EXIT     (BUTTON_RC_PLAY | BUTTON_REPEAT)
  56
  57 #elif CONFIG_KEYPAD == GIGABEAT_S_PAD
  58 #define MPEG_START_TIME_SELECT      BUTTON_SELECT
  59 #define MPEG_START_TIME_LEFT        BUTTON_LEFT
  60 #define MPEG_START_TIME_RIGHT       BUTTON_RIGHT
  61 #define MPEG_START_TIME_UP          BUTTON_UP
  62 #define MPEG_START_TIME_DOWN        BUTTON_DOWN
  63 #define MPEG_START_TIME_LEFT2       BUTTON_VOL_UP
  64 #define MPEG_START_TIME_RIGHT2      BUTTON_VOL_DOWN
  65 #define MPEG_START_TIME_EXIT        BUTTON_POWER
  66
  67 #define MPEG_START_TIME_RC_SELECT   (BUTTON_RC_PLAY | BUTTON_REL)
  68 #define MPEG_START_TIME_RC_LEFT     BUTTON_RC_REW
  69 #define MPEG_START_TIME_RC_RIGHT    BUTTON_RC_FF
  70 #define MPEG_START_TIME_RC_UP       BUTTON_RC_VOL_UP
  71 #define MPEG_START_TIME_RC_DOWN     BUTTON_RC_VOL_DOWN
  72 #define MPEG_START_TIME_RC_EXIT     (BUTTON_RC_PLAY | BUTTON_REPEAT)
  73
  74 #elif CONFIG_KEYPAD == IRIVER_H10_PAD
  75 #define MPEG_START_TIME_SELECT      BUTTON_PLAY
  76 #define MPEG_START_TIME_LEFT        BUTTON_LEFT
  77 #define MPEG_START_TIME_RIGHT       BUTTON_RIGHT
  78 #define MPEG_START_TIME_UP          BUTTON_SCROLL_UP
  79 #define MPEG_START_TIME_DOWN        BUTTON_SCROLL_DOWN
  80 #define MPEG_START_TIME_EXIT        BUTTON_POWER
  81
  82 #elif (CONFIG_KEYPAD == SANSA_E200_PAD)
  83 #define MPEG_START_TIME_SELECT      BUTTON_SELECT
  84 #define MPEG_START_TIME_LEFT        BUTTON_LEFT
  85 #define MPEG_START_TIME_RIGHT       BUTTON_RIGHT
  86 #define MPEG_START_TIME_UP          BUTTON_UP
  87 #define MPEG_START_TIME_DOWN        BUTTON_DOWN
  88 #define MPEG_START_TIME_LEFT2       BUTTON_SCROLL_BACK
  89 #define MPEG_START_TIME_RIGHT2      BUTTON_SCROLL_FWD
  90 #define MPEG_START_TIME_EXIT        BUTTON_POWER
  91
  92 #elif (CONFIG_KEYPAD == SANSA_FUZE_PAD)
  93 #define MPEG_START_TIME_SELECT      BUTTON_SELECT
  94 #define MPEG_START_TIME_LEFT        BUTTON_LEFT
  95 #define MPEG_START_TIME_RIGHT       BUTTON_RIGHT
  96 #define MPEG_START_TIME_UP          BUTTON_UP
  97 #define MPEG_START_TIME_DOWN        BUTTON_DOWN
  98 #define MPEG_START_TIME_LEFT2       BUTTON_SCROLL_BACK
  99 #define MPEG_START_TIME_RIGHT2      BUTTON_SCROLL_FWD
 100 #define MPEG_START_TIME_EXIT        (BUTTON_HOME|BUTTON_REPEAT)
 101
 102 #elif (CONFIG_KEYPAD == SANSA_C200_PAD) || \
 103 (CONFIG_KEYPAD == SANSA_CLIP_PAD) || \
 104 (CONFIG_KEYPAD == SANSA_M200_PAD)
 105 #define MPEG_START_TIME_SELECT      BUTTON_SELECT
 106 #define MPEG_START_TIME_LEFT        BUTTON_LEFT
 107 #define MPEG_START_TIME_RIGHT       BUTTON_RIGHT
 108 #define MPEG_START_TIME_UP          BUTTON_UP
 109 #define MPEG_START_TIME_DOWN        BUTTON_DOWN
 110 #define MPEG_START_TIME_LEFT2       BUTTON_VOL_UP
 111 #define MPEG_START_TIME_RIGHT2      BUTTON_VOL_DOWN
 112 #define MPEG_START_TIME_EXIT        BUTTON_POWER
 113
 114 #elif CONFIG_KEYPAD == MROBE500_PAD
 115 #define MPEG_START_TIME_SELECT      BUTTON_RC_HEART
 116 #define MPEG_START_TIME_LEFT        BUTTON_LEFT
 117 #define MPEG_START_TIME_RIGHT       BUTTON_RIGHT
 118 #define MPEG_START_TIME_UP          BUTTON_RC_PLAY
 119 #define MPEG_START_TIME_DOWN        BUTTON_RC_DOWN
 120 #define MPEG_START_TIME_LEFT2       BUTTON_RC_VOL_UP
 121 #define MPEG_START_TIME_RIGHT2      BUTTON_RC_VOL_DOWN
 122 #define MPEG_START_TIME_EXIT        BUTTON_POWER
 123
 124 #elif CONFIG_KEYPAD == MROBE100_PAD
 125 #define MPEG_START_TIME_SELECT      BUTTON_SELECT
 126 #define MPEG_START_TIME_LEFT        BUTTON_LEFT
 127 #define MPEG_START_TIME_RIGHT       BUTTON_RIGHT
 128 #define MPEG_START_TIME_UP          BUTTON_UP
 129 #define MPEG_START_TIME_DOWN        BUTTON_DOWN
 130 #define MPEG_START_TIME_LEFT2       BUTTON_PLAY
 131 #define MPEG_START_TIME_RIGHT2      BUTTON_MENU
 132 #define MPEG_START_TIME_EXIT        BUTTON_POWER
 133
 134 #elif CONFIG_KEYPAD == IAUDIO_M3_PAD
 135 #define MPEG_START_TIME_SELECT      BUTTON_RC_PLAY
 136 #define MPEG_START_TIME_LEFT        BUTTON_RC_REW
 137 #define MPEG_START_TIME_RIGHT       BUTTON_RC_FF
 138 #define MPEG_START_TIME_UP          BUTTON_RC_VOL_UP
 139 #define MPEG_START_TIME_DOWN        BUTTON_RC_VOL_DOWN
 140 #define MPEG_START_TIME_EXIT        BUTTON_RC_REC
 141
 142 #elif CONFIG_KEYPAD == COWON_D2_PAD
 143 #define MPEG_START_TIME_EXIT        BUTTON_POWER
 144
 145 #elif CONFIG_KEYPAD == IAUDIO67_PAD
 146 #define MPEG_START_TIME_SELECT      BUTTON_MENU
 147 #define MPEG_START_TIME_LEFT        BUTTON_LEFT
 148 #define MPEG_START_TIME_RIGHT       BUTTON_RIGHT
 149 #define MPEG_START_TIME_UP          BUTTON_STOP
 150 #define MPEG_START_TIME_DOWN        BUTTON_PLAY
 151 #define MPEG_START_TIME_EXIT        BUTTON_POWER
 152
 153 #elif CONFIG_KEYPAD == CREATIVEZVM_PAD
 154 #define MPEG_START_TIME_SELECT      BUTTON_SELECT
 155 #define MPEG_START_TIME_LEFT        BUTTON_LEFT
 156 #define MPEG_START_TIME_RIGHT       BUTTON_RIGHT
 157 #define MPEG_START_TIME_UP          BUTTON_UP
 158 #define MPEG_START_TIME_DOWN        BUTTON_DOWN
 159 #define MPEG_START_TIME_LEFT2       BUTTON_PLAY
 160 #define MPEG_START_TIME_RIGHT2      BUTTON_MENU
 161 #define MPEG_START_TIME_EXIT        BUTTON_BACK
 162
 163 #elif CONFIG_KEYPAD == PHILIPS_HDD1630_PAD
 164 #define MPEG_START_TIME_SELECT      BUTTON_SELECT
 165 #define MPEG_START_TIME_LEFT        BUTTON_LEFT
 166 #define MPEG_START_TIME_RIGHT       BUTTON_RIGHT
 167 #define MPEG_START_TIME_UP          BUTTON_UP
 168 #define MPEG_START_TIME_DOWN        BUTTON_DOWN
 169 #define MPEG_START_TIME_LEFT2       BUTTON_VOL_UP
 170 #define MPEG_START_TIME_RIGHT2      BUTTON_VOL_DOWN
 171 #define MPEG_START_TIME_EXIT        BUTTON_POWER
 172
 173 #elif CONFIG_KEYPAD == PHILIPS_SA9200_PAD
 174 #define MPEG_START_TIME_SELECT      BUTTON_PLAY
 175 #define MPEG_START_TIME_LEFT        BUTTON_PREV
 176 #define MPEG_START_TIME_RIGHT       BUTTON_NEXT
 177 #define MPEG_START_TIME_UP          BUTTON_UP
 178 #define MPEG_START_TIME_DOWN        BUTTON_DOWN
 179 #define MPEG_START_TIME_LEFT2       BUTTON_VOL_UP
 180 #define MPEG_START_TIME_RIGHT2      BUTTON_VOL_DOWN
 181 #define MPEG_START_TIME_EXIT        BUTTON_POWER
 182
 183 #elif CONFIG_KEYPAD == ONDAVX747_PAD
 184 #define MPEG_START_TIME_EXIT        BUTTON_POWER
 185
 186 #elif CONFIG_KEYPAD == ONDAVX777_PAD
 187 #define MPEG_START_TIME_EXIT        BUTTON_POWER
 188
 189 #elif CONFIG_KEYPAD == SAMSUNG_YH_PAD
 190 #define MPEG_START_TIME_SELECT      BUTTON_PLAY
 191 #define MPEG_START_TIME_LEFT        BUTTON_LEFT
 192 #define MPEG_START_TIME_RIGHT       BUTTON_RIGHT
 193 #define MPEG_START_TIME_UP          BUTTON_UP
 194 #define MPEG_START_TIME_DOWN        BUTTON_DOWN
 195 #define MPEG_START_TIME_LEFT2       BUTTON_REW
 196 #define MPEG_START_TIME_RIGHT2      BUTTON_FFWD
 197 #define MPEG_START_TIME_EXIT        BUTTON_REC
 198
 199 #elif CONFIG_KEYPAD == PBELL_VIBE500_PAD
 200 #define MPEG_START_TIME_SELECT      BUTTON_PLAY
 201 #define MPEG_START_TIME_LEFT        BUTTON_PREV
 202 #define MPEG_START_TIME_RIGHT       BUTTON_NEXT
 203 #define MPEG_START_TIME_UP          BUTTON_UP
 204 #define MPEG_START_TIME_DOWN        BUTTON_DOWN
 205 #define MPEG_START_TIME_LEFT2       BUTTON_OK
 206 #define MPEG_START_TIME_RIGHT2      BUTTON_CANCEL
 207 #define MPEG_START_TIME_EXIT        BUTTON_REC
 208
 209 #elif CONFIG_KEYPAD == MPIO_HD200_PAD
 210 #define MPEG_START_TIME_SELECT      BUTTON_SELECT
 211 #define MPEG_START_TIME_LEFT        BUTTON_PREV
 212 #define MPEG_START_TIME_RIGHT       BUTTON_NEXT
 213 #define MPEG_START_TIME_UP          BUTTON_VOL_UP
 214 #define MPEG_START_TIME_DOWN        BUTTON_VOL_DOWN
 215 #define MPEG_START_TIME_EXIT        BUTTON_REC
 216
 217 #else
 218 #error No keymap defined!
 219 #endif
 220
 221 #ifdef HAVE_TOUCHSCREEN
 222 #ifndef MPEG_START_TIME_SELECT
 223 #define MPEG_START_TIME_SELECT      BUTTON_CENTER
 224 #endif
 225 #ifndef MPEG_START_TIME_LEFT
 226 #define MPEG_START_TIME_LEFT        BUTTON_MIDLEFT
 227 #endif
 228 #ifndef MPEG_START_TIME_RIGHT
 229 #define MPEG_START_TIME_RIGHT       BUTTON_MIDRIGHT
 230 #endif
 231 #ifndef MPEG_START_TIME_UP
 232 #define MPEG_START_TIME_UP          BUTTON_TOPMIDDLE
 233 #endif
 234 #ifndef MPEG_START_TIME_DOWN
 235 #define MPEG_START_TIME_DOWN        BUTTON_BOTTOMMIDDLE
 236 #endif
 237 #ifndef MPEG_START_TIME_LEFT2
 238 #define MPEG_START_TIME_LEFT2       BUTTON_TOPRIGHT
 239 #endif
 240 #ifndef MPEG_START_TIME_RIGHT2
 241 #define MPEG_START_TIME_RIGHT2      BUTTON_TOPLEFT
 242 #endif
 243 #ifndef MPEG_START_TIME_EXIT
 244 #define MPEG_START_TIME_EXIT        BUTTON_TOPLEFT
 245 #endif
 246 #endif
 247
 248 static struct configdata config[] =
 249 {
 250     {TYPE_INT, 0, 2, { .int_p = &settings.showfps }, "Show FPS", NULL},
 251     {TYPE_INT, 0, 2, { .int_p = &settings.limitfps }, "Limit FPS", NULL},
 252     {TYPE_INT, 0, 2, { .int_p = &settings.skipframes }, "Skip frames", NULL},
 253     {TYPE_INT, 0, INT_MAX, { .int_p = &settings.resume_count }, "Resume count",
 254      NULL},
 255     {TYPE_INT, 0, MPEG_RESUME_NUM_OPTIONS,
 256      { .int_p = &settings.resume_options }, "Resume options", NULL},
 257 #if MPEG_OPTION_DITHERING_ENABLED
 258     {TYPE_INT, 0, INT_MAX, { .int_p = &settings.displayoptions },
 259      "Display options", NULL},
 260 #endif
 261     {TYPE_INT, 0, 2, { .int_p = &settings.tone_controls }, "Tone controls",
 262      NULL},
 263     {TYPE_INT, 0, 2, { .int_p = &settings.channel_modes }, "Channel modes",
 264      NULL},
 265     {TYPE_INT, 0, 2, { .int_p = &settings.crossfeed }, "Crossfeed", NULL},
 266     {TYPE_INT, 0, 2, { .int_p = &settings.equalizer }, "Equalizer", NULL},
 267     {TYPE_INT, 0, 2, { .int_p = &settings.dithering }, "Dithering", NULL},
 268 #ifdef HAVE_BACKLIGHT_BRIGHTNESS
 269     {TYPE_INT, -1, INT_MAX, { .int_p = &settings.backlight_brightness },
 270      "Backlight brightness", NULL},
 271 #endif
 272 };
 273
 274 static const struct opt_items noyes[2] = {
 275     { "No", -1 },
 276     { "Yes", -1 },
 277 };
 278
 279 static const struct opt_items enabledisable[2] = {
 280     { "Disable", -1 },
 281     { "Enable", -1 },
 282 };
 283
 284 static const struct opt_items globaloff[2] = {
 285     { "Force off", -1 },
 286     { "Use sound setting", -1 },
 287 };
 288
 289 #ifdef HAVE_BACKLIGHT_BRIGHTNESS
 290 #define BACKLIGHT_OPTION_DEFAULT "Use setting"
 291 #endif
 292
 293 static void mpeg_settings(void);
 294 static long mpeg_menu_sysevent_id;
 295
 296 void mpeg_menu_sysevent_clear(void)
 297 {
 298     mpeg_menu_sysevent_id = 0;
 299 }
 300
 301 int mpeg_menu_sysevent_callback(int btn, const struct menu_item_ex *menu)
 302 {
 303     switch (btn)
 304     {
 305     case SYS_USB_CONNECTED:
 306     case SYS_POWEROFF:
 307         mpeg_menu_sysevent_id = btn;
 308         return ACTION_STD_CANCEL;
 309     }
 310
 311     return btn;
 312     (void)menu;
 313 }
 314
 315 long mpeg_menu_sysevent(void)
 316 {
 317     return mpeg_menu_sysevent_id;
 318 }
 319
 320 void mpeg_menu_sysevent_handle(void)
 321 {
 322     long id = mpeg_menu_sysevent();
 323     if (id != 0)
 324         rb->default_event_handler(id);
 325 }
 326
 327 static bool mpeg_set_option(const char* string,
 328                             void* variable,
 329                             enum optiontype type,
 330                             const struct opt_items* options,
 331                             int numoptions,
 332                             void (*function)(int))
 333 {
 334     mpeg_menu_sysevent_clear();
 335
 336     /* This eats SYS_POWEROFF - :\ */
 337     bool usb = rb->set_option(string, variable, type, options, numoptions,
 338                               function);
 339
 340     if (usb)
 341         mpeg_menu_sysevent_id = ACTION_STD_CANCEL;
 342
 343     return usb;
 344 }
 345
 346 #ifdef HAVE_BACKLIGHT_BRIGHTNESS /* Only used for this atm */
 347 static bool mpeg_set_int(const char *string, const char *unit,
 348                          int voice_unit, const int *variable,
 349                          void (*function)(int), int step,
 350                          int min,
 351                          int max,
 352                          const char* (*formatter)(char*, size_t, int, const char*))
 353 {
 354     mpeg_menu_sysevent_clear();
 355
 356     bool usb = rb->set_int(string, unit, voice_unit, variable, function,
 357                            step, min, max, formatter);
 358
 359     if (usb)
 360         mpeg_menu_sysevent_id = ACTION_STD_CANCEL;
 361
 362     return usb;
 363 }
 364 #endif /* HAVE_BACKLIGHT_BRIGHTNESS */
 365
 366 #ifdef HAVE_BACKLIGHT_BRIGHTNESS
 367 void mpeg_backlight_update_brightness(int value)
 368 {
 369     if (value >= 0)
 370     {
 371         value += MIN_BRIGHTNESS_SETTING;
 372         backlight_brightness_set(value);
 373     }
 374     else
 375     {
 376         backlight_brightness_use_setting();
 377     }
 378 }
 379
 380 static void backlight_brightness_function(int value)
 381 {
 382     mpeg_backlight_update_brightness(value);
 383 }
 384
 385 static const char* backlight_brightness_formatter(char *buf, size_t length,
 386                                                   int value, const char *input)
 387 {
 388     (void)input;
 389
 390     if (value < 0)
 391         return BACKLIGHT_OPTION_DEFAULT;
 392     else
 393         rb->snprintf(buf, length, "%d", value + MIN_BRIGHTNESS_SETTING);
 394     return buf;
 395 }
 396 #endif /* HAVE_BACKLIGHT_BRIGHTNESS */
 397
 398 /* Sync a particular audio setting to global or mpegplayer forced off */
 399 static void sync_audio_setting(int setting, bool global)
 400 {
 401     int val0, val1;
 402
 403     switch (setting)
 404     {
 405     case MPEG_AUDIO_TONE_CONTROLS:
 406     #if defined(AUDIOHW_HAVE_BASS) || defined(AUDIOHW_HAVE_TREBLE)
 407         if (global || settings.tone_controls)
 408         {
 409     #ifdef AUDIOHW_HAVE_BASS
 410             val0 = rb->global_settings->bass;
 411     #endif
 412     #ifdef AUDIOHW_HAVE_TREBLE
 413             val1 = rb->global_settings->treble;
 414     #endif
 415         }
 416         else
 417         {
 418     #ifdef AUDIOHW_HAVE_BASS
 419             val0 = rb->sound_default(SOUND_BASS);
 420     #endif
 421     #ifdef AUDIOHW_HAVE_TREBLE
 422             val1 = rb->sound_default(SOUND_TREBLE);
 423     #endif
 424         }
 425     #ifdef AUDIOHW_HAVE_BASS
 426         rb->sound_set(SOUND_BASS, val0);
 427     #endif
 428     #ifdef AUDIOHW_HAVE_TREBLE
 429         rb->sound_set(SOUND_TREBLE, val1);
 430     #endif
 431     #endif /* AUDIOHW_HAVE_BASS || AUDIOHW_HAVE_TREBLE */
 432
 433     #ifdef AUDIOHW_HAVE_EQ
 434         for (val1 = 0;; val1++)
 435         {
 436             int setting = rb->sound_enum_hw_eq_band_setting(val1, AUDIOHW_EQ_GAIN);
 437
 438             if (setting == -1)
 439                 break;
 440
 441             if (global || settings.tone_controls)
 442             {
 443                 val0 = rb->global_settings->hw_eq_bands[val1].gain;
 444             }
 445             else
 446             {
 447                 val0 = rb->sound_default(setting);
 448             }
 449
 450             rb->sound_set(setting, val0);
 451         }
 452     #endif /* AUDIOHW_HAVE_EQ */
 453         break;
 454
 455     case MPEG_AUDIO_CHANNEL_MODES:
 456         val0 = (global || settings.channel_modes) ?
 457                 rb->global_settings->channel_config :
 458                 SOUND_CHAN_STEREO;
 459         rb->sound_set(SOUND_CHANNELS, val0);
 460         break;
 461
 462     case MPEG_AUDIO_CROSSFEED:
 463         rb->dsp_set_crossfeed((global || settings.crossfeed) ?
 464                               rb->global_settings->crossfeed : false);
 465         break;
 466
 467     case MPEG_AUDIO_EQUALIZER:
 468         rb->dsp_set_eq((global || settings.equalizer) ?
 469                        rb->global_settings->eq_enabled : false);
 470         break;
 471
 472     case MPEG_AUDIO_DITHERING:
 473         rb->dsp_dither_enable((global || settings.dithering) ?
 474                               rb->global_settings->dithering_enabled : false);
 475        break;
 476     }
 477 }
 478
 479 /* Sync all audio settings to global or mpegplayer forced off */
 480 static void sync_audio_settings(bool global)
 481 {
 482     static const int setting_index[] =
 483     {
 484         MPEG_AUDIO_TONE_CONTROLS,
 485         MPEG_AUDIO_CHANNEL_MODES,
 486         MPEG_AUDIO_CROSSFEED,
 487         MPEG_AUDIO_EQUALIZER,
 488         MPEG_AUDIO_DITHERING,
 489     };
 490     unsigned i;
 491
 492     for (i = 0; i < ARRAYLEN(setting_index); i++)
 493     {
 494         sync_audio_setting(setting_index[i], global);
 495     }
 496 }
 497
 498 #ifndef HAVE_LCD_COLOR
 499 /* Cheapo splash implementation for the grey surface */
 500 static void grey_splash(int ticks, const unsigned char *fmt, ...)
 501 {
 502     unsigned char buffer[256];
 503     int x, y, w, h;
 504     int oldfg, oldmode;
 505
 506     va_list ap;
 507     va_start(ap, fmt);
 508
 509     rb->vsnprintf(buffer, sizeof (buffer), fmt, ap);
 510
 511     va_end(ap);
 512
 513     grey_getstringsize(buffer, &w, &h);
 514
 515     oldfg = grey_get_foreground();
 516     oldmode = grey_get_drawmode();
 517
 518     grey_set_drawmode(DRMODE_FG);
 519     grey_set_foreground(GREY_LIGHTGRAY);
 520
 521     x = (LCD_WIDTH - w) / 2;
 522     y = (LCD_HEIGHT - h) / 2;
 523
 524     grey_fillrect(x - 1, y - 1, w + 2, h + 2);
 525
 526     grey_set_foreground(GREY_BLACK);
 527
 528     grey_putsxy(x, y, buffer);
 529     grey_drawrect(x - 2, y - 2, w + 4, h + 4);
 530
 531     grey_set_foreground(oldfg);
 532     grey_set_drawmode(oldmode);
 533
 534     grey_update();
 535
 536     if (ticks > 0)
 537         rb->sleep(ticks);
 538 }
 539 #endif /* !HAVE_LCD_COLOR */
 540
 541 static void show_loading(struct vo_rect *rc)
 542 {
 543     int oldmode = mylcd_get_drawmode();
 544     mylcd_set_drawmode(DRMODE_SOLID | DRMODE_INVERSEVID);
 545     mylcd_fillrect(rc->l-1, rc->t-1, rc->r - rc->l + 2, rc->b - rc->t + 2);
 546     mylcd_set_drawmode(oldmode);
 547     mylcd_splash(0, "Loading...");
 548 }
 549
 550 static void draw_slider(uint32_t range, uint32_t pos, struct vo_rect *rc)
 551 {
 552     #define SLIDER_WIDTH   (LCD_WIDTH-SLIDER_LMARGIN-SLIDER_RMARGIN)
 553     #define SLIDER_X       SLIDER_LMARGIN
 554     #define SLIDER_Y       (LCD_HEIGHT-SLIDER_HEIGHT-SLIDER_BMARGIN)
 555     #define SLIDER_HEIGHT  8
 556     #define SLIDER_TEXTMARGIN 1
 557     #define SLIDER_LMARGIN 1
 558     #define SLIDER_RMARGIN 1
 559     #define SLIDER_TMARGIN 1
 560     #define SLIDER_BMARGIN 1
 561     #define SCREEN_MARGIN  1
 562
 563     struct hms hms;
 564     char str[32];
 565     int text_w, text_h, text_y;
 566
 567     /* Put positition on left */
 568     ts_to_hms(pos, &hms);
 569     hms_format(str, sizeof(str), &hms);
 570     mylcd_getstringsize(str, NULL, &text_h);
 571     text_y = SLIDER_Y - SLIDER_TEXTMARGIN - text_h;
 572
 573     if (rc == NULL)
 574     {
 575         int oldmode = mylcd_get_drawmode();
 576         mylcd_set_drawmode(DRMODE_BG | DRMODE_INVERSEVID);
 577         mylcd_fillrect(SLIDER_X, text_y, SLIDER_WIDTH,
 578                        LCD_HEIGHT - SLIDER_BMARGIN - text_y
 579                        - SLIDER_TMARGIN);
 580         mylcd_set_drawmode(oldmode);
 581
 582         mylcd_putsxy(SLIDER_X, text_y, str);
 583
 584         /* Put duration on right */
 585         ts_to_hms(range, &hms);
 586         hms_format(str, sizeof(str), &hms);
 587         mylcd_getstringsize(str, &text_w, NULL);
 588
 589         mylcd_putsxy(SLIDER_X + SLIDER_WIDTH - text_w, text_y, str);
 590
 591         /* Draw slider */
 592         mylcd_drawrect(SLIDER_X, SLIDER_Y, SLIDER_WIDTH, SLIDER_HEIGHT);
 593         mylcd_fillrect(SLIDER_X, SLIDER_Y,
 594                       muldiv_uint32(pos, SLIDER_WIDTH, range),
 595                       SLIDER_HEIGHT);
 596
 597         /* Update screen */
 598         mylcd_update_rect(SLIDER_X, text_y - SLIDER_TMARGIN, SLIDER_WIDTH,
 599                          LCD_HEIGHT - SLIDER_BMARGIN - text_y + SLIDER_TEXTMARGIN);
 600     }
 601     else
 602     {
 603         /* Just return slider rectangle */
 604         rc->l = SLIDER_X;
 605         rc->t = text_y - SLIDER_TMARGIN;
 606         rc->r = rc->l + SLIDER_WIDTH;
 607         rc->b = rc->t + LCD_HEIGHT - SLIDER_BMARGIN - text_y;
 608     }
 609 }
 610
 611 static bool display_thumb_image(const struct vo_rect *rc)
 612 {
 613     if (!stream_display_thumb(rc))
 614     {
 615         mylcd_splash(0, "Frame not available");
 616         return false;
 617     }
 618
 619     /* Draw a raised border around the frame */
 620     int oldcolor = mylcd_get_foreground();
 621     mylcd_set_foreground(MYLCD_LIGHTGRAY);
 622
 623     mylcd_hline(rc->l-1, rc->r-1, rc->t-1);
 624     mylcd_vline(rc->l-1, rc->t, rc->b-1);
 625
 626     mylcd_set_foreground(MYLCD_DARKGRAY);
 627
 628     mylcd_hline(rc->l-1, rc->r, rc->b);
 629     mylcd_vline(rc->r, rc->t-1, rc->b);
 630
 631     mylcd_set_foreground(oldcolor);
 632
 633     mylcd_update_rect(rc->l-1, rc->t-1, rc->r - rc->l + 2, 1);
 634     mylcd_update_rect(rc->l-1, rc->t, 1, rc->b - rc->t);
 635     mylcd_update_rect(rc->l-1, rc->b, rc->r - rc->l + 2, 1);
 636     mylcd_update_rect(rc->r, rc->t, 1, rc->b - rc->t);
 637
 638     return true;
 639 }
 640
 641 /* Add an amount to the specified time - with saturation */
 642 static uint32_t increment_time(uint32_t val, int32_t amount, uint32_t range)
 643 {
 644     if (amount < 0)
 645     {
 646         uint32_t off = -amount;
 647         if (range > off && val >= off)
 648             val -= off;
 649         else
 650             val = 0;
 651     }
 652     else if (amount > 0)
 653     {
 654         uint32_t off = amount;
 655         if (range > off && val <= range - off)
 656             val += off;
 657         else
 658             val = range;
 659     }
 660
 661     return val;
 662 }
 663
 664 #if defined(HAVE_LCD_ENABLE) || defined(HAVE_LCD_SLEEP)
 665 static void get_start_time_lcd_enable_hook(void *param)
 666 {
 667     (void)param;
 668     rb->queue_post(rb->button_queue, LCD_ENABLE_EVENT_0, 0);
 669 }
 670 #endif /* HAVE_LCD_ENABLE */
 671
 672 static int get_start_time(uint32_t duration)
 673 {
 674     int button = 0;
 675     int tmo = TIMEOUT_NOBLOCK;
 676     uint32_t resume_time = settings.resume_time;
 677     struct vo_rect rc_vid, rc_bound;
 678     uint32_t aspect_vid, aspect_bound;
 679
 680     enum state_enum slider_state = STATE0;
 681
 682     mylcd_clear_display();
 683     mylcd_update();
 684
 685 #if defined(HAVE_LCD_ENABLE) || defined(HAVE_LCD_SLEEP)
 686     rb->add_event(LCD_EVENT_ACTIVATION, false, get_start_time_lcd_enable_hook);
 687 #endif
 688
 689     draw_slider(0, 100, &rc_bound);
 690     rc_bound.b = rc_bound.t - SLIDER_TMARGIN;
 691     rc_bound.t = SCREEN_MARGIN;
 692
 693     DEBUGF("rc_bound: %d, %d, %d, %d\n", rc_bound.l, rc_bound.t,
 694            rc_bound.r, rc_bound.b);
 695
 696     rc_vid.l = rc_vid.t = 0;
 697     if (!stream_vo_get_size((struct vo_ext *)&rc_vid.r))
 698     {
 699         /* Can't get size - fill whole thing */
 700         rc_vid.r = rc_bound.r - rc_bound.l;
 701         rc_vid.b = rc_bound.b - rc_bound.t;
 702     }
 703
 704     /* Get aspect ratio of bounding rectangle and video in u16.16 */
 705     aspect_bound = ((rc_bound.r - rc_bound.l) << 16) /
 706                     (rc_bound.b - rc_bound.t);
 707
 708     DEBUGF("aspect_bound: %u.%02u\n", (unsigned)(aspect_bound >> 16),
 709            (unsigned)(100*(aspect_bound & 0xffff) >> 16));
 710
 711     aspect_vid = (rc_vid.r << 16) / rc_vid.b;
 712
 713     DEBUGF("aspect_vid: %u.%02u\n", (unsigned)(aspect_vid >> 16),
 714            (unsigned)(100*(aspect_vid & 0xffff) >> 16));
 715
 716     if (aspect_vid >= aspect_bound)
 717     {
 718         /* Video proportionally wider than or same as bounding rectangle */
 719         if (rc_vid.r > rc_bound.r - rc_bound.l)
 720         {
 721             rc_vid.r = rc_bound.r - rc_bound.l;
 722             rc_vid.b = (rc_vid.r << 16) / aspect_vid;
 723         }
 724         /* else already fits */
 725     }
 726     else
 727     {
 728         /* Video proportionally narrower than bounding rectangle */
 729         if (rc_vid.b > rc_bound.b - rc_bound.t)
 730         {
 731             rc_vid.b = rc_bound.b - rc_bound.t;
 732             rc_vid.r = (aspect_vid * rc_vid.b) >> 16;
 733         }
 734         /* else already fits */
 735     }
 736
 737     /* Even width and height >= 2 */
 738     rc_vid.r = (rc_vid.r < 2) ? 2 : (rc_vid.r & ~1);
 739     rc_vid.b = (rc_vid.b < 2) ? 2 : (rc_vid.b & ~1);
 740
 741     /* Center display in bounding rectangle */
 742     rc_vid.l = ((rc_bound.l + rc_bound.r) - rc_vid.r) / 2;
 743     rc_vid.r += rc_vid.l;
 744
 745     rc_vid.t = ((rc_bound.t + rc_bound.b) - rc_vid.b) / 2;
 746     rc_vid.b += rc_vid.t;
 747
 748     DEBUGF("rc_vid: %d, %d, %d, %d\n", rc_vid.l, rc_vid.t,
 749            rc_vid.r, rc_vid.b);
 750
 751 #ifndef HAVE_LCD_COLOR
 752     stream_gray_show(true);
 753 #endif
 754
 755     while (slider_state < STATE9)
 756     {
 757         mpeg_menu_sysevent_clear();
 758         button = tmo == TIMEOUT_BLOCK ?
 759             rb->button_get(true) : rb->button_get_w_tmo(tmo);
 760
 761         button = mpeg_menu_sysevent_callback(button, NULL);
 762
 763         switch (button)
 764         {
 765         case BUTTON_NONE:
 766             break;
 767
 768         /* Coarse (1 minute) control */
 769         case MPEG_START_TIME_DOWN:
 770         case MPEG_START_TIME_DOWN | BUTTON_REPEAT:
 771 #ifdef MPEG_START_TIME_RC_DOWN
 772         case MPEG_START_TIME_RC_DOWN:
 773         case MPEG_START_TIME_RC_DOWN | BUTTON_REPEAT:
 774 #endif
 775             resume_time = increment_time(resume_time, -60*TS_SECOND, duration);
 776             slider_state = STATE0;
 777             break;
 778
 779         case MPEG_START_TIME_UP:
 780         case MPEG_START_TIME_UP | BUTTON_REPEAT:
 781 #ifdef MPEG_START_TIME_RC_UP
 782         case MPEG_START_TIME_RC_UP:
 783         case MPEG_START_TIME_RC_UP | BUTTON_REPEAT:
 784 #endif
 785             resume_time = increment_time(resume_time, 60*TS_SECOND, duration);
 786             slider_state = STATE0;
 787             break;
 788
 789         /* Fine (1 second) control */
 790         case MPEG_START_TIME_LEFT:
 791         case MPEG_START_TIME_LEFT | BUTTON_REPEAT:
 792 #ifdef MPEG_START_TIME_RC_LEFT
 793         case MPEG_START_TIME_RC_LEFT:
 794         case MPEG_START_TIME_RC_LEFT | BUTTON_REPEAT:
 795 #endif
 796 #ifdef MPEG_START_TIME_LEFT2
 797         case MPEG_START_TIME_LEFT2:
 798         case MPEG_START_TIME_LEFT2 | BUTTON_REPEAT:
 799 #endif
 800             resume_time = increment_time(resume_time, -TS_SECOND, duration);
 801             slider_state = STATE0;
 802             break;
 803
 804         case MPEG_START_TIME_RIGHT:
 805         case MPEG_START_TIME_RIGHT | BUTTON_REPEAT:
 806 #ifdef MPEG_START_TIME_RC_RIGHT
 807         case MPEG_START_TIME_RC_RIGHT:
 808         case MPEG_START_TIME_RC_RIGHT | BUTTON_REPEAT:
 809 #endif
 810 #ifdef MPEG_START_TIME_RIGHT2
 811         case MPEG_START_TIME_RIGHT2:
 812         case MPEG_START_TIME_RIGHT2 | BUTTON_REPEAT:
 813 #endif
 814             resume_time = increment_time(resume_time, TS_SECOND, duration);
 815             slider_state = STATE0;
 816             break;
 817
 818         case MPEG_START_TIME_SELECT:
 819 #ifdef MPEG_START_TIME_RC_SELECT
 820         case MPEG_START_TIME_RC_SELECT:
 821 #endif
 822             settings.resume_time = resume_time;
 823             button = MPEG_START_SEEK;
 824             slider_state = STATE9;
 825             break;
 826
 827         case MPEG_START_TIME_EXIT:
 828 #ifdef MPEG_START_TIME_RC_EXIT
 829         case MPEG_START_TIME_RC_EXIT:
 830 #endif
 831             button = MPEG_START_EXIT;
 832             slider_state = STATE9;
 833             break;
 834
 835         case ACTION_STD_CANCEL:
 836             button = MPEG_START_QUIT;
 837             slider_state = STATE9;
 838             break;
 839
 840 #ifdef HAVE_LCD_ENABLE
 841         case LCD_ENABLE_EVENT_0:
 842             if (slider_state == STATE2)
 843                 display_thumb_image(&rc_vid);
 844             continue;
 845 #endif
 846
 847         default:
 848             rb->default_event_handler(button);
 849             rb->yield();
 850             continue;
 851         }
 852
 853         switch (slider_state)
 854         {
 855         case STATE0:
 856             trigger_cpu_boost();
 857             stream_seek(resume_time, SEEK_SET);
 858             show_loading(&rc_bound);
 859             draw_slider(duration, resume_time, NULL);
 860             slider_state = STATE1;
 861             tmo = THUMB_DELAY;
 862             break;
 863         case STATE1:
 864             display_thumb_image(&rc_vid);
 865             slider_state = STATE2;
 866         case STATE2:
 867             cancel_cpu_boost();
 868             tmo = TIMEOUT_BLOCK;
 869         default:
 870             break;
 871         }
 872
 873         rb->yield();
 874     }
 875
 876 #if defined(HAVE_LCD_ENABLE) || defined(HAVE_LCD_SLEEP)
 877     rb->remove_event(LCD_EVENT_ACTIVATION, get_start_time_lcd_enable_hook);
 878 #endif
 879 #ifndef HAVE_LCD_COLOR
 880     stream_gray_show(false);
 881     grey_clear_display();
 882     grey_update();
 883 #endif
 884
 885     cancel_cpu_boost();
 886
 887     return button;
 888 }
 889
 890 static int show_start_menu(uint32_t duration)
 891 {
 892     int selected = 0;
 893     int result = 0;
 894     bool menu_quit = false;
 895
 896     /* add the resume time to the menu display */
 897     static char resume_str[32];
 898     char hms_str[32];
 899     struct hms hms;
 900
 901     MENUITEM_STRINGLIST(menu, "Mpegplayer Menu", mpeg_menu_sysevent_callback,
 902                         "Play from beginning", resume_str, "Set start time",
 903                         "Settings", "Quit mpegplayer");
 904
 905     ts_to_hms(settings.resume_time, &hms);
 906     hms_format(hms_str, sizeof(hms_str), &hms);
 907     rb->snprintf(resume_str, sizeof (resume_str),
 908                      "Resume at: %s", hms_str);
 909
 910     rb->button_clear_queue();
 911
 912     while (!menu_quit)
 913     {
 914         mpeg_menu_sysevent_clear();
 915         result = rb->do_menu(&menu, &selected, NULL, false);
 916
 917         switch (result)
 918         {
 919         case MPEG_START_RESTART:
 920             settings.resume_time = 0;
 921             menu_quit = true;
 922             break;
 923
 924         case MPEG_START_RESUME:
 925             menu_quit = true;
 926             break;
 927
 928         case MPEG_START_SEEK:
 929             if (!stream_can_seek())
 930             {
 931                 rb->splash(HZ, "Unavailable");
 932                 break;
 933             }
 934
 935             result = get_start_time(duration);
 936
 937             if (result != MPEG_START_EXIT)
 938                 menu_quit = true;
 939             break;
 940
 941         case MPEG_START_SETTINGS:
 942             mpeg_settings();
 943             break;
 944
 945         default:
 946             result = MPEG_START_QUIT;
 947             menu_quit = true;
 948             break;
 949         }
 950
 951         if (mpeg_menu_sysevent() != 0)
 952         {
 953             result = MPEG_START_QUIT;
 954             menu_quit = true;
 955         }
 956     }
 957
 958     return result;
 959 }
 960
 961 /* Return the desired resume action */
 962 int mpeg_start_menu(uint32_t duration)
 963 {
 964     mpeg_menu_sysevent_clear();
 965
 966     switch (settings.resume_options)
 967     {
 968     case MPEG_RESUME_MENU_IF_INCOMPLETE:
 969         if (!stream_can_seek() || settings.resume_time == 0)
 970         {
 971     case MPEG_RESUME_RESTART:
 972             settings.resume_time = 0;
 973             return MPEG_START_RESTART;
 974         }
 975     default:
 976     case MPEG_RESUME_MENU_ALWAYS:
 977         return show_start_menu(duration);
 978     case MPEG_RESUME_ALWAYS:
 979         return MPEG_START_SEEK;
 980     }
 981 }
 982
 983 int mpeg_menu(void)
 984 {
 985     int result;
 986
 987     MENUITEM_STRINGLIST(menu, "Mpegplayer Menu", mpeg_menu_sysevent_callback,
 988                         "Settings", "Resume playback", "Quit mpegplayer");
 989
 990     rb->button_clear_queue();
 991
 992     mpeg_menu_sysevent_clear();
 993
 994     result = rb->do_menu(&menu, NULL, NULL, false);
 995
 996     switch (result)
 997     {
 998     case MPEG_MENU_SETTINGS:
 999         mpeg_settings();
1000         break;
1001
1002     case MPEG_MENU_RESUME:
1003         break;
1004
1005     case MPEG_MENU_QUIT:
1006         break;
1007
1008     default:
1009         break;
1010     }
1011
1012     if (mpeg_menu_sysevent() != 0)
1013         result = MPEG_MENU_QUIT;
1014
1015     return result;
1016 }
1017
1018 static void display_options(void)
1019 {
1020     int selected = 0;
1021     int result;
1022     bool menu_quit = false;
1023
1024     MENUITEM_STRINGLIST(menu, "Display Options", mpeg_menu_sysevent_callback,
1025 #if MPEG_OPTION_DITHERING_ENABLED
1026                         "Dithering",
1027 #endif
1028                         "Display FPS", "Limit FPS", "Skip frames",
1029 #ifdef HAVE_BACKLIGHT_BRIGHTNESS
1030                         "Backlight brightness",
1031 #endif
1032                         );
1033
1034     rb->button_clear_queue();
1035
1036     while (!menu_quit)
1037     {
1038         mpeg_menu_sysevent_clear();
1039         result = rb->do_menu(&menu, &selected, NULL, false);
1040
1041         switch (result)
1042         {
1043 #if MPEG_OPTION_DITHERING_ENABLED
1044         case MPEG_OPTION_DITHERING:
1045             result = (settings.displayoptions & LCD_YUV_DITHER) ? 1 : 0;
1046             mpeg_set_option("Dithering", &result, INT, noyes, 2, NULL);
1047             settings.displayoptions =
1048                 (settings.displayoptions & ~LCD_YUV_DITHER)
1049                       | ((result != 0) ? LCD_YUV_DITHER : 0);
1050             rb->lcd_yuv_set_options(settings.displayoptions);
1051             break;
1052 #endif /* MPEG_OPTION_DITHERING_ENABLED */
1053
1054         case MPEG_OPTION_DISPLAY_FPS:
1055             mpeg_set_option("Display FPS", &settings.showfps, INT,
1056                             noyes, 2, NULL);
1057             break;
1058
1059         case MPEG_OPTION_LIMIT_FPS:
1060             mpeg_set_option("Limit FPS", &settings.limitfps, INT,
1061                             noyes, 2, NULL);
1062             break;
1063
1064         case MPEG_OPTION_SKIP_FRAMES:
1065             mpeg_set_option("Skip frames", &settings.skipframes, INT,
1066                             noyes, 2, NULL);
1067             break;
1068
1069 #ifdef HAVE_BACKLIGHT_BRIGHTNESS
1070         case MPEG_OPTION_BACKLIGHT_BRIGHTNESS:
1071             result = settings.backlight_brightness;
1072             mpeg_backlight_update_brightness(result);
1073             mpeg_set_int("Backlight brightness", NULL, -1, &result,
1074                          backlight_brightness_function, 1, -1,
1075                          MAX_BRIGHTNESS_SETTING - MIN_BRIGHTNESS_SETTING,
1076                          backlight_brightness_formatter);
1077             settings.backlight_brightness = result;
1078             mpeg_backlight_update_brightness(-1);
1079             break;
1080 #endif /* HAVE_BACKLIGHT_BRIGHTNESS */
1081
1082         default:
1083             menu_quit = true;
1084             break;
1085         }
1086
1087         if (mpeg_menu_sysevent() != 0)
1088             menu_quit = true;
1089     }
1090 }
1091
1092 static void audio_options(void)
1093 {
1094     int selected = 0;
1095     int result;
1096     bool menu_quit = false;
1097
1098     MENUITEM_STRINGLIST(menu, "Audio Options", mpeg_menu_sysevent_callback,
1099                         "Tone Controls", "Channel Modes", "Crossfeed",
1100                         "Equalizer", "Dithering");
1101
1102     rb->button_clear_queue();
1103
1104     while (!menu_quit)
1105     {
1106         mpeg_menu_sysevent_clear();
1107         result = rb->do_menu(&menu, &selected, NULL, false);
1108
1109         switch (result)
1110         {
1111         case MPEG_AUDIO_TONE_CONTROLS:
1112             mpeg_set_option("Tone Controls", &settings.tone_controls, INT,
1113                             globaloff, 2, NULL);
1114             sync_audio_setting(result, false);
1115             break;
1116
1117         case MPEG_AUDIO_CHANNEL_MODES:
1118             mpeg_set_option("Channel Modes", &settings.channel_modes,
1119                             INT, globaloff, 2, NULL);
1120             sync_audio_setting(result, false);
1121             break;
1122
1123         case MPEG_AUDIO_CROSSFEED:
1124             mpeg_set_option("Crossfeed", &settings.crossfeed, INT,
1125                             globaloff, 2, NULL);
1126             sync_audio_setting(result, false);
1127             break;
1128
1129         case MPEG_AUDIO_EQUALIZER:
1130             mpeg_set_option("Equalizer", &settings.equalizer, INT,
1131                             globaloff, 2, NULL);
1132             sync_audio_setting(result, false);
1133             break;
1134
1135         case MPEG_AUDIO_DITHERING:
1136             mpeg_set_option("Dithering", &settings.dithering, INT,
1137                             globaloff, 2, NULL);
1138             sync_audio_setting(result, false);
1139             break;
1140
1141         default:
1142             menu_quit = true;
1143             break;
1144         }
1145
1146         if (mpeg_menu_sysevent() != 0)
1147             menu_quit = true;
1148     }
1149 }
1150
1151 static void resume_options(void)
1152 {
1153     static const struct opt_items items[MPEG_RESUME_NUM_OPTIONS] = {
1154         [MPEG_RESUME_MENU_ALWAYS] =
1155             { "Start menu", -1 },
1156         [MPEG_RESUME_MENU_IF_INCOMPLETE] =
1157             { "Start menu if not completed", -1 },
1158         [MPEG_RESUME_ALWAYS] =
1159             { "Resume automatically", -1 },
1160         [MPEG_RESUME_RESTART] =
1161             { "Play from beginning", -1 },
1162     };
1163
1164     mpeg_set_option("Resume Options", &settings.resume_options,
1165                     INT, items, MPEG_RESUME_NUM_OPTIONS, NULL);
1166 }
1167
1168 static void clear_resume_count(void)
1169 {
1170     settings.resume_count = 0;
1171     configfile_save(SETTINGS_FILENAME, config, ARRAYLEN(config),
1172                     SETTINGS_VERSION);
1173 }
1174
1175 static void mpeg_settings(void)
1176 {
1177     int selected = 0;
1178     int result;
1179     bool menu_quit = false;
1180     static char clear_str[32];
1181
1182     MENUITEM_STRINGLIST(menu, "Settings", mpeg_menu_sysevent_callback,
1183                         "Display Options", "Audio Options",
1184                         "Resume Options", clear_str);
1185
1186     rb->button_clear_queue();
1187
1188     while (!menu_quit)
1189     {
1190         mpeg_menu_sysevent_clear();
1191
1192         /* Format and add resume option to the menu display */
1193         rb->snprintf(clear_str, sizeof(clear_str),
1194                      "Clear all resumes: %u", settings.resume_count);
1195
1196         result = rb->do_menu(&menu, &selected, NULL, false);
1197
1198         switch (result)
1199         {
1200         case MPEG_SETTING_DISPLAY_SETTINGS:
1201             display_options();
1202             break;
1203
1204         case MPEG_SETTING_AUDIO_SETTINGS:
1205             audio_options();
1206             break;
1207
1208         case MPEG_SETTING_ENABLE_START_MENU:
1209             resume_options();
1210             break;
1211
1212         case MPEG_SETTING_CLEAR_RESUMES:
1213             clear_resume_count();
1214             break;
1215
1216         default:
1217             menu_quit = true;
1218             break;
1219         }
1220
1221         if (mpeg_menu_sysevent() != 0)
1222             menu_quit = true;
1223     }
1224 }
1225
1226 void init_settings(const char* filename)
1227 {
1228     /* Set the default settings */
1229     settings.showfps = 0;     /* Do not show FPS */
1230     settings.limitfps = 1;    /* Limit FPS */
1231     settings.skipframes = 1;  /* Skip frames */
1232     settings.resume_options = MPEG_RESUME_MENU_ALWAYS; /* Enable start menu */
1233     settings.resume_count = 0;
1234 #ifdef HAVE_BACKLIGHT_BRIGHTNESS
1235     settings.backlight_brightness = -1; /* Use default setting */
1236 #endif
1237 #if MPEG_OPTION_DITHERING_ENABLED
1238     settings.displayoptions = 0; /* No visual effects */
1239 #endif
1240     settings.tone_controls = false;
1241     settings.channel_modes = false;
1242     settings.crossfeed = false;
1243     settings.equalizer = false;
1244     settings.dithering = false;
1245
1246     if (configfile_load(SETTINGS_FILENAME, config, ARRAYLEN(config),
1247                         SETTINGS_MIN_VERSION) < 0)
1248     {
1249         /* Generate a new config file with default values */
1250         configfile_save(SETTINGS_FILENAME, config, ARRAYLEN(config),
1251                         SETTINGS_VERSION);
1252     }
1253
1254     rb->strlcpy(settings.resume_filename, filename, MAX_PATH);
1255
1256     /* get the resume time for the current mpeg if it exists */
1257     if ((settings.resume_time = configfile_get_value
1258          (SETTINGS_FILENAME, filename)) < 0)
1259     {
1260         settings.resume_time = 0;
1261     }
1262
1263 #if MPEG_OPTION_DITHERING_ENABLED
1264     rb->lcd_yuv_set_options(settings.displayoptions);
1265 #endif
1266
1267     /* Set our audio options */
1268     sync_audio_settings(false);
1269 }
1270
1271 void save_settings(void)
1272 {
1273     unsigned i;
1274     for (i = 0; i < ARRAYLEN(config); i++)
1275     {
1276         configfile_update_entry(SETTINGS_FILENAME, config[i].name,
1277                                 *(config[i].int_p));
1278     }
1279
1280     /* If this was a new resume entry then update the total resume count */
1281     if (configfile_update_entry(SETTINGS_FILENAME, settings.resume_filename,
1282                                 settings.resume_time) == 0)
1283     {
1284         configfile_update_entry(SETTINGS_FILENAME, "Resume count",
1285                                 ++settings.resume_count);
1286     }
1287
1288     /* Restore audio options */
1289     sync_audio_settings(true);
1290 }