Automatic Gain Control during recording. At this point only compiled for iriver h1x0 and h3x0. Patch FS#4748 by Jvo Studer, Martin Scarratt and myself.

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

7 files changed, 732 insertions, 5 deletions

diff --git a/apps/lang/english.lang b/apps/lang/english.lang
index 984aa1be95..6a7d752ec6 100644
--- a/apps/lang/english.lang
+++ b/apps/lang/english.lang
@@ -9660,3 +9660,120 @@
     *: "Full Path"
   </voice>
 </phrase>
+<phrase>
+  id: LANG_RECORD_AGC_PRESET
+  desc: automatic gain control in record settings
+  <source>
+    *: "Automatic Gain Control"
+  </source>
+  <dest>
+    *: "Automatic Gain Control"
+  </dest>
+  <voice>
+    *: "pixels"
+  </voice>
+</phrase>
+<phrase>
+  id: LANG_AGC_SAFETY
+  desc: AGC preset
+  <source>
+    *: "Safety (clip)"
+  </source>
+  <dest>
+    *: "Safety (clip)"
+  </dest>
+  <voice>
+    *: "pixels"
+  </voice>
+</phrase>
+<phrase>
+  id: LANG_AGC_LIVE
+  desc: AGC preset
+  <source>
+    *: "Live (slow)"
+  </source>
+  <dest>
+    *: "Live (slow)"
+  </dest>
+  <voice>
+    *: "pixels"
+  </voice>
+</phrase>
+<phrase>
+  id: LANG_AGC_DJSET
+  desc: AGC preset
+  <source>
+    *: "DJ-Set (slow)"
+  </source>
+  <dest>
+    *: "DJ-Set (slow)"
+  </dest>
+  <voice>
+    *: "pixels"
+  </voice>
+</phrase>
+<phrase>
+  id: LANG_AGC_MEDIUM
+  desc: AGC preset
+  <source>
+    *: "Medium"
+  </source>
+  <dest>
+    *: "Medium"
+  </dest>
+  <voice>
+    *: "pixels"
+  </voice>
+</phrase>
+<phrase>
+  id: LANG_AGC_VOICE
+  desc: AGC preset
+  <source>
+    *: "Voice (fast)"
+  </source>
+  <dest>
+    *: "Voice (fast)"
+  </dest>
+  <voice>
+    *: "pixels"
+  </voice>
+</phrase>
+<phrase>
+  id: LANG_RECORD_AGC_CLIPTIME
+  desc: in record settings
+  <source>
+    *: "AGC clip time"
+  </source>
+  <dest>
+    *: "AGC clip time"
+  </dest>
+  <voice>
+    *: "pixels"
+  </voice>
+</phrase>
+<phrase>
+  id: LANG_RECORDING_AGC_PRESET
+  desc: automatic gain control in recording screen
+  <source>
+    *: "AGC"
+  </source>
+  <dest>
+    *: "AGC"
+  </dest>
+  <voice>
+    *: "pixels"
+  </voice>
+</phrase>
+<phrase>
+  id: LANG_RECORDING_AGC_MAXGAIN
+  desc: AGC maximum gain in recording screen
+  <source>
+    *: "AGC max. gain"
+  </source>
+  <dest>
+    *: "AGC max. gain"
+  </dest>
+  <voice>
+    *: "pixels"
+  </voice>
+</phrase>
diff --git a/apps/recorder/peakmeter.c b/apps/recorder/peakmeter.c
index 0f8da98308..58c85b2161 100644
--- a/apps/recorder/peakmeter.c
+++ b/apps/recorder/peakmeter.c
@@ -62,6 +62,10 @@ 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;
+#ifdef HAVE_AGC
+static int pm_peakhold_left;   /* max. peak values between peakhold calls */
+static int pm_peakhold_right;  /* used for AGC and histogram display */
+#endif
 
 /* Clip hold */
 static bool pm_clip_left = false;  /* when true a clip has occurred */
@@ -716,6 +720,10 @@ static int peak_meter_read_l(void)
        by peak_meter_peek since the last call of peak_meter_read_l */
     int retval = pm_max_left;
 
+#ifdef HAVE_AGC
+    /* store max peak value for peak_meter_get_peakhold_x readout */
+    pm_peakhold_left = MAX(pm_max_left, pm_peakhold_left);
+#endif
 #ifdef PM_DEBUG
     peek_calls = 0;
 #endif
