1 files changed, 652 insertions, 583 deletions

diff --git a/apps/plugins/fft/fft.c b/apps/plugins/fft/fft.c
index 1e323ec7bd..709fbf9f46 100644
--- a/apps/plugins/fft/fft.c
+++ b/apps/plugins/fft/fft.c
@@ -1,5 +1,5 @@
 /***************************************************************************
-*             __________               __   ___.
+ *             __________               __   ___.
  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
@@ -21,6 +21,8 @@
 #include "plugin.h"
 
 #include "lib/helper.h"
+#include "lib/pluginlib_exit.h"
+#include "lib/configfile.h"
 #include "lib/xlcd.h"
 #include "math.h"
 #include "fracmul.h"
@@ -28,6 +30,7 @@
 #include "lib/grey.h"
 #endif
 #include "lib/mylcd.h"
+#include "lib/osd.h"
 
 
 
@@ -318,6 +321,9 @@ GREY_INFO_STRUCT
 #include "_kiss_fft_guts.h" /* sizeof(struct kiss_fft_state) */
 #include "const.h"
 
+
+/******************************* FFT globals *******************************/
+
 #define LCD_SIZE MAX(LCD_WIDTH, LCD_HEIGHT)
 
 #if (LCD_SIZE <= 511)
@@ -331,14 +337,14 @@ GREY_INFO_STRUCT
 #define ARRAYLEN_IN (FFT_SIZE)
 #define ARRAYLEN_OUT (FFT_SIZE)
 #define ARRAYLEN_PLOT (FFT_SIZE/2-1) /* FFT is symmetric, ignore DC */
-#define BUFSIZE_FFT (sizeof(struct kiss_fft_state)+sizeof(kiss_fft_cpx)*(FFT_SIZE-1))
+#define BUFSIZE_FFT (sizeof(struct kiss_fft_state)+\
+                     sizeof(kiss_fft_cpx)*(FFT_SIZE-1))
 
 #define __COEFF(type,size) type##_##size
-#define _COEFF(x, y) __COEFF(x,y) /* force the preprocessor to evaluate FFT_SIZE) */
+#define _COEFF(x, y) __COEFF(x,y) /* force CPP evaluation of FFT_SIZE */
 #define HANN_COEFF _COEFF(hann, FFT_SIZE)
 #define HAMMING_COEFF _COEFF(hamming, FFT_SIZE)
 
-/****************************** Globals ****************************/
 /* cacheline-aligned buffers with COP, otherwise word-aligned */
 /* CPU/COP only applies when compiled for more than one core */
 
@@ -370,75 +376,156 @@ static kiss_fft_cfg fft_state SHAREDBSS_ATTR;
 static char fft_buffer[CACHEALIGN_UP_SIZE(char, BUFSIZE_FFT)]
                 CACHEALIGN_AT_LEAST_ATTR(4);
 /* CPU */
-static int32_t plot_history[ARRAYLEN_PLOT];
-static int32_t plot[ARRAYLEN_PLOT];
+static uint32_t linf_magnitudes[ARRAYLEN_PLOT]; /* ling freq bin plot */
+static uint32_t logf_magnitudes[ARRAYLEN_PLOT]; /* log freq plot output */
+static uint32_t *plot;                          /* use this to plot */
 static struct
 {
     int16_t bin;   /* integer bin number */
     uint16_t frac; /* interpolation fraction */
 } binlog[ARRAYLEN_PLOT] __attribute__((aligned(4)));
 
-enum fft_window_func
+/**************************** End of FFT globals ***************************/
+
+
+/********************************* Settings ********************************/
+
+enum fft_orientation
 {
-    FFT_WF_FIRST = 0,
-    FFT_WF_HAMMING = 0,
-    FFT_WF_HANN,
+    FFT_MIN_OR = 0,
+    FFT_OR_VERT = 0, /* Amplitude vertical, frequency horizontal * */
+    FFT_OR_HORZ,     /* Amplitude horizontal, frequency vertical */
+    FFT_MAX_OR,
 };
-#define FFT_WF_COUNT (FFT_WF_HANN+1)
 
 enum fft_display_mode
 {
-    FFT_DM_FIRST = 0,
-    FFT_DM_LINES = 0,
-    FFT_DM_BARS,
-    FFT_DM_SPECTROGRAPH,
+    FFT_MIN_DM = 0,
+    FFT_DM_LINES = 0,   /* Bands are displayed as single-pixel lines * */
+    FFT_DM_BARS,        /* Bands are combined into wide bars */
+    FFT_DM_SPECTROGRAM, /* Band amplitudes are denoted by color */
+    FFT_MAX_DM,
 };
-#define FFT_DM_COUNT (FFT_DM_SPECTROGRAPH+1)
-
-static const unsigned char* const modes_text[FFT_DM_COUNT] =
-{ "Lines", "Bars", "Spectrogram" };
 
-static const unsigned char* const amp_scales_text[2] =
-{ "Linear amplitude", "Logarithmic amplitude" };
+enum fft_amp_scale
+{
+    FFT_MIN_AS = 0,
+    FFT_AS_LOG = 0, /* Amplitude is plotted on log scale * */
+    FFT_AS_LIN,     /* Amplitude is plotted on linear scale */
+    FFT_MAX_AS,
+};
 
-static const unsigned char* const freq_scales_text[2] =
-{ "Linear frequency", "Logarithmic frequency" };
+enum fft_freq_scale
+{
+    FFT_MIN_FS = 0,
+    FFT_FS_LOG = 0, /* Frequency is plotted on log scale * */
+    FFT_FS_LIN,     /* Frequency is plotted on linear scale */
+    FFT_MAX_FS
+};
 
-static const unsigned char* const window_text[FFT_WF_COUNT] =
-{ "Hamming window", "Hann window" };
+enum fft_window_func
+{
+    FFT_MIN_WF = 0,
+    FFT_WF_HAMMING = 0, /* Hamming window applied to each input frame * */
+    FFT_WF_HANN,        /* Hann window applied to each input frame */
+    FFT_MAX_WF,
+};
 
