Make EQ Gui optional and seize updating the graph when the analysis is not visible...

[ardour.git] / gtk2_ardour / fft.cc

diff --git a/gtk2_ardour/fft.cc b/gtk2_ardour/fft.cc
index 92f52bb64e665d85a6455da208e14affb204fde7..eda1a96e3f6c601b6cad76fdd5d80cc15d2db969 100644 (file)
--- a/gtk2_ardour/fft.cc
+++ b/gtk2_ardour/fft.cc
@@ -24,18 +24,18 @@
 #include <math.h>
 
 FFT::FFT(uint32_t windowSize)
-       : _windowSize(windowSize),
-         _dataSize(_windowSize/2),
+       : _window_size(windowSize),
+         _data_size(_window_size/2),
        _iterations(0)
 {
-       _fftInput  = (float *) fftwf_malloc(sizeof(float) * _windowSize);
+       _fftInput  = (float *) fftwf_malloc(sizeof(float) * _window_size);
 
-       _fftOutput = (float *) fftwf_malloc(sizeof(float) * _windowSize);
+       _fftOutput = (float *) fftwf_malloc(sizeof(float) * _window_size);
 
-       _powerAtBin  = (float *) malloc(sizeof(float) * _dataSize);
-       _phaseAtBin  = (float *) malloc(sizeof(float) * _dataSize);
+       _power_at_bin  = (float *) malloc(sizeof(float) * _data_size);
+       _phase_at_bin  = (float *) malloc(sizeof(float) * _data_size);
 
-       _plan = fftwf_plan_r2r_1d(_windowSize, _fftInput, _fftOutput, FFTW_R2HC, FFTW_ESTIMATE);
+       _plan = fftwf_plan_r2r_1d(_window_size, _fftInput, _fftOutput, FFTW_R2HC, FFTW_ESTIMATE);
 
        reset();
 }
@@ -43,8 +43,8 @@ FFT::FFT(uint32_t windowSize)
 void
 FFT::reset()
 {
-       memset(_powerAtBin, 0, sizeof(float) * _dataSize);
-       memset(_phaseAtBin, 0, sizeof(float) * _dataSize);
+       memset(_power_at_bin, 0, sizeof(float) * _data_size);
+       memset(_phase_at_bin, 0, sizeof(float) * _data_size);
        
        _iterations = 0;
 }
@@ -54,19 +54,19 @@ FFT::analyze(ARDOUR::Sample *input)
 {
        _iterations++;
 
-       memcpy(_fftInput, input, sizeof(float) * _windowSize);
+       memcpy(_fftInput, input, sizeof(float) * _window_size);
 
        fftwf_execute(_plan);
 
-       _powerAtBin[0] += _fftOutput[0] * _fftOutput[0];
-       _phaseAtBin[0] += 0.0;
+       _power_at_bin[0] += _fftOutput[0] * _fftOutput[0];
+       _phase_at_bin[0] += 0.0;
 
        float power;
        float phase;
 
 #define Re (_fftOutput[i])
-#define Im (_fftOutput[_windowSize-i])
-               for (uint32_t i=1; i < _dataSize - 1; i++) { 
+#define Im (_fftOutput[_window_size-i])
+               for (uint32_t i=1; i < _data_size - 1; i++) { 
 
                power = (Re * Re) + (Im * Im);
                phase = atanf(Im / Re);
@@ -77,8 +77,8 @@ FFT::analyze(ARDOUR::Sample *input)
                        phase -= M_PI;
                }
 
-               _powerAtBin[i] += power;
-               _phaseAtBin[i] += phase;
+               _power_at_bin[i] += power;
+               _phase_at_bin[i] += phase;
        }
 #undef Re
 #undef Im
@@ -88,9 +88,9 @@ void
 FFT::calculate()
 {
        if (_iterations > 1) {
-               for (uint32_t i=0; i < _dataSize - 1; i++) { 
-                       _powerAtBin[i] /= (float)_iterations;
-                       _phaseAtBin[i] /= (float)_iterations;
+               for (uint32_t i=0; i < _data_size - 1; i++) { 
+                       _power_at_bin[i] /= (float)_iterations;
+                       _phase_at_bin[i] /= (float)_iterations;
                }
                _iterations = 1;
        }
@@ -100,8 +100,8 @@ FFT::calculate()
 FFT::~FFT()
 {
        fftwf_destroy_plan(_plan);
-       free(_powerAtBin);
-       free(_phaseAtBin);
+       free(_power_at_bin);
+       free(_phase_at_bin);
        free(_fftOutput);
        free(_fftInput);
 }