Consolidate compressor settings into a struct.

Doing that makes things cleaner for later on.

Change-Id: I4e279aa57ace16a348acc0fc09059592325ec95f

1 files changed, 183 insertions, 185 deletions

diff --git a/lib/rbcodec/dsp/compressor.c b/lib/rbcodec/dsp/compressor.c
index 3a8d52e..a6c1ac1 100644
--- a/lib/rbcodec/dsp/compressor.c
+++ b/lib/rbcodec/dsp/compressor.c
@@ -29,6 +29,8 @@
 /*#define LOGF_ENABLE*/
 #include "logf.h"
 
+static struct compressor_settings curr_set; /* Cached settings */
+
 static int32_t comp_rel_slope IBSS_ATTR;   /* S7.24 format */
 static int32_t comp_makeup_gain IBSS_ATTR; /* S7.24 format */
 static int32_t comp_curve[66] IBSS_ATTR;   /* S7.24 format */
@@ -38,214 +40,210 @@ static int32_t release_gain IBSS_ATTR;     /* S7.24 format */
 
 /** COMPRESSOR UPDATE
  *  Called via the menu system to configure the compressor process */
-bool compressor_update(void)
+bool compressor_update(const struct compressor_settings *settings)
 {
-    static int curr_set[5];
-    int new_set[5] = {
-        global_settings.compressor_threshold,
-        global_settings.compressor_makeup_gain,
-        global_settings.compressor_ratio,
-        global_settings.compressor_knee,
-        global_settings.compressor_release_time};
-    
-    /* make menu values useful */
-    int  threshold  =  new_set[0];
-    bool auto_gain  = (new_set[1] == 1);
-    const int comp_ratios[] = {2, 4, 6, 10, 0};
-    int  ratio      =  comp_ratios[new_set[2]];
-    bool soft_knee  = (new_set[3] == 1);
-    int  release    =  new_set[4] * NATIVE_FREQUENCY / 1000;
+    /* make settings values useful */
+    int  threshold  = settings->threshold;
+    bool auto_gain  = settings->makeup_gain == 1;
+    static const int comp_ratios[] = { 2, 4, 6, 10, 0 };
+    int  ratio      = comp_ratios[settings->ratio];
+    bool soft_knee  = settings->knee == 1;
+    int  release    = settings->release_time * NATIVE_FREQUENCY / 1000;
 
     bool changed = false;
-    bool active  = (threshold < 0);
+    bool active  = threshold < 0;
 
-    for (int i = 0; i < 5; i++)
+    if (memcmp(settings, &curr_set, sizeof (curr_set)))
     {
-        if (curr_set[i] != new_set[i])
-        {
-            changed = true;
-            curr_set[i] = new_set[i];
+        /* Compressor settings have changed since last call */
+        changed = true;
             
 #if defined(ROCKBOX_HAS_LOGF) && defined(LOGF_ENABLE)
-            switch (i)
-            {
-            case 0:
-                logf("   Compressor Threshold: %d dB\tEnabled: %s",
-                    threshold, active ? "Yes" : "No");
-                break;
-            case 1:
-                logf("   Compressor Makeup Gain: %s",
-                    auto_gain ? "Auto" : "Off");
-                break;
-            case 2:
-                if (ratio)
-                    { logf("   Compressor Ratio: %d:1", ratio); }
-                else
-                    { logf("   Compressor Ratio: Limit"); }
-                break;
-            case 3:
-                logf("   Compressor Knee: %s", soft_knee?"Soft":"Hard");
-                break;
-            case 4:
-                logf("   Compressor Release: %d", release);
-                break;
-            }
-#endif
+        if (settings->threshold != curr_set.threshold)
+        {
+            logf("   Compressor Threshold: %d dB\tEnabled: %s",
+                 threshold, active ? "Yes" : "No");
         }
-    }
 
-    if (changed && active)
-    {
-        /* configure variables for compressor operation */
-        static const int32_t db[] = {
-            /* positive db equivalents in S15.16 format */
-            0x000000, 0x241FA4, 0x1E1A5E, 0x1A94C8,
-            0x181518, 0x1624EA, 0x148F82, 0x1338BD,
-            0x120FD2, 0x1109EB, 0x101FA4, 0x0F4BB6,
-            0x0E8A3C, 0x0DD840, 0x0D3377, 0x0C9A0E,
-            0x0C0A8C, 0x0B83BE, 0x0B04A5, 0x0A8C6C,
-            0x0A1A5E, 0x09ADE1, 0x094670, 0x08E398,
-            0x0884F6, 0x082A30, 0x07D2FA, 0x077F0F,
-            0x072E31, 0x06E02A, 0x0694C8, 0x064BDF,
-            0x060546, 0x05C0DA, 0x057E78, 0x053E03,
-            0x04FF5F, 0x04C273, 0x048726, 0x044D64,
-            0x041518, 0x03DE30, 0x03A89B, 0x037448,
-            0x03412A, 0x030F32, 0x02DE52, 0x02AE80,
-            0x027FB0, 0x0251D6, 0x0224EA, 0x01F8E2,
-            0x01CDB4, 0x01A359, 0x0179C9, 0x0150FC,
-            0x0128EB, 0x010190, 0x00DAE4, 0x00B4E1,
-            0x008F82, 0x006AC1, 0x004699, 0x002305};
-        
-        struct curve_point
+        if (settings->makeup_gain != curr_set.makeup_gain)
         {
-            int32_t db;     /* S15.16 format */
-            int32_t offset; /* S15.16 format */
-        } db_curve[5];
-        
-        /** Set up the shape of the compression curve first as decibel
-            values */
-        /* db_curve[0] = bottom of knee
-                   [1] = threshold
-                   [2] = top of knee
-                   [3] = 0 db input
-                   [4] = ~+12db input (2 bits clipping overhead) */
-        
-        db_curve[1].db = threshold << 16;
-        if (soft_knee)
+            logf("   Compressor Makeup Gain: %s",
+                 auto_gain ? "Auto" : "Off");
+         }
+
+        if (settings->ratio != cur_set.ratio)
         {
-            /* bottom of knee is 3dB below the threshold for soft knee*/
-            db_curve[0].db = db_curve[1].db - (3 << 16);
-            /* top of knee is 3dB above the threshold for soft knee */
-            db_curve[2].db = db_curve[1].db + (3 << 16);
             if (ratio)
-                /* offset = -3db * (ratio - 1) / ratio */
-                db_curve[2].offset = (int32_t)((long long)(-3 << 16)
-                    * (ratio - 1) / ratio);
+                { logf("   Compressor Ratio: %d:1", ratio); }
             else
-                /* offset = -3db for hard limit */
-                db_curve[2].offset = (-3 << 16);
+                { logf("   Compressor Ratio: Limit"); }
         }
-        else
+
+        if (settings->knee != cur_set.knee)
         {
-            /* bottom of knee is at the threshold for hard knee */
-            db_curve[0].db = threshold << 16;
-            /* top of knee is at the threshold for hard knee */
-            db_curve[2].db = threshold << 16;
-            db_curve[2].offset = 0;
+            logf("   Compressor Knee: %s", soft_knee?"Soft":"Hard");
         }
-        
-        /* Calculate 0db and ~+12db offsets */
-        db_curve[4].db = 0xC0A8C; /* db of 2 bits clipping */
-        if (ratio)
+
+        if (settings->release_time != cur_set.release_time)
         {
-            /* offset = threshold * (ratio - 1) / ratio */
-            db_curve[3].offset = (int32_t)((long long)(threshold << 16)
-                * (ratio - 1) / ratio);
-            db_curve[4].offset = (int32_t)((long long)-db_curve[4].db
-                * (ratio - 1) / ratio) + db_curve[3].offset;
+            logf("   Compressor Release: %d", release);
         }
+#endif
+
+        curr_set = *settings;
+    }
+
+    if (!changed || !active)
+        return active;
+
+    /* configure variables for compressor operation */
+    static const int32_t db[] = {
+        /* positive db equivalents in S15.16 format */
+        0x000000, 0x241FA4, 0x1E1A5E, 0x1A94C8,
+        0x181518, 0x1624EA, 0x148F82, 0x1338BD,
+        0x120FD2, 0x1109EB, 0x101FA4, 0x0F4BB6,
+        0x0E8A3C, 0x0DD840, 0x0D3377, 0x0C9A0E,
+        0x0C0A8C, 0x0B83BE, 0x0B04A5, 0x0A8C6C,
+        0x0A1A5E, 0x09ADE1, 0x094670, 0x08E398,
+        0x0884F6, 0x082A30, 0x07D2FA, 0x077F0F,
+        0x072E31, 0x06E02A, 0x0694C8, 0x064BDF,
+        0x060546, 0x05C0DA, 0x057E78, 0x053E03,
+        0x04FF5F, 0x04C273, 0x048726, 0x044D64,
+        0x041518, 0x03DE30, 0x03A89B, 0x037448,
+        0x03412A, 0x030F32, 0x02DE52, 0x02AE80,
+        0x027FB0, 0x0251D6, 0x0224EA, 0x01F8E2,
+        0x01CDB4, 0x01A359, 0x0179C9, 0x0150FC,
+        0x0128EB, 0x010190, 0x00DAE4, 0x00B4E1,
+        0x008F82, 0x006AC1, 0x004699, 0x002305};
+
+    struct curve_point
+    {
+        int32_t db;     /* S15.16 format */
+        int32_t offset; /* S15.16 format */
+    } db_curve[5];
+
+    /** Set up the shape of the compression curve first as decibel
+        values */
+    /* db_curve[0] = bottom of knee
+               [1] = threshold
+               [2] = top of knee
+               [3] = 0 db input
+               [4] = ~+12db input (2 bits clipping overhead) */
+
+    db_curve[1].db = threshold << 16;
+    if (soft_knee)
+    {
+        /* bottom of knee is 3dB below the threshold for soft knee*/
+        db_curve[0].db = db_curve[1].db - (3 << 16);
+        /* top of knee is 3dB above the threshold for soft knee */
+        db_curve[2].db = db_curve[1].db + (3 << 16);
+        if (ratio)
+            /* offset = -3db * (ratio - 1) / ratio */
+            db_curve[2].offset = (int32_t)((long long)(-3 << 16)
+                * (ratio - 1) / ratio);
         else
-        {
-            /* offset = threshold for hard limit */
-            db_curve[3].offset = (threshold << 16);
-            db_curve[4].offset = -db_curve[4].db + db_curve[3].offset;
-        }
-        
-        /** Now set up the comp_curve table with compression offsets in the
-            form of gain factors in S7.24 format */
-        /* comp_curve[0] is 0 (-infinity db) input */
-        comp_curve[0] = UNITY;
-        /* comp_curve[1 to 63] are intermediate compression values 
-           corresponding to the 6 MSB of the input values of a non-clipped
-           signal */
-        for (int i = 1; i < 64; i++)
-        {
-            /* db constants are stored as positive numbers;
-               make them negative here */
-            int32_t this_db = -db[i];
-            
-            /* no compression below the knee */
-            if (this_db <= db_curve[0].db)
-                comp_curve[i] = UNITY;
-            
-            /* if soft knee and below top of knee,
-               interpolate along soft knee slope */
-            else if (soft_knee && (this_db <= db_curve[2].db))
-                comp_curve[i] = fp_factor(fp_mul(
-                    ((this_db - db_curve[0].db) / 6),
-                    db_curve[2].offset, 16), 16) << 8;
-            
-            /* interpolate along ratio slope above the knee */
-            else
-                comp_curve[i] = fp_factor(fp_mul(
-                    fp_div((db_curve[1].db - this_db), db_curve[1].db, 16),
-                    db_curve[3].offset, 16), 16) << 8;
-        }
-        /* comp_curve[64] is the compression level of a maximum level,
-           non-clipped signal */
-        comp_curve[64] = fp_factor(db_curve[3].offset, 16) << 8;
-        
-        /* comp_curve[65] is the compression level of a maximum level,
-           clipped signal */
-        comp_curve[65] = fp_factor(db_curve[4].offset, 16) << 8;
-        
+            /* offset = -3db for hard limit */
+            db_curve[2].offset = (-3 << 16);
+    }
+    else
+    {
+        /* bottom of knee is at the threshold for hard knee */
+        db_curve[0].db = threshold << 16;
+        /* top of knee is at the threshold for hard knee */
+        db_curve[2].db = threshold << 16;
+        db_curve[2].offset = 0;
+    }
+
+    /* Calculate 0db and ~+12db offsets */
+    db_curve[4].db = 0xC0A8C; /* db of 2 bits clipping */
+    if (ratio)
+    {
+        /* offset = threshold * (ratio - 1) / ratio */
+        db_curve[3].offset = (int32_t)((long long)(threshold << 16)
+            * (ratio - 1) / ratio);
+        db_curve[4].offset = (int32_t)((long long)-db_curve[4].db
+            * (ratio - 1) / ratio) + db_curve[3].offset;
+    }
+    else
+    {
+        /* offset = threshold for hard limit */
+        db_curve[3].offset = (threshold << 16);
+        db_curve[4].offset = -db_curve[4].db + db_curve[3].offset;
+    }
+
+    /** Now set up the comp_curve table with compression offsets in the
+        form of gain factors in S7.24 format */
+    /* comp_curve[0] is 0 (-infinity db) input */
+    comp_curve[0] = UNITY;
+    /* comp_curve[1 to 63] are intermediate compression values 
+       corresponding to the 6 MSB of the input values of a non-clipped
+       signal */
+    for (int i = 1; i < 64; i++)
+    {
+        /* db constants are stored as positive numbers;
+           make them negative here */
+        int32_t this_db = -db[i];
+
+        /* no compression below the knee */
+        if (this_db <= db_curve[0].db)
+            comp_curve[i] = UNITY;
+
+        /* if soft knee and below top of knee,
+           interpolate along soft knee slope */
+        else if (soft_knee && (this_db <= db_curve[2].db))
+            comp_curve[i] = fp_factor(fp_mul(
+                ((this_db - db_curve[0].db) / 6),
+                db_curve[2].offset, 16), 16) << 8;
+
+        /* interpolate along ratio slope above the knee */
+        else
+            comp_curve[i] = fp_factor(fp_mul(
+                fp_div((db_curve[1].db - this_db), db_curve[1].db, 16),
+                db_curve[3].offset, 16), 16) << 8;
+    }
+    /* comp_curve[64] is the compression level of a maximum level,
+       non-clipped signal */
+    comp_curve[64] = fp_factor(db_curve[3].offset, 16) << 8;
+
+    /* comp_curve[65] is the compression level of a maximum level,
+       clipped signal */
+    comp_curve[65] = fp_factor(db_curve[4].offset, 16) << 8;
+
 #if defined(ROCKBOX_HAS_LOGF) && defined(LOGF_ENABLE)
-        logf("\n   *** Compression Offsets ***");
-        /* some settings for display only, not used in calculations */
-        db_curve[0].offset = 0;
-        db_curve[1].offset = 0;
-        db_curve[3].db = 0;
-        
-        for (int i = 0; i <= 4; i++)
-        {
-            logf("Curve[%d]: db: % 6.2f\toffset: % 6.2f", i,
-                (float)db_curve[i].db / (1 << 16),
-                (float)db_curve[i].offset / (1 << 16));
-        }
-        
-        logf("\nGain factors:");
-        for (int i = 1; i <= 65; i++)
-        {
-            debugf("%02d: %.6f  ", i, (float)comp_curve[i] / UNITY);
-            if (i % 4 == 0) debugf("\n");
-        }
-        debugf("\n");
-#endif
-        
-        /* if using auto peak, then makeup gain is max offset -
-           .1dB headroom */
-        comp_makeup_gain = auto_gain ?
-            fp_factor(-(db_curve[3].offset) - 0x199A, 16) << 8 : UNITY;
-        logf("Makeup gain:\t%.6f", (float)comp_makeup_gain / UNITY);
+    logf("\n   *** Compression Offsets ***");
+    /* some settings for display only, not used in calculations */
+    db_curve[0].offset = 0;
+    db_curve[1].offset = 0;
+    db_curve[3].db = 0;
 
-        /* calculate per-sample gain change a rate of 10db over release time
-         */
-        comp_rel_slope = 0xAF0BB2 / release;
-        logf("Release slope:\t%.6f", (float)comp_rel_slope / UNITY);
-        
-        release_gain = UNITY;
+    for (int i = 0; i <= 4; i++)
+    {
+        logf("Curve[%d]: db: % 6.2f\toffset: % 6.2f", i,
+            (float)db_curve[i].db / (1 << 16),
+            (float)db_curve[i].offset / (1 << 16));
     }
 
+    logf("\nGain factors:");
+    for (int i = 1; i <= 65; i++)
+    {
+        debugf("%02d: %.6f  ", i, (float)comp_curve[i] / UNITY);
+        if (i % 4 == 0) debugf("\n");
+    }
+    debugf("\n");
+#endif
+
+    /* if using auto peak, then makeup gain is max offset -
+       .1dB headroom */
+    comp_makeup_gain = auto_gain ?
+        fp_factor(-(db_curve[3].offset) - 0x199A, 16) << 8 : UNITY;
+    logf("Makeup gain:\t%.6f", (float)comp_makeup_gain / UNITY);
+
+    /* calculate per-sample gain change a rate of 10db over release time
+     */
+    comp_rel_slope = 0xAF0BB2 / release;
+    logf("Release slope:\t%.6f", (float)comp_rel_slope / UNITY);
+
+    release_gain = UNITY;
     return active;
 }