VE7UWU
/
sdrangel
mirror of https://github.com/f4exb/sdrangel.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

TCP source: use settings in GUI

This commit is contained in:
f4exb 2017-10-07 10:24:25 +02:00
parent 62b8a9d95d
commit 8cc0f53635
7 changed files with 470 additions and 187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
plugins/channelrx/tcpsrc/tcpsrc.cpp
View File

@ -31,7 +31,7 @@ TCPSrc::TCPSrc(MessageQueue* uiMessageQueue, TCPSrcGUI* tcpSrcGUI, BasebandSampl
setObjectName("TCPSrc");
m_inputSampleRate = 96000;
m_sampleFormat = FormatSSB;
m_sampleFormat = TCPSrcSettings::FormatSSB;
m_outputSampleRate = 48000;
m_rfBandwidth = 32000;
m_tcpServer = 0;
@ -61,7 +61,7 @@ TCPSrc::~TCPSrc()
if (TCPFilter) delete TCPFilter;
}
void TCPSrc::configure(MessageQueue* messageQueue, SampleFormat sampleFormat, Real outputSampleRate, Real rfBandwidth, int tcpPort, int boost)
void TCPSrc::configure(MessageQueue* messageQueue, TCPSrcSettings::SampleFormat sampleFormat, Real outputSampleRate, Real rfBandwidth, int tcpPort, int boost)
{
Message* cmd = MsgTCPSrcConfigure::create(sampleFormat, outputSampleRate, rfBandwidth, tcpPort, boost);
messageQueue->push(cmd);
@ -110,7 +110,7 @@ void TCPSrc::feed(const SampleVector::const_iterator& begin, const SampleVector:
m_s16leSockets[i].socket->write((const char*)&m_sampleBuffer[0], m_sampleBuffer.size() * 4);
}
if((m_sampleFormat == FormatSSB) && (m_ssbSockets.count() > 0)) {
if((m_sampleFormat == TCPSrcSettings::FormatSSB) && (m_ssbSockets.count() > 0)) {
for(SampleVector::const_iterator it = m_sampleBuffer.begin(); it != m_sampleBuffer.end(); ++it) {
//Complex cj(it->real() / 30000.0, it->imag() / 30000.0);
Complex cj(it->real(), it->imag());
@ -130,7 +130,7 @@ void TCPSrc::feed(const SampleVector::const_iterator& begin, const SampleVector:
}
}
if((m_sampleFormat == FormatNFM) && (m_ssbSockets.count() > 0)) {
if((m_sampleFormat == TCPSrcSettings::FormatNFM) && (m_ssbSockets.count() > 0)) {
for(SampleVector::const_iterator it = m_sampleBuffer.begin(); it != m_sampleBuffer.end(); ++it) {
Complex cj(it->real() / 32768.0f, it->imag() / 32768.0f);
// An FFT filter here is overkill, but was already set up for SSB
@ -225,7 +225,7 @@ bool TCPSrc::handleMessage(const Message& cmd)
m_interpolator.create(16, m_inputSampleRate, m_rfBandwidth / 2.0);
m_sampleDistanceRemain = m_inputSampleRate / m_outputSampleRate;
if (m_sampleFormat == FormatSSB)
if (m_sampleFormat == TCPSrcSettings::FormatSSB)
{
TCPFilter->create_filter(0.3 / 48.0, m_rfBandwidth / 2.0 / m_outputSampleRate);
}
@ -311,10 +311,10 @@ void TCPSrc::processNewConnection()
switch(m_sampleFormat) {
case FormatNFM:
case FormatSSB:
case TCPSrcSettings::FormatNFM:
case TCPSrcSettings::FormatSSB:
{
quint32 id = (FormatSSB << 24) | m_nextSSBId;
quint32 id = (TCPSrcSettings::FormatSSB << 24) | m_nextSSBId;
MsgTCPSrcConnection* msg = MsgTCPSrcConnection::create(true, id, connection->peerAddress(), connection->peerPort());
m_nextSSBId = (m_nextSSBId + 1) & 0xffffff;
m_ssbSockets.push_back(Socket(id, connection));
@ -322,10 +322,10 @@ void TCPSrc::processNewConnection()
break;
}
case FormatS16LE:
case TCPSrcSettings::FormatS16LE:
{
qDebug("TCPSrc::processNewConnection: establish new S16LE connection");
quint32 id = (FormatS16LE << 24) | m_nextS16leId;
quint32 id = (TCPSrcSettings::FormatS16LE << 24) | m_nextS16leId;
MsgTCPSrcConnection* msg = MsgTCPSrcConnection::create(true, id, connection->peerAddress(), connection->peerPort());
m_nextS16leId = (m_nextS16leId + 1) & 0xffffff;
m_s16leSockets.push_back(Socket(id, connection));

22
plugins/channelrx/tcpsrc/tcpsrc.h
View File

@ -1,14 +1,17 @@
#ifndef INCLUDE_TCPSRC_H
#define INCLUDE_TCPSRC_H
#include <dsp/basebandsamplesink.h>
#include <QMutex>
#include <QHostAddress>
#include <dsp/basebandsamplesink.h>
#include "dsp/nco.h"
#include "dsp/fftfilt.h"
#include "dsp/interpolator.h"
#include "util/message.h"
#include "tcpsrcsettings.h"
#define tcpFftLen 2048
class QTcpServer;
@ -19,17 +22,10 @@ class TCPSrc : public BasebandSampleSink {
Q_OBJECT
public:
enum SampleFormat {
FormatSSB,
FormatNFM,
FormatS16LE,
FormatNone
};
TCPSrc(MessageQueue* uiMessageQueue, TCPSrcGUI* tcpSrcGUI, BasebandSampleSink* spectrum);
virtual ~TCPSrc();
void configure(MessageQueue* messageQueue, SampleFormat sampleFormat, Real outputSampleRate, Real rfBandwidth, int tcpPort, int boost);
void configure(MessageQueue* messageQueue, TCPSrcSettings::SampleFormat sampleFormat, Real outputSampleRate, Real rfBandwidth, int tcpPort, int boost);
void setSpectrum(MessageQueue* messageQueue, bool enabled);
double getMagSq() const { return m_magsq; }
@ -72,25 +68,25 @@ protected:
MESSAGE_CLASS_DECLARATION
public:
SampleFormat getSampleFormat() const { return m_sampleFormat; }
TCPSrcSettings::SampleFormat getSampleFormat() const { return m_sampleFormat; }
Real getOutputSampleRate() const { return m_outputSampleRate; }
Real getRFBandwidth() const { return m_rfBandwidth; }
int getTCPPort() const { return m_tcpPort; }
int getBoost() const { return m_boost; }
static MsgTCPSrcConfigure* create(SampleFormat sampleFormat, Real sampleRate, Real rfBandwidth, int tcpPort, int boost)
static MsgTCPSrcConfigure* create(TCPSrcSettings::SampleFormat sampleFormat, Real sampleRate, Real rfBandwidth, int tcpPort, int boost)
{
return new MsgTCPSrcConfigure(sampleFormat, sampleRate, rfBandwidth, tcpPort, boost);
}
private:
SampleFormat m_sampleFormat;
TCPSrcSettings::SampleFormat m_sampleFormat;
Real m_outputSampleRate;
Real m_rfBandwidth;
int m_tcpPort;
int m_boost;
MsgTCPSrcConfigure(SampleFormat sampleFormat, Real outputSampleRate, Real rfBandwidth, int tcpPort, int boost) :
MsgTCPSrcConfigure(TCPSrcSettings::SampleFormat sampleFormat, Real outputSampleRate, Real rfBandwidth, int tcpPort, int boost) :
Message(),
m_sampleFormat(sampleFormat),
m_outputSampleRate(outputSampleRate),

376
plugins/channelrx/tcpsrc/tcpsrcgui.cpp
View File

@ -49,93 +49,97 @@ QString TCPSrcGUI::getName() const
void TCPSrcGUI::resetToDefaults()
{
blockApplySettings(true);
ui->sampleFormat->setCurrentIndex(0);
ui->sampleRate->setText("48000");
ui->rfBandwidth->setText("32000");
ui->tcpPort->setText("9999");
ui->spectrumGUI->resetToDefaults();
ui->boost->setValue(1);
blockApplySettings(false);
applySettings();
m_settings.resetToDefaults();
displaySettings();
applySettings();
}
QByteArray TCPSrcGUI::serialize() const
{
SimpleSerializer s(1);
s.writeS32(2, m_channelMarker.getCenterFrequency());
s.writeS32(3, m_sampleFormat);
s.writeReal(4, m_outputSampleRate);
s.writeReal(5, m_rfBandwidth);
s.writeS32(6, m_tcpPort);
s.writeBlob(7, ui->spectrumGUI->serialize());
s.writeS32(8, (qint32)m_boost);
s.writeS32(9, m_channelMarker.getCenterFrequency());
return s.final();
return m_settings.serialize();
// SimpleSerializer s(1);
// s.writeS32(2, m_channelMarker.getCenterFrequency());
// s.writeS32(3, m_sampleFormat);
// s.writeReal(4, m_outputSampleRate);
// s.writeReal(5, m_rfBandwidth);
// s.writeS32(6, m_tcpPort);
// s.writeBlob(7, ui->spectrumGUI->serialize());
// s.writeS32(8, (qint32)m_boost);
// s.writeS32(9, m_channelMarker.getCenterFrequency());
// return s.final();
}
bool TCPSrcGUI::deserialize(const QByteArray& data)
{
SimpleDeserializer d(data);
if(m_settings.deserialize(data))
{
qDebug("TCPSrcGUI::deserialize: m_squelchGate: %d", m_settings.m_squelchGate);
displaySettings();
applySettings();
return true;
} else {
resetToDefaults();
return false;
}
if (!d.isValid())
{
resetToDefaults();
return false;
}
if (d.getVersion() == 1)
{
QByteArray bytetmp;
qint32 s32tmp;
Real realtmp;
blockApplySettings(true);
m_channelMarker.blockSignals(true);
d.readS32(2, &s32tmp, 0);
m_channelMarker.setCenterFrequency(s32tmp);
d.readS32(3, &s32tmp, TCPSrc::FormatSSB);
switch(s32tmp) {
case TCPSrc::FormatSSB:
ui->sampleFormat->setCurrentIndex(0);
break;
case TCPSrc::FormatNFM:
ui->sampleFormat->setCurrentIndex(1);
break;
case TCPSrc::FormatS16LE:
ui->sampleFormat->setCurrentIndex(2);
break;
default:
ui->sampleFormat->setCurrentIndex(0);
break;
}
d.readReal(4, &realtmp, 48000);
ui->sampleRate->setText(QString("%1").arg(realtmp, 0));
d.readReal(5, &realtmp, 32000);
ui->rfBandwidth->setText(QString("%1").arg(realtmp, 0));
d.readS32(6, &s32tmp, 9999);
ui->tcpPort->setText(QString("%1").arg(s32tmp));
d.readBlob(7, &bytetmp);
ui->spectrumGUI->deserialize(bytetmp);
d.readS32(8, &s32tmp, 1);
ui->boost->setValue(s32tmp);
d.readS32(9, &s32tmp, 0);
m_channelMarker.setCenterFrequency(s32tmp);
blockApplySettings(false);
m_channelMarker.blockSignals(false);
applySettings();
return true;
}
else
{
resetToDefaults();
return false;
}
// SimpleDeserializer d(data);
//
// if (!d.isValid())
// {
// resetToDefaults();
// return false;
// }
//
// if (d.getVersion() == 1)
// {
// QByteArray bytetmp;
// qint32 s32tmp;
// Real realtmp;
//
// blockApplySettings(true);
// m_channelMarker.blockSignals(true);
//
// d.readS32(2, &s32tmp, 0);
// m_channelMarker.setCenterFrequency(s32tmp);
// d.readS32(3, &s32tmp, TCPSrcSettings::FormatSSB);
// switch(s32tmp) {
// case TCPSrcSettings::FormatSSB:
// ui->sampleFormat->setCurrentIndex(0);
// break;
// case TCPSrcSettings::FormatNFM:
// ui->sampleFormat->setCurrentIndex(1);
// break;
// case TCPSrcSettings::FormatS16LE:
// ui->sampleFormat->setCurrentIndex(2);
// break;
// default:
// ui->sampleFormat->setCurrentIndex(0);
// break;
// }
// d.readReal(4, &realtmp, 48000);
// ui->sampleRate->setText(QString("%1").arg(realtmp, 0));
// d.readReal(5, &realtmp, 32000);
// ui->rfBandwidth->setText(QString("%1").arg(realtmp, 0));
// d.readS32(6, &s32tmp, 9999);
// ui->tcpPort->setText(QString("%1").arg(s32tmp));
// d.readBlob(7, &bytetmp);
// ui->spectrumGUI->deserialize(bytetmp);
// d.readS32(8, &s32tmp, 1);
// ui->volume->setValue(s32tmp);
// d.readS32(9, &s32tmp, 0);
// m_channelMarker.setCenterFrequency(s32tmp);
//
// blockApplySettings(false);
// m_channelMarker.blockSignals(false);
//
// applySettings();
// return true;
// }
// else
// {
// resetToDefaults();
// return false;
// }
}
bool TCPSrcGUI::handleMessage(const Message& message)
@ -189,6 +193,7 @@ TCPSrcGUI::TCPSrcGUI(PluginAPI* pluginAPI, DeviceSourceAPI *deviceAPI, QWidget*
m_channelMarker(this),
m_channelPowerDbAvg(40,0),
m_basicSettingsShown(false),
m_rfBandwidthChanged(false),
m_doApplySettings(true)
{
ui->setupUi(this);
@ -216,11 +221,11 @@ TCPSrcGUI::TCPSrcGUI(PluginAPI* pluginAPI, DeviceSourceAPI *deviceAPI, QWidget*
ui->glSpectrum->connectTimer(m_pluginAPI->getMainWindow()->getMasterTimer());
connect(&m_pluginAPI->getMainWindow()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick()));
//m_channelMarker = new ChannelMarker(this);
m_channelMarker.setBandwidth(16000);
m_channelMarker.setCenterFrequency(0);
m_channelMarker.setColor(Qt::green);
m_channelMarker.setVisible(true);
m_channelMarker.setColor(m_settings.m_rgbColor);
setTitleColor(m_channelMarker.getColor());
connect(&m_channelMarker, SIGNAL(changed()), this, SLOT(channelMarkerChanged()));
@ -241,7 +246,6 @@ TCPSrcGUI::~TCPSrcGUI()
delete m_channelizer;
delete m_tcpSrc;
delete m_spectrumVis;
//delete m_channelMarker;
delete ui;
}
@ -254,115 +258,177 @@ void TCPSrcGUI::applySettings()
{
if (m_doApplySettings)
{
bool ok;
Real outputSampleRate = ui->sampleRate->text().toDouble(&ok);
if((!ok) || (outputSampleRate < 1000))
{
outputSampleRate = 48000;
}
Real rfBandwidth = ui->rfBandwidth->text().toDouble(&ok);
if((!ok) || (rfBandwidth > outputSampleRate))
{
rfBandwidth = outputSampleRate;
}
int tcpPort = ui->tcpPort->text().toInt(&ok);
if((!ok) || (tcpPort < 1) || (tcpPort > 65535))
{
tcpPort = 9999;
}
int boost = ui->boost->value();
setTitleColor(m_channelMarker.getColor());
ui->deltaFrequency->setValue(m_channelMarker.getCenterFrequency());
ui->sampleRate->setText(QString("%1").arg(outputSampleRate, 0));
ui->rfBandwidth->setText(QString("%1").arg(rfBandwidth, 0));
ui->tcpPort->setText(QString("%1").arg(tcpPort));
ui->boost->setValue(boost);
m_channelMarker.disconnect(this, SLOT(channelMarkerChanged()));
m_channelMarker.setBandwidth((int)rfBandwidth);
connect(&m_channelMarker, SIGNAL(changed()), this, SLOT(channelMarkerChanged()));
ui->glSpectrum->setSampleRate(outputSampleRate);
ui->glSpectrum->setSampleRate(m_settings.m_outputSampleRate);
m_channelizer->configure(m_channelizer->getInputMessageQueue(),
outputSampleRate,
m_settings.m_outputSampleRate,
m_channelMarker.getCenterFrequency());
TCPSrc::SampleFormat sampleFormat;
switch(ui->sampleFormat->currentIndex())
{
case 0:
sampleFormat = TCPSrc::FormatSSB;
break;
case 1:
sampleFormat = TCPSrc::FormatNFM;
break;
case 2:
sampleFormat = TCPSrc::FormatS16LE;
break;
default:
sampleFormat = TCPSrc::FormatSSB;
break;
}
m_sampleFormat = sampleFormat;
m_outputSampleRate = outputSampleRate;
m_rfBandwidth = rfBandwidth;
m_tcpPort = tcpPort;
m_boost = boost;
m_tcpSrc->configure(m_tcpSrc->getInputMessageQueue(),
sampleFormat,
outputSampleRate,
rfBandwidth,
tcpPort,
boost);
ui->applyBtn->setEnabled(false);
m_settings.m_sampleFormat,
m_settings.m_outputSampleRate,
m_settings.m_rfBandwidth,
m_settings.m_tcpPort,
m_settings.m_volume);
}
}
void TCPSrcGUI::on_deltaFrequency_changed(qint64 value)
{
m_channelMarker.setCenterFrequency(value);
m_settings.m_inputFrequencyOffset = m_channelMarker.getCenterFrequency();
applySettings();
}
void TCPSrcGUI::on_sampleFormat_currentIndexChanged(int index __attribute__((unused)))
void TCPSrcGUI::on_sampleFormat_currentIndexChanged(int index)
{
ui->applyBtn->setEnabled(true);
setSampleFormat(index);
ui->applyBtn->setEnabled(true);
ui->applyBtn->setStyleSheet("QPushButton { background-color : green; }");
}
void TCPSrcGUI::on_sampleRate_textEdited(const QString& arg1 __attribute__((unused)))
{
ui->applyBtn->setEnabled(true);
bool ok;
Real outputSampleRate = ui->sampleRate->text().toDouble(&ok);
if((!ok) || (outputSampleRate < 1000))
{
m_settings.m_outputSampleRate = 48000;
ui->sampleRate->setText(QString("%1").arg(outputSampleRate, 0));
}
else
{
m_settings.m_outputSampleRate = outputSampleRate;
}
ui->applyBtn->setEnabled(true);
ui->applyBtn->setStyleSheet("QPushButton { background-color : green; }");
}
void TCPSrcGUI::on_rfBandwidth_textEdited(const QString& arg1 __attribute__((unused)))
{
ui->applyBtn->setEnabled(true);
bool ok;
Real rfBandwidth = ui->rfBandwidth->text().toDouble(&ok);
if((!ok) || (rfBandwidth > m_settings.m_outputSampleRate))
{
m_settings.m_rfBandwidth = m_settings.m_outputSampleRate;
ui->rfBandwidth->setText(QString("%1").arg(m_settings.m_rfBandwidth, 0));
}
else
{
m_settings.m_rfBandwidth = rfBandwidth;
}
m_rfBandwidthChanged = true;
ui->applyBtn->setEnabled(true);
ui->applyBtn->setStyleSheet("QPushButton { background-color : green; }");
}
void TCPSrcGUI::on_tcpPort_textEdited(const QString& arg1 __attribute__((unused)))
{
bool ok;
int tcpPort = ui->tcpPort->text().toInt(&ok);
if((!ok) || (tcpPort < 1) || (tcpPort > 65535))
{
m_settings.m_tcpPort = 9999;
ui->tcpPort->setText(QString("%1").arg(m_settings.m_tcpPort, 0));
}
else
{
m_settings.m_tcpPort = tcpPort;
}
ui->applyBtn->setEnabled(true);
ui->applyBtn->setStyleSheet("QPushButton { background-color : green; }");
}
void TCPSrcGUI::on_applyBtn_clicked()
{
if (m_rfBandwidthChanged)
{
blockApplySettings(true);
m_channelMarker.setBandwidth((int) m_settings.m_rfBandwidth);
m_rfBandwidthChanged = false;
blockApplySettings(false);
}
ui->glSpectrum->setSampleRate(m_settings.m_outputSampleRate);
ui->applyBtn->setEnabled(false);
ui->applyBtn->setStyleSheet("QPushButton { background:rgb(79,79,79); }");
applySettings();
}
void TCPSrcGUI::on_boost_valueChanged(int value)
void TCPSrcGUI::displaySettings()
{
ui->boost->setValue(value);
ui->boostText->setText(QString("%1").arg(value));
m_channelMarker.blockSignals(true);
m_channelMarker.setCenterFrequency(m_settings.m_inputFrequencyOffset);
m_channelMarker.setUDPAddress(m_settings.m_udpAddress);
m_channelMarker.setUDPSendPort(m_settings.m_udpPort);
m_channelMarker.setColor(m_settings.m_rgbColor);
setTitleColor(m_settings.m_rgbColor);
m_channelMarker.blockSignals(false);
ui->deltaFrequency->setValue(m_channelMarker.getCenterFrequency());
ui->sampleRate->setText(QString("%1").arg(m_settings.m_outputSampleRate, 0));
setSampleFormatIndex(m_settings.m_sampleFormat);
ui->rfBandwidth->setText(QString("%1").arg(m_settings.m_rfBandwidth, 0));
ui->volume->setValue(m_settings.m_volume);
ui->volumeText->setText(QString("%1").arg(ui->volume->value()));
ui->glSpectrum->setSampleRate(m_settings.m_outputSampleRate);
}
void TCPSrcGUI::setSampleFormatIndex(const TCPSrcSettings::SampleFormat& sampleFormat)
{
switch(sampleFormat)
{
case TCPSrcSettings::FormatS16LE:
ui->sampleFormat->setCurrentIndex(0);
break;
case TCPSrcSettings::FormatNFM:
ui->sampleFormat->setCurrentIndex(1);
break;
case TCPSrcSettings::FormatSSB:
ui->sampleFormat->setCurrentIndex(2);
break;
default:
ui->sampleFormat->setCurrentIndex(0);
break;
}
}
void TCPSrcGUI::setSampleFormat(int index)
{
switch(index)
{
case 0:
m_settings.m_sampleFormat = TCPSrcSettings::FormatS16LE;
break;
case 1:
m_settings.m_sampleFormat = TCPSrcSettings::FormatNFM;
break;
case 2:
m_settings.m_sampleFormat = TCPSrcSettings::FormatSSB;
break;
default:
m_settings.m_sampleFormat = TCPSrcSettings::FormatS16LE;
break;
}
}
void TCPSrcGUI::on_volume_valueChanged(int value)
{
ui->volume->setValue(value);
ui->volumeText->setText(QString("%1").arg(value));
ui->applyBtn->setEnabled(true);
}

10
plugins/channelrx/tcpsrc/tcpsrcgui.h
View File

@ -10,6 +10,7 @@
#include "util/messagequeue.h"
#include "tcpsrc.h"
#include "tcpsrcsettings.h"
class PluginAPI;
class DeviceSourceAPI;
@ -52,7 +53,7 @@ private slots:
void on_applyBtn_clicked();
void onWidgetRolled(QWidget* widget, bool rollDown);
void onMenuDoubleClicked();
void on_boost_valueChanged(int value);
void on_volume_valueChanged(int value);
void tick();
private:
@ -64,12 +65,14 @@ private:
MovingAverage<double> m_channelPowerDbAvg;
// settings
TCPSrc::SampleFormat m_sampleFormat;
TCPSrcSettings m_settings;
TCPSrcSettings::SampleFormat m_sampleFormat;
Real m_outputSampleRate;
Real m_rfBandwidth;
int m_boost;
int m_tcpPort;
bool m_basicSettingsShown;
bool m_rfBandwidthChanged;
bool m_doApplySettings;
// RF path
@ -83,6 +86,9 @@ private:
void blockApplySettings(bool block);
void applySettings();
void displaySettings();
void setSampleFormat(int index);
void setSampleFormatIndex(const TCPSrcSettings::SampleFormat& sampleFormat);
void addConnection(quint32 id, const QHostAddress& peerAddress, int peerPort);
void delConnection(quint32 id);

14
plugins/channelrx/tcpsrc/tcpsrcgui.ui
View File

@ -60,11 +60,11 @@
<string>Sample format</string>
</property>
<property name="currentIndex">
<number>2</number>
<number>0</number>
</property>
<item>
<property name="text">
<string>S16LE SSB</string>
<string>S16LE I/Q</string>
</property>
</item>
<item>
@ -74,7 +74,7 @@
</item>
<item>
<property name="text">
<string>S16LE I/Q</string>
<string>S16LE SSB</string>
</property>
</item>
</widget>
@ -310,14 +310,14 @@
<item row="5" column="1">
<layout class="QHBoxLayout" name="BoostLayout">
<item>
<widget class="QLabel" name="boostLabel">
<widget class="QLabel" name="volumeLabel">
<property name="text">
<string>Boost</string>
<string>Vol</string>
</property>
</widget>
</item>
<item>
<widget class="QSlider" name="boost">
<widget class="QSlider" name="volume">
<property name="toolTip">
<string>Amplitude boost</string>
</property>
@ -333,7 +333,7 @@
</widget>
</item>
<item>
<widget class="QLabel" name="boostText">
<widget class="QLabel" name="volumeText">
<property name="text">
<string>0</string>
</property>

145
plugins/channelrx/tcpsrc/tcpsrcsettings.cpp Normal file
View File

@ -0,0 +1,145 @@
///////////////////////////////////////////////////////////////////////////////////
// Copyright (C) 2017 Edouard Griffiths, F4EXB //
// //
// 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 //
// //
// 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 <QColor>
#include "dsp/dspengine.h"
#include "util/simpleserializer.h"
#include "settings/serializable.h"
#include "tcpsrcsettings.h"
TCPSrcSettings::TCPSrcSettings() :
m_channelMarker(0),
m_spectrumGUI(0)
{
resetToDefaults();
}
void TCPSrcSettings::resetToDefaults()
{
m_outputSampleRate = 48000;
m_sampleFormat = FormatS16LE;
m_inputSampleRate = 48000;
m_inputFrequencyOffset = 0;
m_rfBandwidth = 12500;
m_tcpPort = 9999;
m_fmDeviation = 2500;
m_channelMute = false;
m_gain = 1.0;
m_squelchdB = -60;
m_squelchGate = 0.0;
m_squelchEnabled = true;
m_agc = false;
m_audioActive = false;
m_audioStereo = false;
m_volume = 20;
m_udpAddress = "127.0.0.1";
m_udpPort = 9999;
m_audioPort = 9998;
m_rgbColor = QColor(225, 25, 99).rgb();
}
QByteArray TCPSrcSettings::serialize() const
{
SimpleSerializer s(1);
s.writeS32(2, m_inputFrequencyOffset);
s.writeS32(3, (int) m_sampleFormat);
s.writeReal(4, m_outputSampleRate);
s.writeReal(5, m_rfBandwidth);
s.writeS32(6, m_tcpPort);
if (m_channelMarker) {
s.writeBlob(10, m_channelMarker->serialize());
}
if (m_spectrumGUI) {
s.writeBlob(7, m_spectrumGUI->serialize());
}
s.writeS32(8, m_gain*10.0);
s.writeU32(9, m_rgbColor);
s.writeBool(11, m_audioActive);
s.writeS32(12, m_volume);
s.writeBool(14, m_audioStereo);
s.writeS32(15, m_fmDeviation);
s.writeS32(16, m_squelchdB);
s.writeS32(17, m_squelchGate);
s.writeBool(18, m_agc);
return s.final();
}
bool TCPSrcSettings::deserialize(const QByteArray& data)
{
SimpleDeserializer d(data);
if (!d.isValid())
{
resetToDefaults();
return false;
}
if (d.getVersion() == 1)
{
QByteArray bytetmp;
QString strtmp;
int32_t s32tmp;
if (m_channelMarker) {
d.readBlob(10, &bytetmp);
m_channelMarker->deserialize(bytetmp);
}
d.readS32(2, &s32tmp, 0);
m_inputFrequencyOffset = s32tmp;
d.readS32(3, &s32tmp, FormatS16LE);
if ((s32tmp >= 0) && (s32tmp < (int) FormatNone)) {
m_sampleFormat = (SampleFormat) s32tmp;
} else {
m_sampleFormat = FormatS16LE;
}
d.readReal(4, &m_outputSampleRate, 48000.0);
d.readReal(5, &m_rfBandwidth, 32000.0);
d.readS32(6, &s32tmp, 10);
m_tcpPort = s32tmp < 1024 ? 9999 : s32tmp % (1<<16);
if (m_spectrumGUI) {
d.readBlob(7, &bytetmp);
m_spectrumGUI->deserialize(bytetmp);
}
d.readS32(8, &s32tmp, 10);
m_gain = s32tmp / 10.0;
d.readU32(9, &m_rgbColor);
d.readBool(11, &m_audioActive, false);
d.readS32(12, &m_volume, 0);
d.readBool(14, &m_audioStereo, false);
d.readS32(15, &m_fmDeviation, 2500);
d.readS32(16, &m_squelchdB, -60);
d.readS32(17, &m_squelchGate, 5);
d.readBool(18, &m_agc, false);
return true;
}
else
{
resetToDefaults();
return false;
}
}

70
plugins/channelrx/tcpsrc/tcpsrcsettings.h Normal file
View File

@ -0,0 +1,70 @@
///////////////////////////////////////////////////////////////////////////////////
// Copyright (C) 2017 Edouard Griffiths, F4EXB //
// //
// 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 //
// //
// 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 PLUGINS_CHANNELRX_TCPSRC_TCPSRCSETTINGS_H_
#define PLUGINS_CHANNELRX_TCPSRC_TCPSRCSETTINGS_H_
#include <QByteArray>
#include <QString>
#include <stdint.h>
struct Serializable;
struct TCPSrcSettings
{
enum SampleFormat {
FormatS16LE,
FormatNFM,
FormatSSB,
FormatNone
};
float m_outputSampleRate;
SampleFormat m_sampleFormat;
float m_inputSampleRate;
int64_t m_inputFrequencyOffset;
float m_rfBandwidth;
uint16_t m_tcpPort;
int m_fmDeviation;
bool m_channelMute;
float m_gain;
int m_squelchdB; //!< power dB
int m_squelchGate; //!< 100ths seconds
bool m_squelchEnabled;
bool m_agc;
bool m_audioActive;
bool m_audioStereo;
int m_volume;
quint32 m_rgbColor;
QString m_udpAddress;
uint16_t m_udpPort;
uint16_t m_audioPort;
Serializable *m_channelMarker;
Serializable *m_spectrumGUI;
TCPSrcSettings();
void resetToDefaults();
void setChannelMarker(Serializable *channelMarker) { m_channelMarker = channelMarker; }
void setSpectrumGUI(Serializable *spectrumGUI) { m_spectrumGUI = spectrumGUI; }
QByteArray serialize() const;
bool deserialize(const QByteArray& data);
};
#endif /* PLUGINS_CHANNELRX_TCPSRC_TCPSRCSETTINGS_H_ */