comparison SimpleCepstrum.cpp @ 43:fcb6562b43f7

Docs and fixes from plugin tester reports

 
     ParameterDescriptor d;
 
     d.identifier = "fmin";
     d.name = "Minimum frequency";
-    d.description = "";
+    d.description = "Frequency whose period corresponds to the quefrency of the last cepstrum bin in range";
     d.unit = "Hz";
     d.minValue = m_inputSampleRate / m_blockSize;
     d.maxValue = m_inputSampleRate / 2;
     d.defaultValue = 50;
     d.isQuantized = false;
     list.push_back(d);
 
     d.identifier = "fmax";
     d.name = "Maximum frequency";
-    d.description = "";
+    d.description = "Frequency whose period corresponds to the quefrency of the first cepstrum bin in range";
     d.unit = "Hz";
     d.minValue = m_inputSampleRate / m_blockSize;
     d.maxValue = m_inputSampleRate / 2;
     d.defaultValue = 1000;
     d.isQuantized = false;
     list.push_back(d);
 
     d.identifier = "histlen";
     d.name = "Mean filter history length";
-    d.description = "";
+    d.description = "Length of mean filter used for smoothing cepstrum across time bins";
     d.unit = "";
     d.minValue = 1;
     d.maxValue = 10;
     d.defaultValue = 1;
     d.isQuantized = true;
     d.quantizeStep = 1;
     list.push_back(d);
 
     d.identifier = "vflen";
     d.name = "Vertical filter length";
-    d.description = "";
+    d.description = "Length of mean filter used for smoothing cepstrum across quefrency bins";
     d.unit = "";
     d.minValue = 1;
     d.maxValue = 11;
     d.defaultValue = 1;
     d.isQuantized = true;
     d.quantizeStep = 2;
     list.push_back(d);
 
     d.identifier = "method";
     d.name = "Cepstrum transform method";
-    d.unit = "";
+    d.unit = "Method to use for calculating cepstrum, starting from the complex short-time Fourier transform of the input audio.\nInverse symmetric - Real part of inverse FFT of log magnitude spectrum, with frequencies above Nyquist reflecting those below it.\nInverse asymmetric - Real part of inverse FFT of log magnitude spectrum, with frequencies above Nyquist set to zero.\nInverse complex - Real part of inverse FFT of complex log spectrum.\nForward magnitude - Magnitude of forward FFT of log magnitude spectrum.\nForward difference - Difference between imaginary and real parts of forward FFT of log magnitude spectrum";
     d.minValue = 0;
     d.maxValue = 4;
     d.defaultValue = 0;
     d.isQuantized = true;
     d.quantizeStep = 1;

     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.unit = "If set, no negative values will be returned; they will be replaced by zeroes";
     d.minValue = 0;
     d.maxValue = 1;
     d.defaultValue = 0;
     d.isQuantized = true;
     d.quantizeStep = 1;

     d.unit = "";
     d.description = "The unprocessed cepstrum bins within the specified range";
 
     int from = int(m_inputSampleRate / m_fmax);
     int to = int(m_inputSampleRate / m_fmin);
+    if (from >= (int)m_blockSize / 2) {
+        from = m_blockSize / 2 - 1;
+    }
     if (to >= (int)m_blockSize / 2) {
         to = m_blockSize / 2 - 1;
+    }
+    if (to < from) {
+        to = from;
     }
     d.binCount = to - from + 1;
     for (int i = from; i <= to; ++i) {
         float freq = m_inputSampleRate / i;
-        char buffer[20];
+        char buffer[50];
         sprintf(buffer, "%.2f Hz", freq);
         d.binNames.push_back(buffer);
     }
 
     d.hasKnownExtents = false;

     d.description = "Envelope calculated from the cepstral values below the specified minimum";
     d.binCount = m_blockSize/2 + 1;
     d.binNames.clear();
     for (int i = 0; i < (int)d.binCount; ++i) {
         float freq = (m_inputSampleRate / m_blockSize) * i;
-        char buffer[20];
+        char buffer[50];
         sprintf(buffer, "%.2f Hz", freq);
         d.binNames.push_back(buffer);
     }
     m_envOutput = n++;
     outputs.push_back(d);

     m_channels = channels;
     m_stepSize = stepSize;
     m_blockSize = blockSize;
 
     m_binFrom = int(m_inputSampleRate / m_fmax);
-    m_binTo = int(m_inputSampleRate / m_fmin); 
-
+    m_binTo = int(m_inputSampleRate / m_fmin);
+
+    if (m_binFrom >= (int)m_blockSize / 2) {
+        m_binFrom = m_blockSize / 2 - 1;
+    }
     if (m_binTo >= (int)m_blockSize / 2) {
         m_binTo = m_blockSize / 2 - 1;
+    }
+    if (m_binTo < m_binFrom) {
+        m_binTo = m_binFrom;
     }
 
     m_bins = (m_binTo - m_binFrom) + 1;
 
     m_history = new double *[m_histlen];

     }
     for (int i = m_binFrom; i < bs; ++i) {
         ecep[i] = 0;
     }
     ecep[0] /= 2;
-    ecep[m_binFrom-1] /= 2;
+    if (m_binFrom > 0) {
+        ecep[m_binFrom-1] /= 2;
+    }
 
     double *env = new double[bs];
     double *io = new double[bs];
 
     //!!! This is only right if the previous transform was an inverse one!