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

plugins/samplesource/airspy/airspyinput.cpp

@@ -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;
 }

plugins/samplesource/airspy/airspyinput.h

@@ -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;

plugins/samplesource/airspyhf/airspyhfinput.cpp

@@ -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

plugins/samplesource/airspyhf/airspyhfinput.h

@@ -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;

plugins/samplesource/bladerf1input/bladerf1input.cpp

@@ -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

plugins/samplesource/bladerf1input/bladerf1input.h

@@ -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;

plugins/samplesource/bladerf2input/bladerf2input.cpp

@@ -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

plugins/samplesource/fcdpro/fcdproinput.cpp

@@ -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

plugins/samplesource/fcdproplus/fcdproplusinput.cpp

@@ -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

plugins/samplesource/hackrfinput/hackrfinput.cpp

@@ -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;

plugins/samplesource/hackrfinput/hackrfinput.h

@@ -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;

plugins/samplesource/limesdrinput/limesdrinput.cpp

@@ -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;

plugins/samplesource/limesdrinput/limesdrinput.h

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

plugins/samplesource/plutosdrinput/plutosdrinput.cpp

@@ -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

plugins/samplesource/sdrplay/sdrplayinput.cpp

@@ -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

plugins/samplesource/sdrplay/sdrplayinput.h

@@ -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;

plugins/samplesource/sdrplayv3/sdrplayv3input.cpp

@@ -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

plugins/samplesource/sdrplayv3/sdrplayv3input.h

@@ -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;

plugins/samplesource/sigmffileinput/sigmffileinput.cpp

@@ -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();

plugins/samplesource/sigmffileinput/sigmffileinput.h

@@ -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;

plugins/samplesource/soapysdrinput/soapysdrinput.cpp

@@ -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

plugins/samplesource/testsource/testsourceinput.cpp

@@ -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;

plugins/samplesource/usrpinput/usrpinput.cpp

@@ -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();
 }

plugins/samplesource/xtrxinput/xtrxinput.cpp

@@ -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()