Release 0.5.3

* Added normalization of output sample.

Author: sadko4u

CHANGELOG

@@ -2,6 +2,9 @@
 * RECENT CHANGES
 *******************************************************************************
 
+=== 0.5.3 ===
+* Added normalization of output sample.
+
 === 0.5.2 ===
 
 * Fixed command-line parsing.

README.md

@@ -20,6 +20,8 @@ The available option list will be the following:
   -g, --gain             Gain (in dB) of the sine sweep
   -h, --help             Output this help message
   -i, --in-file          Input audio file
+  -n, --normalize        Set normalization mode
+  -ng, --norm-gain       Set normalization peak gain (in dB)
   -o, --out-file         Output audio file
   -r, --reference        Reference audio file
   -s, --sweep            Produce sine sweep signal
@@ -110,6 +112,13 @@ For more information, see `room-raider --help`.
 
 The file `response.wav` will have the same number of channels as `room-outputs.wav` and will contain the electroacoustic impulse responses from soundcard output to each of the test microphones.
 
+Additionally, the output sample can be normalized with options ```-n``` and ```-ng```. While ```-ng``` option sets the maximum peak level (in dB) of the output sample, 
+the ```-n``` option allows to specify the normalization algorithm:
+  * **none** - do not use normalization (default);
+  * **above** - normalize the file if the maximum signal peak is above the specified peak level;
+  * **below** - normalize the file if the maximum signal peak is below the specified peak level;
+  * **always** - always normalize output files to match the maximum signal peak to specified peak level.
+
 Requirements
 ======
 

include/private/config.h

@@ -36,6 +36,14 @@ namespace room_raider
         M_DECONVOLVE
     };
 
+    enum normalize_t
+    {
+        NORM_NONE,              // No normalization
+        NORM_ABOVE,             // When the maximum peak is above the threshold
+        NORM_BELOW,             // When the maximum peak is below the threshold
+        NORM_ALWAYS             // Always normalize
+    };
+
     /**
      * Overall configuration
      */
@@ -54,6 +62,8 @@ namespace room_raider
             LSPString                               sInFile;        // Source file
             LSPString                               sOutFile;       // Destination file
             LSPString                               sReference;     // Reference file
+            ssize_t                                 nNormalize;     // Normalization method
+            float                                   fNormGain;      // Normalization gain
 
         public:
             explicit config_t();

include/private/dsp.h

@@ -28,7 +28,17 @@
 namespace room_raider
 {
     status_t synth_test_sweep(const config_t *cfg, dspu::Sample &out);
+
     status_t deconvolve(const config_t *cfg, const dspu::Sample &in, const dspu::Sample &ref, dspu::Sample &out);
+
+    /**
+     * Normalize sample to the specified gain
+     * @param dst sample to normalize
+     * @param gain the maximum peak gain
+     * @param mode the normalization mode
+     * @return status of operation
+     */
+    status_t normalize(dspu::Sample *dst, float gain, size_t mode);
 }
 
 #endif

project.mk

@@ -22,7 +22,7 @@
 ARTIFACT_ID                 = ROOM_RAIDER
 ARTIFACT_NAME               = room-raider
 ARTIFACT_DESC               = Room-Raider - a tool for performing off-line impulse response capture of the room
-ARTIFACT_VERSION            = 0.5.2
+ARTIFACT_VERSION            = 0.5.3
 
 #------------------------------------------------------------------------------
 # Plugin dependencies

src/main/cmdline.cpp

@@ -40,13 +40,21 @@ namespace room_raider
         const char *s_desc;
     } option_t;
 