-static struct {
-    bool orientation_vertical;
-    enum fft_display_mode mode;
-    bool logarithmic_amp;
-    bool logarithmic_freq;
-    enum fft_window_func window_func;
-    int spectrogram_pos; /* row or column - only used by one at a time */
-    union
-    {
-        struct
-        {
-            bool orientation : 1;
-            bool mode        : 1;
-            bool amp_scale   : 1;
-            bool freq_scale  : 1;
-            bool window_func : 1;
-            bool do_clear    : 1;
-        };
-        bool clear_all; /* Write 'false' to clear all above */
-    } changed;
-} graph_settings SHAREDDATA_ATTR = 
+static struct fft_config
+{
+    int orientation;
+    int drawmode;
+    int amp_scale;
+    int freq_scale;
+    int window_func;
+} fft_disk = 
 {
      /* Defaults */
-    .orientation_vertical = true,
-    .mode                 = FFT_DM_LINES,
-    .logarithmic_amp      = true,
-    .logarithmic_freq     = true,
-    .window_func          = FFT_WF_HAMMING,
-    .spectrogram_pos      = 0,
-    .changed              = { .clear_all = false },
+    .orientation = FFT_OR_VERT,
+    .drawmode    = FFT_DM_LINES,
+    .amp_scale   = FFT_AS_LOG,
+    .freq_scale  = FFT_FS_LOG,
+    .window_func = FFT_WF_HAMMING,
+};
+
+#define CFGFILE_VERSION    0
+#define CFGFILE_MINVERSION 0
+
+static const char cfg_filename[] =  "fft.cfg";
+static struct configdata disk_config[] =
+{
+   { TYPE_ENUM, FFT_MIN_OR, FFT_MAX_OR,
+     { .int_p = &fft_disk.orientation }, "orientation",
+        (char * []){ [FFT_OR_VERT] = "vertical",
+                     [FFT_OR_HORZ] = "horizontal" } },
+   { TYPE_ENUM, FFT_MIN_DM, FFT_MAX_DM,
+     { .int_p = &fft_disk.drawmode }, "drawmode",
+        (char * []){ [FFT_DM_LINES]       = "lines",
+                     [FFT_DM_BARS]        = "bars",
+                     [FFT_DM_SPECTROGRAM] = "spectrogram" } },
+   { TYPE_ENUM, FFT_MIN_AS, FFT_MAX_AS,
+     { .int_p = &fft_disk.amp_scale }, "amp scale",
+        (char * []){ [FFT_AS_LOG] = "logarithmic",
+                     [FFT_AS_LIN] = "linear" } },
+   { TYPE_ENUM, FFT_MIN_FS, FFT_MAX_FS,
+     { .int_p = &fft_disk.freq_scale }, "freq scale",
+        (char * []){ [FFT_FS_LOG] = "logarithmic",
+                     [FFT_FS_LIN] = "linear" } },
+   { TYPE_ENUM, FFT_MIN_WF, FFT_MAX_WF,
+     { .int_p = &fft_disk.window_func }, "window function",
+        (char * []){ [FFT_WF_HAMMING] = "hamming",
+                     [FFT_WF_HANN]    = "hann" } },
 };
 
+/* Hint flags for setting changes */
+enum fft_setting_flags
+{
+    FFT_SETF_OR = 1 << 0,
+    FFT_SETF_DM = 1 << 1,
+    FFT_SETF_AS = 1 << 2,
+#ifdef FFT_FREQ_SCALE /* 'Till all keymaps are defined */
+    FFT_SETF_FS = 1 << 3,
+#endif
+    FFT_SETF_WF = 1 << 4,
+    FFT_SETF_ALL = 0x1f
+};
+
+/***************************** End of settings *****************************/
+
+
+/**************************** Operational data *****************************/
+
+#define COLOR_DEFAULT_FG    MYLCD_DEFAULT_FG
+#define COLOR_DEFAULT_BG    MYLCD_DEFAULT_BG
+
+#ifdef HAVE_LCD_COLOR
+#define COLOR_MESSAGE_FRAME LCD_RGBPACK(0xc6, 0x00, 0x00)
+#define COLOR_MESSAGE_BG    LCD_BLACK
+#define COLOR_MESSAGE_FG    LCD_WHITE
+#else
+#define COLOR_MESSAGE_FRAME GREY_DARKGRAY
+#define COLOR_MESSAGE_BG    GREY_WHITE
+#define COLOR_MESSAGE_FG    GREY_BLACK
+#endif
+
+#define FFT_OSD_MARGIN_SIZE 1
+
+#define FFT_PERIOD  (HZ/50) /* How fast to try to go */
+
+/* Based on feeding-in a 0db sinewave at FS/4 */
+#define QLOG_MAX 0x0009154B
+/* Fudge it a little or it's not very visbile */
+#define QLIN_MAX (0x00002266 >> 1)
+
+static struct fft_config fft;
+typedef void (* fft_drawfn_t)(unsigned, unsigned);
+static fft_drawfn_t fft_drawfn = NULL; /* plotting function */
+static int fft_spectrogram_pos = -1; /* row or column - only used by one at a time */
+static uint32_t fft_graph_scale = 0; /* max level over time, for scaling display */
+static int fft_message_id = -1; /* current message id displayed */
+static char fft_osd_message[32]; /* current message string displayed */
+static long fft_next_frame_tick = 0; /* next tick to attempt drawing */
+
 #ifdef HAVE_LCD_COLOR
 #define SHADES BMPWIDTH_fft_colors
 #define SPECTROGRAPH_PALETTE(index) (fft_colors[index])
@@ -447,121 +534,103 @@ static struct {
 #define SPECTROGRAPH_PALETTE(index) (255 - (index))
 #endif
 
-/************************* End of globals *************************/
+/************************* End of operational data *************************/
 
-/************************* Math functions *************************/
 
-/* Based on feeding-in a 0db sinewave at FS/4 */
-#define QLOG_MAX 0x0009154B
-/* fudge it a little or it's not very visbile */
-#define QLIN_MAX (0x00002266 >> 1)
+/***************************** Math functions ******************************/
 
 /* Apply window function to input */
 static void apply_window_func(enum fft_window_func mode)
 {
-    int i;
-
-    switch(mode)
+    static const int16_t * const coefs[] =
     {
-        case FFT_WF_HAMMING:
-            for(i = 0; i < ARRAYLEN_IN; ++i)
-            {
-                input[i].r = (input[i].r * HAMMING_COEFF[i] + 16384) >> 15;
-            } 
-            break;
+        [FFT_WF_HAMMING] = HAMMING_COEFF,
+        [FFT_WF_HANN]    = HANN_COEFF,
+    };
 
-        case FFT_WF_HANN:
-            for(i = 0; i < ARRAYLEN_IN; ++i)
-            {
-                input[i].r = (input[i].r * HANN_COEFF[i] + 16384) >> 15;
-            }
-            break;
-    }
+    const int16_t * const c = coefs[mode];
+
+    for(int i = 0; i < ARRAYLEN_IN; ++i)
+        input[i].r = (input[i].r * c[i] + 16384) >> 15;
 }
 
 /* Calculates the magnitudes from complex numbers and returns the maximum */
-static int32_t calc_magnitudes(bool logarithmic_amp)
+static unsigned calc_magnitudes(enum fft_amp_scale scale)
 {
     /* A major assumption made when calculating the Q*MAX constants 
      * is that the maximum magnitude is 29 bits long. */
-    uint32_t max = 0;
+    unsigned this_max = 0;
     kiss_fft_cpx *this_output = output[output_head] + 1; /* skip DC */
-    int i;
 
     /* Calculate the magnitude, discarding the phase. */
-    for(i = 0; i < ARRAYLEN_PLOT; ++i)
+    for(int i = 0; i < ARRAYLEN_PLOT; ++i)
     {
         int32_t re = this_output[i].r;
         int32_t im = this_output[i].i;
 
-        uint32_t tmp = re*re + im*im;
+        uint32_t d = re*re + im*im;
 
-        if(tmp > 0)
+        if(d > 0)
         {
-            if(tmp > 0x7FFFFFFF) /* clip */
+            if(d > 0x7FFFFFFF) /* clip */
             {
-                tmp = 0x7FFFFFFF; /* if our assumptions are correct,
-                                     this should never happen. It's just
-                                     a safeguard. */
+                d = 0x7FFFFFFF; /* if our assumptions are correct,
+                                   this should never happen. It's just
+                                   a safeguard. */
             }
 
-            if(logarithmic_amp)
+            if(scale == FFT_AS_LOG)
             {
-                if(tmp < 0x8000) /* be more precise */
+                if(d < 0x8000) /* be more precise */
                 {
                     /* ln(x ^ .5) = .5*ln(x) */
-                    tmp = fp16_log(tmp << 16) >> 1;
+                    d = fp16_log(d << 16) >> 1;
                 }
                 else
                 {
-                    tmp = isqrt(tmp); /* linear scaling, nothing
-                                         bad should happen */
-                    tmp = fp16_log(tmp << 16); /* the log function
-                                                  expects s15.16 values */
+                    d = isqrt(d); /* linear scaling, nothing
+                                     bad should happen */
+                    d = fp16_log(d << 16); /* the log function
+                                              expects s15.16 values */
                 }
             }
             else
             {
-                tmp = isqrt(tmp); /* linear scaling, nothing
-                                     bad should happen */
+                d = isqrt(d); /* linear scaling, nothing
+                                 bad should happen */
             }
         }
 
         /* Length 2 moving average - last transform and this one */
-        tmp = (plot_history[i] + tmp) >> 1;
-        plot[i] = tmp;
-        plot_history[i] = tmp;
+        linf_magnitudes[i] = (linf_magnitudes[i] + d) >> 1;
 
-        if(tmp > max)
-            max = tmp;
+        if(d > this_max)
+            this_max = d;
     }
 
-    return max;
+    return this_max;
 }
 
 /* Move plot bins into a logarithmic scale by sliding them towards the
  * Nyquist bin according to the translation in the binlog array. */