@@ -737,6 +745,10 @@ static int peak_meter_read_r(void)
        by peak_meter_peek since the last call of peak_meter_read_r */
     int retval = pm_max_right;
 
+#ifdef HAVE_AGC
+    /* store max peak value for peak_meter_get_peakhold_x readout */
+    pm_peakhold_right = MAX(pm_max_right, pm_peakhold_right);
+#endif
 #ifdef PM_DEBUG
     peek_calls = 0;
 #endif
@@ -746,6 +758,23 @@ static int peak_meter_read_r(void)
     return retval;
 }
 
+#ifdef HAVE_AGC
+/**
+ * Reads out the current peak-hold values since the last call.
+ * This is used by the histogram feature in the recording screen.
+ * Values are in the range 0 <= peak_x < MAX_PEAK. MAX_PEAK is typ 32767.
+ */
+extern void peak_meter_get_peakhold(int *peak_left, int *peak_right)
+{
+    if (peak_left)
+        *peak_left  = pm_peakhold_left;
+    if (peak_right)
+        *peak_right = pm_peakhold_right;
+    pm_peakhold_left  = 0;
+    pm_peakhold_right = 0;
+}
+#endif
+
 /**
  * Reset the detected clips. This method is for
  * use by the user interface.
diff --git a/apps/recorder/peakmeter.h b/apps/recorder/peakmeter.h
index 5456419181..548b95b7da 100644
--- a/apps/recorder/peakmeter.h
+++ b/apps/recorder/peakmeter.h
@@ -34,7 +34,9 @@ extern void peak_meter_set_clip_hold(int time);
 extern void peak_meter_peek(void);
 extern void peak_meter_init_range( bool dbfs, int range_min, int range_max);
 extern void peak_meter_init_times(int release, int hold, int clip_hold);
-
+#ifdef HAVE_AGC
+extern void peak_meter_get_peakhold(int *peak_left, int *peak_right);
+#endif
 extern void peak_meter_set_min(int newmin);
 extern int  peak_meter_get_min(void);
 extern void peak_meter_set_max(int newmax);
diff --git a/apps/recorder/recording.c b/apps/recorder/recording.c
index 47d2cce674..0d4f12742f 100644
--- a/apps/recorder/recording.c
+++ b/apps/recorder/recording.c
@@ -168,6 +168,63 @@ const char* const freq_str[6] =
     "16kHz"
 };
 
+#ifdef HAVE_AGC
+/* Timing counters:
+ * peak_time is incremented every 0.2s, every 2nd run of record screen loop.
+ * hist_time is incremented every 0.5s, display update.
+ * peak_time is the counter of the peak hold read and agc process,
+ * overflow every 13 years 8-)
+ */
+static long peak_time = 0;
+static long hist_time = 0;
+
+static short peak_valid_mem[4];
+#define BAL_MEM_SIZE 24
+static short balance_mem[BAL_MEM_SIZE];
+
+/* Automatic Gain Control */
+#define AGC_MODE_SIZE 5
+static char* agc_preset_str[] =
+{ "Off", "S", "L", "D", "M", "V" };
+/*  "Off",
+    "Safety (clip)",
+    "Live (slow)",
+    "DJ-Set (slow)",
+    "Medium",
+    "Voice (fast)"  */
+#define AGC_CLIP 32766
+#define AGC_PEAK 29883 /* fast gain reduction threshold -0.8dB */
+#define AGC_HIGH 27254 /* accelerated gain reduction threshold -1.6dB */
+#define AGC_IMG    823 /* threshold for balance control -32dB */
+/* autogain high level thresholds (-3dB, -7dB, -4dB, -5dB, -5dB) */
+const short agc_th_hi[AGC_MODE_SIZE] =
+{ 23197, 14637, 21156, 18428, 18426 };
+/* autogain low level thresholds (-14dB, -11dB, -6dB, -7dB, -8dB) */
+const short agc_th_lo[AGC_MODE_SIZE] =
+{ 6538, 9235, 16422, 14636, 13045 };
+/* autogain threshold times [1/5s] or [200ms] */
+const short agc_tdrop[AGC_MODE_SIZE] =
+{ 900,  225, 150, 60, 8 };
+const short agc_trise[AGC_MODE_SIZE] =
+{ 9000, 750, 400, 150, 20 };
+const short agc_tbal[AGC_MODE_SIZE] =
+{ 4500, 500, 300, 100, 15 };
+/* AGC operation */
+static bool agc_enable = true;
+static short agc_preset;
+/* AGC levels */
+static int agc_left = 0;
+static int agc_right = 0;
+/* AGC time since high target volume was exceeded */
+static short agc_droptime = 0;
+/* AGC time since volume fallen below low target */
+static short agc_risetime = 0;
+/* AGC balance time exceeding +/- 0.7dB */
+static short agc_baltime = 0;
+/* AGC maximum gain */
+static short agc_maxgain;
+#endif /* HAVE_AGC */
+
 static void set_gain(void)
 {
     if(global_settings.rec_source == SOURCE_MIC)
@@ -183,6 +240,229 @@ static void set_gain(void)
     }
 }
 
