comparison SimpleCepstrum.cpp @ 3:a6f9ece68482

Add choice of cepstrum transform method

     m_channels(0),
     m_stepSize(256),
     m_blockSize(1024),
     m_fmin(50),
     m_fmax(1000),
-    m_clamp(false)
+    m_clamp(false),
+    m_method(InverseSymmetric)
 {
 }
 
 SimpleCepstrum::~SimpleCepstrum()
 {

     d.maxValue = m_inputSampleRate / 2;
     d.defaultValue = 1000;
     d.isQuantized = false;
     list.push_back(d);
 
+    d.identifier = "method";
+    d.name = "Cepstrum transform method";
+    d.unit = "";
+    d.minValue = 0;
+    d.maxValue = 3;
+    d.defaultValue = 0;
+    d.isQuantized = true;
+    d.quantizeStep = 1;
+    d.valueNames.push_back("Inverse symmetric");
+    d.valueNames.push_back("Inverse asymmetric");
+    d.valueNames.push_back("Forward magnitude");
+    d.valueNames.push_back("Forward difference");
+    list.push_back(d);
+
     d.identifier = "clamp";
     d.name = "Clamp negative values in cepstrum at zero";
     d.unit = "";
     d.minValue = 0;
     d.maxValue = 1;
     d.defaultValue = 0;
     d.isQuantized = true;
     d.quantizeStep = 1;
+    d.valueNames.clear();
     list.push_back(d);
 
     return list;
 }
 

 SimpleCepstrum::getParameter(string identifier) const
 {
     if (identifier == "fmin") return m_fmin;
     else if (identifier == "fmax") return m_fmax;
     else if (identifier == "clamp") return (m_clamp ? 1 : 0);
+    else if (identifier == "method") return (int)m_method;
     else return 0.f;
 }
 
 void
 SimpleCepstrum::setParameter(string identifier, float value) 
 {
     if (identifier == "fmin") m_fmin = value;
     else if (identifier == "fmax") m_fmax = value;
     else if (identifier == "clamp") m_clamp = (value > 0.5);
+    else if (identifier == "method") m_method = Method(int(value + 0.5));
 }
 
 SimpleCepstrum::ProgramList
 SimpleCepstrum::getPrograms() const
 {

 
     int bs = m_blockSize;
     int hs = m_blockSize/2 + 1;
 
     double *logmag = new double[bs];
+
     for (int i = 0; i < hs; ++i) {
+
         double mag = sqrt(inputBuffers[0][i*2  ] * inputBuffers[0][i*2  ] +
                           inputBuffers[0][i*2+1] * inputBuffers[0][i*2+1]);
-        logmag[i] = log(mag + 0.00000001);
-        if (i > 0) {
-            logmag[bs - i] = logmag[i];
+        double lm = log(mag + 0.00000001);
+
+        switch (m_method) {
+        case InverseSymmetric:
+            logmag[i] = lm;
+            if (i > 0) logmag[bs - i] = lm;
+            break;
+        case InverseAsymmetric:
+            logmag[i] = lm;
+            if (i > 0) logmag[bs - i] = 0;
+            break;
+        case ForwardMagnitude:
+        case ForwardDifference:
+            logmag[bs/2 + i - 1] = lm;
+            if (i < hs-1) {
+                logmag[bs/2 - i - 1] = lm;
+            }
+            break;
         }
     }
 
     double *cep = new double[bs];
-    double *discard = new double[bs];
-    fft(bs, true, logmag, 0, cep, discard);
+    double *io = new double[bs];
+
+    if (m_method == InverseSymmetric ||
+        m_method == InverseAsymmetric) {
+
+        fft(bs, true, logmag, 0, cep, io);
+
+    } else {
+
+        fft(bs, false, logmag, 0, cep, io);
+
+        if (m_method == ForwardDifference) {
+            for (int i = 0; i < hs; ++i) {
+                cep[i] = fabs(io[i]) - fabs(cep[i]);
+            }
+        } else {
+            for (int i = 0; i < hs; ++i) {
+                cep[i] = sqrt(cep[i]*cep[i] + io[i]*io[i]);
+            }
+        }
+    }
 
     if (m_clamp) {
         for (int i = 0; i < bs; ++i) {
             if (cep[i] < 0) cep[i] = 0;
         }

         cep[i] /= bs; 
     }
     for (int i = from; i < bs; ++i) {
         cep[i] = 0;
     }
-    fft(bs, false, cep, 0, logmag, discard);
+    fft(bs, false, cep, 0, logmag, io);
     for (int i = 0; i < hs; ++i) {
         logmag[i] = exp(logmag[i]);
     }
     Feature env;
     for (int i = 0; i < hs; ++i) {

         double mag = sqrt(re*re + im*im);
         es.values.push_back(mag);
     }
     fs[m_esOutput].push_back(es);
 
-    delete[] discard;
+    delete[] io;
     delete[] logmag;
     delete[] cep;
 
     return fs;
 }