-static void logarithmic_plot_translate(void)
+static void log_plot_translate(void)
 {
-    int i;
-
-    for(i = ARRAYLEN_PLOT-1; i > 0; --i)
+    for(int i = ARRAYLEN_PLOT-1; i > 0; --i)
     {
-        int bin;
         int s = binlog[i].bin;
         int e = binlog[i-1].bin;
-        int frac = binlog[i].frac;
+        unsigned frac = binlog[i].frac;
 
-        bin = plot[s];
+        int bin = linf_magnitudes[s];
 
         if(frac)
         {
             /* slope < 1, Interpolate stretched bins (linear for now) */
-            int diff = plot[s+1] - bin;
+            int diff = linf_magnitudes[s+1] - bin;
 
             do
             {
-                plot[i] = bin + FRACMUL(frac << 15, diff);
+                logf_magnitudes[i] = bin + FRACMUL(frac << 15, diff);
                 frac = binlog[--i].frac;
             }
             while(frac);
@@ -571,33 +640,32 @@ static void logarithmic_plot_translate(void)
             /* slope > 1, Find peak of two or more bins */
             while(--s > e)
             {
-                int val = plot[s];
+                int val = linf_magnitudes[s];
 
                 if (val > bin)
                     bin = val;
             }
         }
 
-        plot[i] = bin;
+        logf_magnitudes[i] = bin;
     }
 }
 
 /* Calculates the translation for logarithmic plot bins */
 static void logarithmic_plot_init(void)
 {
-    int i, j;
     /*
      * log: y = round(n * ln(x) / ln(n))
      * anti: y = round(exp(x * ln(n) / n))
      */
-    j = fp16_log((ARRAYLEN_PLOT - 1) << 16);
-    for(i = 0; i < ARRAYLEN_PLOT; ++i)
+    int j = fp16_log((ARRAYLEN_PLOT - 1) << 16);
+    for(int i = 0; i < ARRAYLEN_PLOT; ++i)
     {
         binlog[i].bin = (fp16_exp(i * j / (ARRAYLEN_PLOT - 1)) + 32768) >> 16;
     }
 
     /* setup fractions for interpolation of stretched bins */
-    for(i = 0; i < ARRAYLEN_PLOT-1; i = j)
+    for(int i = 0; i < ARRAYLEN_PLOT-1; i = j)
     {
         j = i + 1;
 
@@ -619,192 +687,13 @@ static void logarithmic_plot_init(void)
     }
 }
 