+#ifdef HAVE_AGC
+/* Read peak meter values & calculate balance.
+ * Returns validity of peak values.
+ * Used for automatic gain control and history diagram.
+ */
+bool read_peak_levels(int *peak_l, int *peak_r, int *balance)
+{
+    peak_meter_get_peakhold(peak_l, peak_r);
+    peak_valid_mem[peak_time % 3] = *peak_l;
+    if (((peak_valid_mem[0] == peak_valid_mem[1]) &&
+         (peak_valid_mem[1] == peak_valid_mem[2])) &&
+        ((*peak_l < 32767)
+#ifndef SIMULATOR
+         || ata_disk_is_active()
+#endif         
+         ))
+            return false;
+
+    if (*peak_r > *peak_l)
+        balance_mem[peak_time % BAL_MEM_SIZE] =
+            MIN((10000 * *peak_r) / *peak_l - 10000, 15118);
+    else
+        balance_mem[peak_time % BAL_MEM_SIZE] =
+            MAX(10000 - (10000 * *peak_l) / *peak_r, -15118);
+    *balance = 0;
+    int i;
+    for (i = 0; i < BAL_MEM_SIZE; i++)
+        *balance += balance_mem[i];
+    *balance = *balance / BAL_MEM_SIZE;
+
+    return true;
+}
+
+/* AGC helper function to check if maximum gain is reached */
+bool agc_gain_is_max(bool left, bool right)
+{
+    /* range -128...+108 [0.5dB] */
+    short gain_current_l;
+    short gain_current_r;
+
+    if (agc_preset == 0)
+        return false;
+
+    if (global_settings.rec_source == SOURCE_LINE)
+    {
+        gain_current_l = global_settings.rec_left_gain;
+        gain_current_r = global_settings.rec_right_gain;
+    } else
+    {
+        gain_current_l = global_settings.rec_mic_gain;
+        gain_current_r = global_settings.rec_mic_gain;
+    }
+
+    return ((left && (gain_current_l >= agc_maxgain)) ||
+            (right && (gain_current_r >= agc_maxgain)));
+}
+
+void change_recording_gain(bool increment, bool left, bool right)
+{
+    int factor = (increment ? 1 : -1);
+
+    if (global_settings.rec_source == SOURCE_LINE)
+    {
+        if(left) global_settings.rec_left_gain += factor;
+        if (right) global_settings.rec_right_gain += factor;
+    }
+    else
+    {
+         global_settings.rec_mic_gain += factor;
+    }
+}
+
+/* 
+ * Handle automatic gain control (AGC).
+ * Change recording gain if peak_x levels are above or below
+ * target volume for specified timeouts.
+ */
+void auto_gain_control(int *peak_l, int *peak_r, int *balance)
+{
+    int agc_mono;
+    short agc_mode;
+    bool increment;
+
+    if (*peak_l > agc_left)
+        agc_left = *peak_l;
+    else
+        agc_left -= (agc_left - *peak_l + 3) >> 2;
+    if (*peak_r > agc_right)
+        agc_right = *peak_r;
+    else
+        agc_right -= (agc_right - *peak_r + 3) >> 2;
+    agc_mono = (agc_left + agc_right) / 2;
+    
+    agc_mode = abs(agc_preset) - 1;
+    if (agc_mode < 0) {
+        agc_enable = false;
+        return;
+    }
+
+    /* Automatic balance control */
+    if ((agc_left > AGC_IMG) && (agc_right > AGC_IMG))
+    {
+        if (*balance < -556)
+        {
+            if (*balance > -900)
+                agc_baltime -= !(peak_time % 4); /* 0.47 - 0.75dB */
+            else if (*balance > -4125)
+                agc_baltime--;                   /* 0.75 - 3.00dB */
+            else if (*balance > -7579)
+                agc_baltime -= 2;                /* 3.00 - 4.90dB */
+            else
+                agc_baltime -= !(peak_time % 8); /* 4.90 - inf dB */
+            if (agc_baltime > 0)
+                agc_baltime -= (peak_time % 2);
+        }
+        else if (*balance > 556)
+        {
+            if (*balance < 900)
+                agc_baltime += !(peak_time % 4);
+            else if (*balance < 4125)
+                agc_baltime++;
+            else if (*balance < 7579)
+                agc_baltime += 2;
+            else
+                agc_baltime += !(peak_time % 8);
+            if (agc_baltime < 0)
+                agc_baltime += (peak_time % 2);
+        }
+
+        if ((*balance * agc_baltime) < 0)
+        {
+            if (*balance < 0)
+                agc_baltime -= peak_time % 2;
+            else
+                agc_baltime += peak_time % 2;
+        }
+
+        increment = ((agc_risetime / 2) > agc_droptime);
+        
+        if (agc_baltime < -agc_tbal[agc_mode])
+        {
+            if (!increment || !agc_gain_is_max(!increment, increment)) {
+                change_recording_gain(increment, !increment, increment);
+                set_gain();
+            }
+            agc_baltime = 0;
+        }
+        else if (agc_baltime > +agc_tbal[agc_mode])
+        {
+            if (!increment || !agc_gain_is_max(increment, !increment)) {
+                change_recording_gain(increment, increment, !increment);
+                set_gain();
+            }
+            agc_baltime = 0;
+        }
+    }
+    else if (!(hist_time % 4))
+    {
+        if (agc_baltime < 0)
+            agc_baltime++;
+        else
+            agc_baltime--;
+    }
+    
+    /* Automatic gain control */
+    if ((agc_left > agc_th_hi[agc_mode]) || (agc_right > agc_th_hi[agc_mode]))
+    {
+        if ((agc_left > AGC_CLIP) || (agc_right > AGC_CLIP))
+            agc_droptime += agc_tdrop[agc_mode] /
+                            (global_settings.rec_agc_cliptime + 1);
+        if (agc_left  > AGC_HIGH) {
+            agc_droptime++;
+            agc_risetime=0;
+            if (agc_left > AGC_PEAK)
+                agc_droptime += 2;
+        }
+        if (agc_right > AGC_HIGH) {
+            agc_droptime++;
+            agc_risetime=0;
+            if (agc_right > AGC_PEAK)
+                agc_droptime += 2;
+        }
+        if (agc_mono > agc_th_hi[agc_mode])
+            agc_droptime++;
+        else
+            agc_droptime += !(peak_time % 2);
+    
+        if (agc_droptime >= agc_tdrop[agc_mode])
+        {
+            change_recording_gain(false, true, true);
+            agc_droptime = 0;
+            agc_risetime = 0;
+            set_gain();
+        }
+        agc_risetime = MAX(agc_risetime - 1, 0);
+    }
+    else if (agc_mono < agc_th_lo[agc_mode])
+    {
+        if (agc_mono < (agc_th_lo[agc_mode] / 8))
+            agc_risetime += !(peak_time % 5);
+        else if (agc_mono < (agc_th_lo[agc_mode] / 2))
+            agc_risetime += 2;
+        else
+            agc_risetime++;
+    
+        if (agc_risetime >= agc_trise[agc_mode]) {
+            if (!agc_gain_is_max(true, true)) {
+                change_recording_gain(true, true, true);
+                set_gain();
+            }
+            agc_risetime = 0;
+            agc_droptime = 0;
+        }
+        agc_droptime = MAX(agc_droptime - 1, 0);
+    }
+    else if (!(peak_time % 6)) /* on target level every 1.2 sec */
+    {
+        agc_risetime = MAX(agc_risetime - 1, 0);
+        agc_droptime = MAX(agc_droptime - 1, 0);
+    }
+}
+#endif /* HAVE_AGC */
+
 static const char* const fmtstr[] =
 {
     "%c%d %s",            /* no decimals */
@@ -226,6 +506,22 @@ void adjust_cursor(void)
     if(cursor < 0)
         cursor = 0;
 
+#ifdef HAVE_AGC
+    switch(global_settings.rec_source)
+    {
+    case SOURCE_MIC:
+        if(cursor == 2)
+            cursor = 4;
+        else if(cursor == 3)
+            cursor = 1;
+    case SOURCE_LINE:
+        max_cursor = 5;
+        break;
+    default:
+        max_cursor = 0;
+        break;
+    }
+#else
     switch(global_settings.rec_source)
     {
     case SOURCE_MIC:
@@ -238,6 +534,7 @@ void adjust_cursor(void)
         max_cursor = 0;
         break;
     }
+#endif /* HAVE_AGC */
 
     if(cursor > max_cursor)
         cursor = max_cursor;
@@ -353,6 +650,14 @@ bool recording_screen(void)
     bool led_state = false;
     int led_countdown = 2;
 #endif
+#ifdef HAVE_AGC
+    bool peak_read = false;
+    bool peak_valid = false;
+    int peak_l, peak_r;
+    int balance = 0;
+    bool display_agc[NB_SCREENS];
+#endif
+    int line[NB_SCREENS];
     int i;
     int filename_offset[NB_SCREENS];
     int pm_y[NB_SCREENS];
@@ -392,6 +697,9 @@ bool recording_screen(void)
     peak_meter_playback(true);
 #endif
     peak_meter_enabled = true;
+#ifdef HAVE_AGC
+    peak_meter_get_peakhold(&peak_l, &peak_r);
+#endif
 
 #if CONFIG_CODEC != SWCODEC
     if (global_settings.rec_prerecord_time)
@@ -414,6 +722,23 @@ bool recording_screen(void)
 
     settings_apply_trigger();
 
+#ifdef HAVE_AGC
+    agc_preset_str[0] = str(LANG_OFF);
+    agc_preset_str[1] = str(LANG_AGC_SAFETY);
+    agc_preset_str[2] = str(LANG_AGC_LIVE);
+    agc_preset_str[3] = str(LANG_AGC_DJSET);
+    agc_preset_str[4] = str(LANG_AGC_MEDIUM);
+    agc_preset_str[5] = str(LANG_AGC_VOICE);
+    if (global_settings.rec_source == SOURCE_MIC) {
+        agc_preset = global_settings.rec_agc_preset_mic;
+        agc_maxgain = global_settings.rec_agc_maxgain_mic;
+    }
+    else {
+        agc_preset = global_settings.rec_agc_preset_line;
+        agc_maxgain = global_settings.rec_agc_maxgain_line;
+    }
+#endif
+
     FOR_NB_SCREENS(i)
     {
         screens[i].setfont(FONT_SYSFIXED);
@@ -698,6 +1023,33 @@ bool recording_screen(void)
                            sound_max(SOUND_RIGHT_GAIN))
                             global_settings.rec_right_gain++;
                         break;
+#ifdef HAVE_AGC
+                    case 4:
+                        agc_preset = MIN(agc_preset + 1, AGC_MODE_SIZE);
+                        agc_enable = (agc_preset != 0);
+                        if (global_settings.rec_source == SOURCE_MIC) {
+                            global_settings.rec_agc_preset_mic = agc_preset;
+                            agc_maxgain = global_settings.rec_agc_maxgain_mic;
+                        } else {
+                            global_settings.rec_agc_preset_line = agc_preset;
+                            agc_maxgain = global_settings.rec_agc_maxgain_line;
+                        }
+                        break;
+                    case 5:
+                        if (global_settings.rec_source == SOURCE_MIC)
+                        {
+                            agc_maxgain = MIN(agc_maxgain + 1,
+                                              sound_max(SOUND_MIC_GAIN));
+                            global_settings.rec_agc_maxgain_mic = agc_maxgain;
+                        }
+                        else
+                        {
+                            agc_maxgain = MIN(agc_maxgain + 1,
+                                              sound_max(SOUND_LEFT_GAIN));
+                            global_settings.rec_agc_maxgain_line = agc_maxgain;
+                        }
+                        break;
+#endif
                 }
                 set_gain();
                 update_countdown = 1; /* Update immediately */