+    typedef struct cfg_flag_t
+    {
+        const char     *name;
+        ssize_t         value;
+    } cfg_flag_t;
+
     static const option_t options[] =
     {
         { "-d",   "--deconvolve",       true,      "Deconvolve the captured signal"             },
         { "-ef",  "--end-freq",         false,     "End frequency of the sine sweep"            },
         { "-g",   "--gain",             false,     "Gain (in dB) of the sine sweep"             },
         { "-h",   "--help",             true,      "Output this help message"                   },
         { "-i",   "--in-file",          false,     "Input audio file"                           },
+        { "-n",   "--normalize",        false,     "Set normalization mode"                     },
+        { "-ng",  "--norm-gain",        false,     "Set normalization peak gain (in dB)"        },
         { "-o",   "--out-file",         false,     "Output audio file"                          },
         { "-r",   "--reference",        false,     "Reference audio file"                       },
         { "-s",   "--sweep",            true,      "Produce sine sweep signal"                  },
@@ -56,6 +64,15 @@ namespace room_raider
         { NULL, NULL, false, NULL }
     };
 
+    const cfg_flag_t normalize_flags[] =
+    {
+        { "none",   NORM_NONE   },
+        { "above",  NORM_ABOVE  },
+        { "below",  NORM_BELOW  },
+        { "always", NORM_ALWAYS },
+        { NULL,     0           }
+    };
+
     status_t print_usage(const char *name, bool fail)
     {
         LSPString buf, fmt;
@@ -143,6 +160,55 @@ namespace room_raider
         return STATUS_OK;
     }
 
+    const cfg_flag_t *find_config_flag(const LSPString *s, const cfg_flag_t *flags)
+    {
+        for (size_t i=0; (flags != NULL) && (flags->name != NULL); ++i, ++flags)
+        {
+            if (s->equals_ascii_nocase(flags->name))
+                return flags;
+        }
+        return NULL;
+    }
+
+    status_t parse_cmdline_enum(ssize_t *dst, const char *parameter, const char *val, const cfg_flag_t *flags)
+    {
+        LSPString in;
+        if (!in.set_native(val))
+        {
+            fprintf(stderr, "Out of memory\n");
+            return STATUS_NO_MEM;
+        }
+
+        io::InStringSequence is(&in);
+        expr::Tokenizer t(&is);
+        const cfg_flag_t *flag = NULL;
+
+        switch (t.get_token(expr::TF_GET | expr::TF_XKEYWORDS))
+        {
+            case expr::TT_BAREWORD:
+                if ((flag = find_config_flag(t.text_value(), flags)) == NULL)
+                {
+                    fprintf(stderr, "Bad '%s' value\n", parameter);
+                    return STATUS_BAD_FORMAT;
+                }
+                break;
+
+            default:
+                fprintf(stderr, "Bad '%s' value\n", parameter);
+                return STATUS_BAD_FORMAT;
+        }
+
+        if (t.get_token(expr::TF_GET) != expr::TT_EOF)
+        {
+            fprintf(stderr, "Bad '%s' value\n", parameter);
+            return STATUS_INVALID_VALUE;
+        }
+
+        *dst = flag->value;
+
+        return STATUS_OK;
+    }
+
     status_t parse_cmdline(config_t *cfg, int argc, const char **argv)
     {
         const char *cmd = argv[0], *val;
@@ -262,6 +328,16 @@ namespace room_raider
             if ((res = parse_cmdline_float(&cfg->fSweepLength, val, "sweep length")) != STATUS_OK)
                 return res;
         }
+        if ((val = options.get("--norm-gain")) != NULL)
+        {
+            if ((res = parse_cmdline_float(&cfg->fNormGain, val, "norm-gain")) != STATUS_OK)
+                return res;
+        }
+        if ((val = options.get("--normalize")) != NULL)
+        {
+            if ((res = parse_cmdline_enum(&cfg->nNormalize, "normalize", val, normalize_flags)) != STATUS_OK)
+                return res;
+        }
 
         return STATUS_OK;
     }

src/main/config.cpp

@@ -34,6 +34,9 @@ namespace room_raider
         fEndFreq        = 20000.0f;
         fGain           = 0.0f;
         fSweepLength    = 20.0f;