-/************************ End of math functions ***********************/
-
-/********************* Plotting functions (modes) *********************/
-static void draw_lines_vertical(void);
-static void draw_lines_horizontal(void);
-static void draw_bars_vertical(void);
-static void draw_bars_horizontal(void);
-static void draw_spectrogram_vertical(void);
-static void draw_spectrogram_horizontal(void);
-
-#define COLOR_DEFAULT_FG    MYLCD_DEFAULT_FG
-#define COLOR_DEFAULT_BG    MYLCD_DEFAULT_BG
-
-#ifdef HAVE_LCD_COLOR
-#define COLOR_MESSAGE_FRAME LCD_RGBPACK(0xc6, 0x00, 0x00)
-#define COLOR_MESSAGE_BG    LCD_BLACK
-#define COLOR_MESSAGE_FG    LCD_WHITE
-#else
-#define COLOR_MESSAGE_FRAME GREY_DARKGRAY
-#define COLOR_MESSAGE_BG    GREY_WHITE
-#define COLOR_MESSAGE_FG    GREY_BLACK
-#endif
-
-#define POPUP_HPADDING      3 /* 3 px of horizontal padding and */
-#define POPUP_VPADDING      2 /* 2 px of vertical padding */
-
-static void draw_message_string(const unsigned char *message, bool active)
-{
-    int x, y;
-    mylcd_getstringsize(message, &x, &y);
-
-    /* x and y give the size of the box for the popup */
-    x += POPUP_HPADDING*2;
-    y += POPUP_VPADDING*2;
-
-    /* In vertical spectrogram mode, leave space for the popup
-     * before actually drawing it (if space is needed) */
-    if(active &&
-       graph_settings.mode == FFT_DM_SPECTROGRAPH &&
-       graph_settings.orientation_vertical &&
-       graph_settings.spectrogram_pos >= LCD_WIDTH - x) 
-    {
-        mylcd_scroll_left(graph_settings.spectrogram_pos -
-                          LCD_WIDTH + x);
-        graph_settings.spectrogram_pos = LCD_WIDTH - x - 1;
-    }
-
-    mylcd_set_foreground(COLOR_MESSAGE_FRAME);
-    mylcd_fillrect(LCD_WIDTH - x, 0, LCD_WIDTH - 1, y);
-
-    mylcd_set_foreground(COLOR_MESSAGE_FG);
-    mylcd_set_background(COLOR_MESSAGE_BG);
-    mylcd_putsxy(LCD_WIDTH - x + POPUP_HPADDING,
-                 POPUP_VPADDING, message);
-    mylcd_set_foreground(COLOR_DEFAULT_FG);
-    mylcd_set_background(COLOR_DEFAULT_BG);
-}
-
-static void draw(const unsigned char* message)
-{
-    static long show_message_tick = 0;
-    static const unsigned char* last_message = 0;
-
-    if(message != NULL)
-    {
-        last_message = message;
-        show_message_tick = (*rb->current_tick + HZ) | 1;
-    }
-
-    /* maybe take additional actions depending upon the changed setting */
-    if(graph_settings.changed.orientation)
-    {
-       graph_settings.changed.amp_scale = true;
-       graph_settings.changed.do_clear = true;
-    }
-
-    if(graph_settings.changed.mode)
-    {
-        graph_settings.changed.amp_scale = true;
-        graph_settings.changed.do_clear = true;
-    }
-
-    if(graph_settings.changed.amp_scale)
-        memset(plot_history, 0, sizeof (plot_history));
-
-    if(graph_settings.changed.freq_scale)
-        graph_settings.changed.freq_scale = true;
-
-    mylcd_set_foreground(COLOR_DEFAULT_FG);
-    mylcd_set_background(COLOR_DEFAULT_BG);
+/************************** End of math functions **************************/
 
-    switch (graph_settings.mode)
-    {
-        default:
-        case FFT_DM_LINES: {
-
-            mylcd_clear_display();
-
-            if (graph_settings.orientation_vertical)
-                draw_lines_vertical();
-            else
-                draw_lines_horizontal();
-            break;
-        }
-        case FFT_DM_BARS: {
 
-            mylcd_clear_display();
-
-            if(graph_settings.orientation_vertical)
-                draw_bars_vertical();
-            else
-                draw_bars_horizontal();
-
-            break;
-        }
-        case FFT_DM_SPECTROGRAPH: {
-
-            if(graph_settings.changed.do_clear)
-            {
-                graph_settings.spectrogram_pos = 0;
-                mylcd_clear_display();
-            }
-
-            if(graph_settings.orientation_vertical)
-                draw_spectrogram_vertical();
-            else
-                draw_spectrogram_horizontal();
-            break;
-        }
-    }
+/*********************** Plotting functions (modes) ************************/
 
-    if(show_message_tick != 0)
-    {
-        if(TIME_BEFORE(*rb->current_tick, show_message_tick))
-        {
-                /* We have a message to show */
-            draw_message_string(last_message, true);
-        }
-        else
-        {
-            /* Stop drawing message */
-            show_message_tick = 0;
-        }
-    }
-    else if(last_message != NULL)
-    {
-        if(graph_settings.mode == FFT_DM_SPECTROGRAPH)
-        {
-                /* Spectrogram mode - need to erase the popup */
-                        int x, y;
-                        mylcd_getstringsize(last_message, &x, &y);
-                        /* Recalculate the size */
-                        x += POPUP_HPADDING*2;
-                        y += POPUP_VPADDING*2;
-
-                        if(!graph_settings.orientation_vertical)
-                        {
-                                /* In horizontal spectrogram mode, just scroll up by Y lines */
-                                mylcd_scroll_up(y);
-                                graph_settings.spectrogram_pos -= y;
-                                if(graph_settings.spectrogram_pos < 0)
-                                        graph_settings.spectrogram_pos = 0;
-                        }
-                        else
-                        {
-                                /* In vertical spectrogram mode, erase the popup */
-                mylcd_set_foreground(COLOR_DEFAULT_BG);
-                                mylcd_fillrect(graph_settings.spectrogram_pos + 1, 0,
-                               LCD_WIDTH, y);
-                mylcd_set_foreground(COLOR_DEFAULT_FG);
-                        }
-        }
-        /* else These modes clear the screen themselves */
-                        
-        last_message = NULL;
-    }
-
-    mylcd_update();
-
-    graph_settings.changed.clear_all = false;
-}
-
-static void draw_lines_vertical(void)
+static void draw_lines_vertical(unsigned this_max, unsigned graph_max)
 {
-    static int max = 0;
-
 #if LCD_WIDTH < ARRAYLEN_PLOT /* graph compression */
     const int offset = 0;
     const int plotwidth = LCD_WIDTH;
@@ -813,13 +702,7 @@ static void draw_lines_vertical(void)
     const int plotwidth = ARRAYLEN_PLOT;
 #endif
 
-    int this_max;
-    int i, x;
-
-    if(graph_settings.changed.amp_scale)
-        max = 0; /* reset the graph on scaling mode change */
-
-    this_max = calc_magnitudes(graph_settings.logarithmic_amp);
+    mylcd_clear_display();
 
     if(this_max == 0)
     {
@@ -827,21 +710,16 @@ static void draw_lines_vertical(void)
         return;
     }
 
-    if(graph_settings.logarithmic_freq)
-        logarithmic_plot_translate();
-
-    /* take the maximum of neighboring bins if we have to scale the graph
-     * horizontally */
+    /* take the maximum of neighboring bins if we have to scale down the
+     * graph horizontally */
     if(LCD_WIDTH < ARRAYLEN_PLOT) /* graph compression */
     {
         int bins_acc = LCD_WIDTH / 2;
-        int bins_max = 0;
+        unsigned bins_max = 0;
         
-        i = 0, x = 0;
-
-        for(;;)
+        for(int i = 0, x = 0; i < ARRAYLEN_PLOT; ++i)
         {
-            int bin = plot[i++];
+            unsigned bin = plot[i];
 
             if(bin > bins_max)
                 bins_max = bin;
@@ -850,14 +728,10 @@ static void draw_lines_vertical(void)
 
             if(bins_acc >= ARRAYLEN_PLOT)
             {
-                plot[x] = bins_max;
-                
-                if(bins_max > max)
-                    max = bins_max;
-
-                if(++x >= LCD_WIDTH)
-                    break;
+                int h = LCD_HEIGHT*bins_max / graph_max;
+                mylcd_vline(x, LCD_HEIGHT - h, LCD_HEIGHT-1);
 
+                x++;
                 bins_acc -= ARRAYLEN_PLOT;
                 bins_max = 0;
             }
@@ -865,21 +739,16 @@ static void draw_lines_vertical(void)
     }
     else
     {
-        if(this_max > max)
-            max = this_max;
-    }
-
-    for(x = 0; x < plotwidth; ++x)
-    {
-        int h = LCD_HEIGHT*plot[x] / max;
-        mylcd_vline(x + offset, LCD_HEIGHT - h, LCD_HEIGHT-1);
+        for(int i = 0; i < plotwidth; ++i)
+        {
+            int h = LCD_HEIGHT*plot[i] / graph_max;
+            mylcd_vline(i + offset, LCD_HEIGHT - h, LCD_HEIGHT-1);
+        }
     }
 }
 
-static void draw_lines_horizontal(void)
+static void draw_lines_horizontal(unsigned this_max, unsigned graph_max)
 {
-    static int max = 0;
-
 #if LCD_WIDTH < ARRAYLEN_PLOT /* graph compression */
     const int offset = 0;
     const int plotwidth = LCD_HEIGHT;
@@ -888,13 +757,7 @@ static void draw_lines_horizontal(void)
     const int plotwidth = ARRAYLEN_PLOT;
 #endif
 
-    int this_max;
-    int y;
-
-    if(graph_settings.changed.amp_scale)
-        max = 0; /* reset the graph on scaling mode change */
-
-    this_max = calc_magnitudes(graph_settings.logarithmic_amp);
+    mylcd_clear_display();
 
     if(this_max == 0)
     {
@@ -902,38 +765,28 @@ static void draw_lines_horizontal(void)
         return;
     }
 
-    if(graph_settings.logarithmic_freq)
-        logarithmic_plot_translate();
-
     /* take the maximum of neighboring bins if we have to scale the graph
      * horizontally */
     if(LCD_HEIGHT < ARRAYLEN_PLOT) /* graph compression */
     {
         int bins_acc = LCD_HEIGHT / 2;
-        int bins_max = 0;
-        int i = 0;
-
-        y = 0;
+        unsigned bins_max = 0;
 
-        for(;;)
+        for(int i = 0, y = 0; i < ARRAYLEN_PLOT; ++i)
         {
-            int bin = plot[i++];
+            unsigned bin = plot[i];
 
-            if (bin > bins_max)
+            if(bin > bins_max)
                 bins_max = bin;
 
             bins_acc += LCD_HEIGHT;
 
             if(bins_acc >= ARRAYLEN_PLOT)
             {
-                plot[y] = bins_max;
-
-                if(bins_max > max)
-                    max = bins_max;
-
-                if(++y >= LCD_HEIGHT)
-                    break;
+                int w = LCD_WIDTH*bins_max / graph_max;
+                mylcd_hline(0, w - 1, y);
 
+                y++;
                 bins_acc -= ARRAYLEN_PLOT;
                 bins_max = 0;
             }
@@ -941,21 +794,16 @@ static void draw_lines_horizontal(void)
     }
     else
     {
-        if(this_max > max)
-            max = this_max;
-    }
-
-    for(y = 0; y < plotwidth; ++y)
-    {
-        int w = LCD_WIDTH*plot[y] / max;
-        mylcd_hline(0, w - 1, y + offset);
+        for(int i = 0; i < plotwidth; ++i)
+        {
+            int w = LCD_WIDTH*plot[i] / graph_max;
+            mylcd_hline(0, w - 1, i + offset);
+        }
     }
 }
 
-static void draw_bars_vertical(void)
+static void draw_bars_vertical(unsigned this_max, unsigned graph_max)
 {
-    static int max = 0;
-
 #if LCD_WIDTH < LCD_HEIGHT
     const int bars = 15;
 #else
@@ -964,26 +812,20 @@ static void draw_bars_vertical(void)
     const int border = 2;
     const int barwidth = LCD_WIDTH / (bars + border);
     const int width = barwidth - border;
-    const int offset = (LCD_WIDTH - bars*barwidth) / 2;
-
-    if(graph_settings.changed.amp_scale)
-        max = 0; /* reset the graph on scaling mode change */
+    const int offset = (LCD_WIDTH - bars*barwidth + border) / 2;
 
+    mylcd_clear_display();
     mylcd_hline(0, LCD_WIDTH-1, LCD_HEIGHT-1); /* Draw baseline */
 
-    if(calc_magnitudes(graph_settings.logarithmic_amp) == 0)
+    if(this_max == 0)
         return; /* nothing more to draw */
 
-    if(graph_settings.logarithmic_freq)
-        logarithmic_plot_translate();
-
     int bins_acc = bars / 2;
-    int bins_max = 0;
-    int x = 0, i = 0;
+    unsigned bins_max = 0;
 
-    for(;;)
+    for(int i = 0, x = offset;; ++i)
     {
-        int bin = plot[i++];
+        unsigned bin = plot[i];
 
         if(bin > bins_max)
             bins_max = bin;
@@ -992,30 +834,21 @@ static void draw_bars_vertical(void)
 
         if(bins_acc >= ARRAYLEN_PLOT)
         {
-            plot[x] = bins_max;
+            int h = LCD_HEIGHT*bins_max / graph_max;
+            mylcd_fillrect(x, LCD_HEIGHT - h, width, h - 1);
 
-            if(bins_max > max)
-                max = bins_max;
-
-            if(++x >= bars)
+            if(i >= ARRAYLEN_PLOT-1)
                 break;
 
+            x += barwidth;
             bins_acc -= ARRAYLEN_PLOT;
             bins_max = 0;
         }
     }
-
-    for(i = 0, x = offset; i < bars; ++i, x += barwidth)
-    {
-        int h = LCD_HEIGHT * plot[i] / max;
-        mylcd_fillrect(x, LCD_HEIGHT - h, width, h - 1);
-    }
 }
 
-static void draw_bars_horizontal(void)
+static void draw_bars_horizontal(unsigned this_max, unsigned graph_max)
 {
-    static int max = 0;
-
 #if LCD_WIDTH < LCD_HEIGHT
     const int bars = 20;
 #else
@@ -1024,70 +857,56 @@ static void draw_bars_horizontal(void)
     const int border = 2;
     const int barwidth = LCD_HEIGHT / (bars + border);
     const int height = barwidth - border;
-    const int offset = (LCD_HEIGHT - bars*barwidth) / 2;
-
-    if(graph_settings.changed.amp_scale)
-        max = 0; /* reset the graph on scaling mode change */
+    const int offset = (LCD_HEIGHT - bars*barwidth + border) / 2;
 
+    mylcd_clear_display();
     mylcd_vline(0, 0, LCD_HEIGHT-1); /* Draw baseline */
 
-    if(calc_magnitudes(graph_settings.logarithmic_amp) == 0)
+    if(this_max == 0)
         return; /* nothing more to draw */
 
-    if(graph_settings.logarithmic_freq)
-        logarithmic_plot_translate();
-
     int bins_acc = bars / 2;
-    int bins_max = 0;
-    int y = 0, i = 0;
+    unsigned bins_max = 0;
 
-    for(;;)
+    for(int i = 0, y = offset;; ++i)
     {
-        int bin = plot[i++];
+        unsigned bin = plot[i];
 
-        if (bin > bins_max)
+        if(bin > bins_max)
             bins_max = bin;
 
         bins_acc += bars;
 
         if(bins_acc >= ARRAYLEN_PLOT)
         {
-            plot[y] = bins_max;
-
-            if(bins_max > max)
-                max = bins_max;
+            int w = LCD_WIDTH*bins_max / graph_max;
+            mylcd_fillrect(1, y, w, height);
 
-            if(++y >= bars)
+            if(i >= ARRAYLEN_PLOT-1)
                 break;
 
+            y += barwidth;
             bins_acc -= ARRAYLEN_PLOT;
             bins_max = 0;
         }
     }
-
-    for(i = 0, y = offset; i < bars; ++i, y += barwidth)
-    {
-        int w = LCD_WIDTH * plot[i] / max;
-        mylcd_fillrect(1, y, w, height);
-    }
 }
 
-static void draw_spectrogram_vertical(void)
+static void draw_spectrogram_vertical(unsigned this_max, unsigned graph_max)
 {
-    const int32_t scale_factor = MIN(LCD_HEIGHT, ARRAYLEN_PLOT);
-
-    calc_magnitudes(graph_settings.logarithmic_amp);
+    const int scale_factor = MIN(LCD_HEIGHT, ARRAYLEN_PLOT);
 
-    if(graph_settings.logarithmic_freq)
-        logarithmic_plot_translate();
+    if(fft_spectrogram_pos < LCD_WIDTH-1)
+        fft_spectrogram_pos++;
+    else
+        mylcd_scroll_left(1);
 
     int bins_acc = scale_factor / 2;
-    int bins_max = 0;
-    int y = 0, i = 0;
+    unsigned bins_max = 0;
 
-    for(;;)
+    for(int i = 0, y = LCD_HEIGHT-1;; ++i)
     {
-        int bin = plot[i++];
+        unsigned bin = plot[i];
 
         if(bin > bins_max)
             bins_max = bin;
@@ -1096,12 +915,7 @@ static void draw_spectrogram_vertical(void)
 
         if(bins_acc >= ARRAYLEN_PLOT)
         {
-            unsigned index;
-
-            if(graph_settings.logarithmic_amp)
-                index = (SHADES-1)*bins_max / QLOG_MAX;
-            else
-                index = (SHADES-1)*bins_max / QLIN_MAX;
+            unsigned index = (SHADES-1)*bins_max / graph_max;
 
             /* These happen because we exaggerate the graph a little for
              * linear mode */
@@ -1109,10 +923,9 @@ static void draw_spectrogram_vertical(void)
                 index = SHADES-1;
 
             mylcd_set_foreground(SPECTROGRAPH_PALETTE(index));
-            mylcd_drawpixel(graph_settings.spectrogram_pos,
-                            scale_factor-1 - y);
+            mylcd_drawpixel(fft_spectrogram_pos, y);
 
-            if(++y >= scale_factor)
+            if(--y < 0)
                 break;
 
             bins_acc -= ARRAYLEN_PLOT;
@@ -1120,28 +933,24 @@ static void draw_spectrogram_vertical(void)
         }
     }
 
-    if(graph_settings.spectrogram_pos < LCD_WIDTH-1)
-        graph_settings.spectrogram_pos++;
-    else
-        mylcd_scroll_left(1);
+    (void)this_max;
 }
 
-static void draw_spectrogram_horizontal(void)
+static void draw_spectrogram_horizontal(unsigned this_max, unsigned graph_max)
 {
-    const int32_t scale_factor = MIN(LCD_WIDTH, ARRAYLEN_PLOT);
+    const int scale_factor = MIN(LCD_WIDTH, ARRAYLEN_PLOT);
 
-    calc_magnitudes(graph_settings.logarithmic_amp);
-
-    if(graph_settings.logarithmic_freq)
-        logarithmic_plot_translate();
+    if(fft_spectrogram_pos < LCD_HEIGHT-1)
+        fft_spectrogram_pos++;
+    else
+        mylcd_scroll_up(1);
 
     int bins_acc = scale_factor / 2;
-    int bins_max = 0;
-    int x = 0, i = 0;
+    unsigned bins_max = 0;
 
-    for(;;)
+    for(int i = 0, x = 0;; ++i)
     {
-        int bin = plot[i++];
+        unsigned bin = plot[i];
 
         if(bin > bins_max)
             bins_max = bin;
@@ -1150,12 +959,7 @@ static void draw_spectrogram_horizontal(void)
 
         if(bins_acc >= ARRAYLEN_PLOT)
         {
-            unsigned index;
-
-            if(graph_settings.logarithmic_amp)
-                index = (SHADES-1)*bins_max / QLOG_MAX;
-            else
-                index = (SHADES-1)*bins_max / QLIN_MAX;
+            unsigned index = (SHADES-1)*bins_max / graph_max;
 
             /* These happen because we exaggerate the graph a little for
              * linear mode */
@@ -1163,9 +967,9 @@ static void draw_spectrogram_horizontal(void)
                 index = SHADES-1;
 
             mylcd_set_foreground(SPECTROGRAPH_PALETTE(index));
-            mylcd_drawpixel(x, graph_settings.spectrogram_pos);
+            mylcd_drawpixel(x, fft_spectrogram_pos);
 
-            if(++x >= scale_factor)
+            if(++x >= LCD_WIDTH)
                 break;
 
             bins_acc -= ARRAYLEN_PLOT;
@@ -1173,15 +977,14 @@ static void draw_spectrogram_horizontal(void)
         }
     }
 
-    if(graph_settings.spectrogram_pos < LCD_HEIGHT-1)
-        graph_settings.spectrogram_pos++;
-    else
-        mylcd_scroll_up(1);
+    (void)this_max;
 }
 
-/********************* End of plotting functions (modes) *********************/
+/******************** End of plotting functions (modes) ********************/
+
+
+/***************************** FFT functions *******************************/
 
-/****************************** FFT functions ********************************/
 static bool is_playing(void)
 {
     return rb->mixer_channel_status(PCM_MIXER_CHAN_PLAYBACK) == CHANNEL_PLAYING;
@@ -1232,7 +1035,7 @@ static inline bool fft_get_fft(void)
         input[fft_idx].r = (left + right) >> 1; /* to mono */
     } while (fft_idx++, --count > 0);
 
-    apply_window_func(graph_settings.window_func);
+    apply_window_func(fft.window_func);
 
     rb->yield();
 
@@ -1246,14 +1049,14 @@ static inline bool fft_get_fft(void)
 #if NUM_CORES > 1
 /* use a worker thread if there is another processor core */
 static volatile bool fft_thread_run SHAREDDATA_ATTR = false;
-static unsigned long fft_thread;
+static unsigned long fft_thread = 0;
 
 static long fft_thread_stack[CACHEALIGN_UP(DEFAULT_STACK_SIZE*4/sizeof(long))]
                              CACHEALIGN_AT_LEAST_ATTR(4);
 
 static void fft_thread_entry(void)
 {
-    if (!fft_init_fft_lib())
+    if(!fft_init_fft_lib())
     {
         output_tail = -1; /* tell that we bailed */
         fft_thread_run = true;
@@ -1276,7 +1079,8 @@ static void fft_thread_entry(void)
             continue;
         }
 
-        /* write back output for other processor and invalidate for next frame read */
+        /* write back output for other processor and invalidate for next
+           frame read */
         rb->commit_discard_dcache();
 
         int new_tail = output_tail ^ 1;
@@ -1364,168 +1168,433 @@ static inline void fft_close_fft(void)
     /* nothing to do */
 }
 #endif /* NUM_CORES */
-/*************************** End of FFT functions ****************************/
 
-enum plugin_status plugin_start(const void* parameter)
+/************************** End of FFT functions ***************************/
+
+
+/****************************** OSD functions ******************************/
+
+/* Format a message to display */
+static void fft_osd_format_message(enum fft_setting_flags id)
 {
-    /* Defaults */
-    bool run = true;
-    bool showing_warning = false;
+    const char *msg = "";
 
-    if (!fft_init_fft())
-        return PLUGIN_ERROR;
+    switch (id)
+    {
+    case FFT_SETF_DM:
+        msg = (const char * [FFT_MAX_DM]) {
+                [FFT_DM_LINES]       = "Lines",
+                [FFT_DM_BARS]        = "Bars",
+                [FFT_DM_SPECTROGRAM] = "Spectrogram",
+            }[fft.drawmode];
+        break;
+
+    case FFT_SETF_WF:
+        msg = (const char * [FFT_MAX_WF]) {
+                [FFT_WF_HAMMING] = "Hamming window",
+                [FFT_WF_HANN]    = "Hann window",
+            }[fft.window_func];
+        break;
+
+    case FFT_SETF_AS:
+        msg = (const char * [FFT_MAX_AS]) {
+                [FFT_AS_LOG] = "Logarithmic amplitude",
+                [FFT_AS_LIN] = "Linear amplitude"
+            }[fft.amp_scale];
+        break;
+
+#ifdef FFT_FREQ_SCALE /* 'Till all keymaps are defined */
+    case FFT_SETF_FS:
+        msg = (const char * [FFT_MAX_FS]) {
+                [FFT_FS_LOG] = "Logarithmic frequency",
+                [FFT_FS_LIN] = "Linear frequency",
+            }[fft.freq_scale];
+        break;
+#endif
+
+    case FFT_SETF_OR:
+        rb->snprintf(fft_osd_message, sizeof (fft_osd_message),
+                     (const char * [FFT_MAX_OR]) {
+                        [FFT_OR_VERT] = "Vertical %s",
+                        [FFT_OR_HORZ] = "Horizontal %s",
+                     }[fft.orientation],
+                     (const char * [FFT_MAX_DM]) {
+                        [FFT_DM_LINES ... FFT_DM_BARS] = "amplitude",
+                        [FFT_DM_SPECTROGRAM] = "frequency"
+                     }[fft.drawmode]);
+        return;
+
+#if 0
+    /* Pertentially */
+    case FFT_SETF_VOLUME:
+        rb->snprintf(fft_osd_message, sizeof (fft_osd_message),
+                     "Volume: %d%s",
+                     rb->sound_val2phys(SOUND_VOLUME, global_settings.volume),
+                     rb->sound_unit(SOUND_VOLUME));
+        return;
+#endif
+
+    default:
+        break;
+    }
+
+    /* Default action: copy string */
+    rb->strlcpy(fft_osd_message, msg, sizeof (fft_osd_message));
+}
+
+static void fft_osd_draw_cb(int x, int y, int width, int height)
+{
+#if LCD_DEPTH > 1
+    mylcd_set_foreground(COLOR_MESSAGE_FG);
+    mylcd_set_background(COLOR_MESSAGE_BG);
+#endif
+#if FFT_OSD_MARGIN_SIZE != 0
+    mylcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
+    mylcd_fillrect(1, 1, width - 2, height - 2);
+    mylcd_set_drawmode(DRMODE_SOLID);
+#endif
+    mylcd_putsxy(1+FFT_OSD_MARGIN_SIZE, 1+FFT_OSD_MARGIN_SIZE,
+                 fft_osd_message);
+#if LCD_DEPTH > 1
+    mylcd_set_foreground(COLOR_MESSAGE_FRAME);
+#endif
+
+    mylcd_drawrect(0, 0, width, height);
+
+    (void)x; (void)y;
+}
+
+static void fft_osd_show_message(enum fft_setting_flags id)
+{
+    fft_osd_format_message(id);
+
+    if(!myosd_enabled())
+        return;
+
+    int width, height;
+    int maxwidth, maxheight;
+
+    mylcd_set_viewport(myosd_get_viewport());
+    myosd_get_max_dims(&maxwidth, &maxheight);
+    mylcd_setfont(FONT_UI);
+    mylcd_getstringsize(fft_osd_message, &width, &height);
+    mylcd_set_viewport(NULL);
+
+    width += 2 + 2*FFT_OSD_MARGIN_SIZE;
+    if(width > maxwidth)
+        width = maxwidth;
+
+    height += 2 + 2*FFT_OSD_MARGIN_SIZE;
+    if(height > maxheight)
+        height = maxheight;
+
+    bool drawn = myosd_update_pos((LCD_WIDTH - width) / 2,
+                                  (LCD_HEIGHT - height) / 2,
+                                  width, height);
+
+    myosd_show(OSD_SHOW | (drawn ? 0 : OSD_UPDATENOW));
+}
+
+static void fft_popupmsg(enum fft_setting_flags id)
+{
+    fft_message_id = id;
+}
+
+/************************** End of OSD functions ***************************/
+
+
+static void fft_setting_update(unsigned which)
+{
+    static fft_drawfn_t fft_drawfns[FFT_MAX_DM][FFT_MAX_OR] =
+    {
+        [FFT_DM_LINES] =
+        {
+            [FFT_OR_HORZ] = draw_lines_horizontal,
+            [FFT_OR_VERT] = draw_lines_vertical,
+        },
+        [FFT_DM_BARS] =
+        {
+            [FFT_OR_HORZ] = draw_bars_horizontal,
+            [FFT_OR_VERT] = draw_bars_vertical,
+        },
+        [FFT_DM_SPECTROGRAM] = 
+        {
+            [FFT_OR_HORZ] = draw_spectrogram_horizontal,
+            [FFT_OR_VERT] = draw_spectrogram_vertical,
+        },
+    };
+
+    if(which & (FFT_SETF_DM | FFT_SETF_OR))
+    {
+        fft_drawfn = fft_drawfns[fft.drawmode]
+                                [fft.orientation];
+
+        if(fft.drawmode == FFT_DM_SPECTROGRAM)
+        {
+            fft_spectrogram_pos = -1;
+            myosd_lcd_update_prepare();
+            mylcd_clear_display();
+            myosd_lcd_update();
+        }
+    }
+
+    if(which & (FFT_SETF_DM | FFT_SETF_AS))
+    {
+        if(fft.drawmode == FFT_DM_SPECTROGRAM)
+        {
+            fft_graph_scale = fft.amp_scale == FFT_AS_LIN ?
+                QLIN_MAX : QLOG_MAX;
+        }
+        else
+        {
+            fft_graph_scale = 0;
+        }
+    }
+
+#ifdef FFT_FREQ_SCALE /* 'Till all keymaps are defined */
+    if(which & FFT_SETF_FS)
+    {
+        plot = fft.freq_scale == FFT_FS_LIN ?
+                linf_magnitudes : logf_magnitudes;
+    }
+#endif
+
+    if(which & FFT_SETF_AS)
+    {
+        memset(linf_magnitudes, 0, sizeof (linf_magnitudes));
+        memset(logf_magnitudes, 0, sizeof (logf_magnitudes));
+    }
+}
+
+static long fft_draw(void)
+{
+    long tick = *rb->current_tick;
+
+    if(fft_message_id != -1)
+    {
+        /* Show a new message */
+        fft_osd_show_message((enum fft_setting_flags)fft_message_id);
+        fft_message_id = -1;
+    }
+    else
+    {
+        /* Monitor OSD timeout */
+        myosd_monitor_timeout();
+    }
+
+    if(TIME_BEFORE(tick, fft_next_frame_tick))
+        return fft_next_frame_tick - tick; /* Too early */
+
+    unsigned this_max;
+
+    if(!fft_have_fft())
+    {
+        if(is_playing())
+            return HZ/100;
+
+        /* All magnitudes == 0 thus this_max == 0 */
+        for(int i = 0; i < ARRAYLEN_PLOT; i++)
+            linf_magnitudes[i] >>= 1; /* decay */
 
+        this_max = 0;
+    }
+    else
+    {
+        this_max = calc_magnitudes(fft.amp_scale);
+
+        fft_free_fft_output(); /* COP only */
+
+        if(fft.drawmode != FFT_DM_SPECTROGRAM &&
+           this_max > fft_graph_scale)
+        {
+            fft_graph_scale = this_max;
+        }
+    }
+
+    if (fft.freq_scale == FFT_FS_LOG)
+        log_plot_translate();
+
+    myosd_lcd_update_prepare();
+
+    mylcd_set_foreground(COLOR_DEFAULT_FG);
+    mylcd_set_background(COLOR_DEFAULT_BG);
+
+    fft_drawfn(this_max, fft_graph_scale);
+
+    myosd_lcd_update();
+
+    fft_next_frame_tick = tick + FFT_PERIOD;
+    return fft_next_frame_tick - *rb->current_tick;
+}
+
+static void fft_osd_init(void *buf, size_t bufsize)
+{
+    int width, height;
+    mylcd_setfont(FONT_UI);
+    mylcd_getstringsize("M", NULL, &height);
+    width = LCD_WIDTH;
+    height += 2 + 2*FFT_OSD_MARGIN_SIZE;
+    myosd_init(OSD_INIT_MAJOR_HEIGHT | OSD_INIT_MINOR_MAX, buf, bufsize,
+               fft_osd_draw_cb, &width, &height, NULL);
+    myosd_set_timeout(HZ);
+}
+
+static void fft_cleanup(void)
+{
+    myosd_destroy();
+
+    fft_close_fft();    
+
+#ifdef HAVE_ADJUSTABLE_CPU_FREQ
+    rb->cancel_cpu_boost();
+#endif
 #ifndef HAVE_LCD_COLOR
-    unsigned char *gbuf;
-    size_t  gbuf_size = 0;
-    /* get the remainder of the plugin buffer */
-    gbuf = (unsigned char *) rb->plugin_get_buffer(&gbuf_size);
+    grey_release();
+#endif
+    backlight_use_settings();
+
+    /* save settings if changed */
+    if (rb->memcmp(&fft, &fft_disk, sizeof(fft)))
+    {
+        fft_disk = fft;
+        configfile_save(cfg_filename, disk_config, ARRAYLEN(disk_config),
+                        CFGFILE_VERSION);
+    }
+}
+
+static bool fft_setup(void)
+{
+    atexit(fft_cleanup);
 
+    configfile_load(cfg_filename, disk_config, ARRAYLEN(disk_config),
+                    CFGFILE_MINVERSION);
+    fft = fft_disk; /* copy to running config */
+
+    if(!fft_init_fft())
+        return false;
+
+    /* get the remainder of the plugin buffer for OSD and perhaps
+       greylib */
+    size_t bufsize = 0;
+    unsigned char *buf = rb->plugin_get_buffer(&bufsize);
+
+#ifndef HAVE_LCD_COLOR
     /* initialize the greyscale buffer.*/
-    if (!grey_init(gbuf, gbuf_size, GREY_ON_COP | GREY_BUFFERED,
-                   LCD_WIDTH, LCD_HEIGHT, NULL))
+    long grey_size;
+    if(!grey_init(buf, bufsize, GREY_ON_COP | GREY_BUFFERED,
+                  LCD_WIDTH, LCD_HEIGHT, &grey_size))
     {
         rb->splash(HZ, "Couldn't init greyscale display");
-        fft_close_fft();
-        return PLUGIN_ERROR;
+        return false;
     }
-    grey_show(true); 
-#endif
 
-    logarithmic_plot_init();
+    grey_show(true);
+
+    buf += grey_size;
+    bufsize -= grey_size;
+#endif /* !HAVE_LCD_COLOR */
+
+    fft_osd_init(buf, bufsize);
 
 #if LCD_DEPTH > 1
+    myosd_lcd_update_prepare();
     rb->lcd_set_backdrop(NULL);
     mylcd_clear_display();
-    mylcd_update();
+    myosd_lcd_update();
 #endif
     backlight_ignore_timeout();
 
 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
-    rb->cpu_boost(true);
+    rb->trigger_cpu_boost();
 #endif
 
-    while (run)
-    {
-        /* Unless otherwise specified, HZ/50 is around the window length
-         * and quite fast. We want to be done with drawing by this time. */
-        long next_frame_tick = *rb->current_tick + HZ/50;
-        int button;
-
-        while (!fft_have_fft())
-                {
-            int timeout;
-
-            if(!is_playing())
-            {
-                showing_warning = true;
-                mylcd_clear_display();
-                draw_message_string("No audio playing", false);
-                mylcd_update();
-                timeout = HZ/5;
-            }
-            else
-            {
-                if(showing_warning)
-                {
-                    showing_warning = false;
-                    mylcd_clear_display();
-                    mylcd_update();
-                }
+    logarithmic_plot_init();
+    fft_setting_update(FFT_SETF_ALL);
+    fft_next_frame_tick = *rb->current_tick;
 
-                timeout = HZ/100; /* 'till end of curent tick, don't use 100% CPU */
-            }
+    return true;
+}
 
-            /* Make sure the FFT has produced something before doing anything
-             * but watching for buttons. Music might not be playing or things
-             * just aren't going well for picking up buffers so keys are
-             * scanned to avoid lockup.  */
-             button = rb->button_get_w_tmo(timeout);
-             if (button != BUTTON_NONE)
-                 goto read_button;
-                }
+enum plugin_status plugin_start(const void* parameter)
+{
+    bool run = true;
 
-            draw(NULL);
+    if(!fft_setup())
+        return PLUGIN_ERROR;
 
-        fft_free_fft_output(); /* COP only */
+    while(run)
+    {
+            long delay = fft_draw();
 
-        long tick = *rb->current_tick;
-        if(TIME_BEFORE(tick, next_frame_tick))
-        {
-            tick = next_frame_tick - tick;
-        }
-        else
+        if(delay <= 0)
         {
+            delay = 0;
             rb->yield(); /* tmo = 0 won't yield */
-            tick = 0;
         }
 
-                button = rb->button_get_w_tmo(tick);
-    read_button:
+                int button = rb->button_get_w_tmo(delay);
+
         switch (button)
         {
             case FFT_QUIT:
                 run = false;
                 break;
-            case FFT_PREV_GRAPH: {
-                if (graph_settings.mode-- <= FFT_DM_FIRST)
-                    graph_settings.mode = FFT_DM_COUNT-1;
-                graph_settings.changed.mode = true;
-                draw(modes_text[graph_settings.mode]);
+
+            case FFT_ORIENTATION:
+                if (++fft.orientation >= FFT_MAX_OR)
+                    fft.orientation = FFT_MIN_OR;
+
+                fft_setting_update(FFT_SETF_OR);
+                fft_popupmsg(FFT_SETF_OR);
                 break;
-            }
-            case FFT_NEXT_GRAPH: {
-                if (++graph_settings.mode >= FFT_DM_COUNT)
-                    graph_settings.mode = FFT_DM_FIRST;
-                graph_settings.changed.mode = true;
-                draw(modes_text[graph_settings.mode]);
+
+            case FFT_PREV_GRAPH:
+                if (fft.drawmode-- <= FFT_MIN_DM)
+                    fft.drawmode = FFT_MAX_DM-1;
+
+                fft_setting_update(FFT_SETF_DM);
+                fft_popupmsg(FFT_SETF_DM);
                 break;
-            }
-            case FFT_WINDOW: {
-                if(++graph_settings.window_func >= FFT_WF_COUNT)
-                    graph_settings.window_func = FFT_WF_FIRST;
-                graph_settings.changed.window_func = true;
-                draw(window_text[graph_settings.window_func]);
+
+            case FFT_NEXT_GRAPH:
+                if (++fft.drawmode >= FFT_MAX_DM)
+                    fft.drawmode = FFT_MIN_DM;
+
+                fft_setting_update(FFT_SETF_DM);
+                fft_popupmsg(FFT_SETF_DM);
                 break;
-            }
-            case FFT_AMP_SCALE: {
-                graph_settings.logarithmic_amp = !graph_settings.logarithmic_amp;
-                graph_settings.changed.amp_scale = true;
-                draw(amp_scales_text[graph_settings.logarithmic_amp ? 1 : 0]);
+
+            case FFT_AMP_SCALE:
+                if (++fft.amp_scale >= FFT_MAX_AS)
+                    fft.amp_scale = FFT_MIN_AS;
+
+                fft_setting_update(FFT_SETF_AS);
+                fft_popupmsg(FFT_SETF_AS);
                 break;
-            }
+
 #ifdef FFT_FREQ_SCALE /* 'Till all keymaps are defined */
-            case FFT_FREQ_SCALE: {
-                graph_settings.logarithmic_freq = !graph_settings.logarithmic_freq;
-                graph_settings.changed.freq_scale = true;
-                draw(freq_scales_text[graph_settings.logarithmic_freq ? 1 : 0]);
+            case FFT_FREQ_SCALE:
+                if (++fft.freq_scale >= FFT_MAX_FS)
+                    fft.freq_scale = FFT_MIN_FS;
+
+                fft_setting_update(FFT_SETF_FS);
+                fft_popupmsg(FFT_SETF_FS);
                 break;
-            }
 #endif
-            case FFT_ORIENTATION: {
-                graph_settings.orientation_vertical =
-                    !graph_settings.orientation_vertical;
-                graph_settings.changed.orientation = true;
-                draw(NULL);
+            case FFT_WINDOW:
+                if(++fft.window_func >= FFT_MAX_WF)
+                    fft.window_func = FFT_MIN_WF;
+
+                fft_setting_update(FFT_SETF_WF);
+                fft_popupmsg(FFT_SETF_WF);
                 break;
-            }
-            default: {
-                if (rb->default_event_handler(button) == SYS_USB_CONNECTED)
-                    return PLUGIN_USB_CONNECTED;
-            }
 
+            default:
+                exit_on_usb(button);
+                break;
         }
     }
 
-    fft_close_fft();    
-
-#ifdef HAVE_ADJUSTABLE_CPU_FREQ
-    rb->cpu_boost(false);
-#endif
-#ifndef HAVE_LCD_COLOR
-    grey_release();
-#endif
-    backlight_use_settings();
     return PLUGIN_OK;
     (void)parameter;
 }