VE7UWU/sdrangel
1
0
Fork 0
mirror of https://github.com/f4exb/sdrangel.git synced 2025-09-03 05:37:50 -04:00
Code Issues Projects Releases Wiki Activity

WDSP: BPSNBA: replaced static methods

Browse Source
This commit is contained in:
f4exb 2024-07-24 23:11:29 +02:00
parent cc8c6d8004
commit 0bd4bbe0d4
3 changed files with 139 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
wdsp/RXA.cpp
View File

@ -180,7 +180,7 @@ RXA* RXA::create_rxa (
rxa->ndb); // addr of database pointer rxa->ndb); // addr of database pointer
// bandpass for snba // bandpass for snba
rxa->bpsnba = BPSNBA::create_bpsnba ( rxa->bpsnba = new BPSNBA (
0, // bpsnba run flag 0, // bpsnba run flag
0, // run the notches 0, // run the notches
0, // position 0, // position
@ -584,7 +584,7 @@ void RXA::destroy_rxa (RXA *rxa)
AMSQ::destroy_amsq (rxa->amsq); AMSQ::destroy_amsq (rxa->amsq);
delete (rxa->smeter); delete (rxa->smeter);
SENDER::destroy_sender (rxa->sender); SENDER::destroy_sender (rxa->sender);
BPSNBA::destroy_bpsnba (rxa->bpsnba); delete (rxa->bpsnba);
delete (rxa->nbp0); delete (rxa->nbp0);
delete (rxa->ndb); delete (rxa->ndb);
delete (rxa->adcmeter); delete (rxa->adcmeter);
@ -609,7 +609,7 @@ void RXA::flush_rxa (RXA *rxa)
rxa->rsmpin->flush(); rxa->rsmpin->flush();
rxa->adcmeter->flush(); rxa->adcmeter->flush();
rxa->nbp0->flush(); rxa->nbp0->flush();
BPSNBA::flush_bpsnba (rxa->bpsnba); rxa->bpsnba->flush();
SENDER::flush_sender (rxa->sender); SENDER::flush_sender (rxa->sender);
rxa->smeter->flush(); rxa->smeter->flush();
AMSQ::flush_amsq (rxa->amsq); AMSQ::flush_amsq (rxa->amsq);
@ -640,17 +640,17 @@ void RXA::xrxa (RXA *rxa)
rxa->shift->execute(); rxa->shift->execute();
rxa->rsmpin->execute(); rxa->rsmpin->execute();
rxa->adcmeter->execute(); rxa->adcmeter->execute();
BPSNBA::xbpsnbain (rxa->bpsnba, 0); rxa->bpsnba->exec_in(0);
rxa->nbp0->execute(0); rxa->nbp0->execute(0);
rxa->smeter->execute(); rxa->smeter->execute();
SENDER::xsender (rxa->sender); SENDER::xsender (rxa->sender);
AMSQ::xamsqcap (rxa->amsq); AMSQ::xamsqcap (rxa->amsq);
BPSNBA::xbpsnbaout (rxa->bpsnba, 0); rxa->bpsnba->exec_out(0);
AMD::xamd (rxa->amd); AMD::xamd (rxa->amd);
FMD::xfmd (rxa->fmd); FMD::xfmd (rxa->fmd);
FMSQ::xfmsq (rxa->fmsq); FMSQ::xfmsq (rxa->fmsq);
BPSNBA::xbpsnbain (rxa->bpsnba, 1); rxa->bpsnba->exec_in(1);
BPSNBA::xbpsnbaout (rxa->bpsnba, 1); rxa->bpsnba->exec_out(1);
SNBA::xsnba (rxa->snba); SNBA::xsnba (rxa->snba);
EQP::xeqp (rxa->eqp); EQP::xeqp (rxa->eqp);
ANF::xanf (rxa->anf, 0); ANF::xanf (rxa->anf, 0);
@ -754,7 +754,7 @@ void RXA::setDSPSamplerate (RXA *rxa, int dsp_rate)
// dsp_rate blocks // dsp_rate blocks
rxa->adcmeter->setSamplerate(rxa->dsp_rate); rxa->adcmeter->setSamplerate(rxa->dsp_rate);
rxa->nbp0->setSamplerate(rxa->dsp_rate); rxa->nbp0->setSamplerate(rxa->dsp_rate);
BPSNBA::setSamplerate_bpsnba (rxa->bpsnba, rxa->dsp_rate); rxa->bpsnba->setSamplerate(rxa->dsp_rate);
rxa->smeter->setSamplerate(rxa->dsp_rate); rxa->smeter->setSamplerate(rxa->dsp_rate);
SENDER::setSamplerate_sender (rxa->sender, rxa->dsp_rate); SENDER::setSamplerate_sender (rxa->sender, rxa->dsp_rate);
AMSQ::setSamplerate_amsq (rxa->amsq, rxa->dsp_rate); AMSQ::setSamplerate_amsq (rxa->amsq, rxa->dsp_rate);
@ -819,8 +819,8 @@ void RXA::setDSPBuffsize (RXA *rxa, int dsp_size)
rxa->adcmeter->setSize(rxa->dsp_size); rxa->adcmeter->setSize(rxa->dsp_size);
rxa->nbp0->setBuffers(rxa->midbuff, rxa->midbuff); rxa->nbp0->setBuffers(rxa->midbuff, rxa->midbuff);
rxa->nbp0->setSize(rxa->dsp_size); rxa->nbp0->setSize(rxa->dsp_size);
BPSNBA::setBuffers_bpsnba (rxa->bpsnba, rxa->midbuff, rxa->midbuff); rxa->bpsnba->setBuffers(rxa->midbuff, rxa->midbuff);
BPSNBA::setSize_bpsnba (rxa->bpsnba, rxa->dsp_size); rxa->bpsnba->setSize(rxa->dsp_size);
rxa->smeter->setBuffers(rxa->midbuff); rxa->smeter->setBuffers(rxa->midbuff);
rxa->smeter->METER::setSize(rxa->dsp_size); rxa->smeter->METER::setSize(rxa->dsp_size);
SENDER::setBuffers_sender (rxa->sender, rxa->midbuff); SENDER::setBuffers_sender (rxa->sender, rxa->midbuff);
@ -1028,7 +1028,7 @@ void RXA::bpsnbaCheck (RXA& rxa, int mode, int notch_run)
a->f_high = f_high; a->f_high = f_high;
a->run_notches = run_notches; a->run_notches = run_notches;
// f_low, f_high, run_notches are needed for the filter recalculation // f_low, f_high, run_notches are needed for the filter recalculation
BPSNBA::recalc_bpsnba_filter (a, 0); rxa.bpsnba->recalc_bpsnba_filter(0);
} }
} }
@ -1087,7 +1087,7 @@ void RXA::UpdateNBPFilters(RXA& rxa)
} }
if (b->bpsnba->fnfrun) if (b->bpsnba->fnfrun)
{ {
BPSNBA::recalc_bpsnba_filter (b, 1); b->recalc_bpsnba_filter(1);
} }
} }
@ -1199,7 +1199,7 @@ void RXA::NBPSetWindow (RXA& rxa, int wintype)
if ((b->wintype != wintype)) if ((b->wintype != wintype))
{ {
b->wintype = wintype; b->wintype = wintype;
BPSNBA::recalc_bpsnba_filter (b, 1); b->recalc_bpsnba_filter(1);
} }
} }
@ -1221,7 +1221,7 @@ void RXA::NBPSetAutoIncrease (RXA& rxa, int autoincr)
if ((b->autoincr != autoincr)) if ((b->autoincr != autoincr))
{ {
b->autoincr = autoincr; b->autoincr = autoincr;
BPSNBA::recalc_bpsnba_filter (b, 1); b->recalc_bpsnba_filter(1);
} }
} }
@ -1242,7 +1242,7 @@ void RXA::SetNC (RXA& rxa, int nc)
{ {
int oldstate = rxa.state; int oldstate = rxa.state;
rxa.nbp0->SetNC (nc); rxa.nbp0->SetNC (nc);
BPSNBA::BPSNBASetNC (rxa, nc); rxa.bpsnba->SetNC (nc);
BANDPASS::SetBandpassNC (rxa, nc); BANDPASS::SetBandpassNC (rxa, nc);
EQP::SetEQNC (rxa, nc); EQP::SetEQNC (rxa, nc);
FMSQ::SetFMSQNC (rxa, nc); FMSQ::SetFMSQNC (rxa, nc);
@ -1254,7 +1254,7 @@ void RXA::SetNC (RXA& rxa, int nc)
void RXA::SetMP (RXA& rxa, int mp) void RXA::SetMP (RXA& rxa, int mp)
{ {
rxa.nbp0->SetMP (mp); rxa.nbp0->SetMP (mp);
BPSNBA::BPSNBASetMP (rxa, mp); rxa.bpsnba->SetMP (mp);
BANDPASS::SetBandpassMP (rxa, mp); BANDPASS::SetBandpassMP (rxa, mp);
EQP::SetEQMP (rxa, mp); EQP::SetEQMP (rxa, mp);
FMSQ::SetFMSQMP (rxa, mp); FMSQ::SetFMSQMP (rxa, mp);

211
wdsp/bpsnba.cpp
View File

@ -51,135 +51,132 @@ namespace WDSP {
// for its input and output to happen at different points in the processing pipeline. This means it must // for its input and output to happen at different points in the processing pipeline. This means it must
// include a buffer, 'buff'. Its input and output are done via functions xbpshbain() and xbpshbaout(). // include a buffer, 'buff'. Its input and output are done via functions xbpshbain() and xbpshbaout().
void BPSNBA::calc_bpsnba (BPSNBA *a) void BPSNBA::calc()
{ {
a->buff = new float[a->size * 2]; // (double *) malloc0 (a->size * sizeof (complex)); buff = new float[size * 2]; // (double *) malloc0 (size * sizeof (complex));
a->bpsnba = new NBP ( bpsnba = new NBP (
1, // run, always runs (use bpsnba 'run') 1, // run, always runs (use bpsnba 'run')
a->run_notches, // run the notches run_notches, // run the notches
0, // position variable for nbp (not for bpsnba), always 0 0, // position variable for nbp (not for bpsnba), always 0
a->size, // buffer size size, // buffer size
a->nc, // number of filter coefficients nc, // number of filter coefficients
a->mp, // minimum phase flag mp, // minimum phase flag
a->buff, // pointer to input buffer buff, // pointer to input buffer
a->out, // pointer to output buffer out, // pointer to output buffer
a->f_low, // lower filter frequency f_low, // lower filter frequency
a->f_high, // upper filter frequency f_high, // upper filter frequency
a->rate, // sample rate rate, // sample rate
a->wintype, // wintype wintype, // wintype
a->gain, // gain gain, // gain
a->autoincr, // auto-increase notch width if below min autoincr, // auto-increase notch width if below min
a->maxpb, // max number of passbands maxpb, // max number of passbands
a->ptraddr); // addr of database pointer notchdb); // addr of database pointer
} }
BPSNBA* BPSNBA::create_bpsnba ( BPSNBA::BPSNBA(
int run, int _run,
int run_notches, int _run_notches,
int position, int _position,
int size, int _size,
int nc, int _nc,
int mp, int _mp,
float* in, float* _in,
float* out, float* _out,
int rate, int _rate,
double abs_low_freq, double _abs_low_freq,
double abs_high_freq, double _abs_high_freq,
double f_low, double _f_low,
double f_high, double _f_high,
int wintype, int _wintype,
double gain, double _gain,
int autoincr, int _autoincr,
int maxpb, int _maxpb,
NOTCHDB* ptraddr NOTCHDB* _notchdb
) ) :
run(_run),
run_notches(_run_notches),
position(_position),
size(_size),
nc(_nc),
mp(_mp),
in(_in),
out(_out),
rate(_rate),
abs_low_freq(_abs_low_freq),
abs_high_freq(_abs_high_freq),
f_low(_f_low),
f_high(_f_high),
wintype(_wintype),
gain(_gain),
autoincr(_autoincr),
maxpb(_maxpb),
notchdb(_notchdb)
{ {
BPSNBA *a = new BPSNBA; calc();
a->run = run;
a->run_notches = run_notches;
a->position = position;
a->size = size;
a->nc = nc;
a->mp = mp;
a->in = in;
a->out = out;
a->rate = rate;
a->abs_low_freq = abs_low_freq;
a->abs_high_freq = abs_high_freq;
a->f_low = f_low;
a->f_high = f_high;
a->wintype = wintype;
a->gain = gain;
a->autoincr = autoincr;
a->maxpb = maxpb;
a->ptraddr = ptraddr;
calc_bpsnba (a);
return a;
} }
void BPSNBA::decalc_bpsnba (BPSNBA *a) void BPSNBA::decalc()
{ {
delete (a->bpsnba); delete (bpsnba);
delete[] (a->buff); delete[] (buff);
} }
void BPSNBA::destroy_bpsnba (BPSNBA *a) BPSNBA::~BPSNBA()
{ {
decalc_bpsnba (a); decalc();
delete[] (a);
} }
void BPSNBA::flush_bpsnba (BPSNBA *a) void BPSNBA::flush()
{ {
std::fill(a->buff, a->buff + a->size * 2, 0); std::fill(buff, buff + size * 2, 0);
a->bpsnba->flush(); bpsnba->flush();
} }
void BPSNBA::setBuffers_bpsnba (BPSNBA *a, float* in, float* out) void BPSNBA::setBuffers(float* _in, float* _out)
{ {
decalc_bpsnba (a); decalc();
a->in = in; in = _in;
a->out = out; out = _out;
calc_bpsnba (a); calc();
} }
void BPSNBA::setSamplerate_bpsnba (BPSNBA *a, int rate) void BPSNBA::setSamplerate(int _rate)
{ {
decalc_bpsnba (a); decalc();
a->rate = rate; rate = _rate;
calc_bpsnba (a); calc();
} }
void BPSNBA::setSize_bpsnba (BPSNBA *a, int size) void BPSNBA::setSize(int _size)
{ {
decalc_bpsnba (a); decalc();
a->size = size; size = _size;
calc_bpsnba (a); calc();
} }
void BPSNBA::xbpsnbain (BPSNBA *a, int position) void BPSNBA::exec_in(int _position)
{ {
if (a->run && a->position == position) if (run && position == _position)
std::copy(a->in, a->in + a->size * 2, a->buff); std::copy(in, in + size * 2, buff);
} }
void BPSNBA::xbpsnbaout (BPSNBA *a, int position) void BPSNBA::exec_out(int _position)
{ {
if (a->run && a->position == position) if (run && position == _position)
a->bpsnba->execute(0); bpsnba->execute(0);
} }
void BPSNBA::recalc_bpsnba_filter (BPSNBA *a, int update) void BPSNBA::recalc_bpsnba_filter(int update)
{ {
// Call anytime one of the parameters listed below has been changed in // Call anytime one of the parameters listed below has been changed in
// the BPSNBA struct. // the BPSNBA struct.
NBP *b = a->bpsnba; NBP *b = bpsnba;
b->fnfrun = a->run_notches; b->fnfrun = run_notches;
b->flow = a->f_low; b->flow = f_low;
b->fhigh = a->f_high; b->fhigh = f_high;
b->wintype = a->wintype; b->wintype = wintype;
b->gain = a->gain; b->gain = gain;
b->autoincr = a->autoincr; b->autoincr = autoincr;
b->calc_impulse(); b->calc_impulse();
FIRCORE::setImpulse_fircore (b->fircore, b->impulse, update); FIRCORE::setImpulse_fircore (b->fircore, b->impulse, update);
delete[] (b->impulse); delete[] (b->impulse);
@ -187,31 +184,27 @@ void BPSNBA::recalc_bpsnba_filter (BPSNBA *a, int update)
/******************************************************************************************************** /********************************************************************************************************
* * * *
* RXA Properties * * Properties *
* * * *
********************************************************************************************************/ ********************************************************************************************************/
void BPSNBA::BPSNBASetNC (RXA& rxa, int nc) void BPSNBA::SetNC(int _nc)
{ {
BPSNBA *a = rxa.bpsnba; if (nc != _nc)
if (a->nc != nc)
{ {
a->nc = nc; nc = _nc;
a->bpsnba->nc = a->nc; bpsnba->nc = nc;
a->bpsnba->setNc(); bpsnba->setNc();
} }
} }
void BPSNBA::BPSNBASetMP (RXA& rxa, int mp) void BPSNBA::SetMP(int _mp)
{ {
BPSNBA *a = rxa.bpsnba; if (mp != _mp)
if (a->mp != mp)
{ {
a->mp = mp; mp = _mp;
a->bpsnba->mp = a->mp; bpsnba->mp = mp;
a->bpsnba->setMp(); bpsnba->setMp();
} }
} }

41
wdsp/bpsnba.hpp
View File

@ -47,19 +47,19 @@ public:
float* in; // input buffer float* in; // input buffer
float* out; // output buffer float* out; // output buffer
int rate; // sample rate int rate; // sample rate
float* buff; // internal buffer
NBP *bpsnba; // pointer to the notched bandpass filter, nbp
double f_low; // low cutoff frequency
double f_high; // high cutoff frequency
double abs_low_freq; // lowest positive freq supported by SNB double abs_low_freq; // lowest positive freq supported by SNB
double abs_high_freq; // highest positive freq supported by SNG double abs_high_freq; // highest positive freq supported by SNG
double f_low; // low cutoff frequency
double f_high; // high cutoff frequency
float* buff; // internal buffer
int wintype; // filter window type int wintype; // filter window type
double gain; // filter gain double gain; // filter gain
int autoincr; // use auto increment for notch width int autoincr; // use auto increment for notch width
int maxpb; // maximum passband segments supported int maxpb; // maximum passband segments supported
NOTCHDB* ptraddr; // pointer to address of NOTCH DATABASE NOTCHDB* notchdb; // pointer to address of NOTCH DATABASE
NBP *bpsnba; // pointer to the notched bandpass filter, nbp
static BPSNBA* create_bpsnba ( BPSNBA(
int run, int run,
int run_notches, int run_notches,
int position, int position,
@ -77,23 +77,24 @@ public:
double gain, double gain,
int autoincr, int autoincr,
int maxpb, int maxpb,
NOTCHDB* ptraddr NOTCHDB* notchdb
); );
static void destroy_bpsnba (BPSNBA *a); ~BPSNBA();
static void flush_bpsnba (BPSNBA *a);
static void setBuffers_bpsnba (BPSNBA *a, float* in, float* out); void flush();
static void setSamplerate_bpsnba (BPSNBA *a, int rate); void setBuffers(float* in, float* out);
static void setSize_bpsnba (BPSNBA *a, int size); void setSamplerate(int rate);
static void xbpsnbain (BPSNBA *a, int position); void setSize(int size);
static void xbpsnbaout (BPSNBA *a, int position); void exec_in(int position);
static void recalc_bpsnba_filter (BPSNBA *a, int update); void exec_out(int position);
// RXA Propertoes void recalc_bpsnba_filter(int update);
static void BPSNBASetNC (RXA& rxa, int nc); // Propertoes
static void BPSNBASetMP (RXA& rxa, int mp); void SetNC(int nc);
void SetMP(int mp);
private: private:
static void calc_bpsnba (BPSNBA *a); void calc();
static void decalc_bpsnba (BPSNBA *a); void decalc();
}; };