VE7UWU/sdrangel
1
0
Fork 0
mirror of https://github.com/f4exb/sdrangel.git synced 2024-12-23 01:55:48 -05:00
Code Issues Projects Releases Wiki Activity

All device plugins: make sure start and stop are effective once only. PArt of #2159

Browse Source
This commit is contained in:
f4exb 2024-08-21 05:27:01 +02:00 committed by Edouard Griffiths
parent 1b37a4f504
commit 585d806ef8
40 changed files with 454 additions and 243 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
plugins/samplemimo/bladerf2mimo/bladerf2mimo.cpp
View File

@ -142,6 +142,12 @@ void BladeRF2MIMO::init()
bool BladeRF2MIMO::startRx()
{
QMutexLocker mutexLocker(&m_mutex);
if (m_runningRx) {
return true;
}
qDebug("BladeRF2MIMO::startRx");
if (!m_open)
@ -150,12 +156,6 @@ bool BladeRF2MIMO::startRx()
return false;
}
QMutexLocker mutexLocker(&m_mutex);
if (m_runningRx) {
stopRx();
}
m_sourceThread = new BladeRF2MIThread(m_dev->getDev());
m_sampleMIFifo.reset();
m_sourceThread->setFifo(&m_sampleMIFifo);
@ -178,6 +178,12 @@ bool BladeRF2MIMO::startRx()
bool BladeRF2MIMO::startTx()
{
QMutexLocker mutexLocker(&m_mutex);
if (m_runningTx) {
return true;
}
qDebug("BladeRF2MIMO::startTx");
if (!m_open)
@ -186,12 +192,6 @@ bool BladeRF2MIMO::startTx()
return false;
}
QMutexLocker mutexLocker(&m_mutex);
if (m_runningTx) {
stopTx();
}
m_sinkThread = new BladeRF2MOThread(m_dev->getDev());
m_sampleMOFifo.reset();
m_sinkThread->setFifo(&m_sampleMOFifo);
@ -213,18 +213,22 @@ bool BladeRF2MIMO::startTx()
void BladeRF2MIMO::stopRx()
{
qDebug("BladeRF2MIMO::stopRx");
QMutexLocker mutexLocker(&m_mutex);
if (!m_runningRx) {
return;
}
if (!m_sourceThread) {
return;
}
QMutexLocker mutexLocker(&m_mutex);
qDebug("BladeRF2MIMO::stopRx");
m_runningRx = false;
m_sourceThread->stopWork();
delete m_sourceThread;
m_sourceThread = nullptr;
m_runningRx = false;
for (int i = 0; i < 2; i++) {
m_dev->closeRx(i);
@ -233,18 +237,22 @@ void BladeRF2MIMO::stopRx()
void BladeRF2MIMO::stopTx()
{
qDebug("BladeRF2MIMO::stopTx");
QMutexLocker mutexLocker(&m_mutex);
if (!m_runningTx) {
return;
}
if (!m_sinkThread) {
return;
}
QMutexLocker mutexLocker(&m_mutex);
qDebug("BladeRF2MIMO::stopTx");
m_runningTx = false;
m_sinkThread->stopWork();
delete m_sinkThread;
m_sinkThread = nullptr;
m_runningTx = false;
for (int i = 0; i < 2; i++) {
m_dev->closeTx(i);

44
plugins/samplemimo/limesdrmimo/limesdrmimo.cpp
View File

@ -256,6 +256,12 @@ void LimeSDRMIMO::init()
bool LimeSDRMIMO::startRx()
{
QMutexLocker mutexLocker(&m_mutex);
if (m_runningRx) {
return true;
}
qDebug("LimeSDRMIMO::startRx");
lms_stream_t *streams[2];
@ -265,12 +271,6 @@ bool LimeSDRMIMO::startRx()
return false;
}
QMutexLocker mutexLocker(&m_mutex);
if (m_runningRx) {
stopRx();
}
for (unsigned int channel = 0; channel < 2; channel++)
{
if (channel < m_deviceAPI->getNbSourceStreams())
@ -307,18 +307,22 @@ bool LimeSDRMIMO::startRx()
void LimeSDRMIMO::stopRx()
{
qDebug("LimeSDRMIMO::stopRx");
QMutexLocker mutexLocker(&m_mutex);
if (!m_runningRx) {
return;
}
if (!m_sourceThread) {
return;
}
QMutexLocker mutexLocker(&m_mutex);
qDebug("LimeSDRMIMO::stopRx");
m_runningRx = false;
m_sourceThread->stopWork();
delete m_sourceThread;
m_sourceThread = nullptr;
m_runningRx = false;
for (unsigned int channel = 0; channel < 2; channel++)
{
@ -330,6 +334,12 @@ void LimeSDRMIMO::stopRx()
bool LimeSDRMIMO::startTx()
{
QMutexLocker mutexLocker(&m_mutex);
if (m_runningTx) {
return true;
}
qDebug("LimeSDRMIMO::startTx");
lms_stream_t *streams[2];
@ -339,12 +349,6 @@ bool LimeSDRMIMO::startTx()
return false;
}
QMutexLocker mutexLocker(&m_mutex);
if (m_runningTx) {
stopTx();
}
for (unsigned int channel = 0; channel < 2; channel++)
{
if (channel < m_deviceAPI->getNbSinkStreams())
@ -380,18 +384,22 @@ bool LimeSDRMIMO::startTx()
void LimeSDRMIMO::stopTx()
{
qDebug("LimeSDRMIMO::stopTx");
QMutexLocker mutexLocker(&m_mutex);
if (!m_runningTx) {
return;
}
if (!m_sinkThread) {
return;
}
QMutexLocker mutexLocker(&m_mutex);
qDebug("LimeSDRMIMO::stopTx");
m_runningTx = false;
m_sinkThread->stopWork();
delete m_sinkThread;
m_sinkThread = nullptr;
m_runningTx = false;
for (unsigned int channel = 0; channel < 2; channel++)
{

44
plugins/samplemimo/plutosdrmimo/plutosdrmimo.cpp
View File

@ -168,7 +168,11 @@ void PlutoSDRMIMO::init()
bool PlutoSDRMIMO::startRx()
{
qDebug("PlutoSDRMIMO::startRx");
QMutexLocker mutexLocker(&m_mutex);
if (m_runningRx) {
return true;
}
if (!m_open)
{
@ -176,11 +180,7 @@ bool PlutoSDRMIMO::startRx()
return false;
}
QMutexLocker mutexLocker(&m_mutex);
if (m_runningRx) {
stopRx();
}
qDebug("PlutoSDRMIMO::startRx");
m_sourceThread = new PlutoSDRMIThread(m_plutoParams->getBox());
m_sampleMIFifo.reset();
@ -206,7 +206,11 @@ bool PlutoSDRMIMO::startRx()
bool PlutoSDRMIMO::startTx()
{
qDebug("PlutoSDRMIMO::startTx");
QMutexLocker mutexLocker(&m_mutex);
if (m_runningTx) {
return true;
}
if (!m_open)
{
@ -214,11 +218,7 @@ bool PlutoSDRMIMO::startTx()
return false;
}
QMutexLocker mutexLocker(&m_mutex);
if (m_runningTx) {
stopTx();
}
qDebug("PlutoSDRMIMO::startTx");
m_sinkThread = new PlutoSDRMOThread(m_plutoParams->getBox());
m_sampleMOFifo.reset();
@ -243,18 +243,22 @@ bool PlutoSDRMIMO::startTx()
void PlutoSDRMIMO::stopRx()
{
qDebug("PlutoSDRMIMO::stopRx");
QMutexLocker mutexLocker(&m_mutex);
if (!m_runningRx) {
return;
}
if (!m_sourceThread) {
return;
}
QMutexLocker mutexLocker(&m_mutex);
qDebug("PlutoSDRMIMO::stopRx");
m_runningRx = false;
m_sourceThread->stopWork();
delete m_sourceThread;
m_sourceThread = nullptr;
m_runningRx = false;
if (m_nbRx > 1) {
m_plutoParams->getBox()->closeSecondRx();
@ -270,18 +274,22 @@ void PlutoSDRMIMO::stopRx()
void PlutoSDRMIMO::stopTx()
{
qDebug("PlutoSDRMIMO::stopTx");
QMutexLocker mutexLocker(&m_mutex);
if (!m_runningTx) {
return;
}
if (!m_sinkThread) {
return;
}
QMutexLocker mutexLocker(&m_mutex);
qDebug("PlutoSDRMIMO::stopTx");
m_runningTx = false;
m_sinkThread->stopWork();
delete m_sinkThread;
m_sinkThread = nullptr;
m_runningTx = false;
if (m_nbTx > 1) {
m_plutoParams->getBox()->closeSecondTx();

2
plugins/samplemimo/testmi/testmi.cpp
View File

@ -127,7 +127,7 @@ void TestMI::stopRx()
}
qDebug("TestMI::stopRx");
m_running = false;
m_running = false;
stopWorkers();
m_testSourceWorkers.clear();

44
plugins/samplemimo/xtrxmimo/xtrxmimo.cpp
View File

@ -124,7 +124,11 @@ void XTRXMIMO::init()
bool XTRXMIMO::startRx()
{
qDebug("XTRXMIMO::startRx");
QMutexLocker mutexLocker(&m_mutex);
if (m_runningRx) {
return true;
}
if (!m_open)
{
@ -132,11 +136,7 @@ bool XTRXMIMO::startRx()
return false;
}
QMutexLocker mutexLocker(&m_mutex);
if (m_runningRx) {
stopRx();
}
qDebug("XTRXMIMO::startRx");
m_sourceThread = new XTRXMIThread(m_deviceShared.m_dev->getDevice());
m_sampleMIFifo.reset();
@ -152,7 +152,11 @@ bool XTRXMIMO::startRx()
bool XTRXMIMO::startTx()
{
qDebug("XTRXMIMO::startTx");
QMutexLocker mutexLocker(&m_mutex);
if (m_runningTx) {
return true;
}
if (!m_open)
{
@ -160,11 +164,7 @@ bool XTRXMIMO::startTx()
return false;
}
QMutexLocker mutexLocker(&m_mutex);
if (m_runningRx) {
stopRx();
}
qDebug("XTRXMIMO::startTx");
m_sinkThread = new XTRXMOThread(m_deviceShared.m_dev->getDevice());
m_sampleMOFifo.reset();
@ -179,34 +179,42 @@ bool XTRXMIMO::startTx()
void XTRXMIMO::stopRx()
{
qDebug("XTRXMIMO::stopRx");
QMutexLocker mutexLocker(&m_mutex);
if (!m_runningRx){
return;
}
if (!m_sourceThread) {
return;
}
QMutexLocker mutexLocker(&m_mutex);
qDebug("XTRXMIMO::stopRx");
m_runningRx = false;
m_sourceThread->stopWork();
delete m_sourceThread;
m_sourceThread = nullptr;
m_runningRx = false;
}
void XTRXMIMO::stopTx()
{
qDebug("XTRXMIMO::stopTx");
QMutexLocker mutexLocker(&m_mutex);
if (!m_runningTx) {
return;
}
if (!m_sinkThread) {
return;
}
QMutexLocker mutexLocker(&m_mutex);
qDebug("XTRXMIMO::stopTx");
m_runningTx = false;
m_sinkThread->stopWork();
delete m_sinkThread;
m_sinkThread = nullptr;
m_runningTx = false;
}
QByteArray XTRXMIMO::serialize() const

38
plugins/samplesink/bladerf1output/bladerf1output.cpp
View File

@ -144,25 +144,24 @@ void Bladerf1Output::init()
bool Bladerf1Output::start()
{
// QMutexLocker mutexLocker(&m_mutex);
QMutexLocker mutexLocker(&m_mutex);
if (m_running) {
return true;
}
if (!m_dev) {
return false;
}
if (m_running) stop();
m_bladerfThread = new Bladerf1OutputThread(m_dev, &m_sampleSourceFifo);
// mutexLocker.unlock();
applySettings(m_settings, QList<QString>(), true);
m_bladerfThread->setLog2Interpolation(m_settings.m_log2Interp);
m_bladerfThread->startWork();
qDebug("BladerfOutput::start: started");
m_running = true;
mutexLocker.unlock();
applySettings(m_settings, QList<QString>(), true);
return true;
}
@ -171,7 +170,7 @@ void Bladerf1Output::closeDevice()
{
int res;
if (m_dev == 0) { // was never open
if (m_dev == nullptr) { // was never open
return;
}
@ -180,7 +179,7 @@ void Bladerf1Output::closeDevice()
qCritical("BladerfOutput::closeDevice: bladerf_enable_module with return code %d", res);
}
if (m_deviceAPI->getSourceBuddies().size() == 0)
if (m_deviceAPI->getSourceBuddies().empty())
{
qDebug("BladerfOutput::closeDevice: closing device since Rx side is not open");
@ -190,21 +189,26 @@ void Bladerf1Output::closeDevice()
}
}
m_sharedParams.m_dev = 0;
m_sharedParams.m_dev = nullptr;
m_dev = 0;
}
void Bladerf1Output::stop()
{
// QMutexLocker mutexLocker(&m_mutex);
if (m_bladerfThread != 0)
QMutexLocker mutexLocker(&m_mutex);
if (!m_running) {
return;
}
m_running = false;
if (m_bladerfThread)
{
m_bladerfThread->stopWork();
delete m_bladerfThread;
m_bladerfThread = 0;
m_bladerfThread = nullptr;
}
m_running = false;
}
QByteArray Bladerf1Output::serialize() const

15
plugins/samplesink/fileoutput/fileoutput.cpp
View File

@ -44,6 +44,7 @@ MESSAGE_CLASS_DEFINITION(FileOutput::MsgReportFileOutputStreamTiming, Message)
FileOutput::FileOutput(DeviceAPI *deviceAPI) :
m_deviceAPI(deviceAPI),
m_running(false),
m_settings(),
m_fileOutputWorker(nullptr),
m_deviceDescription("FileOutput"),
@ -94,6 +95,11 @@ void FileOutput::init()
bool FileOutput::start()
{
QMutexLocker mutexLocker(&m_mutex);
if (m_running) {
return true;
}
qDebug() << "FileOutput::start";
openFileStream();
@ -104,6 +110,7 @@ bool FileOutput::start()
m_fileOutputWorker->setLog2Interpolation(m_settings.m_log2Interp);
m_fileOutputWorker->connectTimer(m_masterTimer);
startWorker();
m_running = true;
mutexLocker.unlock();
//applySettings(m_generalSettings, m_settings, true);
@ -120,9 +127,15 @@ bool FileOutput::start()
void FileOutput::stop()
{
qDebug() << "FileSourceInput::stop";
QMutexLocker mutexLocker(&m_mutex);
if (!m_running) {
return;
}
qDebug() << "FileSourceInput::stop";
m_running = false;
if (m_fileOutputWorker)
{
stopWorker();

1
plugins/samplesink/fileoutput/fileoutput.h
View File

@ -234,6 +234,7 @@ public:
private:
DeviceAPI *m_deviceAPI;
QMutex m_mutex;
bool m_running;
FileOutputSettings m_settings;
std::ofstream m_ofstream;
FileOutputWorker* m_fileOutputWorker;

21
plugins/samplesink/hackrfoutput/hackrfoutput.cpp
View File

@ -129,27 +129,28 @@ void HackRFOutput::init()
bool HackRFOutput::start()
{
QMutexLocker mutexLocker(&m_mutex);
if (!m_dev) {
return false;
}
if (m_running) {
stop();
return true;
}
m_hackRFThread = new HackRFOutputThread(m_dev, &m_sampleSourceFifo);
// mutexLocker.unlock();
applySettings(m_settings, QList<QString>(), true);
m_hackRFThread->setLog2Interpolation(m_settings.m_log2Interp);
m_hackRFThread->setFcPos((int) m_settings.m_fcPos);
m_hackRFThread->startWork();
m_running = true;
mutexLocker.unlock();
qDebug("HackRFOutput::start: started");
m_running = true;
applySettings(m_settings, QList<QString>(), true);
return true;
}
@ -173,8 +174,14 @@ void HackRFOutput::closeDevice()
void HackRFOutput::stop()
{
QMutexLocker mutexLocker(&m_mutex);
if (!m_running) {
return;
}
qDebug("HackRFOutput::stop");
// QMutexLocker mutexLocker(&m_mutex);
m_running = false;
if(m_hackRFThread != 0)
{
@ -182,8 +189,6 @@ void HackRFOutput::stop()
delete m_hackRFThread;
m_hackRFThread = 0;
}
m_running = false;
}
QByteArray HackRFOutput::serialize() const

23
plugins/samplesink/limesdroutput/limesdroutput.cpp
View File

@ -380,14 +380,17 @@ void LimeSDROutput::init()
bool LimeSDROutput::start()
{
QMutexLocker mutexLocker(&m_mutex);
if (m_running) {
return true;
}
if (!m_deviceShared.m_deviceParams->getDevice()) {
return false;
}
if (m_running) { stop(); }
if (!acquireChannel())
{
if (!acquireChannel()) {
return false;
}
@ -396,20 +399,25 @@ bool LimeSDROutput::start()
m_limeSDROutputThread = new LimeSDROutputThread(&m_streamId, &m_sampleSourceFifo);
qDebug("LimeSDROutput::start: thread created");
applySettings(m_settings, QList<QString>(), true);
m_limeSDROutputThread->setLog2Interpolation(m_settings.m_log2SoftInterp);
m_limeSDROutputThread->startWork();
m_deviceShared.m_thread = m_limeSDROutputThread;
m_running = true;
mutexLocker.unlock();
applySettings(m_settings, QList<QString>(), true);
return true;
}
void LimeSDROutput::stop()
{
if (!m_running) {
return;
}
qDebug("LimeSDROutput::stop");
m_running = false;
if (m_limeSDROutputThread)
{
@ -419,7 +427,6 @@ void LimeSDROutput::stop()
}
m_deviceShared.m_thread = 0;
m_running = false;
releaseChannel();
}

25
plugins/samplesink/plutosdroutput/plutosdroutput.cpp
View File

@ -102,34 +102,44 @@ void PlutoSDROutput::init()
bool PlutoSDROutput::start()
{
QMutexLocker mutexLocker(&m_mutex);
if (m_running) {
return true;
}
if (!m_deviceShared.m_deviceParams->getBox())
{
qCritical("PlutoSDROutput::start: device not open");
return false;
}
if (m_running) {
stop();
}
// start / stop streaming is done in the thread.
m_plutoSDROutputThread = new PlutoSDROutputThread(PLUTOSDR_BLOCKSIZE_SAMPLES, m_deviceShared.m_deviceParams->getBox(), &m_sampleSourceFifo);
qDebug("PlutoSDROutput::start: thread created");
applySettings(m_settings, QList<QString>(), true);
m_plutoSDROutputThread->setLog2Interpolation(m_settings.m_log2Interp);
m_plutoSDROutputThread->startWork();
m_deviceShared.m_thread = m_plutoSDROutputThread;
m_running = true;
mutexLocker.unlock();
applySettings(m_settings, QList<QString>(), true);
return true;
}
void PlutoSDROutput::stop()
{
QMutexLocker mutexLocker(&m_mutex);
if (!m_running) {
return;
}
m_running = false;
if (m_plutoSDROutputThread != 0)
{
m_plutoSDROutputThread->stopWork();
@ -138,7 +148,6 @@ void PlutoSDROutput::stop()
}
m_deviceShared.m_thread = 0;
m_running = false;
}
QByteArray PlutoSDROutput::serialize() const

17
plugins/samplesink/remoteoutput/remoteoutput.cpp
View File

@ -47,6 +47,7 @@ MESSAGE_CLASS_DEFINITION(RemoteOutput::MsgRequestFixedData, Message)
RemoteOutput::RemoteOutput(DeviceAPI *deviceAPI) :
m_deviceAPI(deviceAPI),
m_running(false),
m_settings(),
m_centerFrequency(435000000),
m_sampleRate(48000),
@ -95,6 +96,11 @@ void RemoteOutput::destroy()
bool RemoteOutput::start()
{
QMutexLocker mutexLocker(&m_mutex);
if (m_running) {
return true;
}
qDebug() << "RemoteOutput::start";
m_remoteOutputWorker = new RemoteOutputWorker(&m_sampleSourceFifo);
@ -105,6 +111,7 @@ bool RemoteOutput::start()
m_remoteOutputWorker->setNbBlocksFEC(m_settings.m_nbFECBlocks);
m_remoteOutputWorker->connectTimer(m_masterTimer);
startWorker();
m_running = true;
mutexLocker.unlock();
applySampleRate();
@ -121,12 +128,18 @@ void RemoteOutput::init()
void RemoteOutput::stop()
{
qDebug() << "RemoteOutput::stop";
QMutexLocker mutexLocker(&m_mutex);
if (!m_running) {
return;
}
qDebug() << "RemoteOutput::stop";
m_running = false;
if (m_remoteOutputWorker)
{
stopWorker();
stopWorker();
delete m_remoteOutputWorker;
m_remoteOutputWorker = nullptr;
}

3
plugins/samplesink/remoteoutput/remoteoutput.h
View File

@ -258,7 +258,8 @@ public:
private:
DeviceAPI *m_deviceAPI;
QMutex m_mutex;
QRecursiveMutex m_mutex;
bool m_running;
RemoteOutputSettings m_settings;
uint64_t m_centerFrequency;
int m_sampleRate;

10
plugins/samplesink/soapysdroutput/soapysdroutput.cpp
View File

@ -453,6 +453,11 @@ bool SoapySDROutput::start()
//
// Note: this is quite similar to the BladeRF2 start handling. The main difference is that the channel allocation (enabling) process is
// done in the thread object.
QMutexLocker mutexLocker(&m_mutex);
if (m_running) {
return true;
}
if (!m_openSuccess)
{
@ -558,11 +563,13 @@ void SoapySDROutput::stop()
// channel then the FIFO reference is simply removed from the thread so that this FIFO will not be used anymore.
// In this case the channel is not closed (this is managed in the thread object) so that other channels can continue with the
// same configuration. The device continues streaming on this channel but the samples are set to all zeros.
QMutexLocker mutexLocker(&m_mutex);
if (!m_running) {
return;
}
m_running = false;
int requestedChannel = m_deviceAPI->getDeviceItemIndex();
SoapySDROutputThread *soapySDROutputThread = findThread();
@ -648,9 +655,8 @@ void SoapySDROutput::stop()
soapySDROutputThread->setFifo(requestedChannel, nullptr); // remove FIFO
}
mutexLocker.unlock();
applySettings(m_settings, true); // re-apply forcibly to set sample rate with the new number of channels
m_running = false;
}
QByteArray SoapySDROutput::serialize() const

16
plugins/samplesink/usrpoutput/usrpoutput.cpp
View File

@ -379,12 +379,16 @@ void USRPOutput::init()
bool USRPOutput::start()
{
QMutexLocker mutexLocker(&m_mutex);
if (m_running) {
return true;
}
if (!m_deviceShared.m_deviceParams->getDevice()) {
return false;
}
if (m_running) { stop(); }
if (!acquireChannel()) {
return false;
}
@ -403,7 +407,14 @@ bool USRPOutput::start()
void USRPOutput::stop()
{
QMutexLocker mutexLocker(&m_mutex);
if (!m_running) {
return;
}
qDebug("USRPOutput::stop");
m_running = false;
if (m_usrpOutputThread)
{
@ -413,7 +424,6 @@ void USRPOutput::stop()
}
m_deviceShared.m_thread = 0;
m_running = false;
releaseChannel();
}

19
plugins/samplesink/xtrxoutput/xtrxoutput.cpp
View File

@ -265,6 +265,11 @@ bool XTRXOutput::start()
//
// Eventually it registers the FIFO in the thread. If the thread has to be started it enables the channels up to the number of channels
// allocated in the thread and starts the thread.
QMutexLocker mutexLocker(&m_mutex);
if (m_running) {
return true;
}
if (!m_deviceShared.m_dev || !m_deviceShared.m_dev->getDevice())
{
@ -341,6 +346,8 @@ bool XTRXOutput::start()
xtrxOutputThread->setFifo(requestedChannel, &m_sampleSourceFifo);
xtrxOutputThread->setLog2Interpolation(requestedChannel, m_settings.m_log2SoftInterp);
m_running = true;
mutexLocker.unlock();
applySettings(m_settings, QList<QString>(), true);
@ -351,7 +358,6 @@ bool XTRXOutput::start()
}
qDebug("XTRXOutput::start: started");
m_running = true;
return true;
}
@ -366,16 +372,18 @@ void XTRXOutput::stop()
// If the thread is currently managing both channels (MO mode) then we are removing one channel. Thus we must
// transition from MO to SO. This transition is handled by stopping the thread, deleting it and creating a new one
// managing a single channel.
QMutexLocker mutexLocker(&m_mutex);
if (!m_running) {
return;
}
m_running = false;
int removedChannel = m_deviceAPI->getDeviceItemIndex(); // channel to remove
int requestedChannel = removedChannel ^ 1; // channel to keep (opposite channel)
XTRXOutputThread *xtrxOutputThread = findThread();
if (xtrxOutputThread == 0) { // no thread allocated
if (xtrxOutputThread == nullptr) { // no thread allocated
return;
}
@ -386,8 +394,8 @@ void XTRXOutput::stop()
qDebug("XTRXOutput::stop: SO mode. Just stop and delete the thread");
xtrxOutputThread->stopWork();
delete xtrxOutputThread;
m_XTRXOutputThread = 0;
m_deviceShared.m_thread = 0;
m_XTRXOutputThread = nullptr;
m_deviceShared.m_thread = nullptr;
// remove old thread address from buddies (reset in all buddies)
const std::vector<DeviceAPI*>& sinkBuddies = m_deviceAPI->getSinkBuddies();
@ -417,11 +425,10 @@ void XTRXOutput::stop()
((DeviceXTRXShared*) (*it)->getBuddySharedPtr())->m_sink->setThread(nullptr);
}
mutexLocker.unlock();
applySettings(m_settings, QList<QString>(), true);
xtrxOutputThread->startWork();
}
m_running = false;
}
void XTRXOutput::suspendRxThread()

14
plugins/samplesource/airspy/airspyinput.cpp
View File

@ -197,14 +197,14 @@ bool AirspyInput::start()
{
QMutexLocker mutexLocker(&m_mutex);
if (!m_dev) {
return false;
}
if (m_running) {
return true;
}
if (!m_dev) {
return false;
}
m_airspyWorkerThread = new QThread();
m_airspyWorker = new AirspyWorker(m_dev, &m_sampleFifo);
m_airspyWorker->moveToThread(m_airspyWorkerThread);
@ -217,13 +217,13 @@ bool AirspyInput::start()
m_airspyWorker->setLog2Decimation(m_settings.m_log2Decim);
m_airspyWorker->setIQOrder(m_settings.m_iqOrder);
m_airspyWorker->setFcPos((int) m_settings.m_fcPos);
mutexLocker.unlock();
m_airspyWorkerThread->start();
m_running = true;
mutexLocker.unlock();
qDebug("AirspyInput::startInput: started");
applySettings(m_settings, QList<QString>(), true);
m_running = true;
return true;
}

2
plugins/samplesource/airspy/airspyinput.h
View File

@ -141,7 +141,7 @@ public:
private:
DeviceAPI *m_deviceAPI;
QMutex m_mutex;
QRecursiveMutex m_mutex;
AirspySettings m_settings;
struct airspy_device* m_dev;
AirspyWorker* m_airspyWorker;

23
plugins/samplesource/airspyhf/airspyhfinput.cpp
View File

@ -171,12 +171,12 @@ bool AirspyHFInput::start()
{
QMutexLocker mutexLocker(&m_mutex);
if (!m_dev) {
return false;
if (m_running) {
return true;
}
if (m_running) {
stop();
if (!m_dev) {
return false;
}
m_airspyHFWorkerThread = new QThread();
@ -198,13 +198,13 @@ bool AirspyHFInput::start()
m_airspyHFWorker->setLog2Decimation(m_settings.m_log2Decim);
m_airspyHFWorker->setIQOrder(m_settings.m_iqOrder);
mutexLocker.unlock();
m_airspyHFWorkerThread->start();
m_running = true;
mutexLocker.unlock();
qDebug("AirspyHFInput::startInput: started");
applySettings(m_settings, QList<QString>(), true);
m_running = true;
return m_running;
}
@ -223,9 +223,15 @@ void AirspyHFInput::closeDevice()
void AirspyHFInput::stop()
{
qDebug("AirspyHFInput::stop");
QMutexLocker mutexLocker(&m_mutex);
if (!m_running) {
return;
}
qDebug("AirspyHFInput::stop");
m_running = false;
if (m_airspyHFWorkerThread)
{
m_airspyHFWorkerThread->quit();
@ -234,7 +240,6 @@ void AirspyHFInput::stop()
m_airspyHFWorker = nullptr;
}
m_running = false;
}
QByteArray AirspyHFInput::serialize() const

2
plugins/samplesource/airspyhf/airspyhfinput.h
View File

@ -165,7 +165,7 @@ public:
private:
DeviceAPI *m_deviceAPI;
QMutex m_mutex;
QRecursiveMutex m_mutex;
AirspyHFSettings m_settings;
airspyhf_device_t* m_dev;
AirspyHFWorker* m_airspyHFWorker;

28
plugins/samplesource/bladerf1input/bladerf1input.cpp
View File

@ -151,7 +151,11 @@ void Bladerf1Input::init()
bool Bladerf1Input::start()
{
// QMutexLocker mutexLocker(&m_mutex);
QMutexLocker mutexLocker(&m_mutex);
if (m_running) {
return true;
}
if (!m_dev)
{
@ -159,20 +163,17 @@ bool Bladerf1Input::start()
return false;
}
if (m_running) stop();
m_bladerfThread = new Bladerf1InputThread(m_dev, &m_sampleFifo);
m_bladerfThread->setLog2Decimation(m_settings.m_log2Decim);
m_bladerfThread->setFcPos((int) m_settings.m_fcPos);
m_bladerfThread->setIQOrder(m_settings.m_iqOrder);
m_bladerfThread->startWork();
m_running = true;
// mutexLocker.unlock();
mutexLocker.unlock();
applySettings(m_settings, QList<QString>(), true);
qDebug("BladerfInput::startInput: started");
m_running = true;
return true;
}
@ -194,19 +195,25 @@ void Bladerf1Input::closeDevice()
{
qDebug("BladerfInput::closeDevice: closing device since Tx side is not open");
if(m_dev != 0) // close BladeRF
if(m_dev != nullptr) // close BladeRF
{
bladerf_close(m_dev);
}
}
m_sharedParams.m_dev = 0;
m_dev = 0;
m_sharedParams.m_dev = nullptr;
m_dev = nullptr;
}
void Bladerf1Input::stop()
{
// QMutexLocker mutexLocker(&m_mutex);
QMutexLocker mutexLocker(&m_mutex);
if (!m_running) {
return;
}
m_running = false;
if(m_bladerfThread)
{
@ -215,7 +222,6 @@ void Bladerf1Input::stop()
m_bladerfThread = nullptr;
}
m_running = false;
}
QByteArray Bladerf1Input::serialize() const

2
plugins/samplesource/bladerf1input/bladerf1input.h
View File

@ -135,7 +135,7 @@ public:
private:
DeviceAPI *m_deviceAPI;
QMutex m_mutex;
QRecursiveMutex m_mutex;
BladeRF1InputSettings m_settings;
struct bladerf* m_dev;
Bladerf1InputThread* m_bladerfThread;

12
plugins/samplesource/bladerf2input/bladerf2input.cpp
View File

@ -290,6 +290,11 @@ bool BladeRF2Input::start()
//
// Eventually it registers the FIFO in the thread. If the thread has to be started it enables the channels up to the number of channels
// allocated in the thread and starts the thread.
QMutexLocker mutexLocker(&m_mutex);
if (m_running) {
return true;
}
if (!m_deviceShared.m_dev)
{
@ -383,10 +388,11 @@ bool BladeRF2Input::start()
bladerf2InputThread->startWork();
}
m_running = true;
mutexLocker.unlock();
applySettings(m_settings, QList<QString>(), true);
qDebug("BladeRF2Input::start: started");
m_running = true;
return true;
}
@ -408,6 +414,7 @@ void BladeRF2Input::stop()
// anymore. In this case the channel is not closed (disabled) so that other channels can continue with the
// same configuration. The device continues streaming on this channel but the samples are simply dropped (by
// removing FIFO reference).
QMutexLocker mutexLocker(&m_mutex);
if (!m_running) {
return;
@ -420,6 +427,7 @@ void BladeRF2Input::stop()
return;
}
m_running = false;
int nbOriginalChannels = bladerf2InputThread->getNbChannels();
if (nbOriginalChannels == 1) // SI mode => just stop and delete the thread
@ -500,8 +508,6 @@ void BladeRF2Input::stop()
qDebug("BladeRF2Input::stop: MI mode. Not changing MI configuration. Just remove FIFO reference");
bladerf2InputThread->setFifo(requestedChannel, 0); // remove FIFO
}
m_running = false;
}
QByteArray BladeRF2Input::serialize() const

23
plugins/samplesource/fcdpro/fcdproinput.cpp
View File

@ -121,15 +121,18 @@ void FCDProInput::init()
bool FCDProInput::start()
{
qDebug() << "FCDProInput::start";
// QMutexLocker mutexLocker(&m_mutex);
QMutexLocker mutexLocker(&m_mutex);
if (m_running) {
return true;
}
if (!m_dev) {
return false;
}
if (m_running) stop();
qDebug() << "FCDProInput::start";
/* Apply settings before streaming to avoid bus contention;
* there is very little spare bandwidth on a full speed USB device.
@ -149,12 +152,12 @@ bool FCDProInput::start()
m_FCDThread->setFcPos(m_settings.m_fcPos);
m_FCDThread->setIQOrder(m_settings.m_iqOrder);
m_FCDThread->startWork();
m_running = true;
// mutexLocker.unlock();
mutexLocker.unlock();
applySettings(m_settings, QList<QString>(), true);
qDebug("FCDProInput::started");
m_running = true;
return true;
}
@ -204,7 +207,13 @@ void FCDProInput::closeFCDAudio()
void FCDProInput::stop()
{
// QMutexLocker mutexLocker(&m_mutex);
QMutexLocker mutexLocker(&m_mutex);
if (!m_running) {
return;
}
m_running = false;
if (m_FCDThread)
{
@ -213,8 +222,6 @@ void FCDProInput::stop()
delete m_FCDThread;
m_FCDThread = nullptr;
}
m_running = false;
}
QByteArray FCDProInput::serialize() const

18
plugins/samplesource/fcdproplus/fcdproplusinput.cpp
View File

@ -121,14 +121,14 @@ void FCDProPlusInput::init()
bool FCDProPlusInput::start()
{
// QMutexLocker mutexLocker(&m_mutex);
QMutexLocker mutexLocker(&m_mutex);
if (!m_dev) {
return false;
}
if (m_running) {
stop();
return true;
}
qDebug() << "FCDProPlusInput::start";
@ -151,12 +151,12 @@ bool FCDProPlusInput::start()
m_FCDThread->setFcPos(m_settings.m_fcPos);
m_FCDThread->setIQOrder(m_settings.m_iqOrder);
m_FCDThread->startWork();
m_running = true;
// mutexLocker.unlock();
mutexLocker.unlock();
applySettings(m_settings, QList<QString>(), true);
qDebug("FCDProPlusInput::started");
m_running = true;
return true;
}
@ -170,7 +170,7 @@ void FCDProPlusInput::closeDevice()
fcdClose(m_dev);
m_dev = 0;
closeFCDAudio();
closeFCDAudio();
}
bool FCDProPlusInput::openFCDAudio(const char* cardname)
@ -208,6 +208,12 @@ void FCDProPlusInput::stop()
{
QMutexLocker mutexLocker(&m_mutex);
if (!m_running) {
return;
}
m_running = false;
if (m_FCDThread)
{
m_FCDThread->stopWork();
@ -215,8 +221,6 @@ void FCDProPlusInput::stop()
delete m_FCDThread;
m_FCDThread = nullptr;
}
m_running = false;
}
QByteArray FCDProPlusInput::serialize() const

32
plugins/samplesource/hackrfinput/hackrfinput.cpp
View File

@ -142,29 +142,29 @@ void HackRFInput::init()
bool HackRFInput::start()
{
// QMutexLocker mutexLocker(&m_mutex);
QMutexLocker mutexLocker(&m_mutex);
if (m_running) {
return true;
}
if (!m_dev) {
return false;
}
if (m_running) {
stop();
}
m_hackRFThread = new HackRFInputThread(m_dev, &m_sampleFifo);
// mutexLocker.unlock();
applySettings(m_settings, QList<QString>(), true);
m_hackRFThread->setSamplerate(m_settings.m_devSampleRate);
m_hackRFThread->setLog2Decimation(m_settings.m_log2Decim);
m_hackRFThread->setFcPos((int) m_settings.m_fcPos);
m_hackRFThread->setIQOrder(m_settings.m_iqOrder);
m_hackRFThread->startWork();
m_running = true;
mutexLocker.unlock();
applySettings(m_settings, QList<QString>(), true);
qDebug("HackRFInput::startInput: started");
m_running = true;
return true;
}
@ -188,8 +188,14 @@ void HackRFInput::closeDevice()
void HackRFInput::stop()
{
QMutexLocker mutexLocker(&m_mutex);
if (!m_running) {
return;
}
qDebug("HackRFInput::stop");
// QMutexLocker mutexLocker(&m_mutex);
m_running = false;
if (m_hackRFThread)
{
@ -197,8 +203,6 @@ void HackRFInput::stop()
delete m_hackRFThread;
m_hackRFThread = nullptr;
}
m_running = false;
}
QByteArray HackRFInput::serialize() const
@ -349,7 +353,7 @@ void HackRFInput::setDeviceCenterFrequency(quint64 freq_hz, int loPpmTenths)
bool HackRFInput::applySettings(const HackRFInputSettings& settings, const QList<QString>& settingsKeys, bool force)
{
// QMutexLocker mutexLocker(&m_mutex);
QMutexLocker mutexLocker(&m_mutex);
qDebug() << "HackRFInput::applySettings: forcE: " << force << settings.getDebugString(settingsKeys, force);
bool forwardChange = false;
hackrf_error rc;

2
plugins/samplesource/hackrfinput/hackrfinput.h
View File

@ -153,7 +153,7 @@ public:
private:
DeviceAPI *m_deviceAPI;
QMutex m_mutex;
QRecursiveMutex m_mutex;
HackRFInputSettings m_settings;
struct hackrf_device* m_dev;
HackRFInputThread* m_hackRFThread;

27
plugins/samplesource/limesdrinput/limesdrinput.cpp
View File

@ -409,14 +409,17 @@ void LimeSDRInput::init()
bool LimeSDRInput::start()
{
QMutexLocker mutexLocker(&m_mutex);
if (m_running) {
return true;
}
if (!m_deviceShared.m_deviceParams->getDevice()) {
return false;
}
if (m_running) { stop(); }
if (!acquireChannel())
{
if (!acquireChannel()) {
return false;
}
@ -425,21 +428,28 @@ bool LimeSDRInput::start()
m_limeSDRInputThread = new LimeSDRInputThread(&m_streamId, &m_sampleFifo, &m_replayBuffer);
qDebug("LimeSDRInput::start: thread created");
applySettings(m_settings, QList<QString>(), true);
m_limeSDRInputThread->setLog2Decimation(m_settings.m_log2SoftDecim);
m_limeSDRInputThread->setIQOrder(m_settings.m_iqOrder);
m_limeSDRInputThread->startWork();
m_deviceShared.m_thread = m_limeSDRInputThread;
m_running = true;
mutexLocker.unlock();
applySettings(m_settings, QList<QString>(), true);
return true;
}
void LimeSDRInput::stop()
{
QMutexLocker mutexLocker(&m_mutex);
if (!m_running) {
return;
}
qDebug("LimeSDRInput::stop");
m_running = false;
if (m_limeSDRInputThread)
{
@ -449,7 +459,6 @@ void LimeSDRInput::stop()
}
m_deviceShared.m_thread = 0;
m_running = false;
releaseChannel();
}
@ -803,7 +812,7 @@ bool LimeSDRInput::applySettings(const LimeSDRInputSettings& settings, const QLi
bool doLPCalibration = false;
double clockGenFreq = 0.0;
// QMutexLocker mutexLocker(&m_mutex);
QMutexLocker mutexLocker(&m_mutex);
qint64 deviceCenterFrequency = settings.m_centerFrequency;
deviceCenterFrequency -= settings.m_transverterMode ? settings.m_transverterDeltaFrequency : 0;

2
plugins/samplesource/limesdrinput/limesdrinput.h
View File

@ -290,7 +290,7 @@ public:
private:
DeviceAPI *m_deviceAPI;
QMutex m_mutex;
QRecursiveMutex m_mutex;
LimeSDRInputSettings m_settings;
LimeSDRInputThread* m_limeSDRInputThread;
QString m_deviceDescription;

25
plugins/samplesource/plutosdrinput/plutosdrinput.cpp
View File

@ -102,35 +102,45 @@ void PlutoSDRInput::init()
bool PlutoSDRInput::start()
{
QMutexLocker mutexLocker(&m_mutex);
if (m_running) {
return true;
}
if (!m_deviceShared.m_deviceParams->getBox())
{
qCritical("PlutoSDRInput::start: device not open");
return false;
}
if (m_running) {
stop();
}
// start / stop streaming is done in the thread.
m_plutoSDRInputThread = new PlutoSDRInputThread(PLUTOSDR_BLOCKSIZE_SAMPLES, m_deviceShared.m_deviceParams->getBox(), &m_sampleFifo);
qDebug("PlutoSDRInput::start: thread created");
applySettings(m_settings, QList<QString>(), true);
m_plutoSDRInputThread->setLog2Decimation(m_settings.m_log2Decim);
m_plutoSDRInputThread->setIQOrder(m_settings.m_iqOrder);
m_plutoSDRInputThread->startWork();
m_deviceShared.m_thread = m_plutoSDRInputThread;
m_running = true;
mutexLocker.unlock();
applySettings(m_settings, QList<QString>(), true);
return true;
}
void PlutoSDRInput::stop()
{
QMutexLocker mutexLocker(&m_mutex);
if (!m_running) {
return;
}
m_running = false;
if (m_plutoSDRInputThread)
{
m_plutoSDRInputThread->stopWork();
@ -139,7 +149,6 @@ void PlutoSDRInput::stop()
}
m_deviceShared.m_thread = nullptr;
m_running = false;
}
QByteArray PlutoSDRInput::serialize() const

27
plugins/samplesource/sdrplay/sdrplayinput.cpp
View File

@ -149,15 +149,17 @@ bool SDRPlayInput::openDevice()
bool SDRPlayInput::start()
{
// QMutexLocker mutexLocker(&m_mutex);
int res;
QMutexLocker mutexLocker(&m_mutex);
if (m_running) {
return true;
}
if (!m_dev) {
return false;
}
if (m_running) stop();
int res;
char s12FormatString[] = "336_S16";
if ((res = mirisdr_set_sample_format(m_dev, s12FormatString))) // sample format S12
@ -197,12 +199,11 @@ bool SDRPlayInput::start()
m_sdrPlayThread->setFcPos((int) m_settings.m_fcPos);
m_sdrPlayThread->setIQOrder(m_settings.m_iqOrder);
m_sdrPlayThread->startWork();
// mutexLocker.unlock();
applySettings(m_settings, QList<QString>(), true, true);
m_running = true;
mutexLocker.unlock();
applySettings(m_settings, QList<QString>(), true, true);
return true;
}
@ -224,7 +225,13 @@ void SDRPlayInput::init()
void SDRPlayInput::stop()
{
// QMutexLocker mutexLocker(&m_mutex);
QMutexLocker mutexLocker(&m_mutex);
if (!m_running) {
return;
}
m_running = false;
if(m_sdrPlayThread)
{
@ -232,8 +239,6 @@ void SDRPlayInput::stop()
delete m_sdrPlayThread;
m_sdrPlayThread = nullptr;
}
m_running = false;
}
QByteArray SDRPlayInput::serialize() const

2
plugins/samplesource/sdrplay/sdrplayinput.h
View File

@ -173,7 +173,7 @@ public:
private:
DeviceAPI *m_deviceAPI;
QMutex m_mutex;
QRecursiveMutex m_mutex;
SDRPlayVariant m_variant;
SDRPlaySettings m_settings;
mirisdr_dev_t* m_dev;

21
plugins/samplesource/sdrplayv3/sdrplayv3input.cpp
View File

@ -147,20 +147,25 @@ bool SDRPlayV3Input::openDevice()
bool SDRPlayV3Input::start()
{
qDebug() << "SDRPlayV3Input::start";
QMutexLocker mutexLocker(&m_mutex);
if (m_running) {
return true;
}
if (!m_dev) {
return false;
}
if (m_running) stop();
qDebug() << "SDRPlayV3Input::start";
m_sdrPlayThread = new SDRPlayV3Thread(m_dev, &m_sampleFifo, &m_replayBuffer);
m_sdrPlayThread->setLog2Decimation(m_settings.m_log2Decim);
m_sdrPlayThread->setFcPos((int) m_settings.m_fcPos);
m_sdrPlayThread->startWork();
m_running = m_sdrPlayThread->isRunning();
mutexLocker.unlock();
applySettings(m_settings, QList<QString>(), true, true);
return true;
@ -184,17 +189,21 @@ void SDRPlayV3Input::init()
void SDRPlayV3Input::stop()
{
qDebug() << "SDRPlayV3Input::stop";
QMutexLocker mutexLocker(&m_mutex);
if (!m_running) {
return;
}
qDebug() << "SDRPlayV3Input::stop";
m_running = false;
if(m_sdrPlayThread)
{
m_sdrPlayThread->stopWork();
delete m_sdrPlayThread;
m_sdrPlayThread = nullptr;
}
m_running = false;
}
QByteArray SDRPlayV3Input::serialize() const

2
plugins/samplesource/sdrplayv3/sdrplayv3input.h
View File

@ -158,7 +158,7 @@ public:
private:
DeviceAPI *m_deviceAPI;
QMutex m_mutex;
QRecursiveMutex m_mutex;
SDRPlayV3Settings m_settings;
sdrplay_api_DeviceT m_devs[SDRPLAY_MAX_DEVICES];
sdrplay_api_DeviceT* m_dev;

17
plugins/samplesource/sigmffileinput/sigmffileinput.cpp
View File

@ -61,6 +61,7 @@ MESSAGE_CLASS_DEFINITION(SigMFFileInput::MsgReportTotalSamplesCheck, Message)
SigMFFileInput::SigMFFileInput(DeviceAPI *deviceAPI) :
m_deviceAPI(deviceAPI),
m_running(false),
m_settings(),
m_trackMode(false),
m_currentTrackIndex(0),
@ -446,13 +447,18 @@ void SigMFFileInput::init()
bool SigMFFileInput::start()
{
QMutexLocker mutexLocker(&m_mutex);
if (m_running) {
return true;
}
if (!m_dataStream.is_open())
{
qWarning("SigMFFileInput::start: file not open. not starting");
return false;
}
QMutexLocker mutexLocker(&m_mutex);
qDebug() << "SigMFFileInput::start";
if (m_dataStream.tellg() != (std::streampos) 0) {
@ -472,6 +478,7 @@ bool SigMFFileInput::start()
m_fileInputWorker->setTrackIndex(0);
m_fileInputWorker->moveToThread(&m_fileInputWorkerThread);
m_deviceDescription = "SigMFFileInput";
m_running = true;
mutexLocker.unlock();
qDebug("SigMFFileInput::startInput: started");
@ -486,9 +493,15 @@ bool SigMFFileInput::start()
void SigMFFileInput::stop()
{
qDebug() << "SigMFFileInput::stop";
QMutexLocker mutexLocker(&m_mutex);
if (!m_running) {
return;
}
qDebug() << "SigMFFileInput::stop";
m_running = false;
if (m_fileInputWorker)
{
stopWorker();

1
plugins/samplesource/sigmffileinput/sigmffileinput.h
View File

@ -446,6 +446,7 @@ public:
private:
DeviceAPI *m_deviceAPI;
QMutex m_mutex;
bool m_running;
SigMFFileInputSettings m_settings;
std::ifstream m_metaStream;
std::ifstream m_dataStream;

9
plugins/samplesource/soapysdrinput/soapysdrinput.cpp
View File

@ -481,6 +481,11 @@ bool SoapySDRInput::start()
//
// Note: this is quite similar to the BladeRF2 start handling. The main difference is that the channel allocation (enabling) process is
// done in the thread object.
QMutexLocker mutexLocker(&m_mutex);
if (m_running) {
return true;
}
if (!m_openSuccess)
{
@ -595,11 +600,13 @@ void SoapySDRInput::stop()
//
// Note: this is quite similar to the BladeRF2 stop handling. The main difference is that the channel allocation (enabling) process is
// done in the thread object.
QMutexLocker mutexLocker(&m_mutex);
if (!m_running) {
return;
}
m_running = false;
int requestedChannel = m_deviceAPI->getDeviceItemIndex();
SoapySDRInputThread *soapySDRInputThread = findThread();
@ -688,8 +695,6 @@ void SoapySDRInput::stop()
qDebug("SoapySDRInput::stop: MI mode. Not changing MI configuration. Just remove FIFO reference");
soapySDRInputThread->setFifo(requestedChannel, nullptr); // remove FIFO
}
m_running = false;
}
QByteArray SoapySDRInput::serialize() const

7
plugins/samplesource/testsource/testsourceinput.cpp
View File

@ -119,11 +119,16 @@ bool TestSourceInput::start()
void TestSourceInput::stop()
{
QMutexLocker mutexLocker(&m_mutex);
if (!m_running) {
return;
}
m_running = false;
if (m_testSourceWorkerThread)
{
m_testSourceWorker->stopWork();
m_testSourceWorker->stopWork();
m_testSourceWorkerThread->quit();
m_testSourceWorkerThread->wait();
m_testSourceWorker = nullptr;

19
plugins/samplesource/usrpinput/usrpinput.cpp
View File

@ -414,14 +414,17 @@ void USRPInput::init()
bool USRPInput::start()
{
QMutexLocker mutexLocker(&m_mutex);
if (m_running) {
return true;
}
if (!m_deviceShared.m_deviceParams->getDevice()) {
return false;
}
if (m_running) { stop(); }
if (!acquireChannel())
{
if (!acquireChannel()) {
return false;
}
@ -441,7 +444,14 @@ bool USRPInput::start()
void USRPInput::stop()
{
QMutexLocker mutexLocker(&m_mutex);
if (!m_running) {
return;
}
qDebug("USRPInput::stop");
m_running = false;
if (m_usrpInputThread)
{
@ -451,7 +461,6 @@ void USRPInput::stop()
}
m_deviceShared.m_thread = 0;
m_running = false;
releaseChannel();
}

14
plugins/samplesource/xtrxinput/xtrxinput.cpp
View File

@ -275,6 +275,11 @@ bool XTRXInput::start()
//
// Eventually it registers the FIFO in the thread. If the thread has to be started it enables the channels up to the number of channels
// allocated in the thread and starts the thread.
QMutexLocker mutexLocker(&m_mutex);
if (m_running) {
return true;
}
if (!m_deviceShared.m_dev || !m_deviceShared.m_dev->getDevice())
{
@ -353,8 +358,6 @@ bool XTRXInput::start()
xtrxInputThread->setFifo(requestedChannel, &m_sampleFifo);
xtrxInputThread->setLog2Decimation(requestedChannel, m_settings.m_log2SoftDecim);
applySettings(m_settings, QList<QString>(), true);
if (needsStart)
{
qDebug("XTRXInput::start: (re)start thread");
@ -364,6 +367,9 @@ bool XTRXInput::start()
qDebug("XTRXInput::start: started");
m_running = true;
m_mutex.unlock();
applySettings(m_settings, QList<QString>(), true);
return true;
}
@ -377,11 +383,13 @@ void XTRXInput::stop()
// If the thread is currently managing both channels (MI mode) then we are removing one channel. Thus we must
// transition from MI to SI. This transition is handled by stopping the thread, deleting it and creating a new one
// managing a single channel.
QMutexLocker mutexLocker(&m_mutex);
if (!m_running) {
return;
}
m_running = false;
int removedChannel = m_deviceAPI->getDeviceItemIndex(); // channel to remove
int requestedChannel = removedChannel ^ 1; // channel to keep (opposite channel)
XTRXInputThread *xtrxInputThread = findThread();
@ -432,8 +440,6 @@ void XTRXInput::stop()
applySettings(m_settings, QList<QString>(), true);
xtrxInputThread->startWork();
}
m_running = false;
}
void XTRXInput::suspendTxThread()