VE7UWU/sdrangel
1
0
Fork 0
mirror of https://github.com/f4exb/sdrangel.git synced 2025-02-21 04:58:38 -05:00
Code Issues Projects Releases Wiki Activity

New scope: replaced virtual projectors by a single concrete projector with switch/case

Browse Source
This commit is contained in:
f4exb 2017-02-13 22:52:42 +01:00
parent 10dc1c886c
commit 39ed424081
2 changed files with 74 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
sdrbase/dsp/scopevisng.cpp
View File

@ -33,7 +33,6 @@ MESSAGE_CLASS_DEFINITION(ScopeVisNG::MsgScopeVisNGRemoveTrace, Message)
MESSAGE_CLASS_DEFINITION(ScopeVisNG::MsgScopeVisNGFocusOnTrace, Message) MESSAGE_CLASS_DEFINITION(ScopeVisNG::MsgScopeVisNGFocusOnTrace, Message)
const uint ScopeVisNG::m_traceChunkSize = 4800; const uint ScopeVisNG::m_traceChunkSize = 4800;
const Real ScopeVisNG::ProjectorMagDB::mult = (10.0f / log2f(10.0f));
ScopeVisNG::ScopeVisNG(GLScopeNG* glScope) : ScopeVisNG::ScopeVisNG(GLScopeNG* glScope) :
@ -398,15 +397,15 @@ int ScopeVisNG::processTraces(const SampleVector::const_iterator& cbegin, const
float v; float v;
if (projectionType == ProjectionMagLin) { if (projectionType == ProjectionMagLin) {
v = (itCtl->m_projector->run(*begin) - itData->m_ofs)*itData->m_amp - 1.0f; v = (itCtl->m_projector.run(*begin) - itData->m_ofs)*itData->m_amp - 1.0f;
} else if (projectionType == ProjectionMagDB) { } else if (projectionType == ProjectionMagDB) {
// there is no processing advantage in direct calculation without projector // there is no processing advantage in direct calculation without projector
// uint32_t magsq = begin->m_real*begin->m_real + begin->m_imag*begin->m_imag; // uint32_t magsq = begin->m_real*begin->m_real + begin->m_imag*begin->m_imag;
// v = ((log10f(magsq/1073741824.0f)*0.2f - 2.0f*itData->m_ofs) + 2.0f)*itData->m_amp - 1.0f; // v = ((log10f(magsq/1073741824.0f)*0.2f - 2.0f*itData->m_ofs) + 2.0f)*itData->m_amp - 1.0f;
float p = itCtl->m_projector->run(*begin) - (100.0f * itData->m_ofs); float p = itCtl->m_projector.run(*begin) - (100.0f * itData->m_ofs);
v = ((p/50.0f) + 2.0f)*itData->m_amp - 1.0f; v = ((p/50.0f) + 2.0f)*itData->m_amp - 1.0f;
} else { } else {
v = (itCtl->m_projector->run(*begin) - itData->m_ofs) * itData->m_amp; v = (itCtl->m_projector.run(*begin) - itData->m_ofs) * itData->m_amp;
} }
if(v > 1.0f) { if(v > 1.0f) {
@ -657,7 +656,7 @@ void ScopeVisNG::computeDisplayTriggerLevels()
for (; itData != m_traces.m_tracesData.end(); ++itData) for (; itData != m_traces.m_tracesData.end(); ++itData)
{ {
if ((m_focusedTriggerIndex < m_triggerConditions.size()) && (m_triggerConditions[m_focusedTriggerIndex].m_projector->getProjectionType() == itData->m_projectionType)) if ((m_focusedTriggerIndex < m_triggerConditions.size()) && (m_triggerConditions[m_focusedTriggerIndex].m_projector.getProjectionType() == itData->m_projectionType))
{ {
float level = m_triggerConditions[m_focusedTriggerIndex].m_triggerData.m_triggerLevel; float level = m_triggerConditions[m_focusedTriggerIndex].m_triggerData.m_triggerLevel;
float levelPowerLin = level + 1.0f; float levelPowerLin = level + 1.0f;

143
sdrbase/dsp/scopevisng.h
View File

@ -389,83 +389,48 @@ private:
{} {}
}; };
// === projectors ===
// --------------------------------------------- // ---------------------------------------------
/**
* Projection stuff
*/
class Projector class Projector
{ {
public: public:
Projector(ProjectionType projectionType) : m_projectionType(projectionType) {} Projector(ProjectionType projectionType) :
virtual ~Projector() {} m_projectionType(projectionType),
m_prevArg(0.0f)
{}
~Projector()
{}
ProjectionType getProjectionType() const { return m_projectionType; } ProjectionType getProjectionType() const { return m_projectionType; }
virtual Real run(const Sample& s) = 0; void settProjectionType(ProjectionType projectionType) { m_projectionType = projectionType; }
private:
ProjectionType m_projectionType;
};
// --------------------------------------------- Real run(const Sample& s)
class ProjectorReal : public Projector
{ {
public: switch (m_projectionType)
ProjectorReal() : Projector(ProjectionReal) {}
virtual ~ProjectorReal() {}
virtual Real run(const Sample& s) { return s.m_real / 32768.0f; }
};
// ---------------------------------------------
class ProjectorImag : public Projector
{ {
public: case ProjectionImag:
ProjectorImag() : Projector(ProjectionImag) {} return s.m_imag / 32768.0f;
virtual ~ProjectorImag() {} break;
virtual Real run(const Sample& s) { return s.m_imag / 32768.0f; } case ProjectionMagLin:
};
// ---------------------------------------------
class ProjectorMagLin : public Projector
{
public:
ProjectorMagLin() : Projector(ProjectionMagLin) {}
virtual ~ProjectorMagLin() {}
virtual Real run(const Sample& s)
{ {
uint32_t magsq = s.m_real*s.m_real + s.m_imag*s.m_imag; uint32_t magsq = s.m_real*s.m_real + s.m_imag*s.m_imag;
return std::sqrt(magsq/1073741824.0f); return std::sqrt(magsq/1073741824.0f);
} }
}; break;
case ProjectionMagDB:
// ---------------------------------------------
class ProjectorMagDB : public Projector
{
public:
ProjectorMagDB() : Projector(ProjectionMagDB) {}
virtual ~ProjectorMagDB() {}
virtual Real run(const Sample& s)
{ {
uint32_t magsq = s.m_real*s.m_real + s.m_imag*s.m_imag; uint32_t magsq = s.m_real*s.m_real + s.m_imag*s.m_imag;
//return mult * log2f(magsq/1073741824.0f);
return log10f(magsq/1073741824.0f) * 10.0f; return log10f(magsq/1073741824.0f) * 10.0f;
} }
private: break;
static const Real mult; case ProjectionPhase:
}; return std::atan2((float) s.m_imag, (float) s.m_real) / M_PI;
break;
// --------------------------------------------- case ProjectionDPhase:
class ProjectorPhase : public Projector
{
public:
ProjectorPhase() : Projector(ProjectionPhase) {}
virtual ~ProjectorPhase() {}
virtual Real run(const Sample& s) { return std::atan2((float) s.m_imag, (float) s.m_real) / M_PI; }
};
// ---------------------------------------------
class ProjectorDPhase : public Projector
{
public:
ProjectorDPhase() : Projector(ProjectionDPhase), m_prevArg(0.0f) {}
virtual ~ProjectorDPhase() {}
virtual Real run(const Sample& s)
{ {
Real curArg = std::atan2((float) s.m_imag, (float) s.m_real); Real curArg = std::atan2((float) s.m_imag, (float) s.m_real);
Real dPhi = (curArg - m_prevArg) / M_PI; Real dPhi = (curArg - m_prevArg) / M_PI;
@ -479,32 +444,19 @@ private:
return dPhi; return dPhi;
} }
break;
private:
Real m_prevArg;
};
static Projector *createProjector(ProjectionType projectionType)
{
//qDebug("ScopeVisNG::createProjector: projectionType: %d", projectionType);
switch (projectionType)
{
case ProjectionImag:
return new ProjectorImag();
case ProjectionMagLin:
return new ProjectorMagLin();
case ProjectionMagDB:
return new ProjectorMagDB();
case ProjectionPhase:
return new ProjectorPhase();
case ProjectionDPhase:
return new ProjectorDPhase();
case ProjectionReal: case ProjectionReal:
default: default:
return new ProjectorReal(); return s.m_real / 32768.0f;
break;
} }
} }
private:
ProjectionType m_projectionType;
Real m_prevArg;
};
/** /**
* Trigger stuff * Trigger stuff
*/ */
@ -520,14 +472,14 @@ private:
struct TriggerCondition struct TriggerCondition
{ {
public: public:
Projector *m_projector; Projector m_projector;
TriggerData m_triggerData; //!< Trigger data TriggerData m_triggerData; //!< Trigger data
bool m_prevCondition; //!< Condition (above threshold) at previous sample bool m_prevCondition; //!< Condition (above threshold) at previous sample
uint32_t m_triggerDelayCount; //!< Counter of samples for delay uint32_t m_triggerDelayCount; //!< Counter of samples for delay
uint32_t m_triggerCounter; //!< Counter of trigger occurences uint32_t m_triggerCounter; //!< Counter of trigger occurences
TriggerCondition(const TriggerData& triggerData) : TriggerCondition(const TriggerData& triggerData) :
m_projector(0), m_projector(ProjectionReal),
m_triggerData(triggerData), m_triggerData(triggerData),
m_prevCondition(false), m_prevCondition(false),
m_triggerDelayCount(0), m_triggerDelayCount(0),
@ -541,22 +493,20 @@ private:
void initProjector() void initProjector()
{ {
m_projector = createProjector(m_triggerData.m_projectionType); m_projector.settProjectionType(m_triggerData.m_projectionType);
} }
void releaseProjector() void releaseProjector()
{ {
delete m_projector;
} }
void setData(const TriggerData& triggerData) void setData(const TriggerData& triggerData)
{ {
m_triggerData = triggerData; m_triggerData = triggerData;
if (m_projector->getProjectionType() != m_triggerData.m_projectionType) if (m_projector.getProjectionType() != m_triggerData.m_projectionType)
{ {
delete m_projector; m_projector.settProjectionType(m_triggerData.m_projectionType);
m_projector = createProjector(m_triggerData.m_projectionType);
} }
m_prevCondition = false; m_prevCondition = false;
@ -672,10 +622,10 @@ private:
*/ */
struct TraceControl struct TraceControl
{ {
Projector *m_projector; //!< Projector transform from complex trace to real (displayable) trace Projector m_projector; //!< Projector transform from complex trace to real (displayable) trace
int m_traceCount[2]; //!< Count of samples processed (double buffered) int m_traceCount[2]; //!< Count of samples processed (double buffered)
TraceControl() : m_projector(0) TraceControl() : m_projector(ProjectionReal)
{ {
reset(); reset();
} }
@ -686,12 +636,11 @@ private:
void initProjector(ProjectionType projectionType) void initProjector(ProjectionType projectionType)
{ {
m_projector = createProjector(projectionType); m_projector.settProjectionType(projectionType);
} }
void releaseProjector() void releaseProjector()
{ {
delete m_projector;
} }
void reset() void reset()
@ -821,12 +770,12 @@ private:
bool condition, trigger; bool condition, trigger;
if (triggerCondition.m_projector->getProjectionType() == ProjectionMagDB) { if (triggerCondition.m_projector.getProjectionType() == ProjectionMagDB) {
condition = triggerCondition.m_projector->run(s) > m_levelPowerDB; condition = triggerCondition.m_projector.run(s) > m_levelPowerDB;
} else if (triggerCondition.m_projector->getProjectionType() == ProjectionMagLin) { } else if (triggerCondition.m_projector.getProjectionType() == ProjectionMagLin) {
condition = triggerCondition.m_projector->run(s) > m_levelPowerLin; condition = triggerCondition.m_projector.run(s) > m_levelPowerLin;
} else { } else {
condition = triggerCondition.m_projector->run(s) > m_level; condition = triggerCondition.m_projector.run(s) > m_level;
} }
if (m_reset) if (m_reset)