@@ -744,6 +1096,33 @@ bool recording_screen(void)
                            sound_min(SOUND_RIGHT_GAIN))
                             global_settings.rec_right_gain--;
                         break;
+#ifdef HAVE_AGC
+                    case 4:
+                        agc_preset = MAX(agc_preset - 1, 0);
+                        agc_enable = (agc_preset != 0);
+                        if (global_settings.rec_source == SOURCE_MIC) {
+                            global_settings.rec_agc_preset_mic = agc_preset;
+                            agc_maxgain = global_settings.rec_agc_maxgain_mic;
+                        } else {
+                            global_settings.rec_agc_preset_line = agc_preset;
+                            agc_maxgain = global_settings.rec_agc_maxgain_line;
+                        }
+                        break;
+                    case 5:
+                        if (global_settings.rec_source == SOURCE_MIC)
+                        {
+                            agc_maxgain = MAX(agc_maxgain - 1,
+                                              sound_min(SOUND_MIC_GAIN));
+                            global_settings.rec_agc_maxgain_mic = agc_maxgain;
+                        }
+                        else
+                        {
+                            agc_maxgain = MAX(agc_maxgain - 1,
+                                              sound_min(SOUND_LEFT_GAIN));
+                            global_settings.rec_agc_maxgain_line = agc_maxgain;
+                        }
+                        break;
+#endif
                 }
                 set_gain();
                 update_countdown = 1; /* Update immediately */
