You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
791 lines
34 KiB
791 lines
34 KiB
/////////////////////////////////////////////////////////////////////////////////// |
|
// Copyright (C) 2017-2022 Edouard Griffiths, F4EXB <f4exb06@gmail.com> // |
|
// Copyright (C) 2019 Davide Gerhard <rainbow@irh.it> // |
|
// Copyright (C) 2020 Jon Beniston, M7RCE <jon@beniston.com> // |
|
// // |
|
// Swagger server adapter interface // |
|
// // |
|
// 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 <QDebug> |
|
#include <QSysInfo> |
|
#include <QResource> |
|
|
|
#include "dsp/dspengine.h" |
|
#include "dsp/dspdevicesourceengine.h" |
|
#include "dsp/dspdevicesinkengine.h" |
|
#include "dsp/dspdevicemimoengine.h" |
|
#include "dsp/spectrumvis.h" |
|
#include "device/deviceapi.h" |
|
#include "device/deviceset.h" |
|
#include "device/deviceenumerator.h" |
|
#include "feature/featureset.h" |
|
#include "plugin/pluginmanager.h" |
|
#include "webapi/webapirequestmapper.h" |
|
#include "webapi/webapiserver.h" |
|
#include "webapi/webapiadapter.h" |
|
|
|
#include "mainparser.h" |
|
#include "mainserver.h" |
|
|
|
MainServer *MainServer::m_instance = 0; |
|
|
|
MainServer::MainServer(qtwebapp::LoggerWithFile *logger, const MainParser& parser, QObject *parent) : |
|
QObject(parent), |
|
m_mainCore(MainCore::instance()), |
|
m_dspEngine(DSPEngine::instance()) |
|
{ |
|
qDebug() << "MainServer::MainServer: start"; |
|
|
|
m_instance = this; |
|
m_mainCore->m_logger = logger; |
|
m_mainCore->m_mainMessageQueue = &m_inputMessageQueue; |
|
m_mainCore->m_settings.setAudioDeviceManager(m_dspEngine->getAudioDeviceManager()); |
|
m_mainCore->m_masterTabIndex = -1; |
|
|
|
qDebug() << "MainServer::MainServer: create FFT factory..."; |
|
m_dspEngine->createFFTFactory(parser.getFFTWFWisdomFileName()); |
|
|
|
qDebug() << "MainServer::MainServer: load plugins..."; |
|
m_mainCore->m_pluginManager = new PluginManager(this); |
|
m_mainCore->m_pluginManager->setEnableSoapy(parser.getSoapy()); |
|
m_mainCore->m_pluginManager->loadPlugins(QString("pluginssrv")); |
|
addFeatureSet(); // Create the uniuefeature set |
|
|
|
connect(&m_inputMessageQueue, SIGNAL(messageEnqueued()), this, SLOT(handleMessages()), Qt::QueuedConnection); |
|
m_mainCore->m_masterTimer.start(50); |
|
|
|
qDebug() << "MainServer::MainServer: load settings..."; |
|
loadSettings(); |
|
|
|
qDebug() << "MainServer::MainServer: finishing..."; |
|
QString applicationDirPath = QCoreApplication::instance()->applicationDirPath(); |
|
|
|
m_apiAdapter = new WebAPIAdapter(); |
|
m_requestMapper = new WebAPIRequestMapper(this); |
|
m_requestMapper->setAdapter(m_apiAdapter); |
|
m_apiServer = new WebAPIServer(parser.getServerAddress(), parser.getServerPort(), m_requestMapper); |
|
m_apiServer->start(); |
|
|
|
m_dspEngine->setMIMOSupport(true); |
|
|
|
qDebug() << "MainServer::MainServer: end"; |
|
} |
|
|
|
MainServer::~MainServer() |
|
{ |
|
while (m_mainCore->m_deviceSets.size() > 0) { |
|
removeLastDevice(); |
|
} |
|
|
|
m_apiServer->stop(); |
|
m_mainCore->m_settings.save(); |
|
delete m_apiServer; |
|
delete m_requestMapper; |
|
delete m_apiAdapter; |
|
|
|
delete m_mainCore->m_pluginManager; |
|
|
|
qDebug() << "MainServer::~MainServer: end"; |
|
} |
|
|
|
bool MainServer::handleMessage(const Message& cmd) |
|
{ |
|
if (MainCore::MsgDeleteInstance::match(cmd)) |
|
{ |
|
while (m_mainCore->m_deviceSets.size() > 0) |
|
{ |
|
removeLastDevice(); |
|
} |
|
|
|
emit finished(); |
|
return true; |
|
} |
|
else if (MainCore::MsgLoadPreset::match(cmd)) |
|
{ |
|
MainCore::MsgLoadPreset& notif = (MainCore::MsgLoadPreset&) cmd; |
|
loadPresetSettings(notif.getPreset(), notif.getDeviceSetIndex()); |
|
return true; |
|
} |
|
else if (MainCore::MsgSavePreset::match(cmd)) |
|
{ |
|
MainCore::MsgSavePreset& notif = (MainCore::MsgSavePreset&) cmd; |
|
savePresetSettings(notif.getPreset(), notif.getDeviceSetIndex()); |
|
m_mainCore->m_settings.sortPresets(); |
|
m_mainCore->m_settings.save(); |
|
return true; |
|
} |
|
else if (MainCore::MsgDeletePreset::match(cmd)) |
|
{ |
|
MainCore::MsgDeletePreset& notif = (MainCore::MsgDeletePreset&) cmd; |
|
const Preset *presetToDelete = notif.getPreset(); |
|
// remove preset from settings |
|
m_mainCore->m_settings.deletePreset(presetToDelete); |
|
return true; |
|
} |
|
else if (MainCore::MsgDeleteConfiguration::match(cmd)) |
|
{ |
|
MainCore::MsgDeleteConfiguration& notif = (MainCore::MsgDeleteConfiguration&) cmd; |
|
const Configuration *configuationToDelete = notif.getConfiguration(); |
|
// remove configuration from settings |
|
m_mainCore->m_settings.deleteConfiguration(configuationToDelete); |
|
return true; |
|
} |
|
else if (MainCore::MsgLoadFeatureSetPreset::match(cmd)) |
|
{ |
|
MainCore::MsgLoadFeatureSetPreset& notif = (MainCore::MsgLoadFeatureSetPreset&) cmd; |
|
loadFeatureSetPresetSettings(notif.getPreset(), notif.getFeatureSetIndex()); |
|
return true; |
|
} |
|
else if (MainCore::MsgSaveFeatureSetPreset::match(cmd)) |
|
{ |
|
MainCore::MsgSaveFeatureSetPreset& notif = (MainCore::MsgSaveFeatureSetPreset&) cmd; |
|
saveFeatureSetPresetSettings(notif.getPreset(), notif.getFeatureSetIndex()); |
|
m_mainCore->m_settings.sortPresets(); |
|
m_mainCore->m_settings.save(); |
|
return true; |
|
} |
|
else if (MainCore::MsgDeleteFeatureSetPreset::match(cmd)) |
|
{ |
|
MainCore::MsgDeleteFeatureSetPreset& notif = (MainCore::MsgDeleteFeatureSetPreset&) cmd; |
|
const FeatureSetPreset *presetToDelete = notif.getPreset(); |
|
// remove preset from settings |
|
m_mainCore->m_settings.deleteFeatureSetPreset(presetToDelete); |
|
return true; |
|
} |
|
else if (MainCore::MsgAddDeviceSet::match(cmd)) |
|
{ |
|
MainCore::MsgAddDeviceSet& notif = (MainCore::MsgAddDeviceSet&) cmd; |
|
int direction = notif.getDirection(); |
|
|
|
if (direction == 1) { // Single stream Tx |
|
addSinkDevice(); |
|
} else if (direction == 0) { // Single stream Rx |
|
addSourceDevice(); |
|
} else if (direction == 2) { // MIMO |
|
addMIMODevice(); |
|
} |
|
|
|
return true; |
|
} |
|
else if (MainCore::MsgRemoveLastDeviceSet::match(cmd)) |
|
{ |
|
if (m_mainCore->m_deviceSets.size() > 0) { |
|
removeLastDevice(); |
|
} |
|
|
|
return true; |
|
} |
|
else if (MainCore::MsgSetDevice::match(cmd)) |
|
{ |
|
MainCore::MsgSetDevice& notif = (MainCore::MsgSetDevice&) cmd; |
|
|
|
if (notif.getDeviceType() == 1) { |
|
changeSampleSink(notif.getDeviceSetIndex(), notif.getDeviceIndex()); |
|
} else if (notif.getDeviceType() == 0) { |
|
changeSampleSource(notif.getDeviceSetIndex(), notif.getDeviceIndex()); |
|
} else if (notif.getDeviceType() == 2) { |
|
changeSampleMIMO(notif.getDeviceSetIndex(), notif.getDeviceIndex()); |
|
} |
|
return true; |
|
} |
|
else if (MainCore::MsgAddChannel::match(cmd)) |
|
{ |
|
MainCore::MsgAddChannel& notif = (MainCore::MsgAddChannel&) cmd; |
|
addChannel(notif.getDeviceSetIndex(), notif.getChannelRegistrationIndex()); |
|
return true; |
|
} |
|
else if (MainCore::MsgDeleteChannel::match(cmd)) |
|
{ |
|
MainCore::MsgDeleteChannel& notif = (MainCore::MsgDeleteChannel&) cmd; |
|
deleteChannel(notif.getDeviceSetIndex(), notif.getChannelIndex()); |
|
return true; |
|
} |
|
else if (MainCore::MsgAddFeature::match(cmd)) |
|
{ |
|
MainCore::MsgAddFeature& notif = (MainCore::MsgAddFeature&) cmd; |
|
addFeature(0, notif.getFeatureRegistrationIndex()); |
|
|
|
return true; |
|
} |
|
else if (MainCore::MsgDeleteFeature::match(cmd)) |
|
{ |
|
MainCore::MsgDeleteFeature& notif = (MainCore::MsgDeleteFeature&) cmd; |
|
deleteFeature(0, notif.getFeatureIndex()); |
|
return true; |
|
} |
|
else if (MainCore::MsgApplySettings::match(cmd)) |
|
{ |
|
applySettings(); |
|
return true; |
|
} |
|
else |
|
{ |
|
return false; |
|
} |
|
} |
|
|
|
void MainServer::handleMessages() |
|
{ |
|
Message* message; |
|
|
|
while ((message = m_inputMessageQueue.pop()) != 0) |
|
{ |
|
qDebug("MainServer::handleMessages: message: %s", message->getIdentifier()); |
|
handleMessage(*message); |
|
delete message; |
|
} |
|
} |
|
|
|
void MainServer::loadSettings() |
|
{ |
|
qDebug() << "MainServer::loadSettings"; |
|
|
|
m_mainCore->m_settings.load(); |
|
m_mainCore->m_settings.sortPresets(); |
|
m_mainCore->setLoggingOptions(); |
|
} |
|
|
|
void MainServer::applySettings() |
|
{ |
|
m_mainCore->m_settings.sortPresets(); |
|
m_mainCore->setLoggingOptions(); |
|
} |
|
|
|
void MainServer::addSinkDevice() |
|
{ |
|
DSPDeviceSinkEngine *dspDeviceSinkEngine = m_dspEngine->addDeviceSinkEngine(); |
|
dspDeviceSinkEngine->start(); |
|
|
|
uint dspDeviceSinkEngineUID = dspDeviceSinkEngine->getUID(); |
|
char uidCStr[16]; |
|
sprintf(uidCStr, "UID:%d", dspDeviceSinkEngineUID); |
|
|
|
int deviceTabIndex = m_mainCore->m_deviceSets.size(); |
|
m_mainCore->m_deviceSets.push_back(new DeviceSet(deviceTabIndex, 1)); |
|
m_mainCore->m_deviceSets.back()->m_deviceSourceEngine = nullptr; |
|
m_mainCore->m_deviceSets.back()->m_deviceSinkEngine = dspDeviceSinkEngine; |
|
m_mainCore->m_deviceSets.back()->m_deviceMIMOEngine = nullptr; |
|
dspDeviceSinkEngine->addSpectrumSink(m_mainCore->m_deviceSets.back()->m_spectrumVis); |
|
|
|
char tabNameCStr[16]; |
|
sprintf(tabNameCStr, "T%d", deviceTabIndex); |
|
|
|
DeviceAPI *deviceAPI = new DeviceAPI(DeviceAPI::StreamSingleTx, deviceTabIndex, nullptr, dspDeviceSinkEngine, nullptr); |
|
|
|
m_mainCore->m_deviceSets.back()->m_deviceAPI = deviceAPI; |
|
QList<QString> channelNames; |
|
|
|
// create a file sink by default |
|
int fileSinkDeviceIndex = DeviceEnumerator::instance()->getFileOutputDeviceIndex(); |
|
const PluginInterface::SamplingDevice *samplingDevice = DeviceEnumerator::instance()->getTxSamplingDevice(fileSinkDeviceIndex); |
|
deviceAPI->setSamplingDeviceSequence(samplingDevice->sequence); |
|
deviceAPI->setDeviceNbItems(samplingDevice->deviceNbItems); |
|
deviceAPI->setDeviceItemIndex(samplingDevice->deviceItemIndex); |
|
deviceAPI->setHardwareId(samplingDevice->hardwareId); |
|
deviceAPI->setSamplingDeviceId(samplingDevice->id); |
|
deviceAPI->setSamplingDeviceSerial(samplingDevice->serial); |
|
deviceAPI->setSamplingDeviceDisplayName(samplingDevice->displayedName); |
|
deviceAPI->setSamplingDevicePluginInterface(DeviceEnumerator::instance()->getTxPluginInterface(fileSinkDeviceIndex)); |
|
|
|
QString userArgs = m_mainCore->m_settings.getDeviceUserArgs().findUserArgs(samplingDevice->hardwareId, samplingDevice->sequence); |
|
|
|
if (userArgs.size() > 0) { |
|
deviceAPI->setHardwareUserArguments(userArgs); |
|
} |
|
|
|
DeviceSampleSink *sink = deviceAPI->getPluginInterface()->createSampleSinkPluginInstance( |
|
deviceAPI->getSamplingDeviceId(), deviceAPI); |
|
deviceAPI->setSampleSink(sink); |
|
emit m_mainCore->deviceSetAdded(deviceTabIndex, deviceAPI); |
|
} |
|
|
|
void MainServer::addSourceDevice() |
|
{ |
|
DSPDeviceSourceEngine *dspDeviceSourceEngine = m_dspEngine->addDeviceSourceEngine(); |
|
dspDeviceSourceEngine->start(); |
|
|
|
uint dspDeviceSourceEngineUID = dspDeviceSourceEngine->getUID(); |
|
char uidCStr[16]; |
|
sprintf(uidCStr, "UID:%d", dspDeviceSourceEngineUID); |
|
|
|
int deviceTabIndex = m_mainCore->m_deviceSets.size(); |
|
m_mainCore->m_deviceSets.push_back(new DeviceSet(deviceTabIndex, 0)); |
|
m_mainCore->m_deviceSets.back()->m_deviceSourceEngine = dspDeviceSourceEngine; |
|
m_mainCore->m_deviceSets.back()->m_deviceSinkEngine = nullptr; |
|
m_mainCore->m_deviceSets.back()->m_deviceMIMOEngine = nullptr; |
|
dspDeviceSourceEngine->addSink(m_mainCore->m_deviceSets.back()->m_spectrumVis); |
|
|
|
char tabNameCStr[16]; |
|
sprintf(tabNameCStr, "R%d", deviceTabIndex); |
|
|
|
DeviceAPI *deviceAPI = new DeviceAPI(DeviceAPI::StreamSingleRx, deviceTabIndex, dspDeviceSourceEngine, nullptr, nullptr); |
|
|
|
m_mainCore->m_deviceSets.back()->m_deviceAPI = deviceAPI; |
|
|
|
// Create a file source instance by default |
|
int fileSourceDeviceIndex = DeviceEnumerator::instance()->getFileInputDeviceIndex(); |
|
const PluginInterface::SamplingDevice *samplingDevice = DeviceEnumerator::instance()->getRxSamplingDevice(fileSourceDeviceIndex); |
|
deviceAPI->setSamplingDeviceSequence(samplingDevice->sequence); |
|
deviceAPI->setDeviceNbItems(samplingDevice->deviceNbItems); |
|
deviceAPI->setDeviceItemIndex(samplingDevice->deviceItemIndex); |
|
deviceAPI->setHardwareId(samplingDevice->hardwareId); |
|
deviceAPI->setSamplingDeviceId(samplingDevice->id); |
|
deviceAPI->setSamplingDeviceSerial(samplingDevice->serial); |
|
deviceAPI->setSamplingDeviceDisplayName(samplingDevice->displayedName); |
|
deviceAPI->setSamplingDevicePluginInterface(DeviceEnumerator::instance()->getRxPluginInterface(fileSourceDeviceIndex)); |
|
|
|
QString userArgs = m_mainCore->m_settings.getDeviceUserArgs().findUserArgs(samplingDevice->hardwareId, samplingDevice->sequence); |
|
|
|
if (userArgs.size() > 0) { |
|
deviceAPI->setHardwareUserArguments(userArgs); |
|
} |
|
|
|
DeviceSampleSource *source = deviceAPI->getPluginInterface()->createSampleSourcePluginInstance( |
|
deviceAPI->getSamplingDeviceId(), deviceAPI); |
|
deviceAPI->setSampleSource(source); |
|
emit m_mainCore->deviceSetAdded(deviceTabIndex, deviceAPI); |
|
} |
|
|
|
void MainServer::addMIMODevice() |
|
{ |
|
DSPDeviceMIMOEngine *dspDeviceMIMOEngine = m_dspEngine->addDeviceMIMOEngine(); |
|
dspDeviceMIMOEngine->start(); |
|
|
|
uint dspDeviceMIMOEngineUID = dspDeviceMIMOEngine->getUID(); |
|
char uidCStr[16]; |
|
sprintf(uidCStr, "UID:%d", dspDeviceMIMOEngineUID); |
|
|
|
int deviceTabIndex = m_mainCore->m_deviceSets.size(); |
|
m_mainCore->m_deviceSets.push_back(new DeviceSet(deviceTabIndex, 2)); |
|
m_mainCore->m_deviceSets.back()->m_deviceSourceEngine = nullptr; |
|
m_mainCore->m_deviceSets.back()->m_deviceSinkEngine = nullptr; |
|
m_mainCore->m_deviceSets.back()->m_deviceMIMOEngine = dspDeviceMIMOEngine; |
|
dspDeviceMIMOEngine->addSpectrumSink(m_mainCore->m_deviceSets.back()->m_spectrumVis); |
|
|
|
char tabNameCStr[16]; |
|
sprintf(tabNameCStr, "M%d", deviceTabIndex); |
|
|
|
DeviceAPI *deviceAPI = new DeviceAPI(DeviceAPI::StreamMIMO, deviceTabIndex, nullptr, nullptr, dspDeviceMIMOEngine); |
|
|
|
// create a test MIMO by default |
|
int testMIMODeviceIndex = DeviceEnumerator::instance()->getTestMIMODeviceIndex(); |
|
const PluginInterface::SamplingDevice *samplingDevice = DeviceEnumerator::instance()->getMIMOSamplingDevice(testMIMODeviceIndex); |
|
deviceAPI->setSamplingDeviceSequence(samplingDevice->sequence); |
|
deviceAPI->setDeviceNbItems(samplingDevice->deviceNbItems); |
|
deviceAPI->setDeviceItemIndex(samplingDevice->deviceItemIndex); |
|
deviceAPI->setHardwareId(samplingDevice->hardwareId); |
|
deviceAPI->setSamplingDeviceId(samplingDevice->id); |
|
deviceAPI->setSamplingDeviceSerial(samplingDevice->serial); |
|
deviceAPI->setSamplingDeviceDisplayName(samplingDevice->displayedName); |
|
deviceAPI->setSamplingDevicePluginInterface(DeviceEnumerator::instance()->getMIMOPluginInterface(testMIMODeviceIndex)); |
|
|
|
QString userArgs = m_mainCore->m_settings.getDeviceUserArgs().findUserArgs(samplingDevice->hardwareId, samplingDevice->sequence); |
|
|
|
if (userArgs.size() > 0) { |
|
deviceAPI->setHardwareUserArguments(userArgs); |
|
} |
|
|
|
DeviceSampleMIMO *mimo = deviceAPI->getPluginInterface()->createSampleMIMOPluginInstance( |
|
deviceAPI->getSamplingDeviceId(), deviceAPI); |
|
m_mainCore->m_deviceSets.back()->m_deviceAPI->setSampleMIMO(mimo); |
|
emit m_mainCore->deviceSetAdded(deviceTabIndex, deviceAPI); |
|
} |
|
|
|
void MainServer::removeLastDevice() |
|
{ |
|
int removedTabIndex = m_mainCore->m_deviceSets.size() - 1; |
|
|
|
if (m_mainCore->m_deviceSets.back()->m_deviceSourceEngine) // source set |
|
{ |
|
DSPDeviceSourceEngine *lastDeviceEngine = m_mainCore->m_deviceSets.back()->m_deviceSourceEngine; |
|
lastDeviceEngine->stopAcquistion(); |
|
|
|
// deletes old UI and input object |
|
m_mainCore->m_deviceSets.back()->freeChannels(); // destroys the channel instances |
|
m_mainCore->m_deviceSets.back()->m_deviceAPI->resetSamplingDeviceId(); |
|
m_mainCore->m_deviceSets.back()->m_deviceAPI->getPluginInterface()->deleteSampleSourcePluginInstanceInput( |
|
m_mainCore->m_deviceSets.back()->m_deviceAPI->getSampleSource()); |
|
m_mainCore->m_deviceSets.back()->m_deviceAPI->clearBuddiesLists(); // clear old API buddies lists |
|
|
|
DeviceAPI *sourceAPI = m_mainCore->m_deviceSets.back()->m_deviceAPI; |
|
delete m_mainCore->m_deviceSets.back(); |
|
|
|
lastDeviceEngine->stop(); |
|
m_dspEngine->removeLastDeviceSourceEngine(); |
|
|
|
delete sourceAPI; |
|
} |
|
else if (m_mainCore->m_deviceSets.back()->m_deviceSinkEngine) // sink set |
|
{ |
|
DSPDeviceSinkEngine *lastDeviceEngine = m_mainCore->m_deviceSets.back()->m_deviceSinkEngine; |
|
lastDeviceEngine->stopGeneration(); |
|
|
|
// deletes old UI and output object |
|
m_mainCore->m_deviceSets.back()->freeChannels(); |
|
m_mainCore->m_deviceSets.back()->m_deviceAPI->resetSamplingDeviceId(); |
|
m_mainCore->m_deviceSets.back()->m_deviceAPI->getPluginInterface()->deleteSampleSinkPluginInstanceOutput( |
|
m_mainCore->m_deviceSets.back()->m_deviceAPI->getSampleSink()); |
|
m_mainCore->m_deviceSets.back()->m_deviceAPI->clearBuddiesLists(); // clear old API buddies lists |
|
|
|
DeviceAPI *sinkAPI = m_mainCore->m_deviceSets.back()->m_deviceAPI; |
|
delete m_mainCore->m_deviceSets.back(); |
|
|
|
lastDeviceEngine->stop(); |
|
m_dspEngine->removeLastDeviceSinkEngine(); |
|
|
|
delete sinkAPI; |
|
} |
|
|
|
m_mainCore->m_deviceSets.pop_back(); |
|
emit m_mainCore->deviceSetRemoved(removedTabIndex); |
|
} |
|
|
|
void MainServer::changeSampleSource(int deviceSetIndex, int selectedDeviceIndex) |
|
{ |
|
if (deviceSetIndex >= 0) |
|
{ |
|
qDebug("MainServer::changeSampleSource: deviceSet at %d", deviceSetIndex); |
|
DeviceSet *deviceSet = m_mainCore->m_deviceSets[deviceSetIndex]; |
|
deviceSet->m_deviceAPI->saveSamplingDeviceSettings(m_mainCore->m_settings.getWorkingPreset()); // save old API settings |
|
deviceSet->m_deviceAPI->stopDeviceEngine(); |
|
|
|
// deletes old UI and input object |
|
deviceSet->m_deviceAPI->resetSamplingDeviceId(); |
|
deviceSet->m_deviceAPI->getPluginInterface()->deleteSampleSourcePluginInstanceInput( |
|
deviceSet->m_deviceAPI->getSampleSource()); |
|
deviceSet->m_deviceAPI->clearBuddiesLists(); // clear old API buddies lists |
|
|
|
const PluginInterface::SamplingDevice *samplingDevice = DeviceEnumerator::instance()->getRxSamplingDevice(selectedDeviceIndex); |
|
deviceSet->m_deviceAPI->setSamplingDeviceSequence(samplingDevice->sequence); |
|
deviceSet->m_deviceAPI->setDeviceNbItems(samplingDevice->deviceNbItems); |
|
deviceSet->m_deviceAPI->setDeviceItemIndex(samplingDevice->deviceItemIndex); |
|
deviceSet->m_deviceAPI->setHardwareId(samplingDevice->hardwareId); |
|
deviceSet->m_deviceAPI->setSamplingDeviceId(samplingDevice->id); |
|
deviceSet->m_deviceAPI->setSamplingDeviceSerial(samplingDevice->serial); |
|
deviceSet->m_deviceAPI->setSamplingDeviceDisplayName(samplingDevice->displayedName); |
|
deviceSet->m_deviceAPI->setSamplingDevicePluginInterface(DeviceEnumerator::instance()->getRxPluginInterface(selectedDeviceIndex)); |
|
|
|
if (deviceSet->m_deviceAPI->getSamplingDeviceId().size() == 0) // non existent device => replace by default |
|
{ |
|
qDebug("MainServer::changeSampleSource: non existent device replaced by File Input"); |
|
int deviceIndex = DeviceEnumerator::instance()->getFileInputDeviceIndex(); |
|
samplingDevice = DeviceEnumerator::instance()->getRxSamplingDevice(deviceIndex); |
|
deviceSet->m_deviceAPI->setSamplingDeviceSequence(samplingDevice->sequence); |
|
deviceSet->m_deviceAPI->setDeviceNbItems(samplingDevice->deviceNbItems); |
|
deviceSet->m_deviceAPI->setDeviceItemIndex(samplingDevice->deviceItemIndex); |
|
deviceSet->m_deviceAPI->setHardwareId(samplingDevice->hardwareId); |
|
deviceSet->m_deviceAPI->setSamplingDeviceId(samplingDevice->id); |
|
deviceSet->m_deviceAPI->setSamplingDeviceSerial(samplingDevice->serial); |
|
deviceSet->m_deviceAPI->setSamplingDeviceDisplayName(samplingDevice->displayedName); |
|
deviceSet->m_deviceAPI->setSamplingDevicePluginInterface(DeviceEnumerator::instance()->getRxPluginInterface(deviceIndex)); |
|
} |
|
|
|
// add to buddies list |
|
std::vector<DeviceSet*>::iterator it = m_mainCore->m_deviceSets.begin(); |
|
int nbOfBuddies = 0; |
|
|
|
for (; it != m_mainCore->m_deviceSets.end(); ++it) |
|
{ |
|
if (*it != deviceSet) // do not add to itself |
|
{ |
|
if ((deviceSet->m_deviceAPI->getHardwareId() == (*it)->m_deviceAPI->getHardwareId()) && |
|
(deviceSet->m_deviceAPI->getSamplingDeviceSerial() == (*it)->m_deviceAPI->getSamplingDeviceSerial())) |
|
{ |
|
(*it)->m_deviceAPI->addBuddy(deviceSet->m_deviceAPI); |
|
nbOfBuddies++; |
|
} |
|
} |
|
} |
|
|
|
if (nbOfBuddies == 0) { |
|
deviceSet->m_deviceAPI->setBuddyLeader(true); |
|
} |
|
|
|
// constructs new GUI and input object |
|
DeviceSampleSource *source = deviceSet->m_deviceAPI->getPluginInterface()->createSampleSourcePluginInstance( |
|
deviceSet->m_deviceAPI->getSamplingDeviceId(), deviceSet->m_deviceAPI); |
|
deviceSet->m_deviceAPI->setSampleSource(source); |
|
|
|
deviceSet->m_deviceAPI->loadSamplingDeviceSettings(m_mainCore->m_settings.getWorkingPreset()); // load new API settings |
|
|
|
// Notify |
|
emit m_mainCore->deviceChanged(deviceSetIndex); |
|
} |
|
} |
|
|
|
void MainServer::changeSampleSink(int deviceSetIndex, int selectedDeviceIndex) |
|
{ |
|
if (deviceSetIndex >= 0) |
|
{ |
|
qDebug("MainServer::changeSampleSink: device set at %d", deviceSetIndex); |
|
DeviceSet *deviceSet = m_mainCore->m_deviceSets[deviceSetIndex]; |
|
deviceSet->m_deviceAPI->saveSamplingDeviceSettings(m_mainCore->m_settings.getWorkingPreset()); // save old API settings |
|
deviceSet->m_deviceAPI->stopDeviceEngine(); |
|
|
|
// deletes old UI and output object |
|
deviceSet->m_deviceAPI->resetSamplingDeviceId(); |
|
deviceSet->m_deviceAPI->getPluginInterface()->deleteSampleSinkPluginInstanceOutput( |
|
deviceSet->m_deviceAPI->getSampleSink()); |
|
deviceSet->m_deviceAPI->clearBuddiesLists(); // clear old API buddies lists |
|
|
|
const PluginInterface::SamplingDevice *samplingDevice = DeviceEnumerator::instance()->getTxSamplingDevice(selectedDeviceIndex); |
|
deviceSet->m_deviceAPI->setSamplingDeviceSequence(samplingDevice->sequence); |
|
deviceSet->m_deviceAPI->setDeviceNbItems(samplingDevice->deviceNbItems); |
|
deviceSet->m_deviceAPI->setDeviceItemIndex(samplingDevice->deviceItemIndex); |
|
deviceSet->m_deviceAPI->setHardwareId(samplingDevice->hardwareId); |
|
deviceSet->m_deviceAPI->setSamplingDeviceId(samplingDevice->id); |
|
deviceSet->m_deviceAPI->setSamplingDeviceSerial(samplingDevice->serial); |
|
deviceSet->m_deviceAPI->setSamplingDeviceDisplayName(samplingDevice->displayedName); |
|
deviceSet->m_deviceAPI->setSamplingDevicePluginInterface(DeviceEnumerator::instance()->getTxPluginInterface(selectedDeviceIndex)); |
|
|
|
if (deviceSet->m_deviceAPI->getSamplingDeviceId().size() == 0) // non existent device => replace by default |
|
{ |
|
qDebug("MainServer::changeSampleSink: non existent device replaced by File Sink"); |
|
int fileSinkDeviceIndex = DeviceEnumerator::instance()->getFileOutputDeviceIndex(); |
|
const PluginInterface::SamplingDevice *samplingDevice = DeviceEnumerator::instance()->getTxSamplingDevice(fileSinkDeviceIndex); |
|
deviceSet->m_deviceAPI->setSamplingDeviceSequence(samplingDevice->sequence); |
|
deviceSet->m_deviceAPI->setDeviceNbItems(samplingDevice->deviceNbItems); |
|
deviceSet->m_deviceAPI->setDeviceItemIndex(samplingDevice->deviceItemIndex); |
|
deviceSet->m_deviceAPI->setHardwareId(samplingDevice->hardwareId); |
|
deviceSet->m_deviceAPI->setSamplingDeviceId(samplingDevice->id); |
|
deviceSet->m_deviceAPI->setSamplingDeviceSerial(samplingDevice->serial); |
|
deviceSet->m_deviceAPI->setSamplingDeviceDisplayName(samplingDevice->displayedName); |
|
deviceSet->m_deviceAPI->setSamplingDevicePluginInterface(DeviceEnumerator::instance()->getTxPluginInterface(fileSinkDeviceIndex)); |
|
} |
|
|
|
// add to buddies list |
|
std::vector<DeviceSet*>::iterator it = m_mainCore->m_deviceSets.begin(); |
|
int nbOfBuddies = 0; |
|
|
|
for (; it != m_mainCore->m_deviceSets.end(); ++it) |
|
{ |
|
if (*it != deviceSet) // do not add to itself |
|
{ |
|
if ((deviceSet->m_deviceAPI->getHardwareId() == (*it)->m_deviceAPI->getHardwareId()) && |
|
(deviceSet->m_deviceAPI->getSamplingDeviceSerial() == (*it)->m_deviceAPI->getSamplingDeviceSerial())) |
|
{ |
|
(*it)->m_deviceAPI->addBuddy(deviceSet->m_deviceAPI); |
|
nbOfBuddies++; |
|
} |
|
} |
|
} |
|
|
|
if (nbOfBuddies == 0) { |
|
deviceSet->m_deviceAPI->setBuddyLeader(true); |
|
} |
|
|
|
// constructs new GUI and output object |
|
DeviceSampleSink *sink = deviceSet->m_deviceAPI->getPluginInterface()->createSampleSinkPluginInstance( |
|
deviceSet->m_deviceAPI->getSamplingDeviceId(), deviceSet->m_deviceAPI); |
|
deviceSet->m_deviceAPI->setSampleSink(sink); |
|
|
|
deviceSet->m_deviceAPI->loadSamplingDeviceSettings(m_mainCore->m_settings.getWorkingPreset()); // load new API settings |
|
} |
|
} |
|
|
|
void MainServer::changeSampleMIMO(int deviceSetIndex, int selectedDeviceIndex) |
|
{ |
|
if (deviceSetIndex >= 0) |
|
{ |
|
qDebug("MainServer::changeSampleMIMO: device set at %d", deviceSetIndex); |
|
DeviceSet *deviceSet = m_mainCore->m_deviceSets[deviceSetIndex]; |
|
deviceSet->m_deviceAPI->saveSamplingDeviceSettings(m_mainCore->m_settings.getWorkingPreset()); // save old API settings |
|
deviceSet->m_deviceAPI->stopDeviceEngine(); |
|
|
|
// deletes old UI and output object |
|
deviceSet->m_deviceAPI->resetSamplingDeviceId(); |
|
deviceSet->m_deviceAPI->getPluginInterface()->deleteSampleMIMOPluginInstanceMIMO( |
|
deviceSet->m_deviceAPI->getSampleMIMO()); |
|
|
|
const PluginInterface::SamplingDevice *samplingDevice = DeviceEnumerator::instance()->getMIMOSamplingDevice(selectedDeviceIndex); |
|
deviceSet->m_deviceAPI->setSamplingDeviceSequence(samplingDevice->sequence); |
|
deviceSet->m_deviceAPI->setDeviceNbItems(samplingDevice->deviceNbItems); |
|
deviceSet->m_deviceAPI->setDeviceItemIndex(samplingDevice->deviceItemIndex); |
|
deviceSet->m_deviceAPI->setHardwareId(samplingDevice->hardwareId); |
|
deviceSet->m_deviceAPI->setSamplingDeviceId(samplingDevice->id); |
|
deviceSet->m_deviceAPI->setSamplingDeviceSerial(samplingDevice->serial); |
|
deviceSet->m_deviceAPI->setSamplingDeviceDisplayName(samplingDevice->displayedName); |
|
deviceSet->m_deviceAPI->setSamplingDevicePluginInterface(DeviceEnumerator::instance()->getMIMOPluginInterface(selectedDeviceIndex)); |
|
|
|
if (deviceSet->m_deviceAPI->getSamplingDeviceId().size() == 0) // non existent device => replace by default |
|
{ |
|
qDebug("MainServer::changeSampleMIMO: non existent device replaced by Test MIMO"); |
|
int testMIMODeviceIndex = DeviceEnumerator::instance()->getTestMIMODeviceIndex(); |
|
const PluginInterface::SamplingDevice *samplingDevice = DeviceEnumerator::instance()->getMIMOSamplingDevice(testMIMODeviceIndex); |
|
deviceSet->m_deviceAPI->setSamplingDeviceSequence(samplingDevice->sequence); |
|
deviceSet->m_deviceAPI->setDeviceNbItems(samplingDevice->deviceNbItems); |
|
deviceSet->m_deviceAPI->setDeviceItemIndex(samplingDevice->deviceItemIndex); |
|
deviceSet->m_deviceAPI->setHardwareId(samplingDevice->hardwareId); |
|
deviceSet->m_deviceAPI->setSamplingDeviceId(samplingDevice->id); |
|
deviceSet->m_deviceAPI->setSamplingDeviceSerial(samplingDevice->serial); |
|
deviceSet->m_deviceAPI->setSamplingDeviceDisplayName(samplingDevice->displayedName); |
|
deviceSet->m_deviceAPI->setSamplingDevicePluginInterface(DeviceEnumerator::instance()->getMIMOPluginInterface(testMIMODeviceIndex)); |
|
} |
|
|
|
QString userArgs = m_mainCore->m_settings.getDeviceUserArgs().findUserArgs(samplingDevice->hardwareId, samplingDevice->sequence); |
|
|
|
if (userArgs.size() > 0) { |
|
deviceSet->m_deviceAPI->setHardwareUserArguments(userArgs); |
|
} |
|
|
|
// constructs new GUI and MIMO object |
|
DeviceSampleMIMO *mimo = deviceSet->m_deviceAPI->getPluginInterface()->createSampleMIMOPluginInstance( |
|
deviceSet->m_deviceAPI->getSamplingDeviceId(), deviceSet->m_deviceAPI); |
|
deviceSet->m_deviceAPI->setSampleMIMO(mimo); |
|
|
|
deviceSet->m_deviceAPI->loadSamplingDeviceSettings(m_mainCore->m_settings.getWorkingPreset()); // load new API settings |
|
} |
|
} |
|
|
|
void MainServer::addChannel(int deviceSetIndex, int selectedChannelIndex) |
|
{ |
|
if (deviceSetIndex >= 0) |
|
{ |
|
DeviceSet *deviceSet = m_mainCore->m_deviceSets[deviceSetIndex]; |
|
|
|
if (deviceSet->m_deviceSourceEngine) // source device => Rx channels |
|
{ |
|
deviceSet->addRxChannel(selectedChannelIndex, m_mainCore->m_pluginManager->getPluginAPI()); |
|
} |
|
else if (deviceSet->m_deviceSinkEngine) // sink device => Tx channels |
|
{ |
|
deviceSet->addTxChannel(selectedChannelIndex, m_mainCore->m_pluginManager->getPluginAPI()); |
|
} |
|
} |
|
} |
|
|
|
void MainServer::deleteChannel(int deviceSetIndex, int channelIndex) |
|
{ |
|
if (deviceSetIndex >= 0) |
|
{ |
|
DeviceSet *deviceSet = m_mainCore->m_deviceSets[deviceSetIndex]; |
|
deviceSet->deleteChannel(channelIndex); |
|
} |
|
} |
|
|
|
void MainServer::addFeatureSet() |
|
{ |
|
m_mainCore->appendFeatureSet(); |
|
emit m_mainCore->featureSetAdded(m_mainCore->getFeatureeSets().size() - 1); |
|
} |
|
|
|
void MainServer::removeFeatureSet(unsigned int featureSetIndex) |
|
{ |
|
if (featureSetIndex < m_mainCore->m_featureSets.size()) |
|
{ |
|
m_mainCore->removeFeatureSet(featureSetIndex); |
|
emit m_mainCore->featureSetRemoved(featureSetIndex); |
|
} |
|
} |
|
|
|
void MainServer::addFeature(int featureSetIndex, int selectedFeatureIndex) |
|
{ |
|
if (featureSetIndex >= 0) |
|
{ |
|
FeatureSet *featureSet = m_mainCore->m_featureSets[featureSetIndex]; |
|
featureSet->addFeature(selectedFeatureIndex, m_mainCore->m_pluginManager->getPluginAPI(), m_apiAdapter); |
|
} |
|
} |
|
|
|
void MainServer::deleteFeature(int featureSetIndex, int featureIndex) |
|
{ |
|
if ((featureSetIndex >= 0) && (featureSetIndex < (int) m_mainCore->m_featureSets.size())) |
|
{ |
|
FeatureSet *featureSet = m_mainCore->m_featureSets[featureSetIndex]; |
|
featureSet->deleteFeature(featureIndex); |
|
} |
|
} |
|
|
|
void MainServer::loadPresetSettings(const Preset* preset, int tabIndex) |
|
{ |
|
qDebug("MainServer::loadPresetSettings: preset [%s | %s]", |
|
qPrintable(preset->getGroup()), |
|
qPrintable(preset->getDescription())); |
|
|
|
if (tabIndex >= 0) |
|
{ |
|
DeviceSet *deviceSet = m_mainCore->m_deviceSets[tabIndex]; |
|
deviceSet->m_deviceAPI->loadSamplingDeviceSettings(preset); |
|
|
|
if (deviceSet->m_deviceSourceEngine) { // source device |
|
deviceSet->loadRxChannelSettings(preset, m_mainCore->m_pluginManager->getPluginAPI()); |
|
} else if (deviceSet->m_deviceSinkEngine) { // sink device |
|
deviceSet->loadTxChannelSettings(preset, m_mainCore->m_pluginManager->getPluginAPI()); |
|
} else if (deviceSet->m_deviceMIMOEngine) { // MIMO device |
|
deviceSet->loadMIMOChannelSettings(preset, m_mainCore->m_pluginManager->getPluginAPI()); |
|
} |
|
} |
|
} |
|
|
|
void MainServer::savePresetSettings(Preset* preset, int tabIndex) |
|
{ |
|
qDebug("MainServer::savePresetSettings: preset [%s | %s]", |
|
qPrintable(preset->getGroup()), |
|
qPrintable(preset->getDescription())); |
|
|
|
// Save from currently selected source tab |
|
//int currentSourceTabIndex = ui->tabInputsView->currentIndex(); |
|
DeviceSet *deviceSet = m_mainCore->m_deviceSets[tabIndex]; |
|
|
|
if (deviceSet->m_deviceSourceEngine) // source device |
|
{ |
|
preset->clearChannels(); |
|
preset->setSourcePreset(); |
|
deviceSet->saveRxChannelSettings(preset); |
|
deviceSet->m_deviceAPI->saveSamplingDeviceSettings(preset); |
|
} |
|
else if (deviceSet->m_deviceSinkEngine) // sink device |
|
{ |
|
preset->clearChannels(); |
|
preset->setSinkPreset(); |
|
deviceSet->saveTxChannelSettings(preset); |
|
deviceSet->m_deviceAPI->saveSamplingDeviceSettings(preset); |
|
} |
|
else if (deviceSet->m_deviceMIMOEngine) // MIMO device |
|
{ |
|
preset->clearChannels(); |
|
preset->setMIMOPreset(); |
|
deviceSet->saveMIMOChannelSettings(preset); |
|
deviceSet->m_deviceAPI->saveSamplingDeviceSettings(preset); |
|
} |
|
} |
|
|
|
void MainServer::loadFeatureSetPresetSettings(const FeatureSetPreset* preset, int featureSetIndex) |
|
{ |
|
qDebug("MainServer::loadFeatureSetPresetSettings: preset [%s | %s]", |
|
qPrintable(preset->getGroup()), |
|
qPrintable(preset->getDescription())); |
|
|
|
if (featureSetIndex >= 0) |
|
{ |
|
FeatureSet *featureSet = m_mainCore->m_featureSets[featureSetIndex]; |
|
featureSet->loadFeatureSetSettings(preset, m_mainCore->m_pluginManager->getPluginAPI(), m_apiAdapter); |
|
} |
|
} |
|
|
|
void MainServer::saveFeatureSetPresetSettings(FeatureSetPreset* preset, int featureSetIndex) |
|
{ |
|
qDebug("MainServer::saveFeatureSetPresetSettings: preset [%s | %s]", |
|
qPrintable(preset->getGroup()), |
|
qPrintable(preset->getDescription())); |
|
|
|
// Save from currently selected source tab |
|
//int currentSourceTabIndex = ui->tabInputsView->currentIndex(); |
|
FeatureSet *featureSet = m_mainCore->m_featureSets[featureSetIndex]; |
|
|
|
preset->clearFeatures(); |
|
featureSet->saveFeatureSetSettings(preset); |
|
}
|
|
|