mirror of https://github.com/f4exb/sdrangel.git
New simplified channel sample source interface and corresponding up channelizer
This commit is contained in:
f4exb
parent
9fd190aaae
commit
e7cd9c32cc
|
|
@ -64,8 +64,10 @@ set(sdrbase_SOURCES
|
|||
dsp/agc.cpp
|
||||
dsp/downchannelizer.cpp
|
||||
dsp/upchannelizer.cpp
|
||||
dsp/upsamplechannelizer.cpp
|
||||
dsp/channelmarker.cpp
|
||||
dsp/ctcssdetector.cpp
|
||||
dsp/channelsamplesource.cpp
|
||||
dsp/cwkeyer.cpp
|
||||
dsp/cwkeyersettings.cpp
|
||||
dsp/decimatorsif.cpp
|
||||
|
|
@ -179,7 +181,9 @@ set(sdrbase_HEADERS
|
|||
dsp/autocorrector.h
|
||||
dsp/downchannelizer.h
|
||||
dsp/upchannelizer.h
|
||||
dsp/upsamplechannelizer.h
|
||||
dsp/channelmarker.h
|
||||
dsp/channelsamplesource.h
|
||||
dsp/complex.h
|
||||
dsp/cwkeyer.h
|
||||
dsp/cwkeyersettings.h
|
||||
|
|
|
|||
|
|
@ -0,0 +1,25 @@
|
|||
///////////////////////////////////////////////////////////////////////////////////
|
||||
// Copyright (C) 2019 F4EXB //
|
||||
// written by Edouard Griffiths //
|
||||
// //
|
||||
// This program is free software; you can redistribute it and/or modify //
|
||||
// it under the terms of the GNU General Public License as published by //
|
||||
// the Free Software Foundation as version 3 of the License, or //
|
||||
// (at your option) any later version. //
|
||||
// //
|
||||
// This program is distributed in the hope that it will be useful, //
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of //
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
|
||||
// GNU General Public License V3 for more details. //
|
||||
// //
|
||||
// You should have received a copy of the GNU General Public License //
|
||||
// along with this program. If not, see <http://www.gnu.org/licenses/>. //
|
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include "channelsamplesource.h"
|
||||
|
||||
ChannelSampleSource::ChannelSampleSource()
|
||||
{}
|
||||
|
||||
ChannelSampleSource::~ChannelSampleSource()
|
||||
{}
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
///////////////////////////////////////////////////////////////////////////////////
|
||||
// Copyright (C) 2019 F4EXB //
|
||||
// written by Edouard Griffiths //
|
||||
// //
|
||||
// This program is free software; you can redistribute it and/or modify //
|
||||
// it under the terms of the GNU General Public License as published by //
|
||||
// the Free Software Foundation as version 3 of the License, or //
|
||||
// (at your option) any later version. //
|
||||
// //
|
||||
// This program is distributed in the hope that it will be useful, //
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of //
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
|
||||
// GNU General Public License V3 for more details. //
|
||||
// //
|
||||
// You should have received a copy of the GNU General Public License //
|
||||
// along with this program. If not, see <http://www.gnu.org/licenses/>. //
|
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// This is a lightweight channel sample source interface
|
||||
|
||||
#ifndef SDRBASE_DSP_CHANNELSAMPLESOURCE_H_
|
||||
#define SDRBASE_DSP_CHANNELSAMPLESOURCE_H_
|
||||
|
||||
#include "export.h"
|
||||
#include "dsptypes.h"
|
||||
|
||||
class Message;
|
||||
|
||||
class SDRBASE_API ChannelSampleSource {
|
||||
public:
|
||||
ChannelSampleSource();
|
||||
virtual ~ChannelSampleSource();
|
||||
|
||||
virtual void pull(SampleVector::iterator begin, unsigned int nbSamples) = 0; //!< pull nbSamples from the source and write them starting at begin
|
||||
virtual void pullOne(Sample& sample) = 0; //!< pull a single sample from the source
|
||||
};
|
||||
|
||||
#endif // SDRBASE_DSP_CHANNELSAMPLESOURCE_H_
|
||||
|
|
@ -0,0 +1,319 @@
|
|||
///////////////////////////////////////////////////////////////////////////////////
|
||||
// Copyright (C) 2019 F4EXB //
|
||||
// written by Edouard Griffiths //
|
||||
// //
|
||||
// This program is free software; you can redistribute it and/or modify //
|
||||
// it under the terms of the GNU General Public License as published by //
|
||||
// the Free Software Foundation as version 3 of the License, or //
|
||||
// (at your option) any later version. //
|
||||
// //
|
||||
// This program is distributed in the hope that it will be useful, //
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of //
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
|
||||
// GNU General Public License V3 for more details. //
|
||||
// //
|
||||
// You should have received a copy of the GNU General Public License //
|
||||
// along with this program. If not, see <http://www.gnu.org/licenses/>. //
|
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
#include <QString>
|
||||
#include <QDebug>
|
||||
#include <algorithm>
|
||||
|
||||
#include "inthalfbandfilter.h"
|
||||
#include "dspcommands.h"
|
||||
#include "hbfilterchainconverter.h"
|
||||
#include "upsamplechannelizer.h"
|
||||
|
||||
UpSampleChannelizer::UpSampleChannelizer(ChannelSampleSource* sampleSource) :
|
||||
m_filterChainSetMode(false),
|
||||
m_sampleSource(sampleSource),
|
||||
m_outputSampleRate(0),
|
||||
m_requestedInputSampleRate(0),
|
||||
m_requestedCenterFrequency(0),
|
||||
m_currentInputSampleRate(0),
|
||||
m_currentCenterFrequency(0)
|
||||
{
|
||||
}
|
||||
|
||||
UpSampleChannelizer::~UpSampleChannelizer()
|
||||
{
|
||||
freeFilterChain();
|
||||
}
|
||||
|
||||
void UpSampleChannelizer::pullOne(Sample& sample)
|
||||
{
|
||||
if (m_sampleSource == nullptr)
|
||||
{
|
||||
m_sampleBuffer.clear();
|
||||
return;
|
||||
}
|
||||
|
||||
unsigned int log2Interp = m_filterStages.size();
|
||||
|
||||
if (log2Interp == 0) // optimization when no downsampling is done anyway
|
||||
{
|
||||
m_sampleSource->pullOne(sample);
|
||||
}
|
||||
else
|
||||
{
|
||||
FilterStages::iterator stage = m_filterStages.begin();
|
||||
std::vector<Sample>::iterator stageSample = m_stageSamples.begin();
|
||||
|
||||
for (; stage != m_filterStages.end(); ++stage, ++stageSample)
|
||||
{
|
||||
if(stage == m_filterStages.end() - 1)
|
||||
{
|
||||
if ((*stage)->work(&m_sampleIn, &(*stageSample)))
|
||||
{
|
||||
m_sampleSource->pullOne(m_sampleIn); // get new input sample
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!(*stage)->work(&(*(stageSample+1)), &(*stageSample)))
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
sample = *m_stageSamples.begin();
|
||||
}
|
||||
}
|
||||
|
||||
void UpSampleChannelizer::pull(SampleVector::iterator begin, unsigned int nbSamples)
|
||||
{
|
||||
if (m_sampleSource == nullptr)
|
||||
{
|
||||
m_sampleBuffer.clear();
|
||||
return;
|
||||
}
|
||||
|
||||
unsigned int log2Interp = m_filterStages.size();
|
||||
|
||||
if (log2Interp == 0) // optimization when no downsampling is done anyway
|
||||
{
|
||||
m_sampleSource->pull(begin, nbSamples);
|
||||
}
|
||||
else
|
||||
{
|
||||
std::for_each(
|
||||
begin,
|
||||
begin + nbSamples,
|
||||
[this](Sample& s) {
|
||||
pullOne(s);
|
||||
}
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
void UpSampleChannelizer::applyConfiguration()
|
||||
{
|
||||
m_filterChainSetMode = false;
|
||||
|
||||
if (m_outputSampleRate == 0)
|
||||
{
|
||||
qDebug() << "UpChannelizer::applyConfiguration: aborting (out=0):"
|
||||
<< " out =" << m_outputSampleRate
|
||||
<< ", req =" << m_requestedInputSampleRate
|
||||
<< ", in =" << m_currentInputSampleRate
|
||||
<< ", fc =" << m_currentCenterFrequency;
|
||||
return;
|
||||
}
|
||||
|
||||
freeFilterChain();
|
||||
|
||||
m_currentCenterFrequency = createFilterChain(
|
||||
m_outputSampleRate / -2, m_outputSampleRate / 2,
|
||||
m_requestedCenterFrequency - m_requestedInputSampleRate / 2, m_requestedCenterFrequency + m_requestedInputSampleRate / 2);
|
||||
|
||||
m_currentInputSampleRate = m_outputSampleRate / (1 << m_filterStages.size());
|
||||
|
||||
qDebug() << "UpChannelizer::applyConfiguration:"
|
||||
<< " out=" << m_outputSampleRate
|
||||
<< ", req=" << m_requestedInputSampleRate
|
||||
<< ", in=" << m_currentInputSampleRate
|
||||
<< ", fc=" << m_currentCenterFrequency;
|
||||
}
|
||||
|
||||
void UpSampleChannelizer::applySetting(unsigned int log2Interp, unsigned int filterChainHash)
|
||||
{
|
||||
m_filterChainSetMode = true;
|
||||
std::vector<unsigned int> stageIndexes;
|
||||
m_currentCenterFrequency = m_outputSampleRate * HBFilterChainConverter::convertToIndexes(log2Interp, filterChainHash, stageIndexes);
|
||||
m_requestedCenterFrequency = m_currentCenterFrequency;
|
||||
|
||||
m_mutex.lock();
|
||||
freeFilterChain();
|
||||
m_currentCenterFrequency = m_outputSampleRate * setFilterChain(stageIndexes);
|
||||
m_mutex.unlock();
|
||||
|
||||
m_currentInputSampleRate = m_outputSampleRate / (1 << m_filterStages.size());
|
||||
m_requestedInputSampleRate = m_currentInputSampleRate;
|
||||
|
||||
qDebug() << "UpChannelizer::applySetting in=" << m_outputSampleRate
|
||||
<< ", out=" << m_currentInputSampleRate
|
||||
<< ", fc=" << m_currentCenterFrequency;
|
||||
}
|
||||
|
||||
#ifdef USE_SSE4_1
|
||||
UpSampleChannelizer::FilterStage::FilterStage(Mode mode) :
|
||||
m_filter(new IntHalfbandFilterEO1<UPSAMPLECHANNELIZER_HB_FILTER_ORDER>),
|
||||
m_workFunction(0)
|
||||
{
|
||||
switch(mode) {
|
||||
case ModeCenter:
|
||||
m_workFunction = &IntHalfbandFilterEO1<UPSAMPLECHANNELIZER_HB_FILTER_ORDER>::workInterpolateCenter;
|
||||
break;
|
||||
|
||||
case ModeLowerHalf:
|
||||
m_workFunction = &IntHalfbandFilterEO1<UPSAMPLECHANNELIZER_HB_FILTER_ORDER>::workInterpolateLowerHalf;
|
||||
break;
|
||||
|
||||
case ModeUpperHalf:
|
||||
m_workFunction = &IntHalfbandFilterEO1<UPSAMPLECHANNELIZER_HB_FILTER_ORDER>::workInterpolateUpperHalf;
|
||||
break;
|
||||
}
|
||||
}
|
||||
#else
|
||||
UpSampleChannelizer::FilterStage::FilterStage(Mode mode) :
|
||||
m_filter(new IntHalfbandFilterDB<qint32, UPSAMPLECHANNELIZER_HB_FILTER_ORDER>),
|
||||
m_workFunction(0)
|
||||
{
|
||||
switch(mode) {
|
||||
case ModeCenter:
|
||||
m_workFunction = &IntHalfbandFilterDB<qint32, UPSAMPLECHANNELIZER_HB_FILTER_ORDER>::workInterpolateCenter;
|
||||
break;
|
||||
|
||||
case ModeLowerHalf:
|
||||
m_workFunction = &IntHalfbandFilterDB<qint32, UPSAMPLECHANNELIZER_HB_FILTER_ORDER>::workInterpolateLowerHalf;
|
||||
break;
|
||||
|
||||
case ModeUpperHalf:
|
||||
m_workFunction = &IntHalfbandFilterDB<qint32, UPSAMPLECHANNELIZER_HB_FILTER_ORDER>::workInterpolateUpperHalf;
|
||||
break;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
UpSampleChannelizer::FilterStage::~FilterStage()
|
||||
{
|
||||
delete m_filter;
|
||||
}
|
||||
|
||||
bool UpSampleChannelizer::signalContainsChannel(Real sigStart, Real sigEnd, Real chanStart, Real chanEnd) const
|
||||
{
|
||||
//qDebug(" testing signal [%f, %f], channel [%f, %f]", sigStart, sigEnd, chanStart, chanEnd);
|
||||
if(sigEnd <= sigStart)
|
||||
return false;
|
||||
if(chanEnd <= chanStart)
|
||||
return false;
|
||||
return (sigStart <= chanStart) && (sigEnd >= chanEnd);
|
||||
}
|
||||
|
||||
Real UpSampleChannelizer::createFilterChain(Real sigStart, Real sigEnd, Real chanStart, Real chanEnd)
|
||||
{
|
||||
Real sigBw = sigEnd - sigStart;
|
||||
Real rot = sigBw / 4;
|
||||
Sample s;
|
||||
|
||||
qDebug() << "UpSampleChannelizer::createFilterChain: start:"
|
||||
<< " sig: [" << sigStart << ":" << sigEnd << "]"
|
||||
<< " BW: " << sigBw
|
||||
<< " chan: [" << chanStart << ":" << chanEnd << "]"
|
||||
<< " rot: " << rot;
|
||||
|
||||
// check if it fits into the left half
|
||||
if(signalContainsChannel(sigStart, sigStart + sigBw / 2.0, chanStart, chanEnd))
|
||||
{
|
||||
qDebug() << "UpSampleChannelizer::createFilterChain: take left half (rotate by +1/4 and decimate by 2):"
|
||||
<< " [" << m_filterStages.size() << "]"
|
||||
<< " sig: [" << sigStart << ":" << sigStart + sigBw / 2.0 << "]";
|
||||
m_filterStages.push_back(new FilterStage(FilterStage::ModeLowerHalf));
|
||||
m_stageSamples.push_back(s);
|
||||
return createFilterChain(sigStart, sigStart + sigBw / 2.0, chanStart, chanEnd);
|
||||
}
|
||||
|
||||
// check if it fits into the right half
|
||||
if(signalContainsChannel(sigEnd - sigBw / 2.0f, sigEnd, chanStart, chanEnd))
|
||||
{
|
||||
qDebug() << "UpSampleChannelizer::createFilterChain: take right half (rotate by -1/4 and decimate by 2):"
|
||||
<< " [" << m_filterStages.size() << "]"
|
||||
<< " sig: [" << sigEnd - sigBw / 2.0f << ":" << sigEnd << "]";
|
||||
m_filterStages.push_back(new FilterStage(FilterStage::ModeUpperHalf));
|
||||
m_stageSamples.push_back(s);
|
||||
return createFilterChain(sigEnd - sigBw / 2.0f, sigEnd, chanStart, chanEnd);
|
||||
}
|
||||
|
||||
// check if it fits into the center
|
||||
// Was: if(signalContainsChannel(sigStart + rot + safetyMargin, sigStart + rot + sigBw / 2.0f - safetyMargin, chanStart, chanEnd)) {
|
||||
if(signalContainsChannel(sigStart + rot, sigEnd - rot, chanStart, chanEnd))
|
||||
{
|
||||
qDebug() << "UpSampleChannelizer::createFilterChain: take center half (decimate by 2):"
|
||||
<< " [" << m_filterStages.size() << "]"
|
||||
<< " sig: [" << sigStart + rot << ":" << sigEnd - rot << "]";
|
||||
m_filterStages.push_back(new FilterStage(FilterStage::ModeCenter));
|
||||
m_stageSamples.push_back(s);
|
||||
// Was: return createFilterChain(sigStart + rot, sigStart + sigBw / 2.0f + rot, chanStart, chanEnd);
|
||||
return createFilterChain(sigStart + rot, sigEnd - rot, chanStart, chanEnd);
|
||||
}
|
||||
|
||||
Real ofs = ((chanEnd - chanStart) / 2.0 + chanStart) - ((sigEnd - sigStart) / 2.0 + sigStart);
|
||||
|
||||
qDebug() << "UpSampleChannelizer::createFilterChain: complete:"
|
||||
<< " #stages: " << m_filterStages.size()
|
||||
<< " BW: " << sigBw
|
||||
<< " ofs: " << ofs;
|
||||
|
||||
return ofs;
|
||||
}
|
||||
|
||||
double UpSampleChannelizer::setFilterChain(const std::vector<unsigned int>& stageIndexes)
|
||||
{
|
||||
// filters are described from lower to upper level but the chain is constructed the other way round
|
||||
std::vector<unsigned int>::const_reverse_iterator rit = stageIndexes.rbegin();
|
||||
double ofs = 0.0, ofs_stage = 0.25;
|
||||
Sample s;
|
||||
|
||||
// Each index is a base 3 number with 0 = low, 1 = center, 2 = high
|
||||
// Functions at upper level will convert a number to base 3 to describe the filter chain. Common converting
|
||||
// algorithms will go from LSD to MSD. This explains the reverse order.
|
||||
for (; rit != stageIndexes.rend(); ++rit)
|
||||
{
|
||||
if (*rit == 0)
|
||||
{
|
||||
m_filterStages.push_back(new FilterStage(FilterStage::ModeLowerHalf));
|
||||
m_stageSamples.push_back(s);
|
||||
ofs -= ofs_stage;
|
||||
}
|
||||
else if (*rit == 1)
|
||||
{
|
||||
m_filterStages.push_back(new FilterStage(FilterStage::ModeCenter));
|
||||
m_stageSamples.push_back(s);
|
||||
}
|
||||
else if (*rit == 2)
|
||||
{
|
||||
m_filterStages.push_back(new FilterStage(FilterStage::ModeUpperHalf));
|
||||
m_stageSamples.push_back(s);
|
||||
ofs += ofs_stage;
|
||||
}
|
||||
|
||||
ofs_stage /= 2;
|
||||
}
|
||||
|
||||
return ofs;
|
||||
}
|
||||
|
||||
void UpSampleChannelizer::freeFilterChain()
|
||||
{
|
||||
for(FilterStages::iterator it = m_filterStages.begin(); it != m_filterStages.end(); ++it)
|
||||
delete *it;
|
||||
m_filterStages.clear();
|
||||
m_stageSamples.clear();
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,98 @@
|
|||
///////////////////////////////////////////////////////////////////////////////////
|
||||
// Copyright (C) 2019 F4EXB //
|
||||
// written by Edouard Griffiths //
|
||||
// //
|
||||
// This program is free software; you can redistribute it and/or modify //
|
||||
// it under the terms of the GNU General Public License as published by //
|
||||
// the Free Software Foundation as version 3 of the License, or //
|
||||
// (at your option) any later version. //
|
||||
// //
|
||||
// This program is distributed in the hope that it will be useful, //
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of //
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
|
||||
// GNU General Public License V3 for more details. //
|
||||
// //
|
||||
// You should have received a copy of the GNU General Public License //
|
||||
// along with this program. If not, see <http://www.gnu.org/licenses/>. //
|
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef SDRBASE_DSP_UPSAMPLECHANNELIZER_H_
|
||||
#define SDRBASE_DSP_UPSAMPLECHANNELIZER_H_
|
||||
|
||||
#include <QObject>
|
||||
#include <QMutex>
|
||||
#include <algorithm>
|
||||
|
||||
#include "export.h"
|
||||
#include "channelsamplesource.h"
|
||||
|
||||
#ifdef USE_SSE4_1
|
||||
#include "dsp/inthalfbandfiltereo1.h"
|
||||
#else
|
||||
#include "dsp/inthalfbandfilterdb.h"
|
||||
#endif
|
||||
|
||||
#define UPSAMPLECHANNELIZER_HB_FILTER_ORDER 96
|
||||
|
||||
class SDRBASE_API UpSampleChannelizer : public ChannelSampleSource {
|
||||
public:
|
||||
UpSampleChannelizer(ChannelSampleSource* sampleSource);
|
||||
virtual ~UpSampleChannelizer();
|
||||
|
||||
virtual void pull(SampleVector::iterator begin, unsigned int nbSamples);
|
||||
virtual void pullOne(Sample& sample);
|
||||
|
||||
protected:
|
||||
struct FilterStage {
|
||||
enum Mode {
|
||||
ModeCenter,
|
||||
ModeLowerHalf,
|
||||
ModeUpperHalf
|
||||
};
|
||||
|
||||
#ifdef USE_SSE4_1
|
||||
typedef bool (IntHalfbandFilterEO1<UPSAMPLECHANNELIZER_HB_FILTER_ORDER>::*WorkFunction)(Sample* sIn, Sample *sOut);
|
||||
IntHalfbandFilterEO1<UPSAMPLECHANNELIZER_HB_FILTER_ORDER>* m_filter;
|
||||
#else
|
||||
typedef bool (IntHalfbandFilterDB<qint32, UPSAMPLECHANNELIZER_HB_FILTER_ORDER>::*WorkFunction)(Sample* sIn, Sample *sOut);
|
||||
IntHalfbandFilterDB<qint32, UPSAMPLECHANNELIZER_HB_FILTER_ORDER>* m_filter;
|
||||
#endif
|
||||
WorkFunction m_workFunction;
|
||||
|
||||
FilterStage(Mode mode);
|
||||
~FilterStage();
|
||||
|
||||
bool work(Sample* sampleIn, Sample *sampleOut) {
|
||||
return (m_filter->*m_workFunction)(sampleIn, sampleOut);
|
||||
}
|
||||
};
|
||||
|
||||
typedef std::vector<FilterStage*> FilterStages;
|
||||
FilterStages m_filterStages;
|
||||
bool m_filterChainSetMode;
|
||||
std::vector<Sample> m_stageSamples;
|
||||
ChannelSampleSource* m_sampleSource; //!< Modulator
|
||||
int m_outputSampleRate;
|
||||
int m_requestedInputSampleRate;
|
||||
int m_requestedCenterFrequency;
|
||||
int m_currentInputSampleRate;
|
||||
int m_currentCenterFrequency;
|
||||
SampleVector m_sampleBuffer;
|
||||
Sample m_sampleIn;
|
||||
QMutex m_mutex;
|
||||
|
||||
void applyConfiguration();
|
||||
void applySetting(unsigned int log2Interp, unsigned int filterChainHash);
|
||||
bool signalContainsChannel(Real sigStart, Real sigEnd, Real chanStart, Real chanEnd) const;
|
||||
Real createFilterChain(Real sigStart, Real sigEnd, Real chanStart, Real chanEnd);
|
||||
double setFilterChain(const std::vector<unsigned int>& stageIndexes); //!< returns offset in ratio of sample rate
|
||||
void freeFilterChain();
|
||||
|
||||
signals:
|
||||
void outputSampleRateChanged();
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
#endif // SDRBASE_DSP_UPSAMPLECHANNELIZER_H_
|
||||
Loading…
Reference in New Issue