@@ -777,6 +1156,16 @@ bool recording_screen(void)
                                                global_settings.rec_channels,
                                                global_settings.rec_editable,
                                                global_settings.rec_prerecord_time);
+#ifdef HAVE_AGC
+                    if (global_settings.rec_source == SOURCE_MIC) {
+                        agc_preset = global_settings.rec_agc_preset_mic;
+                        agc_maxgain = global_settings.rec_agc_maxgain_mic;
+                    }
+                    else {
+                        agc_preset = global_settings.rec_agc_preset_line;
+                        agc_maxgain = global_settings.rec_agc_maxgain_line;
+                    }
+#endif
 
                     adjust_cursor();
                     set_gain();
@@ -854,6 +1243,18 @@ bool recording_screen(void)
         if (button != BUTTON_NONE)
             lastbutton = button;
 
+#ifdef HAVE_AGC
+        peak_read = !peak_read;
+        if (peak_read) { /* every 2nd run of loop */
+            peak_time++;
+            peak_valid = read_peak_levels(&peak_l, &peak_r, &balance);
+        }
+
+        /* Handle AGC every 200ms when enabled and peak data is valid */
+        if (peak_read && agc_enable && peak_valid)
+            auto_gain_control(&peak_l, &peak_r, &balance);
+#endif
+
             FOR_NB_SCREENS(i)       
                 screens[i].setfont(FONT_SYSFIXED);
 
