mirror of https://github.com/f4exb/sdrangel.git
Added a generic device API interface
This commit is contained in:
f4exb
parent
ca9c87ff43
commit
69313daeae
|
|
@ -69,6 +69,7 @@ set(sdrbase_SOURCES
|
|||
|
||||
device/devicesourceapi.cpp
|
||||
device/devicesinkapi.cpp
|
||||
device/deviceapi.cpp
|
||||
device/deviceenumerator.cpp
|
||||
|
||||
settings/preferences.cpp
|
||||
|
|
@ -190,6 +191,7 @@ set(sdrbase_HEADERS
|
|||
|
||||
device/devicesourceapi.h
|
||||
device/devicesinkapi.h
|
||||
device/deviceapi.h
|
||||
device/deviceenumerator.h
|
||||
|
||||
plugin/plugininstancegui.h
|
||||
|
|
|
|||
|
|
@ -0,0 +1,749 @@
|
|||
///////////////////////////////////////////////////////////////////////////////////
|
||||
// Copyright (C) 2019 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 //
|
||||
// (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 "plugin/plugininstancegui.h"
|
||||
#include "plugin/plugininterface.h"
|
||||
#include "device/devicesourceapi.h"
|
||||
#include "device/devicesinkapi.h"
|
||||
#include "dsp/dspengine.h"
|
||||
#include "dsp/devicesamplesource.h"
|
||||
#include "dsp/devicesamplesink.h"
|
||||
#include "settings/preset.h"
|
||||
#include "channel/channelsinkapi.h"
|
||||
#include "channel/channelsourceapi.h"
|
||||
|
||||
#include "deviceapi.h"
|
||||
|
||||
DeviceAPI::DeviceAPI(
|
||||
StreamType streamType,
|
||||
int deviceTabIndex,
|
||||
DSPDeviceSourceEngine *deviceSourceEngine,
|
||||
DSPDeviceSinkEngine *deviceSinkEngine
|
||||
) :
|
||||
m_streamType(streamType),
|
||||
m_deviceTabIndex(deviceTabIndex),
|
||||
m_nbItems(1),
|
||||
m_itemIndex(0),
|
||||
m_pluginInterface(0),
|
||||
m_masterTimer(DSPEngine::instance()->getMasterTimer()),
|
||||
m_buddySharedPtr(0),
|
||||
m_isBuddyLeader(false),
|
||||
m_deviceSourceEngine(deviceSourceEngine),
|
||||
m_sampleSourceSequence(0),
|
||||
m_sampleSourcePluginInstanceUI(0),
|
||||
m_deviceSinkEngine(deviceSinkEngine),
|
||||
m_sampleSinkSequence(0),
|
||||
m_sampleSinkPluginInstanceUI(0)
|
||||
{
|
||||
}
|
||||
|
||||
DeviceAPI::~DeviceAPI()
|
||||
{
|
||||
}
|
||||
|
||||
void DeviceAPI::addAncillarySink(BasebandSampleSink *sink)
|
||||
{
|
||||
if (m_deviceSourceEngine) {
|
||||
m_deviceSourceEngine->addSink(sink);
|
||||
} else if (m_deviceSinkEngine) {
|
||||
m_deviceSinkEngine->addSpectrumSink(sink);
|
||||
}
|
||||
}
|
||||
|
||||
void DeviceAPI::removeAncillarySink(BasebandSampleSink* sink)
|
||||
{
|
||||
if (m_deviceSourceEngine) {
|
||||
m_deviceSourceEngine->removeSink(sink);
|
||||
} else if (m_deviceSinkEngine) {
|
||||
m_deviceSinkEngine->removeSpectrumSink(sink);
|
||||
}
|
||||
}
|
||||
|
||||
void DeviceAPI::addChannelSink(ThreadedBasebandSampleSink* sink, int streamIndex)
|
||||
{
|
||||
(void) streamIndex;
|
||||
|
||||
if (m_deviceSourceEngine) {
|
||||
m_deviceSourceEngine->addThreadedSink(sink);
|
||||
}
|
||||
}
|
||||
|
||||
void DeviceAPI::removeChannelSink(ThreadedBasebandSampleSink* sink, int streamIndex)
|
||||
{
|
||||
(void) streamIndex;
|
||||
|
||||
if (m_deviceSourceEngine) {
|
||||
m_deviceSourceEngine->removeThreadedSink(sink);
|
||||
}
|
||||
}
|
||||
|
||||
void DeviceAPI::addChannelSource(ThreadedBasebandSampleSource* source, int streamIndex)
|
||||
{
|
||||
(void) streamIndex;
|
||||
|
||||
if (m_deviceSinkEngine) {
|
||||
m_deviceSinkEngine->addThreadedSource(source);
|
||||
}
|
||||
}
|
||||
|
||||
void DeviceAPI::removeChannelSource(ThreadedBasebandSampleSource* source, int streamIndex)
|
||||
{
|
||||
(void) streamIndex;
|
||||
|
||||
if (m_deviceSinkEngine) {
|
||||
m_deviceSinkEngine->removeThreadedSource(source);
|
||||
}
|
||||
}
|
||||
|
||||
void DeviceAPI::addChannelSinkAPI(ChannelSinkAPI* channelAPI)
|
||||
{
|
||||
m_channelSinkAPIs.append(channelAPI);
|
||||
renumerateChannels();
|
||||
}
|
||||
|
||||
void DeviceAPI::removeChannelSinkAPI(ChannelSinkAPI* channelAPI)
|
||||
{
|
||||
if (m_channelSinkAPIs.removeOne(channelAPI)) {
|
||||
renumerateChannels();
|
||||
}
|
||||
|
||||
channelAPI->setIndexInDeviceSet(-1);
|
||||
}
|
||||
|
||||
void DeviceAPI::addChannelSourceAPI(ChannelSourceAPI* channelAPI)
|
||||
{
|
||||
m_channelSourceAPIs.append(channelAPI);
|
||||
renumerateChannels();
|
||||
}
|
||||
|
||||
void DeviceAPI::removeChannelSourceAPI(ChannelSourceAPI* channelAPI)
|
||||
{
|
||||
if (m_channelSourceAPIs.removeOne(channelAPI)) {
|
||||
renumerateChannels();
|
||||
}
|
||||
|
||||
channelAPI->setIndexInDeviceSet(-1);
|
||||
}
|
||||
|
||||
void DeviceAPI::setSampleSource(DeviceSampleSource* source)
|
||||
{
|
||||
if (m_deviceSourceEngine) {
|
||||
m_deviceSourceEngine->setSource(source);
|
||||
}
|
||||
}
|
||||
|
||||
void DeviceAPI::setSampleSink(DeviceSampleSink* sink)
|
||||
{
|
||||
if (m_deviceSinkEngine) {
|
||||
m_deviceSinkEngine->setSink(sink);
|
||||
}
|
||||
}
|
||||
|
||||
DeviceSampleSource *DeviceAPI::getSampleSource()
|
||||
{
|
||||
if (m_deviceSourceEngine) {
|
||||
return m_deviceSourceEngine->getSource();
|
||||
} else {
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
DeviceSampleSink *DeviceAPI::getSampleSink()
|
||||
{
|
||||
if (m_deviceSinkEngine) {
|
||||
return m_deviceSinkEngine->getSink();
|
||||
} else {
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
bool DeviceAPI::initDeviceEngine()
|
||||
{
|
||||
if (m_deviceSourceEngine) {
|
||||
return m_deviceSourceEngine->initAcquisition();
|
||||
} else if (m_deviceSinkEngine) {
|
||||
return m_deviceSinkEngine->initGeneration();
|
||||
} else {
|
||||
return false; // TODO: not implemented
|
||||
}
|
||||
}
|
||||
|
||||
bool DeviceAPI::startDeviceEngine()
|
||||
{
|
||||
if (m_deviceSourceEngine) {
|
||||
return m_deviceSourceEngine->startAcquisition();
|
||||
} else if (m_deviceSinkEngine) {
|
||||
return m_deviceSinkEngine->startGeneration();
|
||||
} else {
|
||||
return false; // TODO: not implemented
|
||||
}
|
||||
}
|
||||
|
||||
void DeviceAPI::stopDeviceEngine()
|
||||
{
|
||||
if (m_deviceSourceEngine) {
|
||||
m_deviceSourceEngine->stopAcquistion();
|
||||
} else if (m_deviceSinkEngine) {
|
||||
m_deviceSinkEngine->stopGeneration();
|
||||
}
|
||||
}
|
||||
|
||||
DeviceAPI::EngineState DeviceAPI::state() const
|
||||
{
|
||||
if (m_deviceSourceEngine) {
|
||||
return (DeviceAPI::EngineState) m_deviceSourceEngine->state();
|
||||
} else if (m_deviceSinkEngine) {
|
||||
return (DeviceAPI::EngineState) m_deviceSinkEngine->state();
|
||||
} else {
|
||||
return StError; // TODO: not implemented
|
||||
}
|
||||
}
|
||||
|
||||
QString DeviceAPI::errorMessage()
|
||||
{
|
||||
if (m_deviceSourceEngine) {
|
||||
return m_deviceSourceEngine->errorMessage();
|
||||
} else if (m_deviceSinkEngine) {
|
||||
return m_deviceSinkEngine->errorMessage();
|
||||
} else {
|
||||
return "Not implemented"; // TODO: not implemented
|
||||
}
|
||||
}
|
||||
|
||||
uint DeviceAPI::getDeviceUID() const
|
||||
{
|
||||
if (m_deviceSourceEngine) {
|
||||
return m_deviceSourceEngine->getUID();
|
||||
} else if (m_deviceSinkEngine) {
|
||||
return m_deviceSinkEngine->getUID();
|
||||
} else {
|
||||
return 0; // TODO: not implemented
|
||||
}
|
||||
}
|
||||
|
||||
MessageQueue *DeviceAPI::getDeviceEngineInputMessageQueue()
|
||||
{
|
||||
if (m_deviceSourceEngine) {
|
||||
return m_deviceSourceEngine->getInputMessageQueue();
|
||||
} else if (m_deviceSinkEngine) {
|
||||
return m_deviceSinkEngine->getInputMessageQueue();
|
||||
} else {
|
||||
return nullptr; // TODO: not implemented
|
||||
}
|
||||
}
|
||||
|
||||
MessageQueue *DeviceAPI::getSamplingDeviceInputMessageQueue()
|
||||
{
|
||||
if (m_deviceSourceEngine) {
|
||||
return m_deviceSourceEngine->getSource()->getInputMessageQueue();
|
||||
} else if (m_deviceSinkEngine) {
|
||||
return m_deviceSinkEngine->getSink()->getInputMessageQueue();
|
||||
} else {
|
||||
return nullptr; // TODO: not implemented
|
||||
}
|
||||
}
|
||||
|
||||
MessageQueue *DeviceAPI::getSamplingDeviceGUIMessageQueue()
|
||||
{
|
||||
if (m_deviceSourceEngine) {
|
||||
return m_deviceSourceEngine->getSource()->getMessageQueueToGUI();
|
||||
} else if (m_deviceSinkEngine) {
|
||||
return m_deviceSinkEngine->getSink()->getMessageQueueToGUI();
|
||||
} else {
|
||||
return nullptr; // TODO: not implemented
|
||||
}
|
||||
}
|
||||
|
||||
void DeviceAPI::configureCorrections(bool dcOffsetCorrection, bool iqImbalanceCorrection, int streamIndex)
|
||||
{
|
||||
(void) streamIndex;
|
||||
|
||||
if (m_deviceSourceEngine) {
|
||||
m_deviceSourceEngine->configureCorrections(dcOffsetCorrection, iqImbalanceCorrection);
|
||||
}
|
||||
}
|
||||
|
||||
void DeviceAPI::setHardwareId(const QString& id)
|
||||
{
|
||||
m_hardwareId = id;
|
||||
}
|
||||
|
||||
void DeviceAPI::setSamplingDeviceId(const QString& id)
|
||||
{
|
||||
if (m_streamType == StreamSingleRx) {
|
||||
m_sampleSourceId = id;
|
||||
} else if (m_streamType == StreamSingleTx) {
|
||||
m_sampleSinkId = id;
|
||||
}
|
||||
}
|
||||
|
||||
void DeviceAPI::resetSamplingDeviceId()
|
||||
{
|
||||
if (m_streamType == StreamSingleRx) {
|
||||
m_sampleSourceId.clear();
|
||||
} else if (m_streamType == StreamSingleTx) {
|
||||
m_sampleSinkId.clear();
|
||||
}
|
||||
}
|
||||
|
||||
void DeviceAPI::setSamplingDeviceSerial(const QString& serial)
|
||||
{
|
||||
if (m_streamType == StreamSingleRx) {
|
||||
m_sampleSourceSerial = serial;
|
||||
} else if (m_streamType == StreamSingleTx) {
|
||||
m_sampleSinkSerial = serial;
|
||||
}
|
||||
}
|
||||
|
||||
void DeviceAPI::setSamplingDeviceDisplayName(const QString& name)
|
||||
{
|
||||
if (m_streamType == StreamSingleRx) {
|
||||
m_sampleSourceDisplayName = name;
|
||||
} else if (m_streamType == StreamSingleTx) {
|
||||
m_sampleSinkDisplayName = name;
|
||||
}
|
||||
}
|
||||
|
||||
void DeviceAPI::setSamplingDeviceSequence(int sequence)
|
||||
{
|
||||
if (m_deviceSourceEngine)
|
||||
{
|
||||
m_sampleSourceSequence = sequence;
|
||||
m_deviceSourceEngine->setSourceSequence(sequence);
|
||||
}
|
||||
else if (m_deviceSinkEngine)
|
||||
{
|
||||
m_sampleSinkSequence = sequence;
|
||||
m_deviceSinkEngine->setSinkSequence(sequence);
|
||||
}
|
||||
}
|
||||
|
||||
void DeviceAPI::setNbItems(uint32_t nbItems)
|
||||
{
|
||||
m_nbItems = nbItems;
|
||||
}
|
||||
|
||||
void DeviceAPI::setItemIndex(uint32_t index)
|
||||
{
|
||||
m_itemIndex = index;
|
||||
}
|
||||
|
||||
void DeviceAPI::setSamplingDevicePluginInterface(PluginInterface *iface)
|
||||
{
|
||||
m_pluginInterface = iface;
|
||||
}
|
||||
|
||||
void DeviceAPI::setSamplingDevicePluginInstanceGUI(PluginInstanceGUI *gui)
|
||||
{
|
||||
m_sampleSinkPluginInstanceUI = gui;
|
||||
}
|
||||
|
||||
void DeviceAPI::getDeviceEngineStateStr(QString& state)
|
||||
{
|
||||
if (m_deviceSourceEngine)
|
||||
{
|
||||
switch(m_deviceSourceEngine->state())
|
||||
{
|
||||
case DSPDeviceSourceEngine::StNotStarted:
|
||||
state = "notStarted";
|
||||
break;
|
||||
case DSPDeviceSourceEngine::StIdle:
|
||||
state = "idle";
|
||||
break;
|
||||
case DSPDeviceSourceEngine::StReady:
|
||||
state = "ready";
|
||||
break;
|
||||
case DSPDeviceSourceEngine::StRunning:
|
||||
state = "running";
|
||||
break;
|
||||
case DSPDeviceSourceEngine::StError:
|
||||
state = "error";
|
||||
break;
|
||||
default:
|
||||
state = "notStarted";
|
||||
break;
|
||||
}
|
||||
}
|
||||
else if (m_deviceSinkEngine)
|
||||
{
|
||||
switch(m_deviceSinkEngine->state())
|
||||
{
|
||||
case DSPDeviceSinkEngine::StNotStarted:
|
||||
state = "notStarted";
|
||||
break;
|
||||
case DSPDeviceSinkEngine::StIdle:
|
||||
state = "idle";
|
||||
break;
|
||||
case DSPDeviceSinkEngine::StReady:
|
||||
state = "ready";
|
||||
break;
|
||||
case DSPDeviceSinkEngine::StRunning:
|
||||
state = "running";
|
||||
break;
|
||||
case DSPDeviceSinkEngine::StError:
|
||||
state = "error";
|
||||
break;
|
||||
default:
|
||||
state = "notStarted";
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
state = "notStarted";
|
||||
}
|
||||
}
|
||||
|
||||
ChannelSinkAPI *DeviceAPI::getChanelSinkAPIAt(int index)
|
||||
{
|
||||
if (m_streamType == StreamSingleRx)
|
||||
{
|
||||
if (index < m_channelSinkAPIs.size()) {
|
||||
return m_channelSinkAPIs.at(index);
|
||||
} else {
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
else // TODO: not implemented
|
||||
{
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
ChannelSourceAPI *DeviceAPI::getChanelSourceAPIAt(int index)
|
||||
{
|
||||
if (m_streamType == StreamSingleTx)
|
||||
{
|
||||
if (index < m_channelSourceAPIs.size()) {
|
||||
return m_channelSourceAPIs.at(index);
|
||||
} else {
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
else // TODO: not implemented
|
||||
{
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
void DeviceAPI::loadSamplingDeviceSettings(const Preset* preset)
|
||||
{
|
||||
if (m_deviceSourceEngine && (preset->isSourcePreset()))
|
||||
{
|
||||
qDebug("DeviceAPI::loadSamplingDeviceSettings: Loading preset [%s | %s]", qPrintable(preset->getGroup()), qPrintable(preset->getDescription()));
|
||||
|
||||
const QByteArray* sourceConfig = preset->findBestDeviceConfig(m_sampleSourceId, m_sampleSourceSerial, m_sampleSourceSequence);
|
||||
qint64 centerFrequency = preset->getCenterFrequency();
|
||||
qDebug("DeviceAPI::loadSamplingDeviceSettings: center frequency: %llu Hz", centerFrequency);
|
||||
|
||||
if (sourceConfig != 0)
|
||||
{
|
||||
qDebug("DeviceAPI::loadSamplingDeviceSettings: deserializing source %s[%d]: %s", qPrintable(m_sampleSourceId), m_sampleSourceSequence, qPrintable(m_sampleSourceSerial));
|
||||
|
||||
if (m_sampleSourcePluginInstanceUI != 0) // GUI flavor
|
||||
{
|
||||
m_sampleSourcePluginInstanceUI->deserialize(*sourceConfig);
|
||||
}
|
||||
else if (m_deviceSourceEngine->getSource() != 0) // Server flavor
|
||||
{
|
||||
m_deviceSourceEngine->getSource()->deserialize(*sourceConfig);
|
||||
}
|
||||
else
|
||||
{
|
||||
qDebug("DeviceAPI::loadSamplingDeviceSettings: deserializing no source");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
qDebug("DeviceAPI::loadSamplingDeviceSettings: source %s[%d]: %s not found", qPrintable(m_sampleSourceId), m_sampleSourceSequence, qPrintable(m_sampleSourceSerial));
|
||||
}
|
||||
|
||||
// set center frequency anyway
|
||||
if (m_sampleSourcePluginInstanceUI != 0) // GUI flavor
|
||||
{
|
||||
m_sampleSourcePluginInstanceUI->setCenterFrequency(centerFrequency);
|
||||
}
|
||||
else if (m_deviceSourceEngine->getSource() != 0) // Server flavor
|
||||
{
|
||||
m_deviceSourceEngine->getSource()->setCenterFrequency(centerFrequency);
|
||||
}
|
||||
else
|
||||
{
|
||||
qDebug("DeviceAPI::loadSamplingDeviceSettings: no source");
|
||||
}
|
||||
}
|
||||
else if (m_deviceSinkEngine && (!preset->isSourcePreset())) // TODO: refine preset stream type
|
||||
{
|
||||
qDebug("DeviceAPI::loadSamplingDeviceSettings: Loading preset [%s | %s]", qPrintable(preset->getGroup()), qPrintable(preset->getDescription()));
|
||||
|
||||
const QByteArray* sinkConfig = preset->findBestDeviceConfig(m_sampleSinkId, m_sampleSinkSerial, m_sampleSinkSequence);
|
||||
qint64 centerFrequency = preset->getCenterFrequency();
|
||||
qDebug("DeviceAPI::loadSamplingDeviceSettings: center frequency: %llu Hz", centerFrequency);
|
||||
|
||||
if (sinkConfig != 0)
|
||||
{
|
||||
qDebug("DeviceAPI::loadSamplingDeviceSettings: deserializing sink %s[%d]: %s", qPrintable(m_sampleSinkId), m_sampleSinkSequence, qPrintable(m_sampleSinkSerial));
|
||||
|
||||
if (m_sampleSinkPluginInstanceUI != 0) // GUI flavor
|
||||
{
|
||||
m_sampleSinkPluginInstanceUI->deserialize(*sinkConfig);
|
||||
m_sampleSinkPluginInstanceUI->setCenterFrequency(centerFrequency);
|
||||
}
|
||||
else if (m_deviceSinkEngine->getSink() != 0) // Server flavor
|
||||
{
|
||||
m_deviceSinkEngine->getSink()->deserialize(*sinkConfig);
|
||||
m_deviceSinkEngine->getSink()->setCenterFrequency(centerFrequency);
|
||||
}
|
||||
else
|
||||
{
|
||||
qDebug("DeviceAPI::loadSamplingDeviceSettings: no sink");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
qDebug("DeviceAPI::loadSamplingDeviceSettings: sink %s[%d]: %s not found", qPrintable(m_sampleSinkId), m_sampleSinkSequence, qPrintable(m_sampleSinkSerial));
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
qDebug("DeviceAPI::loadSamplingDeviceSettings: Loading preset [%s | %s] is not a suitable preset", qPrintable(preset->getGroup()), qPrintable(preset->getDescription()));
|
||||
}
|
||||
}
|
||||
|
||||
void DeviceAPI::saveSamplingDeviceSettings(Preset* preset)
|
||||
{
|
||||
if (m_deviceSourceEngine && (preset->isSourcePreset()))
|
||||
{
|
||||
qDebug("DeviceAPI::saveSamplingDeviceSettings: serializing source %s[%d]: %s", qPrintable(m_sampleSourceId), m_sampleSourceSequence, qPrintable(m_sampleSourceSerial));
|
||||
|
||||
if (m_sampleSourcePluginInstanceUI != 0)
|
||||
{
|
||||
preset->addOrUpdateDeviceConfig(m_sampleSourceId, m_sampleSourceSerial, m_sampleSourceSequence, m_sampleSourcePluginInstanceUI->serialize());
|
||||
preset->setCenterFrequency(m_sampleSourcePluginInstanceUI->getCenterFrequency());
|
||||
}
|
||||
else if (m_deviceSourceEngine->getSource() != 0)
|
||||
{
|
||||
preset->addOrUpdateDeviceConfig(m_sampleSourceId, m_sampleSourceSerial, m_sampleSourceSequence, m_deviceSourceEngine->getSource()->serialize());
|
||||
preset->setCenterFrequency(m_deviceSourceEngine->getSource()->getCenterFrequency());
|
||||
}
|
||||
else
|
||||
{
|
||||
qDebug("DeviceAPI::saveSamplingDeviceSettings: no source");
|
||||
}
|
||||
}
|
||||
else if (m_deviceSinkEngine && (!preset->isSourcePreset())) // TODO: refine preset stream type
|
||||
{
|
||||
qDebug("DeviceAPI::saveSamplingDeviceSettings: serializing sink %s[%d]: %s", qPrintable(m_sampleSinkId), m_sampleSinkSequence, qPrintable(m_sampleSinkSerial));
|
||||
|
||||
if (m_sampleSinkPluginInstanceUI != 0) // GUI flavor
|
||||
{
|
||||
preset->addOrUpdateDeviceConfig(m_sampleSinkId, m_sampleSinkSerial, m_sampleSinkSequence, m_deviceSinkEngine->getSink()->serialize());
|
||||
preset->setCenterFrequency(m_deviceSinkEngine->getSink()->getCenterFrequency());
|
||||
}
|
||||
else if (m_deviceSinkEngine->getSink() != 0) // Server flavor
|
||||
{
|
||||
preset->addOrUpdateDeviceConfig(m_sampleSinkId, m_sampleSinkSerial, m_sampleSinkSequence, m_deviceSinkEngine->getSink()->serialize());
|
||||
preset->setCenterFrequency(m_deviceSinkEngine->getSink()->getCenterFrequency());
|
||||
}
|
||||
else
|
||||
{
|
||||
qDebug("DeviceAPI::saveSamplingDeviceSettings: no sink");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
qDebug("DeviceAPI::saveSamplingDeviceSettings: not a suitable preset");
|
||||
}
|
||||
}
|
||||
|
||||
void DeviceAPI::addSourceBuddy(DeviceAPI* buddy)
|
||||
{
|
||||
if (buddy->m_streamType != StreamSingleRx)
|
||||
{
|
||||
qDebug("DeviceAPI::addSourceBuddy: buddy %s(%s) is not of single Rx type",
|
||||
qPrintable(buddy->getHardwareId()),
|
||||
qPrintable(buddy->getSamplingDeviceSerial()));
|
||||
return;
|
||||
}
|
||||
|
||||
m_sourceBuddies.push_back(buddy);
|
||||
|
||||
if (m_streamType == StreamSingleRx) {
|
||||
buddy->m_sourceBuddies.push_back(this); // this is a source
|
||||
} else if (m_streamType == StreamSingleTx) {
|
||||
buddy->m_sinkBuddies.push_back(this); // this is a sink
|
||||
} else {
|
||||
qDebug("DeviceAPI::addSourceBuddy: not relevant if this is not a single Rx or Tx");
|
||||
return;
|
||||
}
|
||||
|
||||
qDebug("DeviceAPI::addSourceBuddy: added buddy %s(%s) [%llu] <-> [%llu]",
|
||||
qPrintable(buddy->getHardwareId()),
|
||||
qPrintable(buddy->getSamplingDeviceSerial()),
|
||||
(quint64) buddy,
|
||||
(quint64) this);
|
||||
}
|
||||
|
||||
|
||||
void DeviceAPI::addSinkBuddy(DeviceAPI* buddy)
|
||||
{
|
||||
if (buddy->m_streamType != StreamSingleTx)
|
||||
{
|
||||
qDebug("DeviceAPI::addSinkBuddy: buddy %s(%s) is not of single Tx type",
|
||||
qPrintable(buddy->getHardwareId()),
|
||||
qPrintable(buddy->getSamplingDeviceSerial()));
|
||||
return;
|
||||
}
|
||||
|
||||
m_sinkBuddies.push_back(buddy);
|
||||
|
||||
if (m_streamType == StreamSingleRx) {
|
||||
buddy->m_sourceBuddies.push_back(this); // this is a source
|
||||
} else if (m_streamType == StreamSingleTx) {
|
||||
buddy->m_sinkBuddies.push_back(this); // this is a sink
|
||||
} else {
|
||||
qDebug("DeviceAPI::addSinkBuddy: not relevant if this is not a single Rx or Tx");
|
||||
return;
|
||||
}
|
||||
|
||||
qDebug("DeviceAPI::addSinkBuddy: added buddy %s(%s) [%llu] <-> [%llu]",
|
||||
qPrintable(buddy->getHardwareId()),
|
||||
qPrintable(buddy->getSamplingDeviceSerial()),
|
||||
(quint64) buddy,
|
||||
(quint64) this);
|
||||
}
|
||||
|
||||
void DeviceAPI::removeSourceBuddy(DeviceAPI* buddy)
|
||||
{
|
||||
if (buddy->m_streamType != StreamSingleRx)
|
||||
{
|
||||
qDebug("DeviceAPI::removeSourceBuddy: buddy %s(%s) is not of single Rx type",
|
||||
qPrintable(buddy->getHardwareId()),
|
||||
qPrintable(buddy->getSamplingDeviceSerial()));
|
||||
return;
|
||||
}
|
||||
|
||||
std::vector<DeviceAPI*>::iterator it = m_sourceBuddies.begin();
|
||||
|
||||
for (;it != m_sourceBuddies.end(); ++it)
|
||||
{
|
||||
if (*it == buddy)
|
||||
{
|
||||
qDebug("DeviceAPI::removeSourceBuddy: buddy %s(%s) [%llu] removed from the list of [%llu]",
|
||||
qPrintable(buddy->getHardwareId()),
|
||||
qPrintable(buddy->getSamplingDeviceSerial()),
|
||||
(quint64) (*it),
|
||||
(quint64) this);
|
||||
m_sourceBuddies.erase(it);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
qDebug("DeviceAPI::removeSourceBuddy: buddy %s(%s) [%llu] not found in the list of [%llu]",
|
||||
qPrintable(buddy->getHardwareId()),
|
||||
qPrintable(buddy->getSamplingDeviceSerial()),
|
||||
(quint64) buddy,
|
||||
(quint64) this);
|
||||
}
|
||||
|
||||
void DeviceAPI::removeSinkBuddy(DeviceAPI* buddy)
|
||||
{
|
||||
if (buddy->m_streamType != StreamSingleTx)
|
||||
{
|
||||
qDebug("DeviceAPI::removeSinkBuddy: buddy %s(%s) is not of single Tx type",
|
||||
qPrintable(buddy->getHardwareId()),
|
||||
qPrintable(buddy->getSamplingDeviceSerial()));
|
||||
return;
|
||||
}
|
||||
|
||||
std::vector<DeviceAPI*>::iterator it = m_sinkBuddies.begin();
|
||||
|
||||
for (;it != m_sinkBuddies.end(); ++it)
|
||||
{
|
||||
if (*it == buddy)
|
||||
{
|
||||
qDebug("DeviceAPI::removeSinkBuddy: buddy %s(%s) [%llu] removed from the list of [%llu]",
|
||||
qPrintable(buddy->getHardwareId()),
|
||||
qPrintable(buddy->getSamplingDeviceSerial()),
|
||||
(quint64) (*it),
|
||||
(quint64) this);
|
||||
m_sourceBuddies.erase(it);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
qDebug("DeviceAPI::removeSourceBuddy: buddy %s(%s) [%llu] not found in the list of [%llu]",
|
||||
qPrintable(buddy->getHardwareId()),
|
||||
qPrintable(buddy->getSamplingDeviceSerial()),
|
||||
(quint64) buddy,
|
||||
(quint64) this);
|
||||
}
|
||||
|
||||
void DeviceAPI::clearBuddiesLists()
|
||||
{
|
||||
std::vector<DeviceAPI*>::iterator itSource = m_sourceBuddies.begin();
|
||||
std::vector<DeviceAPI*>::iterator itSink = m_sinkBuddies.begin();
|
||||
bool leaderElected = false;
|
||||
|
||||
for (;itSource != m_sourceBuddies.end(); ++itSource)
|
||||
{
|
||||
if (isBuddyLeader() && !leaderElected)
|
||||
{
|
||||
(*itSource)->setBuddyLeader(true);
|
||||
leaderElected = true;
|
||||
}
|
||||
|
||||
(*itSource)->removeSinkBuddy(this);
|
||||
}
|
||||
|
||||
m_sourceBuddies.clear();
|
||||
|
||||
for (;itSink != m_sinkBuddies.end(); ++itSink)
|
||||
{
|
||||
if (isBuddyLeader() && !leaderElected)
|
||||
{
|
||||
(*itSink)->setBuddyLeader(true);
|
||||
leaderElected = true;
|
||||
}
|
||||
|
||||
(*itSink)->removeSinkBuddy(this);
|
||||
}
|
||||
|
||||
m_sinkBuddies.clear();
|
||||
}
|
||||
|
||||
void DeviceAPI::renumerateChannels()
|
||||
{
|
||||
if (m_streamType == StreamSingleRx)
|
||||
{
|
||||
for (int i = 0; i < m_channelSinkAPIs.size(); ++i)
|
||||
{
|
||||
m_channelSinkAPIs.at(i)->setIndexInDeviceSet(i);
|
||||
m_channelSinkAPIs.at(i)->setDeviceSetIndex(m_deviceTabIndex);
|
||||
//m_channelSinkAPIs.at(i)->setDeviceSourceAPI(this); // FIXME: use generic DeviceAPI in ChannelSinkAPI
|
||||
}
|
||||
}
|
||||
else if (m_streamType == StreamSingleTx)
|
||||
{
|
||||
for (int i = 0; i < m_channelSourceAPIs.size(); ++i)
|
||||
{
|
||||
m_channelSourceAPIs.at(i)->setIndexInDeviceSet(i);
|
||||
m_channelSourceAPIs.at(i)->setDeviceSetIndex(m_deviceTabIndex);
|
||||
//m_channelSourceAPIs.at(i)->setDeviceSinkAPI(this); // FIXME: use generic DeviceAPI in ChannelSourceAPI
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,233 @@
|
|||
///////////////////////////////////////////////////////////////////////////////////
|
||||
// Copyright (C) 2019 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 //
|
||||
// (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_DEVICE_DEVICEAPI_H_
|
||||
#define SDRBASE_DEVICE_DEVICEAPI_H_
|
||||
|
||||
#include <QObject>
|
||||
#include <QString>
|
||||
#include <QTimer>
|
||||
|
||||
#include "export.h"
|
||||
|
||||
class BasebandSampleSink;
|
||||
class ThreadedBasebandSampleSink;
|
||||
class ThreadedBasebandSampleSource;
|
||||
class ChannelSinkAPI;
|
||||
class ChannelSourceAPI;
|
||||
class DeviceSampleSink;
|
||||
class DeviceSampleSource;
|
||||
class MessageQueue;
|
||||
class PluginInterface;
|
||||
class PluginInstanceGUI;
|
||||
class DSPDeviceSourceEngine;
|
||||
class DSPDeviceSinkEngine;
|
||||
class DeviceSourceAPI;
|
||||
class DeviceSinkAPI;
|
||||
class Preset;
|
||||
|
||||
class SDRBASE_API DeviceAPI : public QObject {
|
||||
Q_OBJECT
|
||||
public:
|
||||
enum StreamType //!< This is the same enum as in PluginInterface
|
||||
{
|
||||
StreamSingleRx, //!< Exposes a single input stream that can be one of the streams of a physical device
|
||||
StreamSingleTx, //!< Exposes a single output stream that can be one of the streams of a physical device
|
||||
StreamAny //!< May expose any number of input and/or output streams
|
||||
};
|
||||
|
||||
enum EngineState {
|
||||
StNotStarted, //!< engine is before initialization
|
||||
StIdle, //!< engine is idle
|
||||
StReady, //!< engine is ready to run
|
||||
StRunning, //!< engine is running
|
||||
StError //!< engine is in error
|
||||
};
|
||||
|
||||
DeviceAPI(
|
||||
StreamType streamType,
|
||||
int deviceTabIndex,
|
||||
DSPDeviceSourceEngine *deviceSourceEngine,
|
||||
DSPDeviceSinkEngine *deviceSinkEngine
|
||||
);
|
||||
~DeviceAPI();
|
||||
|
||||
void addAncillarySink(BasebandSampleSink* sink); //!< Adds a sink to receive full baseband and that is not a channel (e.g. spectrum)
|
||||
void removeAncillarySink(BasebandSampleSink* sink); //!< Removes it
|
||||
|
||||
void addChannelSink(ThreadedBasebandSampleSink* sink, int streamIndex = 0); //!< Add a channel sink (Rx)
|
||||
void removeChannelSink(ThreadedBasebandSampleSink* sink, int streamIndex = 0); //!< Remove a channel sink (Rx)
|
||||
void addChannelSource(ThreadedBasebandSampleSource* sink, int streamIndex = 0); //!< Add a channel source (Tx)
|
||||
void removeChannelSource(ThreadedBasebandSampleSource* sink, int streamIndex = 0); //!< Remove a channel source (Tx)
|
||||
|
||||
void addChannelSinkAPI(ChannelSinkAPI* channelAPI);
|
||||
void removeChannelSinkAPI(ChannelSinkAPI* channelAPI);
|
||||
void addChannelSourceAPI(ChannelSourceAPI* channelAPI);
|
||||
void removeChannelSourceAPI(ChannelSourceAPI* channelAPI);
|
||||
|
||||
void setSampleSource(DeviceSampleSource* source); //!< Set the device sample source (single Rx)
|
||||
void setSampleSink(DeviceSampleSink* sink); //!< Set the device sample sink (single Tx)
|
||||
DeviceSampleSource *getSampleSource(); //!< Return pointer to the device sample source (single Rx) or nullptr
|
||||
DeviceSampleSink *getSampleSink(); //!< Return pointer to the device sample sink (single Tx) or nullptr
|
||||
|
||||
bool initDeviceEngine(); //!< Init the device engine corresponding to the stream type
|
||||
bool startDeviceEngine(); //!< Start the device engine corresponding to the stream type
|
||||
void stopDeviceEngine(); //!< Stop the device engine corresponding to the stream type
|
||||
EngineState state() const; //!< Return the state of the device engine corresponding to the stream type
|
||||
QString errorMessage(); //!< Last error message from the device engine
|
||||
uint getDeviceUID() const; //!< Return the current device engine unique ID
|
||||
|
||||
MessageQueue *getDeviceEngineInputMessageQueue(); //!< Device engine message queue
|
||||
MessageQueue *getSamplingDeviceInputMessageQueue(); //!< Sampling device (ex: single Rx) input message queue
|
||||
// MessageQueue *getSampleSinkInputMessageQueue();
|
||||
// MessageQueue *getSampleSourceInputMessageQueue();
|
||||
MessageQueue *getSamplingDeviceGUIMessageQueue(); //!< Sampling device (ex: single Tx) GUI input message queue
|
||||
// MessageQueue *getSampleSinkGUIMessageQueue();
|
||||
// MessageQueue *getSampleSourceGUIMessageQueue();
|
||||
|
||||
void configureCorrections(bool dcOffsetCorrection, bool iqImbalanceCorrection, int streamIndex = 0); //!< Configure current device engine DSP corrections (Rx)
|
||||
|
||||
void setHardwareId(const QString& id);
|
||||
void setSamplingDeviceId(const QString& id);
|
||||
// void setSampleSourceId(const QString& id);
|
||||
// void setSampleSinkId(const QString& id);
|
||||
void resetSamplingDeviceId();
|
||||
// void resetSampleSourceId();
|
||||
// void resetSampleSinkId();
|
||||
void setSamplingDeviceSerial(const QString& serial);
|
||||
// void setSampleSourceSerial(const QString& serial);
|
||||
// void setSampleSinkSerial(const QString& serial);
|
||||
void setSamplingDeviceDisplayName(const QString& name);
|
||||
// void setSampleSourceDisplayName(const QString& serial);
|
||||
// void setSampleSinkDisplayName(const QString& serial);
|
||||
void setSamplingDeviceSequence(int sequence);
|
||||
// void setSampleSourceSequence(int sequence);
|
||||
// void setSampleSinkSequence(int sequence);
|
||||
void setNbItems(uint32_t nbItems);
|
||||
void setItemIndex(uint32_t index);
|
||||
void setSamplingDevicePluginInterface(PluginInterface *iface);
|
||||
// void setSampleSourcePluginInterface(PluginInterface *iface);
|
||||
// void setSampleSinkPluginInterface(PluginInterface *iface);
|
||||
void setSamplingDevicePluginInstanceGUI(PluginInstanceGUI *gui);
|
||||
// void setSampleSourcePluginInstanceGUI(PluginInstanceGUI *gui);
|
||||
// void setSampleSinkPluginInstanceUI(PluginInstanceGUI *gui);
|
||||
|
||||
const QString& getHardwareId() const { return m_hardwareId; }
|
||||
const QString& getSamplingDeviceId() const { return m_sampleSourceId; }
|
||||
// const QString& getSampleSourceId() const { return m_sampleSourceId; }
|
||||
// const QString& getSampleSinkId() const { return m_sampleSinkId; }
|
||||
const QString& getSamplingDeviceSerial() const { return m_sampleSourceSerial; }
|
||||
// const QString& getSampleSourceSerial() const { return m_sampleSourceSerial; }
|
||||
// const QString& getSampleSinkSerial() const { return m_sampleSinkSerial; }
|
||||
const QString& getSamplingDeviceDisplayName() const { return m_sampleSourceDisplayName; }
|
||||
// const QString& getSampleSourceDisplayName() const { return m_sampleSourceDisplayName; }
|
||||
// const QString& getSampleSinkDisplayName() const { return m_sampleSinkDisplayName; }
|
||||
|
||||
uint32_t getSamplingDeviceSequence() const { return m_sampleSourceSequence; }
|
||||
// uint32_t getSampleSourceSequence() const { return m_sampleSourceSequence; }
|
||||
// uint32_t getSampleSinkSequence() const { return m_sampleSinkSequence; }
|
||||
|
||||
uint32_t getNbItems() const { return m_nbItems; }
|
||||
uint32_t getItemIndex() const { return m_itemIndex; }
|
||||
int getDeviceSetIndex() const { return m_deviceTabIndex; }
|
||||
PluginInterface *getPluginInterface() { return m_pluginInterface; }
|
||||
|
||||
PluginInstanceGUI *getSamplingDevicePluginInstanceGUI() { return m_sampleSourcePluginInstanceUI; }
|
||||
// PluginInstanceGUI *getSampleSourcePluginInstanceGUI() { return m_sampleSourcePluginInstanceUI; }
|
||||
// PluginInstanceGUI *getSampleSinkPluginInstanceGUI() { return m_sampleSinkPluginInstanceUI; }
|
||||
|
||||
void getDeviceEngineStateStr(QString& state);
|
||||
|
||||
ChannelSinkAPI *getChanelSinkAPIAt(int index);
|
||||
ChannelSourceAPI *getChanelSourceAPIAt(int index);
|
||||
|
||||
int getNbSourceChannels() const { return m_channelSourceAPIs.size(); }
|
||||
int getNbSinkChannels() const { return m_channelSinkAPIs.size(); }
|
||||
|
||||
void loadSamplingDeviceSettings(const Preset* preset);
|
||||
// void loadSourceSettings(const Preset* preset);
|
||||
// void loadSinkSettings(const Preset* preset);
|
||||
void saveSamplingDeviceSettings(Preset* preset);
|
||||
// void saveSourceSettings(Preset* preset);
|
||||
// void saveSinkSettings(Preset* preset);
|
||||
|
||||
DSPDeviceSourceEngine *getDeviceSourceEngine() { return m_deviceSourceEngine; }
|
||||
DSPDeviceSinkEngine *getDeviceSinkEngine() { return m_deviceSinkEngine; }
|
||||
|
||||
void addSourceBuddy(DeviceAPI* buddy);
|
||||
void addSinkBuddy(DeviceAPI* buddy);
|
||||
void removeSourceBuddy(DeviceAPI* buddy);
|
||||
void removeSinkBuddy(DeviceAPI* buddy);
|
||||
void clearBuddiesLists();
|
||||
void *getBuddySharedPtr() const { return m_buddySharedPtr; }
|
||||
void setBuddySharedPtr(void *ptr) { m_buddySharedPtr = ptr; }
|
||||
bool isBuddyLeader() const { return m_isBuddyLeader; }
|
||||
void setBuddyLeader(bool isBuddyLeader) { m_isBuddyLeader = isBuddyLeader; }
|
||||
const std::vector<DeviceAPI*>& getSourceBuddies() const { return m_sourceBuddies; }
|
||||
const std::vector<DeviceAPI*>& getSinkBuddies() const { return m_sinkBuddies; }
|
||||
|
||||
const QTimer& getMasterTimer() const { return m_masterTimer; } //!< This is the DSPEngine master timer
|
||||
|
||||
protected:
|
||||
// common
|
||||
|
||||
StreamType m_streamType;
|
||||
int m_deviceTabIndex; //!< This is the tab index in the GUI and also the device set index
|
||||
QString m_hardwareId; //!< The internal id that identifies the type of hardware (i.e. HackRF, BladeRF, ...)
|
||||
uint32_t m_nbItems; //!< Number of items or streams in the device. Can be >1 for NxM devices (i.e. 2 for LimeSDR)
|
||||
uint32_t m_itemIndex; //!< The Rx stream index. Can be >0 for NxM devices (i.e. 0 or 1 for LimeSDR)
|
||||
PluginInterface* m_pluginInterface;
|
||||
const QTimer& m_masterTimer; //!< This is the DSPEngine master timer
|
||||
|
||||
// Buddies (single Rx or single Tx)
|
||||
|
||||
std::vector<DeviceAPI*> m_sourceBuddies; //!< Device source APIs referencing the same physical device
|
||||
std::vector<DeviceAPI*> m_sinkBuddies; //!< Device sink APIs referencing the same physical device
|
||||
void *m_buddySharedPtr;
|
||||
bool m_isBuddyLeader;
|
||||
|
||||
// Single Rx (i.e. source)
|
||||
|
||||
DSPDeviceSourceEngine *m_deviceSourceEngine;
|
||||
QString m_sampleSourceId; //!< The internal plugin ID corresponding to the device (i.e. for HackRF input, for HackRF output ...)
|
||||
QString m_sampleSourceSerial; //!< The device serial number defined by the vendor or a fake one (SDRplay)
|
||||
QString m_sampleSourceDisplayName; //!< The human readable name identifying this instance
|
||||
uint32_t m_sampleSourceSequence; //!< The device sequence. >0 when more than one device of the same type is connected
|
||||
PluginInstanceGUI* m_sampleSourcePluginInstanceUI; // TODO: factorize
|
||||
|
||||
QList<ChannelSinkAPI*> m_channelSinkAPIs;
|
||||
|
||||
// Single Tx (i.e. sink)
|
||||
|
||||
DSPDeviceSinkEngine *m_deviceSinkEngine;
|
||||
QString m_sampleSinkId; //!< The internal plugin ID corresponding to the device (i.e. for HackRF input, for HackRF output ...)
|
||||
QString m_sampleSinkSerial; //!< The device serial number defined by the vendor
|
||||
QString m_sampleSinkDisplayName; //!< The human readable name identifying this instance
|
||||
uint32_t m_sampleSinkSequence; //!< The device sequence. >0 when more than one device of the same type is connected
|
||||
PluginInstanceGUI* m_sampleSinkPluginInstanceUI; // TODO: factorize
|
||||
|
||||
QList<ChannelSourceAPI*> m_channelSourceAPIs;
|
||||
|
||||
// Friends
|
||||
|
||||
friend class DeviceSinkAPI;
|
||||
friend class DeviceSourceAPI;
|
||||
|
||||
private:
|
||||
void renumerateChannels();
|
||||
};
|
||||
#endif // SDRBASE_DEVICE_DEVICEAPI_H_
|
||||
Loading…
Reference in New Issue