sdrangel/sdrbase/dsp/agc.h

137 wiersze
3.9 KiB
C
Czysty Zwykły widok Historia

2015-05-12 10:12:13 +00:00
/*
* kissagc.h
*
* Created on: May 12, 2015
* Author: f4exb
*/
#ifndef INCLUDE_GPL_DSP_AGC_H_
#define INCLUDE_GPL_DSP_AGC_H_
#include "movingaverage.h"
2015-09-07 21:31:34 +00:00
class AGC
2015-06-20 07:28:57 +00:00
{
public:
AGC(int historySize, double R);
2015-09-07 21:31:34 +00:00
virtual ~AGC();
void resize(int historySize, double R);
void setOrder(double R) { m_R = R; }
2015-09-07 21:31:34 +00:00
Real getValue();
2015-09-12 14:34:57 +00:00
Real getAverage();
2015-09-07 21:31:34 +00:00
virtual void feed(Complex& ci) = 0;
2015-09-07 21:31:34 +00:00
protected:
2017-08-05 17:08:33 +00:00
double m_u0; //!< AGC factor
2017-08-05 22:02:16 +00:00
double m_R; //!< ordered magnitude
2017-08-05 17:08:33 +00:00
MovingAverage<double> m_moving_average; //!< Averaging engine. The stack length conditions the smoothness of AGC.
int m_historySize; //!< Averaging length (attack)
int m_count; //!< Samples counter
};
2015-09-07 21:31:34 +00:00
class MagAGC : public AGC
{
public:
MagAGC(int historySize, double R, double threshold);
2015-09-07 21:31:34 +00:00
virtual ~MagAGC();
void setSquared(bool squared) { m_squared = squared; }
2017-07-26 06:39:20 +00:00
void resize(int historySize, Real R);
void setOrder(double R);
2015-09-07 21:31:34 +00:00
virtual void feed(Complex& ci);
double feedAndGetValue(const Complex& ci);
double getMagSq() const { return m_magsq; }
2017-07-25 19:21:48 +00:00
void setThreshold(double threshold) { m_threshold = threshold; }
void setThresholdEnable(bool enable);
void setGate(int gate) { m_gate = gate; }
2017-08-05 17:08:33 +00:00
void setStepDownDelay(int stepDownDelay) { m_stepDownDelay = stepDownDelay; }
void setClamping(bool clamping) { m_clamping = clamping; }
void setClampMax(double clampMax) { m_clampMax = clampMax; }
private:
bool m_squared; //!< use squared magnitude (power) to compute AGC value
double m_magsq; //!< current squared magnitude (power)
2017-07-26 06:39:20 +00:00
double m_threshold; //!< squelch on magsq average
bool m_thresholdEnable; //!< enable squelch on power threshold
2017-07-26 06:39:20 +00:00
int m_gate; //!< power threshold gate in number of samples
int m_stepLength; //!< transition step length in number of samples
double m_stepDelta; //!< transition step unit by sample
2017-07-26 06:39:20 +00:00
int m_stepUpCounter; //!< step up transition samples counter
int m_stepDownCounter; //!< step down transition samples counter
int m_gateCounter; //!< threshold gate samples counter
2017-08-05 17:08:33 +00:00
int m_stepDownDelay; //!< delay in samples before cutoff (release)
bool m_clamping; //!< clamping active
2017-08-05 22:02:16 +00:00
double m_R2; //!< square of ordered magnitude
double m_clampMax; //!< maximum to clamp to as power value
2015-09-07 21:31:34 +00:00
};
2015-06-20 07:28:57 +00:00
2015-09-07 21:31:34 +00:00
class AlphaAGC : public AGC
{
public:
AlphaAGC(int historySize, Real R);
AlphaAGC(int historySize, Real R, Real alpha);
virtual ~AlphaAGC();
void resize(int historySize, Real R, Real alpha);
virtual void feed(Complex& ci);
Real getMagSq() const { return m_magsq; }
2015-06-20 07:28:57 +00:00
private:
2015-09-07 21:31:34 +00:00
Real m_alpha;
Real m_magsq;
2015-09-07 21:31:34 +00:00
bool m_squelchOpen;
2015-06-20 07:28:57 +00:00
};
2015-09-07 21:31:34 +00:00
class SimpleAGC
2015-06-20 07:28:57 +00:00
{
public:
2015-09-07 21:31:34 +00:00
SimpleAGC(int historySize, Real initial, Real cutoff=0, Real clip=0) :
m_squelchOpen(false),
m_fill(initial),
m_cutoff(cutoff),
m_clip(clip),
m_moving_average(historySize, initial)
2015-06-20 07:28:57 +00:00
{}
2015-09-07 21:31:34 +00:00
void resize(int historySize, Real initial, Real cutoff=0, Real clip=0)
2015-06-20 07:28:57 +00:00
{
2015-09-07 21:31:34 +00:00
m_fill = initial;
m_cutoff = cutoff;
m_clip = clip;
m_moving_average.resize(historySize, initial);
2015-06-20 07:28:57 +00:00
}
void fill(double value)
{
m_moving_average.fill(value);
}
2015-06-20 07:28:57 +00:00
Real getValue()
{
2015-09-07 21:31:34 +00:00
if (m_moving_average.average() > m_clip)
{
return m_moving_average.average();
} else
{
return m_clip;
}
}
void feed(Real value)
{
if (value > m_cutoff)
{
m_moving_average.feed(value);
}
}
2015-06-20 07:28:57 +00:00
private:
2015-09-07 21:31:34 +00:00
bool m_squelchOpen; // open for processing
Real m_fill; // refill average at this level
Real m_cutoff; // consider samples only above this level
Real m_clip; // never go below this level
MovingAverage<double> m_moving_average; // Averaging engine. The stack length conditions the smoothness of AGC.
2015-05-12 10:12:13 +00:00
};
#endif /* INCLUDE_GPL_DSP_AGC_H_ */