@@ -1041,10 +1442,101 @@ bool recording_screen(void)
                         screens[i].puts(0, filename_offset[i] + 
                                             PM_HEIGHT + 4, buf);
                 }                
+            }
+
+            FOR_NB_SCREENS(i)
+            {
+                if (global_settings.rec_source == SOURCE_LINE)
+                    line[i] = 5;
+                else if (global_settings.rec_source == SOURCE_MIC)
+                    line[i] = 4;
+#ifdef HAVE_SPDIF_IN
+                else if (global_settings.rec_source == SOURCE_SPDIF)
+                    line[i] = 3;
+#endif
+#ifdef HAVE_AGC
+                if (screens[i].height < h * (2 + filename_offset[i] + PM_HEIGHT + line[i]))
+                {
+                    line[i] -= 1;
+                    display_agc[i] = false;
+                }
+                else 
+                    display_agc[i] = true;
+ 
+                if ((cursor==4) || (cursor==5))
+                    display_agc[i] = true;
+             }
+
+            /************** AGC test info ******************
+            snprintf(buf, 32, "D:%d U:%d",
+                     (agc_droptime+2)/5, (agc_risetime+2)/5);
+            lcd_putsxy(1, LCD_HEIGHT - 8, buf);
+            snprintf(buf, 32, "B:%d",
+                     (agc_baltime+2)/5);
+            lcd_putsxy(LCD_WIDTH/2 + 3, LCD_HEIGHT - 8, buf);
+            ***********************************************/
+
+            if (cursor == 5)
+                snprintf(buf, 32, "%s: %s",
+                         str(LANG_RECORDING_AGC_MAXGAIN),
+                         fmt_gain(SOUND_LEFT_GAIN,
+                                  agc_maxgain, buf2, sizeof(buf2)));
+            else if (agc_preset == 0)
+                snprintf(buf, 32, "%s: %s",
+                         str(LANG_RECORDING_AGC_PRESET),
+                         agc_preset_str[agc_preset]);
+            else if (global_settings.rec_source == SOURCE_MIC)
+                snprintf(buf, 32, "%s: %s%s",
+                         str(LANG_RECORDING_AGC_PRESET),
+                         agc_preset_str[agc_preset],
+                         fmt_gain(SOUND_LEFT_GAIN,
+                             agc_maxgain -
+                             global_settings.rec_mic_gain,
+                             buf2, sizeof(buf2)));
+            else
+                snprintf(buf, 32, "%s: %s%s",
+                         str(LANG_RECORDING_AGC_PRESET),
+                         agc_preset_str[agc_preset],
+                         fmt_gain(SOUND_LEFT_GAIN,
+                             agc_maxgain -
+                            (global_settings.rec_left_gain +
+                             global_settings.rec_right_gain)/2,
+                             buf2, sizeof(buf2)));                         
 
