Phil Pertermann's dB peak meter patch

git-svn-id: svn://svn.rockbox.org/rockbox/trunk@2774 a1c6a512-1295-4272-9138-f99709370657

1 files changed, 615 insertions, 16 deletions

diff --git a/apps/recorder/peakmeter.c b/apps/recorder/peakmeter.c
index df7c672617..e1850a4bb0 100644
--- a/apps/recorder/peakmeter.c
+++ b/apps/recorder/peakmeter.c
@@ -46,24 +46,52 @@ static bool peak_meter_r_clip = false;
 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;
+
 /* if set to true clip timeout is disabled */
 static bool peak_meter_clip_eternal = false;
 
+static bool peak_meter_use_dbfs = true;
+
+
 #ifndef SIMULATOR
 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;
+
+#define PEEKS_PER_DRAW_SIZE 40
+static unsigned int peeks_per_redraw[PEEKS_PER_DRAW_SIZE];
+
+#define TICKS_PER_DRAW_SIZE 20
+static unsigned int ticks_per_redraw[TICKS_PER_DRAW_SIZE];
+#endif
+
 /* time out values for max */
 static long max_time_out[] = {
     0 * HZ, HZ / 5, 30, HZ / 2, HZ, 2 * HZ, 
@@ -80,6 +108,353 @@ static long clip_time_out[] = {
     2700 * HZ, 5400 * HZ
 };
 
+/* precalculated peak values that represent magical
+   dBfs values. Used to draw the scale */
+#if 0
+static int db_scale_src_values[] = {
+    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 */
+};
+#else
+static int db_scale_src_values[] = {
+    32752, /*   0 db */
+    22784, /* - 3 db */
+    14256, /* - 6 db */
+    11752, /* - 9 db */
+    9256,  /* -12 db */
+    4256,  /* -18 db */
+    2186,  /* -24 db */
+    1186,  /* -30 db */
+    373,   /* -40 db */
+    102,   /* -50 db */
+    33,    /* -60 db */
+};
+#endif
+
+int db_scale_count = sizeof db_scale_src_values / sizeof (int);
+
+/* if db_scale_valid is false the content of 
+   db_scale_lcd_coord needs recalculation */
+static bool db_scale_valid = false;
+
+/* contains the lcd x coordinates of the magical
+   scale values in db_scale_src_values */
+static int db_scale_lcd_coord[sizeof db_scale_src_values / sizeof (int)];
+
+
+/**
+ * Calculates dB Value for the peak meter, uses peak value as input
+ * @param int sample - The input value 
+ *                    Make sure that 0 <= value < SAMPLE_RANGE
+ *
+ * @return int - The 2 digit fixed comma result of the euation
+ *               20 * log (sample / SAMPLE_RANGE) + 90
+ *               Output range is 0-8961 (that is 0,0 - 89,6 dB).
+ *               Normally 0dB is full scale, here it is shifted +90dB.
+ *               The calculation is based on the results of a linear
+ *               approximation tool written specifically for this problem
+ *               by Andreas Zwirtes (radhard@gmx.de). The result hat an
+ *               accurracy of better than 2%. It is highly runtime optimized,
+ *               the cascading if-clauses do an successive approximation on
+ *               the input value. This avoids big lookup-tables and
+ *               for-loops.
+ */
+
+int calc_db (int isample) {
+    /* return n+m*(isample-istart)/100 */
+    int n;
+    long m;
+    int istart;
+
+    /* Range 1-4 */
+    if (isample < 119) {
+
+        /* Range 1-2 */
+        if (isample < 5) {
+
+            /* Range 1 */
+            if (isample < 1) {
+                istart = 0;
+                n = 0;
+                m = 5900;
+            }
+
+            /* Range 2 */
+            else {
+                istart = 1;
+                n = 59;
+                m = 34950;
+            }
+        }
+
+        /* Range 3-4 */
+        else {
+
+            /* Range 3 */
+            if (isample < 24) {
+                istart = 5;
+                n = 1457;
+                m = 7168;
+            }
+
+            /* Range 4 */
+            else {
+                istart = 24;
+                n = 2819;
+                m = 1464;
+            }
+        }
+    }
+
+    /* Range 5-8 */
+    else {
+
+        /* Range 5-6 */
+        if (isample < 2918) {
+
+            /* Range 5 */
+            if (isample < 592) {
+                istart = 119;
+                n = 4210;
+                m = 295;
+            }
+
+            /* Range 6 */
+            else {
+                istart = 592;
+                n = 5605;
+                m = 60;
+            }
+        }
+
+        /* Range 7-8 */
+        else {
+
+            /* Range 7 */
+            if (isample < 15352) {
+                istart = 2918;
+                n = 7001;
+                m = 12;
+            }
+
+            /* Range 8 */
+            else {
+                istart = 15352;
+                n = 8439;
+                m = 3;
+            }
+        }
+    }
+   
+    return n + (m * (long)(isample - istart)) / 100L;
+}
+
+
+/**
+ * A helper function for db_to_sample. Don't call it separately but
+ * use db_to_sample. If one or both of min and max are outside the 
+ * range 0 <= min (or max) < 8961 the behaviour of this function is
+ * undefined. It may not return.
+ * @param int min - The minimum of the value range that is searched.
+ * @param int max - The maximum of the value range that is searched.
+ * @param int db  - The value in dBfs * (-100) for which the according
+ *                  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){
+    int test = min + (max - min) / 2;
+
+    if (min < max) {
+        if (calc_db(test) < db) {
+            test = db_to_sample_bin_search(test, max, db);
+        } else {
+            if (calc_db(test-1) > db) {
+                test = db_to_sample_bin_search(min, test, db);
+            }
+        }
+    }
+    return test;
+}
+
+/**
+ * Converts a value representing dBfs to a linear
+ * scaled volume info as it is used by the MAS.
+ * An incredibly inefficiant function which is
+ * the vague inverse of calc_db. This really 
+ * should be replaced by something better soon.
+ * 
+ * @param int db - A dBfs * 100 value with 
+ *                 -9000 < value <= 0
+ * @return int - The return value is in the range of
+ *               0 <= return value < MAX_PEAK
+ */
+static int db_to_sample(int db) {
+    int retval = 0;
+
+    /* what is the maximum pseudo db value */
+    int max_peak_db = calc_db(MAX_PEAK - 1);
+
+    /* range check: db value to big */
+    if (max_peak_db + db < 0) {
+        retval = 0;
+    } 
+    
+    /* range check: db value too small */
+    else if (max_peak_db + db >= max_peak_db) {
+        retval = MAX_PEAK -1;
+    } 
+    
+    /* value in range: find the matching linear value */
+    else {
+        retval = db_to_sample_bin_search(0, MAX_PEAK, max_peak_db + db);
+
+        /* as this is a dirty function anyway, we want to adjust the 
+           full scale hit manually to avoid users complaining that when
+           they adjust maximum for 0 dBfs and display it in percent it 
+           shows 99%. That is due to precision loss and this is the 
+           optical fix */
+    }
+
+    return retval;
+}
+
+/**
+ * Set the min value for restriction of the value range.
+ * @param int newmin - depending wether 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) {
+        peak_meter_range_min = db_to_sample(newmin);
+
+    } else {
+        if (newmin < peak_meter_range_max) {
+            peak_meter_range_min = newmin * MAX_PEAK / 100;
+        }
+    }
+    db_scale_valid = false;
+}
+
+/**
+ * Returns the minimum value of the range the meter 
+ * displays. If the scale is set to dBfs it returns
+ * dBfs values * 100 or linear percent values.
+ * @return: using dBfs : -9000 < value <= 0
+ *          using linear scale: 0 <= value <= 100
+ */
+int peak_meter_get_min(void) {
+    int retval = 0;
+    if (peak_meter_use_dbfs) {
+        retval = calc_db(peak_meter_range_min) - calc_db(MAX_PEAK - 1);
+    } else {
+        retval = peak_meter_range_min * 100 / MAX_PEAK;
+    }
+    return retval;
+}
+
+/**
+ * Set the max value for restriction of the value range.
+ * @param int newmax - depending wether dBfs is used
+ * newmax is a value in dBfs * 100 or in linear percent values.
+ * for dBfs: -9000 < newmax <= 0
+ * for linear: 0 <= newmax <= 100
+ */
+void peak_meter_set_max(int newmax) {
+    if (peak_meter_use_dbfs) {
+        peak_meter_range_max = db_to_sample(newmax);
+    } else {
+        if (newmax > peak_meter_range_min) {
+            peak_meter_range_max = newmax * MAX_PEAK / 100;
+        }
+    }
+    db_scale_valid = false;
+}
+
+/**
+ * Returns the minimum value of the range the meter 
+ * displays. If the scale is set to dBfs it returns
+ * dBfs values * 100 or linear percent values
+ * @return: using dBfs : -9000 < value <= 0
+ *          using linear scale: 0 <= value <= 100
+ */
+int peak_meter_get_max(void) {
+    int retval = 0;
+    if (peak_meter_use_dbfs) {
+        retval = calc_db(peak_meter_range_max) - calc_db(MAX_PEAK - 1);
+    } else {
+        retval = peak_meter_range_max * 100 / MAX_PEAK;
+    }
+    return retval;
+}
+
+/**
+ * Returns 1 if the meter currently is
+ * displaying dBfs values, 0 if the meter
+ * displays percent values.
+ * @return int - returns 0 or 1.
+ */
+int peak_meter_get_use_dbfs(void) {
+    return peak_meter_use_dbfs ? 1 : 0;
+}
+
+/**
+ * Specifies wether 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.
+ */
+void peak_meter_set_use_dbfs(int use){
+    peak_meter_use_dbfs = ((use & 1) == 1);
+    db_scale_valid = false;
+}
+
+/**
+ * Initialize the range of the meter. Only values
+ * that are in the range of [range_min ... range_max]
+ * are displayed.
+ * @param bool dbfs - set to true for dBfs, 
+ *                    set to false for linear scaling in percent 
+ * @param int range_min - Specifies the lower value of the range. 
+ *                        Pass a value dBfs * 100 when dbfs is set to true.
+ *                        Pass a percent value when dbfs is set to false.
+ * @param int range_max - Specifies the upper value of the range. 
+ *                        Pass a value dBfs * 100 when dbfs is set to true.
+ *                        Pass a percent value when dbfs is set to false.
+ */
+void peak_meter_init_range( bool dbfs, int range_min, int range_max) {
+    peak_meter_use_dbfs = dbfs;
+    peak_meter_set_min(range_min);
+    peak_meter_set_max(range_max);
+}
+
+/**
+ * Initialize the peak meter with all relevant values concerning times.
+ * @param int release - Set the maximum amount of pixels the meter is allowed
+ *                      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.
+ * @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;
+}
+
 /**
  * Set the source of the peak meter to playback or to 
  * record.
@@ -127,20 +502,58 @@ void peak_meter_peek(void) {
         (left  == MAX_PEAK - 1)) {
         peak_meter_l_clip = true;
         peak_meter_clip_timeout_l = 
-            current_tick + clip_time_out[global_settings.peak_meter_clip_hold];
+            current_tick + clip_time_out[peak_meter_clip_hold];
     }
 
     if ((right == peak_meter_r) && 
         (right == MAX_PEAK - 1)) {
         peak_meter_r_clip = true;
         peak_meter_clip_timeout_r = 
-            current_tick + clip_time_out[global_settings.peak_meter_clip_hold];
+            current_tick + clip_time_out[peak_meter_clip_hold];
     }
 
-    /* peaks are searched -> we have to find the maximum */
+    /* 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
+}
+
+
+/**
+ * The thread function for the peak meter calls peak_meter_peek 
+ * to reas out the mas and find maxima, clips, etc. No display
+ * is performed.
+ */
+/*
+void peak_meter_thread(void) {
+    sleep(5000);
+    while (1) {
+        if (peak_meter_enabled && peak_meter_use_thread){
+            peak_meter_peek();
+        }
+        yield();
+    }
+}
+*/
+
+/**
+ * Creates the peak meter thread 
+ */
+/*
+void peak_meter_init(void) {
+    create_thread(
+        peak_meter_thread, 
+        peak_meter_stack, 
+        sizeof peak_meter_stack, 
+        "peakmeter");
 }
+*/
 
 /**
  * Reads out the peak volume of the left channel.
@@ -149,10 +562,20 @@ void peak_meter_peek(void) {
  * is in the range 0 <= value < MAX_PEAK.
  */
 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;
+#ifdef PM_DEBUG
+    peek_calls = 0;
+#endif
+
 #ifdef SIMULATOR
     peak_meter_l = 8000;
 #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
     return retval;
@@ -165,10 +588,20 @@ static int peak_meter_read_l (void) {
  * 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;
+#ifdef PM_DEBUG
+    peek_calls = 0;
+#endif
+
 #ifdef SIMULATOR
     peak_meter_l = 8000;
 #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
     return retval;
@@ -190,6 +623,51 @@ void peak_meter_set_clip_hold(int time) {
     }
 }
 
+/**
+ * Scales a peak value as read from the MAS to the range of meterwidth.
+ * The scaling is performed according to the scaling method (dBfs / linear)
+ * and the range (peak_meter_range_min .. peak_meter_range_max).
+ * @param unsigned short val - The volume value. Range: 0 <= val < MAX_PEAK
+ * @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){
+    int range;
+    int retval;
+
+    if (val <= peak_meter_range_min) {
+        return 0;
+    }
+
+    if (val >= peak_meter_range_max) {
+        return meterwidth;
+    }
+
+    retval = val;
+
+    /* different scaling is used for dBfs and linear percent */
+    if (peak_meter_use_dbfs) {
+
+        /* needed the offset in 'zoomed' meters */
+        int dbmin = calc_db(peak_meter_range_min);
+
+        range = calc_db(peak_meter_range_max) - dbmin;
+
+        /* scale the samples dBfs */
+        retval  = (calc_db(retval) - dbmin) * meterwidth / range;
+    }
+
+    /* Scale for linear percent display */
+    else
+    {
+        range =(peak_meter_range_max - peak_meter_range_min);
+
+        /* scale the samples */
+        retval  = ((retval - peak_meter_range_min) * meterwidth) / range;
+    }
+    return retval;
+}
+
 
 /**
  * Draws a peak meter in the specified size at the specified position.
@@ -208,22 +686,66 @@ void peak_meter_draw(int x, int y, int width, int height) {
     int meterwidth = width - 3;
     int i;
 
+#ifdef PM_DEBUG
+    static long pm_tick = 0;
+    int tmp = peek_calls;
+#endif
+
     /* if disabled only draw the peak meter */
     if (peak_meter_enabled) {
+
         /* read the volume info from MAS */
         left  = peak_meter_read_l(); 
         right = peak_meter_read_r(); 
-
         peak_meter_peek();
 
+        /* restrict the range to avoid drawing outside the lcd */
+        left = MAX(peak_meter_range_min, left);
+        left = MIN(peak_meter_range_max, left);
+
+        right = MAX(peak_meter_range_min, right);
+        right = MIN(peak_meter_range_max, right);
+
+        /* scale the samples dBfs */
+        left  = peak_meter_scale_value(left, meterwidth);
+        right = peak_meter_scale_value(right, meterwidth);
+    
+        /* if the scale has changed -> recalculate the scale 
+           (The scale becomes invalid when the range changed.) */
+        if (!db_scale_valid){
+
+            if (peak_meter_use_dbfs) {
+                db_scale_count = sizeof db_scale_src_values / sizeof (int);
+                for (i = 0; i < db_scale_count; i++){
+                    /* find the real x-coords for predefined interesting
+                       dBfs values. These only are recalculated when the
+                       scaling of the meter changed. */
+                        db_scale_lcd_coord[i] = 
+                            peak_meter_scale_value(
+                                db_scale_src_values[i], 
+                                meterwidth - 1);
+                } 
+            }
 
-        /* scale the samples */
-        left  /= (MAX_PEAK / meterwidth);
-        right /= (MAX_PEAK / meterwidth);
+            /* when scaling linear we simly make 10% steps */
+            else {
+                int range = peak_meter_range_max - peak_meter_range_min;
+                db_scale_count = 10;
+                for (i = 0; i < db_scale_count; i++) {
+                    db_scale_lcd_coord[i] = 
+                        (i * (MAX_PEAK / 10) - peak_meter_range_min) *
+                        meterwidth / range;
+                }
+            }
+
+            /* mark scale valid to avoid recalculating dBfs values
+               of the scale. */
+            db_scale_valid = true;
+        }
 
         /* apply release */
-        left  = MAX(left , last_left  - global_settings.peak_meter_release);
-        right = MAX(right, last_right - global_settings.peak_meter_release);
+        left  = MAX(left , last_left  - peak_meter_release);
+        right = MAX(right, last_right - peak_meter_release);
 
         /* reset max values after timeout */
         if (TIME_AFTER(current_tick, peak_meter_timeout_l)){
@@ -250,13 +772,13 @@ void peak_meter_draw(int x, int y, int width, int height) {
         if (left > peak_meter_max_l) {
             peak_meter_max_l = left - 1;
             peak_meter_timeout_l = 
-                current_tick + max_time_out[global_settings.peak_meter_hold];
+                current_tick + max_time_out[peak_meter_hold];
         }
 
         if (right > peak_meter_max_r) {
             peak_meter_max_r = right - 1;
             peak_meter_timeout_r = 
-                current_tick + max_time_out[global_settings.peak_meter_hold];
+                current_tick + max_time_out[peak_meter_hold];
         }
     }
 
@@ -283,13 +805,90 @@ void peak_meter_draw(int x, int y, int width, int height) {
         lcd_fillrect(x + meterwidth, y + height / 2, 3, height / 2 - 1);
     }
 
-    /* draw scale */
+    /* draw scale end */
     lcd_drawline(x + meterwidth, y,
                  x + meterwidth, y + height - 2);
-    for (i = 0; i < 10; i++) {
-        lcd_invertpixel(x + meterwidth * i / 10, y + height / 2 - 1);
+    
+    /* draw dots for scale marks */
+    for (i = 0; i < db_scale_count; i++) {
+        /* The x-coordinates of interesting scale mark points 
+           have been calculated before */
+        lcd_invertpixel(db_scale_lcd_coord[i], y + height / 2 - 1);
+    }
+
+#ifdef PM_DEBUG
+    /* display a bar to show how many calls to peak_meter_peek 
+       have ocurred since the last display */
+    lcd_invertrect(x, y, tmp, 3);
+
+    if (tmp < PEEKS_PER_DRAW_SIZE) {
+        peeks_per_redraw[tmp]++;
+    }
+
+    tmp = current_tick - pm_tick;
+    if (tmp < TICKS_PER_DRAW_SIZE ){
+        ticks_per_redraw[tmp] ++;
     }
 
+    /* display a bar to show how many ticks have passed since 
+       the last redraw */
+    lcd_invertrect(x, y + height / 2, current_tick - pm_tick, 2);
+    pm_tick = current_tick;
+#endif
+
     last_left = left;
     last_right = right;
 }
+
+#ifdef PM_DEBUG
+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;
+    }
+
+    for (i = 0; i < PEEKS_PER_DRAW_SIZE; i++) {
+        peeks_per_redraw[i] = (unsigned int)0;
+    }
+}
+
+bool peak_meter_histogram(void) {
+    int i;
+    int btn = BUTTON_NONE;
+    while ((btn & BUTTON_OFF) != BUTTON_OFF )
+    {
+        unsigned int max = 0;
+        int y = 0;
+        int x = 0;
+        lcd_clear_display();
+
+        for (i = 0; i < PEEKS_PER_DRAW_SIZE; i++) {
+            max = MAX(max, peeks_per_redraw[i]);
+        }
+
+        for (i = 0; i < PEEKS_PER_DRAW_SIZE; i++) {
+            x = peeks_per_redraw[i] * (LCD_WIDTH - 1)/ max;
+            lcd_drawline(0, y + i, x, y + i);
+        }
+
+        y = PEEKS_PER_DRAW_SIZE + 1;
+        max = 0;
+
+        for (i = 0; i < TICKS_PER_DRAW_SIZE; i++) {
+            max = MAX(max, ticks_per_redraw[i]);
+        }
+
+        for (i = 0; i < TICKS_PER_DRAW_SIZE; i++) {
+            x = ticks_per_redraw[i] * (LCD_WIDTH - 1)/ max;
+            lcd_drawline(0, y + i, x, y + i);
+        }
+        lcd_update();
+        
+        btn = button_get(true);
+        if (btn == BUTTON_PLAY) {
+            peak_meter_clear_histogram();
+        }
+    }
+    return false;
+}
+#endif