EqualizationFilter Struct Reference

#include <EqualizationFilter.h>

Inheritance diagram for EqualizationFilter:

Collaboration diagram for EqualizationFilter:

Public Member Functions
	EqualizationFilter (const EffectSettingsManager &manager)
bool	CalcFilter ()
void	Filter (size_t len, float *buffer) const
const Envelope &	ChooseEnvelope () const
Envelope &	ChooseEnvelope ()
const Envelope &	ChooseEnvelopeToPaint () const
Public Member Functions inherited from EqualizationParameters
	EqualizationParameters (const EffectSettingsManager &manager)
void	LoadDefaults (int options)
void	SaveConfig (const EffectSettingsManager &manager) const
bool	IsLinear () const

Public Attributes
Envelope	mLinEnvelope
Envelope	mLogEnvelope
HFFT	hFFT { GetFFT(windowSize) }
Floats	mFFTBuffer { windowSize }
Floats	mFilterFuncR { windowSize }
Floats	mFilterFuncI { windowSize }
double	mLoFreq { loFreqI }
double	mHiFreq { mLoFreq }
size_t	mWindowSize { windowSize }
Public Attributes inherited from EqualizationParameters
wxString	mCurveName
float	mdBMin
float	mdBMax
size_t	mM
int	mInterp
bool	mDrawMode
bool	mDrawGrid
bool	mLin

Static Public Attributes
static constexpr int	loFreqI = 20
static constexpr size_t	windowSize = 16384u
Static Public Attributes inherited from EqualizationParameters
static const EnumValueSymbol	kInterpStrings [nInterpolations]
static constexpr EffectParameter	FilterLength
static constexpr EffectParameter	CurveName
static constexpr EffectParameter	InterpLin
static constexpr EnumParameter	InterpMeth
static constexpr EffectParameter	DrawMode
static constexpr EffectParameter	DrawGrid
static constexpr EffectParameter	dBMin
static constexpr EffectParameter	dBMax

Additional Inherited Members
Public Types inherited from EqualizationParameters
enum	kInterpolations { kBspline , kCosine , kCubic , nInterpolations }

Detailed Description

Extend EqualizationParameters with frequency domain coefficients computed from a curve or from frequency band slider positions

Definition at line 24 of file EqualizationFilter.h.

Constructor & Destructor Documentation

EqualizationFilter()

EqualizationFilter::EqualizationFilter ( const EffectSettingsManager &  manager )

explicit

Definition at line 18 of file EqualizationFilter.cpp.

   : EqualizationParameters{ manager }
   , mLogEnvelope{ false,
       dBMin.min, dBMax.max, // MB: this is the highest possible range
       0.0 }
   , mLinEnvelope{ false,
       dBMin.min, dBMax.max, // MB: this is the highest possible range
       0.0 }
{
   mLogEnvelope.SetTrackLen(1.0);
   mLinEnvelope.SetTrackLen(1.0);
}

References mLinEnvelope, mLogEnvelope, and Envelope::SetTrackLen().

Here is the call graph for this function:

Member Function Documentation

CalcFilter()

bool EqualizationFilter::CalcFilter

(

)

Adjust given coefficients so there is a finite impulse response in time domain

Definition at line 32 of file EqualizationFilter.cpp.