+            if(global_settings.invert_cursor && ((cursor==4) || (cursor==5)))
+            {
+                for(i = 0; i < screen_update; i++)
+                    screens[i].puts_style_offset(0, filename_offset[i] + 
+                                        PM_HEIGHT + line[i], buf, STYLE_INVERT,0);
             }
+            else if ((global_settings.rec_source == SOURCE_MIC) 
+                    || (global_settings.rec_source == SOURCE_LINE))    
+            {
+                for(i = 0; i < screen_update; i++) {
+                    if (display_agc[i]) {
+                        screens[i].puts(0, filename_offset[i] + 
+                                        PM_HEIGHT + line[i], buf);
+                    }
+                }
+            }
+            
+            if (global_settings.rec_source == SOURCE_MIC)
+            {
+                if(agc_maxgain < (global_settings.rec_mic_gain))
+                    change_recording_gain(false, true, true);
+            }
+            else
+            {
+                if(agc_maxgain < (global_settings.rec_left_gain))
+                    change_recording_gain(false, true, false);
+                if(agc_maxgain < (global_settings.rec_right_gain))
+                    change_recording_gain(false, false, true);
+            }
+#else
+            }
+#endif /* HAVE_AGC */
 
-            if(!global_settings.invert_cursor){
+            if(!global_settings.invert_cursor) {
                 switch(cursor)
                 {
                     case 1:
@@ -1073,6 +1565,15 @@ bool recording_screen(void)
                                                     filename_offset[i] + 
                                                     PM_HEIGHT + 4, true);
                     break;
+#ifdef HAVE_AGC
+                    case 4:
+                    case 5:
+                        for(i = 0; i < screen_update; i++)
+                            screen_put_cursorxy(&screens[i], 0,
+                                                filename_offset[i] + 
+                                                PM_HEIGHT + line[i], true);
+                        break;
+#endif /* HAVE_AGC */
                     default:
                         for(i = 0; i < screen_update; i++)
                             screen_put_cursorxy(&screens[i], 0, 
@@ -1096,9 +1597,20 @@ bool recording_screen(void)
                      global_settings.rec_channels ?
                          str(LANG_SYSFONT_CHANNEL_MONO) :
                          str(LANG_SYSFONT_CHANNEL_STEREO));
-            for(i = 0; i < screen_update; i++)
-                screens[i].puts(0, filename_offset[i] + PM_HEIGHT + 5, buf);
 
+            for(i = 0; i < screen_update; i++) {
+#ifdef HAVE_AGC
+                if ((global_settings.rec_source == SOURCE_MIC)
+                         || (global_settings.rec_source == SOURCE_LINE))
+                    screens[i].puts(0, filename_offset[i] + PM_HEIGHT + line[i] + 1, buf);
+                else
+#endif
+                    screens[i].puts(0, filename_offset[i] + PM_HEIGHT + line[i], buf);
+            }
+
+#ifdef HAVE_AGC
+            hist_time++;
+#endif
             for(i = 0; i < screen_update; i++)
             {
                 gui_statusbar_draw(&(statusbars.statusbars[i]), true);
diff --git a/apps/settings.c b/apps/settings.c
index f70e29696b..cd984254d9 100644
--- a/apps/settings.c
+++ b/apps/settings.c
@@ -615,7 +615,13 @@ static const struct bit_entry hd_bits[] =
     {1, S_O(hold_lr_for_scroll_in_list), true, "hold_lr_for_scroll_in_list", off_on },
 
     {2, S_O(show_path_in_browser), 0, "show path in browser", "off,current directory,full path" },
-
+#ifdef HAVE_AGC
+    {4, S_O(rec_agc_preset_mic), 1, "agc mic preset", NULL}, /* 0...5 */
+    {4, S_O(rec_agc_preset_line), 1, "agc line preset", NULL}, /* 0...5 */
+    {8|SIGNED, S_O(rec_agc_maxgain_mic), 104, "agc maximum mic gain", NULL},
+    {8|SIGNED, S_O(rec_agc_maxgain_line), 96, "agc maximum line gain", NULL},
+    {3, S_O(rec_agc_cliptime), 1, "agc cliptime", "0.2s,0.4s,0.6s,0.8,1s"},
+#endif
     /* If values are just added to the end, no need to bump the version. */
     /* new stuff to be added at the end */
 
diff --git a/apps/settings.h b/apps/settings.h
index 27f00584a6..d87bc5ee06 100644
--- a/apps/settings.h
+++ b/apps/settings.h
@@ -180,6 +180,26 @@ struct user_settings
     int rec_stop_gap;       /* index of trig_durations */
     int rec_trigger_mode;   /* see TRIG_MODE_XXX constants */
 
+#ifdef HAVE_AGC
+    int rec_agc_preset_mic; /* AGC mic preset modes:
+                             0 = Off
+                             1 = Safety (clip)
+                             2 = Live (slow)
+                             3 = DJ-Set (slow)
+                             4 = Medium
+                             5 = Voice (fast) */
+    int rec_agc_preset_line; /* AGC line-in preset modes:
+                              0 = Off
+                              1 = Safety (clip)
+                              2 = Live (slow)
+                              3 = DJ-Set (slow)
+                              4 = Medium
+                              5 = Voice (fast) */
+    int rec_agc_maxgain_mic;  /* AGC maximum mic gain */
+    int rec_agc_maxgain_line; /* AGC maximum line-in gain */
+    int rec_agc_cliptime;     /* 0.2, 0.4, 0.6, 0.8, 1s */
+#endif
+
     /* device settings */
 
 #ifdef HAVE_LCD_CONTRAST
diff --git a/apps/sound_menu.c b/apps/sound_menu.c
index 280fe52169..34ed9af000 100644
--- a/apps/sound_menu.c
+++ b/apps/sound_menu.c
@@ -516,6 +516,41 @@ static bool cliplight(void)
 }
 #endif /*CONFIG_BACKLIGHT */
 
+#ifdef HAVE_AGC
+static bool agc_preset(void)
+{
+    static const struct opt_items names[] = {
+        { STR(LANG_OFF) },
+        { STR(LANG_AGC_SAFETY) },
+        { STR(LANG_AGC_LIVE) },
+        { STR(LANG_AGC_DJSET) },
+        { STR(LANG_AGC_MEDIUM) },
+        { STR(LANG_AGC_VOICE) },
+    };
+    if (global_settings.rec_source)
+        return set_option(str(LANG_RECORD_AGC_PRESET),
+                          &global_settings.rec_agc_preset_line,
+                          INT, names, 6, NULL );
+    else
+        return set_option(str(LANG_RECORD_AGC_PRESET),
+                          &global_settings.rec_agc_preset_mic,
+                          INT, names, 6, NULL );
+}
+
+static bool agc_cliptime(void)
+{
+    static const struct opt_items names[] = {
+        { "200ms", TALK_ID(200, UNIT_MS) },
+        { "400ms", TALK_ID(400, UNIT_MS) },
+        { "600ms", TALK_ID(600, UNIT_MS) },
+        { "800ms", TALK_ID(800, UNIT_MS) },
+        { "1s", TALK_ID(1, UNIT_SEC) }
+    };
+    return set_option(str(LANG_RECORD_AGC_CLIPTIME),
+                      &global_settings.rec_agc_cliptime,
+                      INT, names, 5, NULL );
+}
+#endif /* HAVE_AGC */
 #endif /* HAVE_RECORDING */
 
 static bool chanconf(void)
@@ -1015,6 +1050,12 @@ bool recording_menu(bool no_source)
     items[i].desc = ID2P(LANG_RECORD_TRIGGER);
     items[i++].function = rectrigger;
 #endif
+#ifdef HAVE_AGC
+    items[i].desc = ID2P(LANG_RECORD_AGC_PRESET);
+    items[i++].function = agc_preset;
+    items[i].desc = ID2P(LANG_RECORD_AGC_CLIPTIME);
+    items[i++].function = agc_cliptime;
+#endif
 
     m=menu_init( items, i, NULL, NULL, NULL, NULL);
     result = menu_run(m);