mirror/SDRPlusPlus
0
0
Fork 0
mirror of https://github.com/AlexandreRouma/SDRPlusPlus.git synced 2025-06-28 13:27:51 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

attemt at a CI build with new DSP

Browse Source
This commit is contained in:
AlexandreRouma
2022-06-17 17:34:23 +02:00
parent d1318d3a0f
commit 36adc102ee
38 changed files with 259 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
core/src/dsp/bench/peak_level_meter.h
View File

@ -3,12 +3,22 @@
namespace dsp::bench {
template<class T>
class PeakLevelMeter : Sink<T> {
class PeakLevelMeter : public Sink<T> {
using base_type = Sink<T>;
public:
PeakLevelMeter() {}
PeakLevelMeter(stream<T>* in) { base_type::init(in); }
PeakLevelMeter(stream<T>* in) { init(in); }
void init(stream<T>* in) {
if constexpr (std::is_same_v<T, float>) {
level = 0.0f;
}
if constexpr (std::is_same_v<T, complex_t> || std::is_same_v<T, stereo_t>) {
level = { 0.0f, 0.0f };
}
base_type::init(in);
}
T getLevel() {
return level;

8
core/src/dsp/channel/rx_vfo.h
View File

@ -82,12 +82,12 @@ namespace dsp::channel {
}
inline int process(int count, const complex_t* in, complex_t* out) {
xlator.process(count, in, xlator.out.writeBuf);
xlator.process(count, in, out);
if (!filterNeeded) {
return resamp.process(count, xlator.out.writeBuf, out);
return resamp.process(count, out, out);
}
count = resamp.process(count, xlator.out.writeBuf, resamp.out.writeBuf);
filter.process(count, resamp.out.writeBuf, out);
count = resamp.process(count, out, out);
filter.process(count, out, out);
return count;
}

7
core/src/dsp/demod/am.h
View File

@ -18,8 +18,8 @@ namespace dsp::demod {
void init(stream<complex_t>* in, AGCMode agcMode, double agcRate) {
_agcMode = agcMode;
carrierAgc.init(NULL, 1.0, agcRate);
audioAgc.init(NULL, 1.0, agcRate);
carrierAgc.init(NULL, 1.0, agcRate, 10e6, 10.0);
audioAgc.init(NULL, 1.0, agcRate, 10e6, 10.0);
base_type::init(in);
}
@ -63,6 +63,9 @@ namespace dsp::demod {
if (_agcMode == AGCMode::AUDIO) {
audioAgc.process(count, out, out);
}
else {
volk_32f_s32f_add_32f(out, out, -1.0f, count);
}
return count;
}

71
core/src/dsp/demod/broadcast_fm.h
View File

@ -1,5 +1,6 @@
#pragma once
#include "fm.h"
#include "../taps/low_pass.h"
#include "../taps/band_pass.h"
#include "../filter/fir.h"
#include "../loop/pll.h"
@ -18,7 +19,7 @@ namespace dsp::demod {
public:
BroadcastFM() {}
BroadcastFM(stream<complex_t>* in, double deviation, double samplerate, bool stereo = true) { init(in, deviation, samplerate, stereo); }
BroadcastFM(stream<complex_t>* in, double deviation, double samplerate, bool stereo = true, bool lowPass = true) { init(in, deviation, samplerate, stereo, lowPass); }
~BroadcastFM() {
if (!base_type::_block_init) { return; }
@ -26,19 +27,26 @@ namespace dsp::demod {
buffer::free(lmr);
buffer::free(l);
buffer::free(r);
taps::free(pilotFirTaps);
taps::free(audioFirTaps);
}
virtual void init(stream<complex_t>* in, double deviation, double samplerate, bool stereo = true) {
virtual void init(stream<complex_t>* in, double deviation, double samplerate, bool stereo = true, bool lowPass = true) {
_deviation = deviation;
_samplerate = samplerate;
_stereo = stereo;
_lowPass = lowPass;
demod.init(NULL, _deviation, _samplerate);
pilotFirTaps = taps::bandPass<complex_t>(18750.0, 19250.0, 3000.0, _samplerate);
pilotFirTaps = taps::bandPass<complex_t>(18750.0, 19250.0, 3000.0, _samplerate, true);
pilotFir.init(NULL, pilotFirTaps);
rtoc.init(NULL);
pilotPLL.init(NULL, 0.1/*TODO: adapt to samplerate*/, 0.0, math::freqToOmega(19000.0, _samplerate), math::freqToOmega(18750.0, _samplerate), math::freqToOmega(19250.0, _samplerate));
delay.init(NULL, pilotFirTaps.size / 2.0);
pilotPLL.init(NULL, 25000.0 / _samplerate, 0.0, math::freqToOmega(19000.0, _samplerate), math::freqToOmega(18750.0, _samplerate), math::freqToOmega(19250.0, _samplerate));
lprDelay.init(NULL, ((pilotFirTaps.size - 1) / 2) + 1);
lmrDelay.init(NULL, ((pilotFirTaps.size - 1) / 2) + 1);
audioFirTaps = taps::lowPass(15000.0, 4000.0, _samplerate);
alFir.init(NULL, audioFirTaps);
arFir.init(NULL, audioFirTaps);
lmr = buffer::alloc<float>(STREAM_BUFFER_SIZE);
l = buffer::alloc<float>(STREAM_BUFFER_SIZE);
@ -62,11 +70,18 @@ namespace dsp::demod {
demod.setDeviation(_deviation, _samplerate);
taps::free(pilotFirTaps);
pilotFirTaps = taps::bandPass<complex_t>(18750.0, 19250.0, 3000.0, samplerate);
pilotFirTaps = taps::bandPass<complex_t>(18750.0, 19250.0, 3000.0, samplerate, true);
pilotFir.setTaps(pilotFirTaps);
pilotPLL.setFrequencyLimits(math::freqToOmega(18750.0, _samplerate), math::freqToOmega(19250.0, _samplerate));
pilotPLL.setInitialFreq(math::freqToOmega(19000.0, _samplerate));
delay.setDelay(pilotFirTaps.size / 2);
lprDelay.setDelay(((pilotFirTaps.size - 1) / 2) + 1);
lmrDelay.setDelay(((pilotFirTaps.size - 1) / 2) + 1);
taps::free(audioFirTaps);
audioFirTaps = taps::lowPass(15000.0, 4000.0, _samplerate);
alFir.setTaps(audioFirTaps);
arFir.setTaps(audioFirTaps);
reset();
base_type::tempStart();
@ -81,6 +96,15 @@ namespace dsp::demod {
base_type::tempStart();
}
void setLowPass(bool lowPass) {
assert(base_type::_block_init);
std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
base_type::tempStop();
_lowPass = lowPass;
reset();
base_type::tempStart();
}
void reset() {
assert(base_type::_block_init);
std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
@ -88,7 +112,10 @@ namespace dsp::demod {
demod.reset();
pilotFir.reset();
pilotPLL.reset();
delay.reset();
lprDelay.reset();
lmrDelay.reset();
alFir.reset();
arFir.reset();
base_type::tempStart();
}
@ -103,21 +130,40 @@ namespace dsp::demod {
pilotFir.process(count, rtoc.out.writeBuf, pilotFir.out.writeBuf);
pilotPLL.process(count, pilotFir.out.writeBuf, pilotPLL.out.writeBuf);
// Conjugate PLL output to down convert the L-R signal
// Delay
lprDelay.process(count, demod.out.writeBuf, demod.out.writeBuf);
lmrDelay.process(count, rtoc.out.writeBuf, rtoc.out.writeBuf);
// Double and conjugate PLL output to down convert the L-R signal
math::Multiply<dsp::complex_t>::process(count, pilotPLL.out.writeBuf, pilotPLL.out.writeBuf, pilotPLL.out.writeBuf);
math::Conjugate::process(count, pilotPLL.out.writeBuf, pilotPLL.out.writeBuf);
math::Multiply<dsp::complex_t>::process(count, rtoc.out.writeBuf, pilotPLL.out.writeBuf, rtoc.out.writeBuf);
// Convert output back to real for further processing
convert::ComplexToReal::process(count, rtoc.out.writeBuf, lmr);
// Amplify by 2x
volk_32f_s32f_multiply_32f(lmr, lmr, 2.0f, count);
// Do L = (L+R) + (L-R), R = (L+R) - (L-R)
math::Add<float>::process(count, demod.out.writeBuf, lmr, l);
math::Subtract<float>::process(count, demod.out.writeBuf, lmr, r);
// Filter if needed
if (_lowPass) {
alFir.process(count, l, l);
arFir.process(count, r, r);
}
// Interleave into stereo
convert::LRToStereo::process(count, l, r, out);
}
else {
// Filter if needed
if (_lowPass) {
alFir.process(count, demod.out.writeBuf, demod.out.writeBuf);
}
// Interleave raw MPX to stereo
convert::LRToStereo::process(count, demod.out.writeBuf, demod.out.writeBuf, out);
}
@ -140,13 +186,18 @@ namespace dsp::demod {
double _deviation;
double _samplerate;
bool _stereo;
bool _lowPass = true;
FM demod;
tap<complex_t> pilotFirTaps;
filter::FIR<complex_t, complex_t> pilotFir;
convert::RealToComplex rtoc;
loop::PLL pilotPLL;
math::Delay<float> delay;
math::Delay<float> lprDelay;
math::Delay<complex_t> lmrDelay;
tap<float> audioFirTaps;
filter::FIR<float, float> arFir;
filter::FIR<float, float> alFir;
float* lmr;
float* l;

2
core/src/dsp/demod/ssb.h
View File

@ -32,7 +32,7 @@ namespace dsp::demod {
_bandwidth = bandwidth;
_samplerate = samplerate;
xlator.init(NULL, getTranslation(), _samplerate);
agc.init(NULL, 1.0, agcRate);
agc.init(NULL, 1.0, agcRate, 10e6, 10.0);
base_type::init(in);
}

45
core/src/dsp/loop/agc.h
View File

@ -8,11 +8,14 @@ namespace dsp::loop {
public:
AGC() {}
AGC(stream<T>* in) { init(in); }
AGC(stream<T>* in, double setPoint, double rate, double maxGain, double maxOutputAmp, double initGain = 1.0) { init(in, setPoint, rate, maxGain, maxOutputAmp, initGain); }
void init(stream<T>* in, double setPoint, double rate, double initGain = 1.0) {
void init(stream<T>* in, double setPoint, double rate, double maxGain, double maxOutputAmp, double initGain = 1.0) {
_setPoint = setPoint;
_rate = rate;
_invRate = 1.0f - _rate;
_maxGain = maxGain;
_maxOutputAmp = maxOutputAmp;
_initGain = initGain;
gain = _initGain;
base_type::init(in);
@ -28,6 +31,19 @@ namespace dsp::loop {
assert(base_type::_block_init);
std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
_rate = rate;
_invRate = 1.0f - _rate;
}
void setMaxGain(double maxGain) {
assert(base_type::_block_init);
std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
_maxGain = maxGain;
}
void setMaxOutputAmp(double maxOutputAmp) {
assert(base_type::_block_init);
std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
_maxOutputAmp = maxOutputAmp;
}
void setInitialGain(double initGain) {
@ -40,22 +56,29 @@ namespace dsp::loop {
assert(base_type::_block_init);
std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
gain = _initGain;
amp = 1.0f;
}
inline int process(int count, T* in, T* out) {
for (int i = 0; i < count; i++) {
// Scale output by gain
out[i] = in[i] * gain;
// Update gain according to setpoint and rate
// Get signal amplitude
float inAmp;
if constexpr (std::is_same_v<T, complex_t>) {
gain += (_setPoint - out[i].amplitude()) * _rate;
inAmp = in[i].amplitude();
}
if constexpr (std::is_same_v<T, float>) {
gain += (_setPoint - fabsf(out[i])) * _rate;
inAmp = fabsf(in[i]);
}
// Update average amplitude
if (inAmp != 0.0f) {
amp = (amp * _invRate) + (inAmp * _rate);
gain = std::min<float>(_setPoint / amp, _maxGain);
}
// Scale output by gain
out[i] = in[i] * gain;
}
printf("%f\n", gain);
return count;
}
@ -73,9 +96,13 @@ namespace dsp::loop {
protected:
float _setPoint;
float _rate;
float _invRate;
float _maxGain;
float _maxOutputAmp;
float _initGain;
float gain;
float amp = 1.0;
};
}

5
core/src/dsp/loop/phase_control_loop.h
View File

@ -35,6 +35,11 @@ namespace dsp::loop {
beta = (4 * bandwidth * bandwidth) / denominator;
}
void setCoefficients(T alpha, T beta) {
_alpha = alpha:
_beta = beta;
}
void setPhaseLimits(T minPhase, T maxPhase) {
assert(maxPhase > minPhase);
_minPhase = minPhase;

10
core/src/dsp/loop/pll.h
View File

@ -24,6 +24,16 @@ namespace dsp::loop {
base_type::init(in);
}
void setBandwidth(double bandwidth) {
assert(base_type::_block_init);
std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
base_type::tempStop();
float alpha, beta;
PhaseControlLoop<float>::criticallyDamped(bandwidth, alpha, beta);
base_type::tempStart();
}
void setInitialPhase(double initPhase) {
assert(base_type::_block_init);
std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);

2
core/src/dsp/math/delay.h
View File

@ -19,7 +19,7 @@ namespace dsp::math {
void init(stream<T>* in, int delay) {
_delay = delay;
buffer = buffer::alloc<float>(STREAM_BUFFER_SIZE + 64000);
buffer = buffer::alloc<T>(STREAM_BUFFER_SIZE + 64000);
bufStart = &buffer[_delay];
buffer::clear(buffer, _delay);

4
core/src/dsp/multirate/power_decimator.h
View File

@ -60,8 +60,8 @@ namespace dsp::multirate {
int last = stageCount - 1;
for (int i = 0; i < stageCount; i++) {
auto fir = decimFirs[i];
count = fir->process(count, data, (i == last) ? out : fir->out.writeBuf);
data = fir->out.writeBuf;
count = fir->process(count, data, out);
data = out;
}
return count;
}

4
core/src/dsp/multirate/rational_resampler.h
View File

@ -63,8 +63,8 @@ namespace dsp::multirate {
inline int process(int count, const T* in, T* out) {
switch(mode) {
case Mode::BOTH:
count = decim.process(count, in, decim.out.writeBuf);
return resamp.process(count, decim.out.writeBuf, out);
count = decim.process(count, in, out);
return resamp.process(count, out, out);
case Mode::DECIM_ONLY:
return decim.process(count, in, out);
case Mode::RESAMP_ONLY:

44
core/src/dsp/routing/stream_link.h Normal file
View File

@ -0,0 +1,44 @@
#pragma once
#include "../sink.h"
namespace dsp::routing {
template <class T>
class StreamLink : public Sink<T> {
using base_type = Sink<T>;
public:
StreamLink() {}
StreamLink(stream<T>* in, stream<T>* out) { init(in, out); }
void init(stream<T>* in, stream<T>* out) {
_out = out;
base_type::registerOutput(_out);
base_type::init(in);
}
void setOutput(stream<T>* out) {
assert(base_type::_block_init);
std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
base_type::tempStop();
base_type::unregisterOutput(_out);
_out = out;
base_type::registerOutput(_out);
base_type::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
memcpy(_out->writeBuf, _in->readBuf, count * sizeof(T));
_in->flush();
if (!_out->swap(count)) { return -1; }
return count;
}
protected:
stream<T>* _out;
};
}

9
core/src/dsp/taps/band_pass.h
View File

@ -8,15 +8,18 @@
namespace dsp::taps {
template<class T>
inline tap<T> bandPass(double bandStart, double bandStop, double transWidth, double sampleRate) {
inline tap<T> bandPass(double bandStart, double bandStop, double transWidth, double sampleRate, bool oddTapCount = false) {
assert(bandStop > bandStart);
float offsetOmega = math::freqToOmega((bandStart + bandStop) / 2.0, sampleRate);
return windowedSinc<T>(estimateTapCount(transWidth, sampleRate), (bandStop - bandStart) / 2.0, sampleRate, [=](double n, double N) {
int count = estimateTapCount(transWidth, sampleRate);
if (oddTapCount && !(count % 2)) { count++; }
return windowedSinc<T>(count, (bandStop - bandStart) / 2.0, sampleRate, [=](double n, double N) {
if constexpr (std::is_same_v<T, float>) {
return cosf(offsetOmega * (float)n) * window::nuttall(n, N);
}
if constexpr (std::is_same_v<T, complex_t>) {
return math::phasor(offsetOmega * (float)n) * window::nuttall(n, N);
// The offset is negative to flip the taps. Complex bandpass are asymetric
return math::phasor(-offsetOmega * (float)n) * window::nuttall(n, N);
}
});
}

6
core/src/dsp/taps/high_pass.h
View File

@ -4,8 +4,10 @@
#include "../window/nuttall.h"
namespace dsp::taps {
inline tap<float> highPass(double cutoff, double transWidth, double sampleRate) {
return windowedSinc<float>(estimateTapCount(transWidth, sampleRate), (sampleRate / 2.0) - cutoff, sampleRate, [=](double n, double N){
inline tap<float> highPass(double cutoff, double transWidth, double sampleRate, bool oddTapCount = false) {
int count = estimateTapCount(transWidth, sampleRate);
if (oddTapCount && !(count % 2)) { count++; }
return windowedSinc<float>(count, (sampleRate / 2.0) - cutoff, sampleRate, [=](double n, double N){
return window::nuttall(n, N) * (((int)round(n) % 2) ? -1.0f : 1.0f);
});
}

6
core/src/dsp/taps/low_pass.h
View File

@ -4,7 +4,9 @@
#include "../window/nuttall.h"
namespace dsp::taps {
inline tap<float> lowPass(double cutoff, double transWidth, double sampleRate) {
return windowedSinc<float>(estimateTapCount(transWidth, sampleRate), cutoff, sampleRate, window::nuttall);
inline tap<float> lowPass(double cutoff, double transWidth, double sampleRate, bool oddTapCount = false) {
int count = estimateTapCount(transWidth, sampleRate);
if (oddTapCount && !(count % 2)) { count++; }
return windowedSinc<float>(count, cutoff, sampleRate, window::nuttall);
}
}

2
core/src/version.h
View File

@ -1,3 +1,3 @@
#pragma once
#define VERSION_STR "1.0.6"
#define VERSION_STR "1.1.0"