1
0
mirror of https://github.com/f4exb/sdrangel.git synced 2024-11-27 02:09:14 -05:00
sdrangel/plugins/channelrx/remotesink/remotesink.h

205 lines
7.5 KiB
C
Raw Normal View History

2018-09-04 19:32:29 -04:00
///////////////////////////////////////////////////////////////////////////////////
// Copyright (C) 2018 Edouard Griffiths, F4EXB. //
// //
// Remote sink channel (Rx) UDP sender thread //
2018-09-04 19:32:29 -04:00
// //
// SDRangel can work as a detached SDR front end. With this plugin it can //
// sends the I/Q samples stream to another SDRangel instance via UDP. //
// It is controlled via a Web REST API. //
2018-09-04 19:32:29 -04:00
// //
// 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 //
2019-04-11 00:39:30 -04:00
// (at your option) any later version. //
2018-09-04 19:32:29 -04:00
// //
// 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 INCLUDE_REMOTESINK_H_
#define INCLUDE_REMOTESINK_H_
2018-09-04 19:32:29 -04:00
#include <channel/remotedatablock.h>
2018-09-05 02:44:14 -04:00
#include <QObject>
2018-09-04 19:32:29 -04:00
#include <QMutex>
2018-12-21 11:39:04 -05:00
#include <QNetworkRequest>
2018-09-04 19:32:29 -04:00
#include "dsp/basebandsamplesink.h"
2019-05-09 11:27:12 -04:00
#include "channel/channelapi.h"
#include "remotesinksettings.h"
2018-09-04 19:32:29 -04:00
2018-12-21 11:39:04 -05:00
class QNetworkAccessManager;
class QNetworkReply;
2019-05-08 16:11:53 -04:00
class DeviceAPI;
2018-09-04 19:32:29 -04:00
class ThreadedBasebandSampleSink;
class DownChannelizer;
class RemoteSinkThread;
2018-09-04 19:32:29 -04:00
2019-05-09 11:27:12 -04:00
class RemoteSink : public BasebandSampleSink, public ChannelAPI {
2018-09-04 19:32:29 -04:00
Q_OBJECT
public:
class MsgConfigureRemoteSink : public Message {
2018-09-04 19:32:29 -04:00
MESSAGE_CLASS_DECLARATION
public:
const RemoteSinkSettings& getSettings() const { return m_settings; }
2018-09-04 19:32:29 -04:00
bool getForce() const { return m_force; }
static MsgConfigureRemoteSink* create(const RemoteSinkSettings& settings, bool force)
2018-09-04 19:32:29 -04:00
{
return new MsgConfigureRemoteSink(settings, force);
2018-09-04 19:32:29 -04:00
}
private:
RemoteSinkSettings m_settings;
2018-09-04 19:32:29 -04:00
bool m_force;
MsgConfigureRemoteSink(const RemoteSinkSettings& settings, bool force) :
2018-09-04 19:32:29 -04:00
Message(),
m_settings(settings),
m_force(force)
{ }
};
2018-09-05 02:44:14 -04:00
class MsgSampleRateNotification : public Message {
MESSAGE_CLASS_DECLARATION
public:
static MsgSampleRateNotification* create(int sampleRate) {
return new MsgSampleRateNotification(sampleRate);
}
int getSampleRate() const { return m_sampleRate; }
private:
MsgSampleRateNotification(int sampleRate) :
Message(),
m_sampleRate(sampleRate)
{ }
int m_sampleRate;
};
class MsgConfigureChannelizer : public Message {
MESSAGE_CLASS_DECLARATION
public:
int getLog2Decim() const { return m_log2Decim; }
int getFilterChainHash() const { return m_filterChainHash; }
static MsgConfigureChannelizer* create(int sampleRate, int centerFrequency)
{
return new MsgConfigureChannelizer(sampleRate, centerFrequency);
}
private:
unsigned int m_log2Decim;
unsigned int m_filterChainHash;
MsgConfigureChannelizer(unsigned int log2Decim, int filterChainHash) :
Message(),
m_log2Decim(log2Decim),
m_filterChainHash(filterChainHash)
{ }
};
2019-05-08 16:11:53 -04:00
RemoteSink(DeviceAPI *deviceAPI);
virtual ~RemoteSink();
2018-09-04 19:32:29 -04:00
virtual void destroy() { delete this; }
virtual void feed(const SampleVector::const_iterator& begin, const SampleVector::const_iterator& end, bool po);
virtual void start();
virtual void stop();
virtual bool handleMessage(const Message& cmd);
virtual void getIdentifier(QString& id) { id = objectName(); }
virtual void getTitle(QString& title) { title = "Remote Sink"; }
virtual qint64 getCenterFrequency() const { return m_frequencyOffset; }
2018-09-04 19:32:29 -04:00
virtual QByteArray serialize() const;
virtual bool deserialize(const QByteArray& data);
2019-05-09 11:27:12 -04:00
virtual int getNbSinkStreams() const { return 1; }
virtual int getNbSourceStreams() const { return 0; }
virtual qint64 getStreamCenterFrequency(int streamIndex, bool sinkElseSource) const
{
(void) streamIndex;
(void) sinkElseSource;
return m_frequencyOffset;
}
2018-09-04 19:32:29 -04:00
virtual int webapiSettingsGet(
SWGSDRangel::SWGChannelSettings& response,
QString& errorMessage);
virtual int webapiSettingsPutPatch(
bool force,
const QStringList& channelSettingsKeys,
SWGSDRangel::SWGChannelSettings& response,
QString& errorMessage);
/** Set center frequency given in Hz */
void setCenterFrequency(uint64_t centerFrequency) { m_centerFrequency = centerFrequency; }
2018-09-04 19:32:29 -04:00
/** Set sample rate given in Hz */
void setSampleRate(uint32_t sampleRate) { m_sampleRate = sampleRate; }
void setNbBlocksFEC(int nbBlocksFEC);
2018-09-05 22:23:27 -04:00
void setTxDelay(int txDelay, int nbBlocksFEC);
2018-09-04 19:32:29 -04:00
void setDataAddress(const QString& address) { m_dataAddress = address; }
void setDataPort(uint16_t port) { m_dataPort = port; }
void setChannelizer(unsigned int log2Decim, unsigned int filterChainHash);
2018-09-04 19:32:29 -04:00
static const QString m_channelIdURI;
static const QString m_channelId;
2018-09-05 23:21:43 -04:00
signals:
void dataBlockAvailable(RemoteDataBlock *dataBlock);
2018-09-05 23:21:43 -04:00
2018-09-04 19:32:29 -04:00
private:
2019-05-08 16:11:53 -04:00
DeviceAPI *m_deviceAPI;
2018-09-04 19:32:29 -04:00
ThreadedBasebandSampleSink* m_threadedChannelizer;
DownChannelizer* m_channelizer;
bool m_running;
RemoteSinkSettings m_settings;
RemoteSinkThread *m_sinkThread;
2018-09-04 19:32:29 -04:00
int m_txBlockIndex; //!< Current index in blocks to transmit in the Tx row
uint16_t m_frameCount; //!< transmission frame count
int m_sampleIndex; //!< Current sample index in protected block data
RemoteSuperBlock m_superBlock;
RemoteMetaDataFEC m_currentMetaFEC;
RemoteDataBlock *m_dataBlock;
2018-09-04 19:32:29 -04:00
QMutex m_dataBlockMutex;
uint64_t m_centerFrequency;
int64_t m_frequencyOffset;
2018-09-04 19:32:29 -04:00
uint32_t m_sampleRate;
uint32_t m_deviceSampleRate;
2018-09-04 19:32:29 -04:00
int m_nbBlocksFEC;
int m_txDelay;
QString m_dataAddress;
uint16_t m_dataPort;
2018-12-21 11:39:04 -05:00
QNetworkAccessManager *m_networkManager;
QNetworkRequest m_networkRequest;
2018-09-04 19:32:29 -04:00
void applySettings(const RemoteSinkSettings& settings, bool force = false);
void validateFilterChainHash(RemoteSinkSettings& settings);
void calculateFrequencyOffset();
void webapiFormatChannelSettings(SWGSDRangel::SWGChannelSettings& response, const RemoteSinkSettings& settings);
void webapiReverseSendSettings(QList<QString>& channelSettingsKeys, const RemoteSinkSettings& settings, bool force);
2018-12-21 11:39:04 -05:00
private slots:
void networkManagerFinished(QNetworkReply *reply);
2018-09-04 19:32:29 -04:00
};
#endif /* INCLUDE_REMOTESINK_H_ */