+
+        nNormalize      = NORM_NONE;    // No normalization by default
+        fNormGain       = 0.0f;         // 0 dB gain by default
     }
 
     config_t::~config_t()
@@ -51,6 +54,9 @@ namespace room_raider
         fGain           = 0.0f;
         fSweepLength    = 20.0f;
 
+        nNormalize      = NORM_NONE;
+        fNormGain       = 0.0f;
+
         sInFile.clear();
         sOutFile.clear();
         sReference.clear();

src/main/dsp.cpp

@@ -170,7 +170,10 @@ namespace room_raider
             // Even though we always use the same impulse response,
             // we initialise at every iteration to make sure the internal state of the convolver is re-initialisated.
             if (!sConvolver.init(vKernel, nBufferSize, 16, 0))
+            {
+                free_aligned(pData);
                 return STATUS_NO_MEM;
+            }
 
             dsp::fill_zero(vInput, nIRSize);
             dsp::copy(vInput, in.getBuffer(ch), in.length());
@@ -198,4 +201,42 @@ namespace room_raider
         // Done.
         return STATUS_OK;
     }
+
+    status_t normalize(dspu::Sample *dst, float gain, size_t mode)
+    {
+        if (mode == NORM_NONE)
+            return STATUS_OK;
+
+        float peak  = 0.0f;
+        for (size_t i=0, n=dst->channels(); i<n; ++i)
+        {
+            float cpeak = dsp::abs_max(dst->channel(i), dst->length());
+            peak        = lsp_max(peak, cpeak);
+        }
+
+        // No peak detected?
+        if (peak < 1e-6)
+            return STATUS_OK;
+
+        switch (mode)
+        {
+            case NORM_BELOW:
+                if (peak >= gain)
+                    return STATUS_OK;
+                break;
+            case NORM_ABOVE:
+                if (peak <= gain)
+                    return STATUS_OK;
+                break;
+            default:
+                break;
+        }
+
+        // Adjust gain
+        float k = gain / peak;
+        for (size_t i=0, n=dst->channels(); i<n; ++i)
+            dsp::mul_k2(dst->channel(i), k, dst->length());
+
+        return STATUS_OK;
+    }
 }

src/main/tool.cpp

@@ -33,6 +33,8 @@
 #define MIN_SAMPLE_RATE         8000
 #define MAX_SAMPLE_RATE         192000
 
+#define MIN_GAIN                -200.0f
+
 namespace room_raider
 {
     using namespace lsp;
@@ -163,6 +165,10 @@ namespace room_raider
         // deconvolution
         deconvolve(cfg, in, ref, out);
 
+        // normalization
+        float norm_gain = (cfg->fNormGain >= MIN_GAIN) ? dspu::db_to_gain(cfg->fNormGain) : 0.0f;
+        normalize(&out, norm_gain, cfg->nNormalize);
+
         // Save the sample to output
         if (out.save(&cfg->sOutFile) < 0)
         {

src/test/utest/cmdline.cpp

@@ -44,6 +44,8 @@ UTEST_BEGIN("room_raider", cmdline)
         UTEST_ASSERT(cfg->sOutFile.equals_ascii("output-file.wav"));
         UTEST_ASSERT(cfg->sReference.equals_ascii("reference-file.wav"));
         UTEST_ASSERT(cfg->nSampleRate == 88200);
+        UTEST_ASSERT(float_equals_absolute(cfg->fNormGain, -3.0f));
+        UTEST_ASSERT(cfg->nNormalize == room_raider::NORM_ALWAYS);
     }
 
     void parse_cmdline(room_raider::config_t *cfg)
@@ -59,6 +61,8 @@ UTEST_BEGIN("room_raider", cmdline)
             "-o",   "output-file.wav",
             "-r",   "reference-file.wav",
             "-sr",  "88200",
+            "-ng",  "-3.0",
+            "-n",   "ALWAYS",
             NULL
         };