{
   // Inverse-transform the given curve from frequency domain to time;
   // Apply a taper to define a finite impulse response;
   // Transform that back to frequency domain to get the modified curve.
 
   double loLog = log10(mLoFreq);
   double hiLog = log10(mHiFreq);
   double denom = hiLog - loLog;
 
   double delta = mHiFreq / ((double)(mWindowSize / 2.));
   double val0;
   double val1;
 
   if ( IsLinear() )
   {
      val0 = mLinEnvelope.GetValue(0.0);   //no scaling required - saved as dB
      val1 = mLinEnvelope.GetValue(1.0);
   }
   else
   {
      val0 = mLogEnvelope.GetValue(0.0);   //no scaling required - saved as dB
      val1 = mLogEnvelope.GetValue(1.0);
   }
   mFilterFuncR[0] = val0;
   double freq = delta;
 
   for(size_t i = 1; i <= mWindowSize / 2; i++)
   {
      double when;
      if ( IsLinear() )
         when = freq/mHiFreq;
      else
         when = (log10(freq) - loLog)/denom;
      if(when < 0.)
      {
         mFilterFuncR[i] = val0;
      }
      else  if(when > 1.0)
      {
         mFilterFuncR[i] = val1;
      }
      else
      {
         if ( IsLinear() )
            mFilterFuncR[i] = mLinEnvelope.GetValue(when);
         else
            mFilterFuncR[i] = mLogEnvelope.GetValue(when);
      }
      freq += delta;
   }
   mFilterFuncR[mWindowSize / 2] = val1;
 
   mFilterFuncR[0] = DB_TO_LINEAR(mFilterFuncR[0]);
 
   {
      size_t i = 1;
      for(; i < mWindowSize / 2; i++)
      {
         mFilterFuncR[i] = DB_TO_LINEAR(mFilterFuncR[i]);
         mFilterFuncR[mWindowSize - i] = mFilterFuncR[i];   //Fill entire array
      }
      mFilterFuncR[i] = DB_TO_LINEAR(mFilterFuncR[i]);   //do last one
   }
 
   //transfer to time domain to do the padding and windowing
   Floats outr{ mWindowSize };
   Floats outi{ mWindowSize };
   InverseRealFFT(mWindowSize, mFilterFuncR.get(), NULL, outr.get()); // To time domain
 
   {
      size_t i = 0;
      for(; i <= (mM - 1) / 2; i++)
      {  //Windowing - could give a choice, fixed for now - MJS
         //      double mult=0.54-0.46*cos(2*M_PI*(i+(mM-1)/2.0)/(mM-1));   //Hamming
         //Blackman
         double mult =
            0.42 -
            0.5 * cos(2 * M_PI * (i + (mM - 1) / 2.0) / (mM - 1)) +
            .08 * cos(4 * M_PI * (i + (mM - 1) / 2.0) / (mM - 1));
         outr[i] *= mult;
         if(i != 0){
            outr[mWindowSize - i] *= mult;
         }
      }
      for(; i <= mWindowSize / 2; i++)
      {   //Padding
         outr[i] = 0;
         outr[mWindowSize - i] = 0;
      }
   }
   Floats tempr{ mM };
   {
      size_t i = 0;
      for(; i < (mM - 1) / 2; i++)
      {   //shift so that padding on right
         tempr[(mM - 1) / 2 + i] = outr[i];
         tempr[i] = outr[mWindowSize - (mM - 1) / 2 + i];
      }
      tempr[(mM - 1) / 2 + i] = outr[i];
   }
 
   for (size_t i = 0; i < mM; i++)
   {   //and copy useful values back
      outr[i] = tempr[i];
   }
   for (size_t i = mM; i < mWindowSize; i++)
   {   //rest is padding
      outr[i]=0.;
   }
 
   //Back to the frequency domain so we can use it
   RealFFT(mWindowSize, outr.get(), mFilterFuncR.get(), mFilterFuncI.get());
 
   return TRUE;
}

References DB_TO_LINEAR, Envelope::GetValue(), InverseRealFFT(), EqualizationParameters::IsLinear(), M_PI, mFilterFuncI, mFilterFuncR, mHiFreq, mLinEnvelope, mLoFreq, mLogEnvelope, EqualizationParameters::mM, mWindowSize, and RealFFT().

Referenced by EffectEqualization::Init(), and EffectEqualization::Process().

Here is the call graph for this function:

Here is the caller graph for this function:

ChooseEnvelope() [1/2]

Envelope & EqualizationFilter::ChooseEnvelope ( )

inline

Definition at line 46 of file EqualizationFilter.h.

   { return mLin ? mLinEnvelope : mLogEnvelope; }

References EqualizationParameters::mLin, mLinEnvelope, and mLogEnvelope.

ChooseEnvelope() [2/2]

const Envelope & EqualizationFilter::ChooseEnvelope ( ) const

inline

Definition at line 44 of file EqualizationFilter.h.

   { return mLin ? mLinEnvelope : mLogEnvelope; }

References EqualizationParameters::mLin, mLinEnvelope, and mLogEnvelope.

ChooseEnvelopeToPaint()

const Envelope & EqualizationFilter::ChooseEnvelopeToPaint ( ) const

inline

Definition at line 50 of file EqualizationFilter.h.

   { return IsLinear() ? mLinEnvelope : mLogEnvelope; }

References EqualizationParameters::IsLinear(), mLinEnvelope, and mLogEnvelope.

Here is the call graph for this function:

Filter()

void EqualizationFilter::Filter	(	size_t	len,
		float *	buffer
	)		const

Transform a given buffer of time domain signal, which should be zero padded left and right for the tails

