12 files changed, 307 insertions, 375 deletions

diff --git a/apps/codecs.h b/apps/codecs.h
index 4a4ccb229c..47cd5711ae 100644
--- a/apps/codecs.h
+++ b/apps/codecs.h
@@ -79,12 +79,12 @@
 #endif
 
 /* increase this every time the api struct changes */
-#define CODEC_API_VERSION 41
+#define CODEC_API_VERSION 42
 
 /* update this to latest version if a change to the api struct breaks
-   backwards compatibility (and please take the opportunity to sort in any 
+   backwards compatibility (and please take the opportunity to sort in any
    new function which are "waiting" at the end of the function table) */
-#define CODEC_MIN_API_VERSION 40
+#define CODEC_MIN_API_VERSION 42
 
 /* codec return codes */
 enum codec_status {
@@ -314,8 +314,8 @@ struct codec_api {
 #if (CONFIG_HWCODEC == MAS3587F) || (CONFIG_HWCODEC == MAS3539F)
     unsigned short (*peak_meter_scale_value)(unsigned short val,
                                              int meterwidth);
-    void (*peak_meter_set_use_dbfs)(int use);
-    int (*peak_meter_get_use_dbfs)(void);
+    void (*peak_meter_set_use_dbfs)(bool use);
+    bool (*peak_meter_get_use_dbfs)(void);
 #endif
 
     /* new stuff at the end, sort into place next time
diff --git a/apps/lang/english.lang b/apps/lang/english.lang
index 75601c858b..6feac25ee8 100644
--- a/apps/lang/english.lang
+++ b/apps/lang/english.lang
@@ -878,21 +878,21 @@ voice: "Numeric"
 new:
 
 id: LANG_PM_PERFORMANCE
-desc: in the peak meter menu
-eng: "Performance"
-voice: "Performance"
+desc: DEPRECATED
+eng: ""
+voice:
 new:
 
 id: LANG_PM_HIGH_PERFORMANCE
-desc: in the peak meter menu
-eng: "High performance"
-voice: "High performance"
+desc: DEPRECATED
+eng: ""
+voice: ""
 new:
 
 id: LANG_PM_ENERGY_SAVER
-desc: in the peak meter menu
-eng: "Save Energy"
-voice: "Save Energy"
+desc: DEPRECATED
+eng: ""
+voice: ""
 new:
 
 id: LANG_PM_SCALE
diff --git a/apps/plugin.h b/apps/plugin.h
index 7cda354808..8760162405 100644
--- a/apps/plugin.h
+++ b/apps/plugin.h
@@ -88,12 +88,12 @@
 #endif
 
 /* increase this every time the api struct changes */
-#define PLUGIN_API_VERSION 47
+#define PLUGIN_API_VERSION 48
 
 /* update this to latest version if a change to the api struct breaks
    backwards compatibility (and please take the opportunity to sort in any 
    new function which are "waiting" at the end of the function table) */
-#define PLUGIN_MIN_API_VERSION 47
+#define PLUGIN_MIN_API_VERSION 48
 
 /* plugin return codes */
 enum plugin_status {
@@ -413,8 +413,8 @@ struct plugin_api {
 #if (CONFIG_HWCODEC == MAS3587F) || (CONFIG_HWCODEC == MAS3539F)
     unsigned short (*peak_meter_scale_value)(unsigned short val,
                                              int meterwidth);
-    void (*peak_meter_set_use_dbfs)(int use);
-    int (*peak_meter_get_use_dbfs)(void);
+    void (*peak_meter_set_use_dbfs)(bool use);
+    bool (*peak_meter_get_use_dbfs)(void);
 #endif
 #ifdef HAVE_LCD_BITMAP
     int (*read_bmp_file)(char* filename, int *get_width, int *get_height,
diff --git a/apps/plugins/splitedit.c b/apps/plugins/splitedit.c
index 142590d9e8..9317419c23 100644
--- a/apps/plugins/splitedit.c
+++ b/apps/plugins/splitedit.c
@@ -271,7 +271,7 @@ static void update_icons(void)
 
 #if (CONFIG_HWCODEC == MAS3587F) || (CONFIG_HWCODEC == MAS3539F)
     /* The scale icon */
-    rb->lcd_mono_bitmap(SCALE_BMP[rb->peak_meter_get_use_dbfs()],
+    rb->lcd_mono_bitmap(SCALE_BMP[rb->peak_meter_get_use_dbfs() ? 1 : 0],
         2 *LCD_WIDTH/3 + LCD_WIDTH/3 / 2 - BMPWIDTH/2, LCD_HEIGHT - BMPHEIGHT,
         BMPWIDTH, BMPHEIGHT);
 #else
@@ -1134,7 +1134,7 @@ unsigned long splitedit_editor(struct mp3entry * mp3_to_split,
 
             case SPLITEDIT_SCALE:
 #if (CONFIG_HWCODEC == MAS3587F) || (CONFIG_HWCODEC == MAS3539F)
-                rb->peak_meter_set_use_dbfs(rb->peak_meter_get_use_dbfs() +1);
+                rb->peak_meter_set_use_dbfs(!rb->peak_meter_get_use_dbfs());
 #endif
                 splitedit_invalidate_osci();
                 update_icons();
diff --git a/apps/recorder/peakmeter.c b/apps/recorder/peakmeter.c
index 002a3c48d5..088cf8e099 100644
--- a/apps/recorder/peakmeter.c
+++ b/apps/recorder/peakmeter.c
@@ -21,6 +21,7 @@
 #include "thread.h"
 #include "kernel.h"
 #include "settings.h"
+#include "ata.h"
 #include "lcd.h"
 #include "widgets.h"
 #include "wps-display.h"
@@ -36,41 +37,48 @@
 #include "pcm_playback.h"
 #endif
 
-/* no inline in simulator mode */
-#ifdef SIMULATOR
-#define inline
+#if !defined(SIMULATOR) && CONFIG_HWCODEC != MASNONE
+/* Data source */
+static int pm_src_left = MAS_REG_DQPEAK_L;
+static int pm_src_right = MAS_REG_DQPEAK_R;
 #endif
 
-/* buffer the read peak value */
-static int peak_meter_max_l;
-static int peak_meter_max_r;
-
-/* point in time when peak_meter_max_x becomes invalid */
-static long peak_meter_timeout_l;
-static long peak_meter_timeout_r;
-
-/* when true a clip has occurred */
-static bool peak_meter_l_clip = false;
-static bool peak_meter_r_clip = false;
-
-/* point in time when peak_meter_x_oveflow becomes invalid */
-static long peak_meter_clip_timeout_l;
-static long peak_meter_clip_timeout_r;
-
-static int  peak_meter_clip_hold;
-
-/* specifies the value range in peak volume values */
-unsigned short peak_meter_range_min;
-unsigned short peak_meter_range_max;
-static unsigned short peak_meter_range;
-
-/* if set to true clip timeout is disabled */
-static bool peak_meter_clip_eternal = false;
+/* Current values and cumulation */
+static int pm_cur_left;        /* current values (last peak_meter_peek) */
+static int pm_cur_right;
+static int pm_max_left;        /* maximum values between peak meter draws */
+static int pm_max_right;
+
+/* Peak hold */
+static int pm_peak_left;       /* buffered peak values */
+static int pm_peak_right;
+static long pm_peak_timeout_l; /* peak hold timeouts */
+static long pm_peak_timeout_r;
+
+/* Clip hold */
+static bool pm_clip_left = false;  /* when true a clip has occurred */
+static bool pm_clip_right = false;
+static long pm_clip_timeout_l;     /* clip hold timeouts */
+static long pm_clip_timeout_r;
+
+/* Temporarily en- / disables peak meter. This is especially for external
+   applications to detect if the peak_meter is in use and needs drawing at all */
+bool peak_meter_enabled = true;
 
-static bool peak_meter_use_dbfs = true;
-static unsigned short db_min = 0;
-static unsigned short db_max = 9000;
-static unsigned short db_range = 9000;
+/** Parameters **/
+/* Range */
+unsigned short peak_meter_range_min;  /* minimum of range in samples */
+unsigned short peak_meter_range_max;  /* maximum of range in samples */
+static unsigned short pm_range;       /* range width in samples */
+static bool pm_use_dbfs = true;       /* true if peakmeter displays dBfs */
+static unsigned short pm_db_min = 0;      /* minimum of range in 1/100 dB */
+static unsigned short pm_db_max = 9000;   /* maximum of range in 1/100 dB */
+static unsigned short pm_db_range = 9000; /* range width in 1/100 dB */
+/* Timing behaviour */
+static int pm_peak_hold = 1;          /* peak hold timeout index */
+static int pm_peak_release = 8;       /* peak release in units per read */
+static int pm_clip_hold = 16;         /* clip hold timeout index */
+static bool pm_clip_eternal = false;  /* true if clip timeout is disabled */
 
 #ifdef HAVE_RECORDING
 static unsigned short trig_strt_threshold;
@@ -92,34 +100,6 @@ static int trig_status = TRIG_OFF;
 static void (*trigger_listener)(int) = NULL;
 #endif
 
-#if CONFIG_HWCODEC == MASNONE
-#define MAS_REG_DQPEAK_L 0
-#define MAS_REG_DQPEAK_R 0
-#endif
-
-#if !defined(SIMULATOR) && CONFIG_HWCODEC != MASNONE
-static int peak_meter_src_l = MAS_REG_DQPEAK_L;
-static int peak_meter_src_r = MAS_REG_DQPEAK_R;
-#endif
-
-/* temporarily en- / disables peak meter. This is
-   especially for external applications to detect 
-   if the peak_meter is in use and needs drawing at all */
-bool peak_meter_enabled = true;
-
-/*
-bool peak_meter_use_thread = false;
-static char peak_meter_stack[DEFAULT_STACK_SIZE];
-*/
-/* used in wps.c to set the display frame rate of the peak meter */
-int peak_meter_fps = 20;
-
-static int peak_meter_l;
-static int peak_meter_r;
-
-static int peak_meter_hold = 1;
-static int peak_meter_release = 8;
-
 /* debug only */
 #ifdef PM_DEBUG
 static int peek_calls = 0;
@@ -132,7 +112,7 @@ static unsigned int ticks_per_redraw[TICKS_PER_DRAW_SIZE];
 #endif
 
 /* time out values for max */
-static const long max_time_out[] = {
+static const short peak_time_out[] = {
     0 * HZ, HZ / 5, 30, HZ / 2, HZ, 2 * HZ, 
     3 * HZ, 4 * HZ, 5 * HZ, 6 * HZ, 7 * HZ, 8 * HZ,
     9 * HZ, 10 * HZ, 15 * HZ, 20 * HZ, 30 * HZ, 60 * HZ
@@ -150,22 +130,6 @@ static const long clip_time_out[] = {
 /* precalculated peak values that represent magical
    dBfs values. Used to draw the scale */
 #define DB_SCALE_SRC_VALUES_SIZE 12
-#if 0
-static const int db_scale_src_values[DB_SCALE_SRC_VALUES_SIZE] = {
-    32767, /*   0 db */
-    23197, /* - 3 db */
-    16422, /* - 6 db */
-    11626, /* - 9 db */
-    8231,  /* -12 db */
-    4125,  /* -18 db */
-    2067,  /* -24 db */
-    1036,  /* -30 db */
-    328,   /* -40 db */
-    104,   /* -50 db */
-    33,    /* -60 db */
-    1,     /* -inf   */
-};
-#else
 static const int db_scale_src_values[DB_SCALE_SRC_VALUES_SIZE] = {
     32752, /*   0 db */
     22784, /* - 3 db */
@@ -180,11 +144,10 @@ static const int db_scale_src_values[DB_SCALE_SRC_VALUES_SIZE] = {
     33,    /* -60 db */
     0,     /* -inf   */
 };
-#endif
 
 static int db_scale_count = DB_SCALE_SRC_VALUES_SIZE;
 
-/* if db_scale_valid is false the content of 
+/* if db_scale_valid is false the content of
    db_scale_lcd_coord needs recalculation */
 static bool db_scale_valid = false;
 
@@ -211,7 +174,8 @@ static int db_scale_lcd_coord[sizeof db_scale_src_values / sizeof (int)];
  *               for-loops.
  */
 
-int calc_db (int isample) {
+int calc_db (int isample) 
+{
     /* return n+m*(isample-istart)/100 */
     int n;
     long m;
@@ -312,7 +276,8 @@ int calc_db (int isample) {
  *                  minimal peak sample is searched.
  * @return int - A linear volume value with 0 <= value < MAX_PEAK
  */
-static int db_to_sample_bin_search(int min, int max, int db){
+static int db_to_sample_bin_search(int min, int max, int db)
+{
     int test = min + (max - min) / 2;
 
     if (min < max) {
@@ -339,7 +304,8 @@ static int db_to_sample_bin_search(int min, int max, int db){
  * @return int - The return value is in the range of
  *               0 <= return value < MAX_PEAK
  */
-int peak_meter_db2sample(int db) {
+int peak_meter_db2sample(int db) 
+{
     int retval = 0;
 
     /* what is the maximum pseudo db value */
@@ -371,13 +337,14 @@ int peak_meter_db2sample(int db) {
 
 /**
  * Set the min value for restriction of the value range.
- * @param int newmin - depending wether dBfs is used
+ * @param int newmin - depending whether dBfs is used
  * newmin is a value in dBfs * 100 or in linear percent values.
  * for dBfs: -9000 < newmin <= 0
  * for linear: 0 <= newmin <= 100
  */
-void peak_meter_set_min(int newmin) {
-    if (peak_meter_use_dbfs) {
+void peak_meter_set_min(int newmin) 
+{
+    if (pm_use_dbfs) {
         peak_meter_range_min = peak_meter_db2sample(newmin);
 
     } else {
@@ -386,10 +353,10 @@ void peak_meter_set_min(int newmin) {
         }
     }
 
-    peak_meter_range = peak_meter_range_max - peak_meter_range_min;
+    pm_range = peak_meter_range_max - peak_meter_range_min;
 
-    db_min = calc_db(peak_meter_range_min);
-    db_range = db_max - db_min;
+    pm_db_min = calc_db(peak_meter_range_min);
+    pm_db_range = pm_db_max - pm_db_min;
     db_scale_valid = false;
 }
 
@@ -400,9 +367,10 @@ void peak_meter_set_min(int newmin) {
  * @return: using dBfs : -9000 < value <= 0
  *          using linear scale: 0 <= value <= 100
  */
-int peak_meter_get_min(void) {
+int peak_meter_get_min(void) 
+{
     int retval = 0;
-    if (peak_meter_use_dbfs) {
+    if (pm_use_dbfs) {
         retval = calc_db(peak_meter_range_min) - calc_db(MAX_PEAK - 1);
     } else {
         retval = peak_meter_range_min * 100 / MAX_PEAK;
@@ -417,8 +385,9 @@ int peak_meter_get_min(void) {
  * for dBfs: -9000 < newmax <= 0
  * for linear: 0 <= newmax <= 100
  */
-void peak_meter_set_max(int newmax) {
-    if (peak_meter_use_dbfs) {
+void peak_meter_set_max(int newmax) 
+{
+    if (pm_use_dbfs) {
         peak_meter_range_max = peak_meter_db2sample(newmax);
     } else {
         if (newmax > peak_meter_range_min) {
@@ -426,10 +395,10 @@ void peak_meter_set_max(int newmax) {
         }
     }
 
-    peak_meter_range = peak_meter_range_max - peak_meter_range_min;
+    pm_range = peak_meter_range_max - peak_meter_range_min;
 
-    db_max = calc_db(peak_meter_range_max);
-    db_range = db_max - db_min;
+    pm_db_max = calc_db(peak_meter_range_max);
+    pm_db_range = pm_db_max - pm_db_min;
     db_scale_valid = false;
 }
 
@@ -440,9 +409,10 @@ void peak_meter_set_max(int newmax) {
  * @return: using dBfs : -9000 < value <= 0
  *          using linear scale: 0 <= value <= 100
  */
-int peak_meter_get_max(void) {
+int peak_meter_get_max(void) 
+{
     int retval = 0;
-    if (peak_meter_use_dbfs) {
+    if (pm_use_dbfs) {
         retval = calc_db(peak_meter_range_max) - calc_db(MAX_PEAK - 1);
     } else {
         retval = peak_meter_range_max * 100 / MAX_PEAK;
@@ -451,23 +421,24 @@ int peak_meter_get_max(void) {
 }
 
 /**
- * Returns 1 if the meter currently is
- * displaying dBfs values, 0 if the meter
- * displays percent values.
- * @return int - returns 0 or 1.
+ * Returns whether the meter is currently displaying dBfs or percent values.
+ * @return bool - true if the meter is displaying dBfs
+                  false if the meter is displaying percent values.
  */
-int peak_meter_get_use_dbfs(void) {
-    return peak_meter_use_dbfs ? 1 : 0;
+bool peak_meter_get_use_dbfs(void)
+{
+    return pm_use_dbfs;
 }
 
 /**
- * Specifies wether the values displayed are scaled
+ * Specifies whether the values displayed are scaled
  * as dBfs or as linear percent values.
- * @param int - Set to 0 for linear percent scale. Any other value
- *              switches on dBfs.
+ * @param use - set to true for dBfs, 
+ *              set to false for linear scaling in percent
  */
-void peak_meter_set_use_dbfs(int use){
-    peak_meter_use_dbfs = ((use & 1) == 1);
+void peak_meter_set_use_dbfs(bool use)
+{
+    pm_use_dbfs = use;
     db_scale_valid = false;
 }
 
@@ -486,7 +457,7 @@ void peak_meter_set_use_dbfs(int use){
  */
 void peak_meter_init_range( bool dbfs, int range_min, int range_max)
 {
-    peak_meter_use_dbfs = dbfs;
+    pm_use_dbfs = dbfs;
     peak_meter_set_min(range_min);
     peak_meter_set_max(range_max);
 }
@@ -497,15 +468,16 @@ void peak_meter_init_range( bool dbfs, int range_min, int range_max)
  *                      to decrease with each redraw
  * @param int hold - Select the time preset for the time the peak indicator 
  *                   is reset after a peak occurred. The preset values are 
- *                   stored in max_time_out.
+ *                   stored in peak_time_out.
  * @param int clip_hold - Select the time preset for the time the peak 
  *                        indicator is reset after a peak occurred. The preset 
  *                        values are stored in clip_time_out.
  */
-void peak_meter_init_times(int release, int hold, int clip_hold) {
-    peak_meter_hold = hold;
-    peak_meter_release = release;
-    peak_meter_clip_hold = clip_hold;
+void peak_meter_init_times(int release, int hold, int clip_hold) 
+{
+    pm_peak_hold = hold;
+    pm_peak_release = release;
+    pm_clip_hold = clip_hold;
 }
 
 /**
@@ -523,17 +495,18 @@ void peak_meter_playback(bool playback)
     (void)playback;
 #else
     if (playback) {
-        peak_meter_src_l = MAS_REG_DQPEAK_L;
-        peak_meter_src_r = MAS_REG_DQPEAK_R;
+        pm_src_left = MAS_REG_DQPEAK_L;
+        pm_src_right = MAS_REG_DQPEAK_R;
     } else {
-        peak_meter_src_l = MAS_REG_QPEAK_L;
-        peak_meter_src_r = MAS_REG_QPEAK_R;
+        pm_src_left = MAS_REG_QPEAK_L;
+        pm_src_right = MAS_REG_QPEAK_R;
     }
 #endif
 }
 
 #ifdef HAVE_RECORDING
-static void set_trig_status(int new_state) {
+static void set_trig_status(int new_state) 
+{
     if (trig_status != new_state) {
         trig_status = new_state;
         if (trigger_listener != NULL) {
@@ -545,24 +518,25 @@ static void set_trig_status(int new_state) {
 
 /**
  * Reads peak values from the MAS, and detects clips. The 
- * values are stored in peak_meter_l peak_meter_r for later 
+ * values are stored in pm_max_left pm_max_right for later
  * evauluation. Consecutive calls to peak_meter_peek detect 
  * that ocurred. This function could be used by a thread for
  * busy reading the MAS.
  */
-inline void peak_meter_peek(void)
+void peak_meter_peek(void)
 {
+    int left, right;
+   /* read current values */
 #ifdef SIMULATOR
-    int left = 8000;
-    int right = 9000;
+    pm_cur_left  = left  = 8000;
+    pm_cur_right = right = 9000;
 #elif CONFIG_HWCODEC == MASNONE
-    int left;
-    int right;
-    pcm_calculate_peaks(&left, &right);
+    pcm_calculate_peaks(&pm_cur_left, &pm_cur_right);
+    left  = pm_cur_left;
+    right = pm_cur_right;
 #else
-   /* read the peak values */
-    int left  = mas_codec_readreg(peak_meter_src_l);
-    int right = mas_codec_readreg(peak_meter_src_r);
+    pm_cur_left  = left  = mas_codec_readreg(pm_src_left);
+    pm_cur_right = right = mas_codec_readreg(pm_src_right);
 #endif
 
     /* check for clips
@@ -571,26 +545,34 @@ inline void peak_meter_peek(void)
        to be inaccurate in both ways: it may detect clips
        when no clip occurred and it may fail to detect
        a real clip. */
-    if ((left  == peak_meter_l) && 
-        (left  == MAX_PEAK - 1)) {
-        peak_meter_l_clip = true;
-        peak_meter_clip_timeout_l = 
-            current_tick + clip_time_out[peak_meter_clip_hold];
+    if ((left == pm_max_left) &&
+        (left == MAX_PEAK - 1)) {
+        pm_clip_left = true;
+        pm_clip_timeout_l = 
+            current_tick + clip_time_out[pm_clip_hold];
     }
 
-    if ((right == peak_meter_r) && 
+    if ((right == pm_max_right) &&
         (right == MAX_PEAK - 1)) {
-        peak_meter_r_clip = true;
-        peak_meter_clip_timeout_r = 
-            current_tick + clip_time_out[peak_meter_clip_hold];
+        pm_clip_right = true;
+        pm_clip_timeout_r = 
+            current_tick + clip_time_out[pm_clip_hold];
     }
 
+    /* peaks are searched -> we have to find the maximum. When
+       many calls of peak_meter_peek the maximum value will be
+       stored in pm_max_xxx. This maximum is reset by the
+       functions peak_meter_read_x. */
+    pm_max_left = MAX(pm_max_left, left);
+    pm_max_right = MAX(pm_max_right, right);
+
 #ifdef HAVE_RECORDING
     switch (trig_status) {
         case TRIG_READY:
             /* no more changes, if trigger was activated as release trigger */
             /* threshold exceeded? */
-            if ((left > trig_strt_threshold) || (right > trig_strt_threshold)) {
+            if ((left > trig_strt_threshold) 
+                || (right > trig_strt_threshold)) {
                 if (trig_strt_duration) {
                     /* reset trigger duration */
                     trig_hightime = current_tick;
@@ -614,8 +596,8 @@ inline void peak_meter_peek(void)
                 set_trig_status(TRIG_GO);
             } else {
                 /* threshold exceeded? */
-                if ((left > trig_strt_threshold) ||
-                    (right > trig_strt_threshold)) {
+                if ((left > trig_strt_threshold)
+                    || (right > trig_strt_threshold)) {
                     /* reset lowtime */
                     trig_lowtime = current_tick;
                 }
@@ -640,7 +622,8 @@ inline void peak_meter_peek(void)
         case TRIG_GO:
         case TRIG_CONTINUE:
             /* threshold exceeded? */
-            if ((left > trig_stp_threshold) || (right > trig_stp_threshold)) {
+            if ((left > trig_stp_threshold) 
+                || (right > trig_stp_threshold)) {
                 /* restart hold time countdown */
                 trig_lowtime = current_tick;
             } else {
@@ -653,8 +636,8 @@ inline void peak_meter_peek(void)
             /* gap time expired? */
             if (current_tick - trig_lowtime > trig_rstrt_gap){
                 /* start threshold exceeded? */
-                if ((left > trig_strt_threshold) ||
-                    (right > trig_strt_threshold)) {
+                if ((left > trig_strt_threshold) 
+                    || (right > trig_strt_threshold)) {
 
                     set_trig_status(TRIG_RETRIG);
                     trig_hightime = current_tick;
@@ -662,8 +645,8 @@ inline void peak_meter_peek(void)
                 else
 
                 /* stop threshold exceeded */
-                if ((left > trig_stp_threshold) ||
-                    (right > trig_stp_threshold)) {
+                if ((left > trig_stp_threshold) 
+                    || (right > trig_stp_threshold)) {
                     if (current_tick - trig_hightime > trig_stp_hold){
                         trig_lowtime = current_tick;
                         set_trig_status(TRIG_CONTINUE);
@@ -685,8 +668,8 @@ inline void peak_meter_peek(void)
             /* still within the gap time */
             else {
                 /* stop threshold exceeded */
-                if ((left > trig_stp_threshold) ||
-                    (right > trig_stp_threshold)) {
+                if ((left > trig_stp_threshold)
+                    || (right > trig_stp_threshold)) {
                     set_trig_status(TRIG_CONTINUE);
                     trig_lowtime = current_tick;
                 }
@@ -702,13 +685,6 @@ inline void peak_meter_peek(void)
     }
 #endif
 
-    /* peaks are searched -> we have to find the maximum. When
-       many calls of peak_meter_peek the maximum value will be
-       stored in peak_meter_x. This maximum is reset by the
-       functions peak_meter_read_x. */
-    peak_meter_l = MAX(peak_meter_l, left);
-    peak_meter_r = MAX(peak_meter_r, right);
-
 #ifdef PM_DEBUG
     peek_calls++;
 #endif
@@ -720,26 +696,18 @@ inline void peak_meter_peek(void)
  * since the last call of peak_meter_read_l. The value
  * is in the range 0 <= value < MAX_PEAK.
  */
-static int peak_meter_read_l (void)
+static int peak_meter_read_l(void)
 {
-    /* peak_meter_l contains the maximum of
-       all peak values that were read by peak_meter_peek 
-       since the last call of peak_meter_read_r */
-    int retval = peak_meter_l;
+    /* pm_max_left contains the maximum of all peak values that were read
+       by peak_meter_peek since the last call of peak_meter_read_l */
+    int retval = pm_max_left;
+
 #ifdef PM_DEBUG
     peek_calls = 0;
 #endif
-
-#ifdef SIMULATOR
-    peak_meter_l = 8000;
-#elif CONFIG_HWCODEC == MASNONE
-    pcm_calculate_peaks(&peak_meter_l, NULL);
-#else
-    /* reset peak_meter_l so that subsequent calls of
-       peak_meter_peek doesn't get fooled by an old
-       maximum value */
-    peak_meter_l = mas_codec_readreg(peak_meter_src_l);
-#endif
+    /* reset pm_max_left so that subsequent calls of peak_meter_peek don't
+       get fooled by an old maximum value */
+    pm_max_left = pm_cur_left;
     return retval;
 }
 
@@ -749,25 +717,18 @@ static int peak_meter_read_l (void)
  * since the last call of peak_meter_read_l. The value
  * is in the range 0 <= value < MAX_PEAK.
  */
-static int peak_meter_read_r (void) {
-    /* peak_meter_r contains the maximum of
-       all peak values that were read by peak_meter_peek 
-       since the last call of peak_meter_read_r */
-    int retval = peak_meter_r;
+static int peak_meter_read_r(void)
+{
+    /* peak_meter_r contains the maximum of all peak values that were read
+       by peak_meter_peek since the last call of peak_meter_read_r */
+    int retval = pm_max_right;
+
 #ifdef PM_DEBUG
     peek_calls = 0;
 #endif
-
-#ifdef SIMULATOR
-    peak_meter_l = 8000;
-#elif CONFIG_HWCODEC == MASNONE
-    pcm_calculate_peaks(NULL, &peak_meter_r);
-#else
-    /* reset peak_meter_r so that subsequent calls of
-       peak_meter_peek doesn't get fooled by an old
-       maximum value */
-    peak_meter_r = mas_codec_readreg(peak_meter_src_r);
-#endif
+    /* reset pm_max_right so that subsequent calls of peak_meter_peek don't
+       get fooled by an old maximum value */
+    pm_max_right = pm_cur_right;
     return retval;
 }
 
@@ -777,13 +738,14 @@ static int peak_meter_read_r (void) {
  * @param int unused - This parameter was added to
  * make the function compatible with set_int
  */
-void peak_meter_set_clip_hold(int time) {
-    peak_meter_clip_eternal = false;
+void peak_meter_set_clip_hold(int time) 
+{
+    pm_clip_eternal = false;
 
     if (time <= 0) {
-        peak_meter_l_clip = false;
-        peak_meter_r_clip = false;
-        peak_meter_clip_eternal = true;
+        pm_clip_left = false;
+        pm_clip_right = false;
+        pm_clip_eternal = true;
     }
 }
 
@@ -795,7 +757,8 @@ void peak_meter_set_clip_hold(int time) {
  * @param int meterwidht - The widht of the meter in pixel
  * @return unsigned short - A value 0 <= return value <= meterwidth
  */
-unsigned short peak_meter_scale_value(unsigned short val, int meterwidth){
+unsigned short peak_meter_scale_value(unsigned short val, int meterwidth)
+{
     int retval;
 
     if (val <= peak_meter_range_min) {
@@ -809,10 +772,10 @@ unsigned short peak_meter_scale_value(unsigned short val, int meterwidth){
     retval = val;
 
     /* different scaling is used for dBfs and linear percent */
-    if (peak_meter_use_dbfs) {
+    if (pm_use_dbfs) {
 
         /* scale the samples dBfs */
-        retval  = (calc_db(retval) - db_min) * meterwidth / db_range;
+        retval  = (calc_db(retval) - pm_db_min) * meterwidth / pm_db_range;
     }
 
     /* Scale for linear percent display */
@@ -820,7 +783,7 @@ unsigned short peak_meter_scale_value(unsigned short val, int meterwidth){
     {
         /* scale the samples */
         retval  = ((retval - peak_meter_range_min) * meterwidth) 
-                  / peak_meter_range;
+                  / pm_range;
     }
     return retval;
 }
@@ -854,8 +817,7 @@ void peak_meter_draw(int x, int y, int width, int height)
 
         /* read the volume info from MAS */
         left  = peak_meter_read_l(); 
-        right = peak_meter_read_r(); 
-        /*peak_meter_peek();*/
+        right = peak_meter_read_r();
 
         /* scale the samples dBfs */
         left  = peak_meter_scale_value(left, meterwidth);
@@ -865,7 +827,7 @@ void peak_meter_draw(int x, int y, int width, int height)
            (The scale becomes invalid when the range changed.) */
         if (!db_scale_valid){
 
-            if (peak_meter_use_dbfs) {
+            if (pm_use_dbfs) {
                 db_scale_count = DB_SCALE_SRC_VALUES_SIZE;
                 for (i = 0; i < db_scale_count; i++){
                     /* find the real x-coords for predefined interesting
@@ -884,7 +846,7 @@ void peak_meter_draw(int x, int y, int width, int height)
                 for (i = 0; i < db_scale_count; i++) {
                     db_scale_lcd_coord[i] = 
                         (i * (MAX_PEAK / 10) - peak_meter_range_min) *
-                        meterwidth / peak_meter_range;
+                        meterwidth / pm_range;
                 }
             }
 
@@ -894,41 +856,41 @@ void peak_meter_draw(int x, int y, int width, int height)
         }
 
         /* apply release */
-        left  = MAX(left , last_left  - peak_meter_release);
-        right = MAX(right, last_right - peak_meter_release);
+        left  = MAX(left , last_left  - pm_peak_release);
+        right = MAX(right, last_right - pm_peak_release);
 
         /* reset max values after timeout */
-        if (TIME_AFTER(current_tick, peak_meter_timeout_l)){
-            peak_meter_max_l = 0;
+        if (TIME_AFTER(current_tick, pm_peak_timeout_l)){
+            pm_peak_left = 0;
         }
 
-        if (TIME_AFTER(current_tick, peak_meter_timeout_r)){
-            peak_meter_max_r = 0;
+        if (TIME_AFTER(current_tick, pm_peak_timeout_r)){
+            pm_peak_right = 0;
         }
 
-        if (!peak_meter_clip_eternal) {
-            if (peak_meter_l_clip && 
-                TIME_AFTER(current_tick, peak_meter_clip_timeout_l)){
-                peak_meter_l_clip = false;
+        if (!pm_clip_eternal) {
+            if (pm_clip_left && 
+                TIME_AFTER(current_tick, pm_clip_timeout_l)){
+                pm_clip_left = false;
             }
 
-            if (peak_meter_r_clip && 
-                TIME_AFTER(current_tick, peak_meter_clip_timeout_r)){
-                peak_meter_r_clip = false;
+            if (pm_clip_right && 
+                TIME_AFTER(current_tick, pm_clip_timeout_r)){
+                pm_clip_right = false;
             }
         }
 
         /* check for new max values */
-        if (left > peak_meter_max_l) {
-            peak_meter_max_l = left - 1;
-            peak_meter_timeout_l = 
-                current_tick + max_time_out[peak_meter_hold];
+        if (left > pm_peak_left) {
+            pm_peak_left = left - 1;
+            pm_peak_timeout_l =
+                current_tick + peak_time_out[pm_peak_hold];
         }
 
-        if (right > peak_meter_max_r) {
-            peak_meter_max_r = right - 1;
-            peak_meter_timeout_r = 
-                current_tick + max_time_out[peak_meter_hold];
+        if (right > pm_peak_right) {
+            pm_peak_right = right - 1;
+            pm_peak_timeout_r = 
+                current_tick + peak_time_out[pm_peak_hold];
         }
     }
 
@@ -939,19 +901,19 @@ void peak_meter_draw(int x, int y, int width, int height)
 
     /* draw left */
     lcd_fillrect (x, y, left, height / 2 - 2 );
-    if (peak_meter_max_l > 0) {
-        lcd_vline(x + peak_meter_max_l, y, y + height / 2 - 2 );
+    if (pm_peak_left > 0) {
+        lcd_vline(x + pm_peak_left, y, y + height / 2 - 2 );
     }
-    if (peak_meter_l_clip) {
+    if (pm_clip_left) {
         lcd_fillrect(x + meterwidth, y, 3, height / 2 - 1);
     }
 
     /* draw right */
     lcd_fillrect(x, y + height / 2 + 1, right, height / 2 - 2);
-    if (peak_meter_max_r > 0) {
-        lcd_vline( x + peak_meter_max_r, y + height / 2, y + height - 2);
+    if (pm_peak_right > 0) {
+        lcd_vline( x + pm_peak_right, y + height / 2, y + height - 2);
     }
-    if (peak_meter_r_clip) {
+    if (pm_clip_right) {
         lcd_fillrect(x + meterwidth, y + height / 2, 3, height / 2 - 1);
     }
 
@@ -1071,7 +1033,8 @@ void peak_meter_define_trigger(
  * Enables or disables the trigger.
  * @param on - If true the trigger is turned on.
  */
-void peak_meter_trigger(bool on) {
+void peak_meter_trigger(bool on) 
+{
     /* don't use set_trigger here as that would fire an undesired event */
     trig_status = on ? TRIG_READY : TRIG_OFF;
 }
@@ -1081,7 +1044,8 @@ void peak_meter_trigger(bool on) {
  * @param listener - The function that is called with each change of
  *                   trig_status. May be set to NULL if no callback is desired.
  */
-void peak_meter_set_trigger_listener(void (*listener)(int status)) {
+void peak_meter_set_trigger_listener(void (*listener)(int status)) 
+{
     trigger_listener = listener;
 }
 
@@ -1097,78 +1061,99 @@ void peak_meter_set_trigger_listener(void (*listener)(int status)) {
  * peak_meter_release_trigger. To turn the trigger off call
  * peak_meter_trigger_off.
  */
-int peak_meter_trigger_status(void) {
+int peak_meter_trigger_status(void) 
+{
    return trig_status; /* & TRIG_PIT_MASK;*/
 }
 
-void peak_meter_draw_trig(int xpos, int ypos) {
-    int x = xpos + ICON_PLAY_STATE_WIDTH + 1;
+void peak_meter_draw_trig(int xpos, int ypos) 
+{
+    int barstart, barend;
+    int icon, ixpos;
     switch (trig_status) {
-        long time_left;
 
         case TRIG_READY:
-            scrollbar(x, ypos + 1, TRIGBAR_WIDTH, TRIG_HEIGHT - 2,
-                      TRIGBAR_WIDTH, 0, 0, HORIZONTAL);
-            lcd_mono_bitmap(bitmap_icons_7x8[Icon_Stop], xpos, ypos,
-                            ICON_PLAY_STATE_WIDTH, STATUSBAR_HEIGHT);
+            barstart = 0;
+            barend = 0;
+            icon = Icon_Stop;
+            ixpos = xpos;
             break;
 
         case TRIG_STEADY:
-        case TRIG_RETRIG:
-            time_left = trig_strt_duration - (current_tick - trig_hightime);
-            time_left = time_left * TRIGBAR_WIDTH / trig_strt_duration;
-            scrollbar(x, ypos + 1, TRIGBAR_WIDTH, TRIG_HEIGHT - 2,
-                      TRIGBAR_WIDTH, 0, TRIGBAR_WIDTH - time_left, HORIZONTAL);
-            lcd_mono_bitmap(bitmap_icons_7x8[Icon_Stop], xpos, ypos,
-                            ICON_PLAY_STATE_WIDTH, STATUSBAR_HEIGHT);
+        case TRIG_RETRIG: 
+            barstart = 0;
+            barend = TRIGBAR_WIDTH * (current_tick - trig_hightime) 
+                   / trig_strt_duration;
+            icon = Icon_Stop;
+            ixpos = xpos;
             break;
 
         case TRIG_GO:
         case TRIG_CONTINUE:
-            scrollbar(x, ypos + 1, TRIGBAR_WIDTH, TRIG_HEIGHT - 2,
-                      TRIGBAR_WIDTH, TRIGBAR_WIDTH, TRIGBAR_WIDTH, HORIZONTAL);
-            lcd_mono_bitmap(bitmap_icons_7x8[Icon_Record],
-                            TRIG_WIDTH - ICON_PLAY_STATE_WIDTH, ypos,
-                            ICON_PLAY_STATE_WIDTH, STATUSBAR_HEIGHT);
+            barstart = TRIGBAR_WIDTH;
+            barend = TRIGBAR_WIDTH;
+            icon = Icon_Record;
+            ixpos = TRIG_WIDTH - ICON_PLAY_STATE_WIDTH;
             break;
 
-        case TRIG_POSTREC:
-            time_left = trig_stp_hold - (current_tick - trig_lowtime);
-            time_left = time_left * TRIGBAR_WIDTH / trig_stp_hold;
-            scrollbar(x, ypos + 1, TRIGBAR_WIDTH, TRIG_HEIGHT - 2,
-                      TRIGBAR_WIDTH, time_left, TRIGBAR_WIDTH, HORIZONTAL);
-            lcd_mono_bitmap(bitmap_icons_7x8[Icon_Record],
-                            TRIG_WIDTH - ICON_PLAY_STATE_WIDTH, ypos,
-                            ICON_PLAY_STATE_WIDTH, STATUSBAR_HEIGHT);
+        case TRIG_POSTREC: 
+            barstart = TRIGBAR_WIDTH
+                     - TRIGBAR_WIDTH * (current_tick - trig_lowtime)
+                       / trig_stp_hold;
+            barend = TRIGBAR_WIDTH;
+            icon = Icon_Record;
+            ixpos = TRIG_WIDTH - ICON_PLAY_STATE_WIDTH;
             break;
-    }
 
+        default:
+            return;
+    }
+    scrollbar(xpos + ICON_PLAY_STATE_WIDTH + 1, ypos + 1,
+              TRIGBAR_WIDTH, TRIG_HEIGHT - 2,
+              TRIGBAR_WIDTH, barstart, barend, HORIZONTAL);
+    lcd_mono_bitmap(bitmap_icons_7x8[icon], ixpos, ypos,
+                    ICON_PLAY_STATE_WIDTH, STATUSBAR_HEIGHT);
 }
 #endif
 
 int peak_meter_draw_get_btn(int x, int y, int width, int height)
 {
-    int button;
+    int button = BUTTON_NONE;
     long next_refresh = current_tick;
     long next_big_refresh = current_tick + HZ / 10;
-    button = BUTTON_NONE;
+#ifndef SIMULATOR
+    bool highperf = !ata_disk_is_active();
+#else
+    bool highperf = false;
+#endif
+    bool dopeek = true;
 
-    while (!TIME_AFTER(current_tick, next_big_refresh)) {
+    while (TIME_BEFORE(current_tick, next_big_refresh)) {
         button = button_get(false);
         if (button != BUTTON_NONE) {
             break;
         }
-        sleep(MAX(next_refresh - current_tick, 0) - 1);
-        next_refresh = current_tick + HZ / peak_meter_fps;
-        peak_meter_peek();
-        peak_meter_draw(x, y, width, height);
-        lcd_update_rect(x, y, width, height);
+        if (dopeek) {          /* Peek only once per refresh when disk is */
+            peak_meter_peek(); /* spinning, but as often as possible */
+            dopeek = highperf; /* otherwise. */
+            yield();
+        } else {
+            sleep(0);          /* Sleep until end of current tick. */
+        }
+        if (TIME_AFTER(current_tick, next_refresh)) {
+            peak_meter_draw(x, y, width, height);
+            lcd_update_rect(x, y, width, height);
+            next_refresh += HZ / PEAK_METER_FPS;
+            dopeek = true;
+        }
     }
+
     return button;
 }
 
 #ifdef PM_DEBUG
-static void peak_meter_clear_histogram(void) {
+static void peak_meter_clear_histogram(void)
+{
     int i = 0;
     for (i = 0; i < TICKS_PER_DRAW_SIZE; i++) {
         ticks_per_redraw[i] = (unsigned int)0;
@@ -1179,7 +1164,8 @@ static void peak_meter_clear_histogram(void) {
     }
 }
 
-bool peak_meter_histogram(void) {
+bool peak_meter_histogram(void) 
+{
     int i;
     int btn = BUTTON_NONE;
     while ((btn & BUTTON_OFF) != BUTTON_OFF )
@@ -1210,7 +1196,7 @@ bool peak_meter_histogram(void) {
             lcd_hline(0, x, y + i);
         }
         lcd_update();
-        
+
         btn = button_get(true);
         if (btn == BUTTON_PLAY) {
             peak_meter_clear_histogram();
diff --git a/apps/recorder/peakmeter.h b/apps/recorder/peakmeter.h
index 3c0a28bf3b..5513dfacf1 100644
--- a/apps/recorder/peakmeter.h
+++ b/apps/recorder/peakmeter.h
@@ -19,13 +19,14 @@
 #ifndef __PEAKMETER_H__
 #define __PEAKMETER_H__
 
+#define PEAK_METER_FPS 20
+
 /*#define PM_DEBUG */
 #ifdef PM_DEBUG 
 extern bool peak_meter_histogram(void);
 #endif
 
 extern bool peak_meter_enabled;
-extern int  peak_meter_fps;
 
 extern void peak_meter_playback(bool playback);
 extern void peak_meter_draw(int x, int y, int width, int height);
@@ -39,8 +40,8 @@ extern void peak_meter_set_min(int newmin);
 extern int  peak_meter_get_min(void);
 extern void peak_meter_set_max(int newmax);
 extern int  peak_meter_get_max(void);
-extern void peak_meter_set_use_dbfs(int use);
-extern int  peak_meter_get_use_dbfs(void);
+extern void peak_meter_set_use_dbfs(bool use);
+extern bool peak_meter_get_use_dbfs(void);
 extern int  calc_db (int isample);
 extern int  peak_meter_db2sample(int db);
 extern unsigned short peak_meter_scale_value(unsigned short val, int meterwidth);
diff --git a/apps/recorder/radio.c b/apps/recorder/radio.c
index 4e6c52ea84..a0280ecf1f 100644
--- a/apps/recorder/radio.c
+++ b/apps/recorder/radio.c
@@ -304,7 +304,7 @@ bool radio_screen(void)
         if(search_dir)
             button = button_get(false);
         else
-            button = button_get_w_tmo(HZ / peak_meter_fps);
+            button = button_get_w_tmo(HZ / PEAK_METER_FPS);
         switch(button)
         {
             case FM_STOP:
@@ -479,13 +479,10 @@ bool radio_screen(void)
             /* Only display the peak meter when not recording */
             if(!audio_status())
             {
-                lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
-                lcd_fillrect(0, 8 + fh*(top_of_screen + 3), LCD_WIDTH, fh);
-                lcd_set_drawmode(DRMODE_SOLID);
                 peak_meter_draw(0, 8 + fh*(top_of_screen + 3), LCD_WIDTH, fh);
                 lcd_update_rect(0, 8 + fh*(top_of_screen + 3), LCD_WIDTH, fh);
             }
-            
+
             if(TIME_AFTER(current_tick, timeout))
             {
                 timeout = current_tick + HZ;
diff --git a/apps/settings.c b/apps/settings.c
index 4811ad2320..6fd2ec64bf 100644
--- a/apps/settings.c
+++ b/apps/settings.c
@@ -78,7 +78,7 @@ const char rec_base_directory[] = REC_BASE_DIR;
 #include "pcm_playback.h"
 #endif
 
-#define CONFIG_BLOCK_VERSION 25
+#define CONFIG_BLOCK_VERSION 26
 #define CONFIG_BLOCK_SIZE 512
 #define RTC_BLOCK_SIZE 44
 
@@ -349,8 +349,7 @@ static const struct bit_entry hd_bits[] =
     /* peak meter */
     {5, S_O(peak_meter_clip_hold), 16, "peak meter clip hold", /* 0...25 */
         "on,1,2,3,4,5,6,7,8,9,10,15,20,25,30,45,60,90,2min,3min,5min,10min,20min,45min,90min" },
-    {1, S_O(peak_meter_performance), false, "peak meter busy", off_on },
-    {5, S_O(peak_meter_hold), 3, "peak meter hold", 
+    {5, S_O(peak_meter_hold), 3, "peak meter hold",
         "off,200ms,300ms,500ms,1,2,3,4,5,6,7,8,9,10,15,20,30,1min" },
     {7, S_O(peak_meter_release), 8, "peak meter release", NULL }, /* 0...126 */
     {1, S_O(peak_meter_dbfs), true, "peak meter dbfs", off_on },
diff --git a/apps/settings.h b/apps/settings.h
index d0041d2e99..c59fe47532 100644
--- a/apps/settings.h
+++ b/apps/settings.h
@@ -250,7 +250,6 @@ struct user_settings
     int peak_meter_hold;      /* hold time for peak meter in 1/100 s */
     int peak_meter_clip_hold; /* hold time for clips */
     bool peak_meter_dbfs;     /* show linear or dbfs values */
-    bool peak_meter_performance;  /* true: high performance, else save energy*/
     int peak_meter_min; /* range minimum */
     int peak_meter_max; /* range maximum */
     bool car_adapter_mode; /* 0=off 1=on */
diff --git a/apps/settings_menu.c b/apps/settings_menu.c
index 9f7259620e..bbbeca3683 100644
--- a/apps/settings_menu.c
+++ b/apps/settings_menu.c
@@ -318,16 +318,6 @@ static bool volume_type(void)
                        INT, names, 2, NULL);
 }
 
-#ifdef PM_DEBUG
-static bool peak_meter_fps_menu(void) {
-    bool retval = false;
-    retval = set_int( "Refresh rate", "/s", UNIT_PER_SEC,
-             &peak_meter_fps,
-             NULL, 1, 5, 40, NULL);
-    return retval;
-}
-#endif /* PM_DEBUG */
-
 /**
  * Menu to set the hold time of normal peaks.
  */
@@ -545,25 +535,6 @@ static bool peak_meter_max(void) {
 }
 
 /**
- * Menu to select wether the meter is in
- * precision or in energy saver mode
- */
-static bool peak_meter_performance(void) {
-    bool retval = false;
-    retval = set_bool_options(str(LANG_PM_PERFORMANCE), 
-        &global_settings.peak_meter_performance, 
-        STR(LANG_PM_HIGH_PERFORMANCE), STR(LANG_PM_ENERGY_SAVER),
-        NULL);
-
-    if (global_settings.peak_meter_performance) {
-        peak_meter_fps = 25;
-    } else {
-        peak_meter_fps = 20;
-    }
-    return retval;
-}
-
-/**
  * Menu to configure the peak meter
  */
 static bool peak_meter_menu(void) 
@@ -575,10 +546,6 @@ static bool peak_meter_menu(void)
         { ID2P(LANG_PM_RELEASE)  , peak_meter_release   },  
         { ID2P(LANG_PM_PEAK_HOLD), peak_meter_hold      },  
         { ID2P(LANG_PM_CLIP_HOLD), peak_meter_clip_hold },
-        { ID2P(LANG_PM_PERFORMANCE), peak_meter_performance },
-#ifdef PM_DEBUG
-        { "Refresh rate" , -1    , peak_meter_fps_menu  },
-#endif
         { ID2P(LANG_PM_SCALE)    , peak_meter_scale     },
         { ID2P(LANG_PM_MIN)      , peak_meter_min       },
         { ID2P(LANG_PM_MAX)      , peak_meter_max       },
diff --git a/apps/wps.c b/apps/wps.c
index bf0283015f..784289ada4 100644
--- a/apps/wps.c
+++ b/apps/wps.c
@@ -391,46 +391,29 @@ long wps_show(void)
 #ifdef HAVE_LCD_BITMAP
         /* when the peak meter is enabled we want to have a
             few extra updates to make it look smooth. On the
-            other hand we don't want to waste energy if it 
+            other hand we don't want to waste energy if it
             isn't displayed */
         if (peak_meter_enabled) {
-            int i;
-
-            /* In high performance mode we read out the mas as
-               often as we can. There is no sleep for cpu */
-            if (global_settings.peak_meter_performance) {
-                long next_refresh = current_tick;
-                long next_big_refresh = current_tick + HZ / 5;
-                button = BUTTON_NONE;
-                while (!TIME_AFTER(current_tick, next_big_refresh)) {
-                    button = button_get(false);
-                    if (button != BUTTON_NONE) {
-                        break;
-                    }
-                    peak_meter_peek();
-                    sleep(1);
-
-                    if (TIME_AFTER(current_tick, next_refresh)) {
-                        wps_refresh(id3, nid3, 0, WPS_REFRESH_PEAK_METER);
-                        next_refresh = current_tick + HZ / peak_meter_fps;
-                    }
+            long next_refresh = current_tick;
+            long next_big_refresh = current_tick + HZ / 5;
+            button = BUTTON_NONE;
+            while (TIME_BEFORE(current_tick, next_big_refresh)) {
+                button = button_get(false);
+                if (button != BUTTON_NONE) {
+                    break;
                 }
-            } 
-            
-            /* In energy saver mode the cpu may sleep a 
-               little bit while waiting for buttons */
-            else {
-                for (i = 0; i < 4; i++) {
-                    button = button_get_w_tmo(HZ / peak_meter_fps);
-                    if (button != 0) {
-                        break;
-                    }
+                peak_meter_peek();
+                sleep(0);   /* Sleep until end of current tick. */  
+
+                if (TIME_AFTER(current_tick, next_refresh)) {
                     wps_refresh(id3, nid3, 0, WPS_REFRESH_PEAK_METER);
+                    next_refresh += HZ / PEAK_METER_FPS;
                 }
             }
-        } 
-        
-        /* The peak meter is disabled 
+
+        }
+
+        /* The peak meter is disabled
            -> no additional screen updates needed */
         else {
             button = button_get_w_tmo(HZ/5);
diff --git a/firmware/pcm_playback.c b/firmware/pcm_playback.c
index f75ec69857..5597f69bdb 100644
--- a/firmware/pcm_playback.c
+++ b/firmware/pcm_playback.c
@@ -99,15 +99,15 @@ static void dma_stop(void)
 
 /*
  * This function goes directly into the DMA buffer to calculate the left and
- * right peak values. To avoid missing peaks it tries to look forward a full
- * refresh period (1/20 sec) although it's always possible that the entire
- * period will not be visible. To reduce CPU load it only looks at every
- * third sample, and this can be reduced even further if needed (even every
- * tenth sample would still be pretty accurate).
+ * right peak values. To avoid missing peaks it tries to look forward two full
+ * peek periods (2/HZ sec, 100% overlap), although it's always possible that
+ * the entire period will not be visible. To reduce CPU load it only looks at
+ * every third sample, and this can be reduced even further if needed (even
+ * every tenth sample would still be pretty accurate).
  */
 
-#define PEAK_SAMPLES    2205    /* 44100 sample rate / 20 Hz refresh */
-#define PEAK_STRIDE     3       /* every 3rd sample is plenty... */
+#define PEAK_SAMPLES  (44100*2/HZ)  /* 44100 samples * 2 / 100 Hz tick */
+#define PEAK_STRIDE   3       /* every 3rd sample is plenty... */
 
 void pcm_calculate_peaks(int *left, int *right)
 {