Definition at line 149 of file EqualizationFilter.cpp.

{
   // Transform a window of the time-domain signal to frequency;
   // Multiply by corresponding coefficients;
   // Inverse transform back to time domain:  that's fast convolution.
 
   float re,im;
   // Apply FFT
   RealFFTf(buffer, hFFT.get());
   //FFT(len, false, inr, NULL, outr, outi);
 
   // Apply filter
   // DC component is purely real
   mFFTBuffer[0] = buffer[0] * mFilterFuncR[0];
   for(size_t i = 1; i < (len / 2); i++)
   {
      re=buffer[hFFT->BitReversed[i]  ];
      im=buffer[hFFT->BitReversed[i]+1];
      mFFTBuffer[2*i  ] = re*mFilterFuncR[i] - im*mFilterFuncI[i];
      mFFTBuffer[2*i+1] = re*mFilterFuncI[i] + im*mFilterFuncR[i];
   }
   // Fs/2 component is purely real
   mFFTBuffer[1] = buffer[1] * mFilterFuncR[len/2];
 
   // Inverse FFT and normalization
   InverseRealFFTf(mFFTBuffer.get(), hFFT.get());
   ReorderToTime(hFFT.get(), mFFTBuffer.get(), buffer);
}

References hFFT, InverseRealFFTf(), mFFTBuffer, mFilterFuncI, mFilterFuncR, RealFFTf(), and ReorderToTime().

Referenced by EffectEqualization::ProcessOne().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

hFFT

HFFT EqualizationFilter::hFFT { GetFFT(windowSize) }

Definition at line 54 of file EqualizationFilter.h.

Referenced by Filter().

loFreqI

constexpr int EqualizationFilter::loFreqI = 20

staticconstexpr

Definition at line 27 of file EqualizationFilter.h.

Referenced by EffectEqualization::Init(), and EqualizationUI::setCurve().

mFFTBuffer

Floats EqualizationFilter::mFFTBuffer { windowSize }

Definition at line 55 of file EqualizationFilter.h.

Referenced by Filter().

mFilterFuncI

Floats EqualizationFilter::mFilterFuncI { windowSize }

Definition at line 56 of file EqualizationFilter.h.

Referenced by CalcFilter(), and Filter().

mFilterFuncR

Floats EqualizationFilter::mFilterFuncR { windowSize }

Definition at line 56 of file EqualizationFilter.h.

Referenced by CalcFilter(), and Filter().

mHiFreq

double EqualizationFilter::mHiFreq { mLoFreq }

Definition at line 58 of file EqualizationFilter.h.

Referenced by CalcFilter(), EffectEqualization::EffectEqualization(), EqualizationCurvesList::EnvelopeUpdated(), EqualizationBandSliders::Init(), and EffectEqualization::Init().

mLinEnvelope

Envelope EqualizationFilter::mLinEnvelope

Definition at line 53 of file EqualizationFilter.h.

Referenced by CalcFilter(), ChooseEnvelope(), ChooseEnvelopeToPaint(), EqualizationCurvesList::EnvelopeUpdated(), EqualizationBandSliders::EnvLinToLog(), EqualizationBandSliders::EnvLogToLin(), EqualizationFilter(), and EqualizationBandSliders::Invert().

mLoFreq

double EqualizationFilter::mLoFreq { loFreqI }

Definition at line 57 of file EqualizationFilter.h.

Referenced by CalcFilter(), and EffectEqualization::Init().

mLogEnvelope

Envelope EqualizationFilter::mLogEnvelope

Definition at line 53 of file EqualizationFilter.h.

Referenced by CalcFilter(), ChooseEnvelope(), ChooseEnvelopeToPaint(), EqualizationCurvesList::EnvelopeUpdated(), EqualizationFilter(), EqualizationBandSliders::ErrMin(), and EqualizationBandSliders::OnSlider().

mWindowSize

size_t EqualizationFilter::mWindowSize { windowSize }

Definition at line 59 of file EqualizationFilter.h.

Referenced by CalcFilter(), and EqualizationPanel::Recalc().

windowSize

constexpr size_t EqualizationFilter::windowSize = 16384u

staticconstexpr

Definition at line 32 of file EqualizationFilter.h.

Referenced by EffectEqualization::Process(), and EffectEqualization::ProcessOne().

---

The documentation for this struct was generated from the following files:

• EqualizationFilter.h
• EqualizationFilter.cpp