diff --git a/src/process/SpectrumVisualProcessor.cpp b/src/process/SpectrumVisualProcessor.cpp
index 75d4887b..74b4a263 100644
--- a/src/process/SpectrumVisualProcessor.cpp
+++ b/src/process/SpectrumVisualProcessor.cpp
@@ -49,21 +49,21 @@ SpectrumVisualProcessor::~SpectrumVisualProcessor() {
 
 bool SpectrumVisualProcessor::isView() {
 	
-	std::lock_guard < SpinMutex > busy_lock(busy_run);
+	std::lock_guard < std::mutex > busy_lock(busy_run);
     
 	return is_view;
 }
 
 void SpectrumVisualProcessor::setView(bool bView) {
 	
-	std::lock_guard < SpinMutex > busy_lock(busy_run);
+	std::lock_guard < std::mutex > busy_lock(busy_run);
 
     is_view = bView;  
 }
 
 void SpectrumVisualProcessor::setView(bool bView, long long centerFreq_in, long bandwidth_in) {
     
-    std::lock_guard < SpinMutex > busy_lock(busy_run);
+    std::lock_guard < std::mutex > busy_lock(busy_run);    
     is_view = bView;
     bandwidth = bandwidth_in;
     centerFreq = centerFreq_in; 
@@ -72,49 +72,49 @@ void SpectrumVisualProcessor::setView(bool bView, long long centerFreq_in, long
 
 void SpectrumVisualProcessor::setFFTAverageRate(float fftAverageRate) {
    
-    std::lock_guard < SpinMutex > busy_lock(busy_run);
+    std::lock_guard < std::mutex > busy_lock(busy_run);    
 
     this->fft_average_rate = fftAverageRate;    
 }
 
 float SpectrumVisualProcessor::getFFTAverageRate() {
 
-	std::lock_guard < SpinMutex > busy_lock(busy_run);
+	std::lock_guard < std::mutex > busy_lock(busy_run);
 
     return this->fft_average_rate;
 }
 
 void SpectrumVisualProcessor::setCenterFrequency(long long centerFreq_in) {
    
-    std::lock_guard < SpinMutex > busy_lock(busy_run);
+    std::lock_guard < std::mutex > busy_lock(busy_run);  
 
     centerFreq = centerFreq_in;  
 }
 
 long long SpectrumVisualProcessor::getCenterFrequency() {
 	
-	std::lock_guard < SpinMutex > busy_lock(busy_run);
+	std::lock_guard < std::mutex > busy_lock(busy_run);
 
     return centerFreq;
 }
 
 void SpectrumVisualProcessor::setBandwidth(long bandwidth_in) {
    
-    std::lock_guard < SpinMutex > busy_lock(busy_run);
+    std::lock_guard < std::mutex > busy_lock(busy_run);    
 
 	bandwidth = bandwidth_in;
 }
 
 long SpectrumVisualProcessor::getBandwidth() {
 
-	std::lock_guard < SpinMutex > busy_lock(busy_run);
+	std::lock_guard < std::mutex > busy_lock(busy_run);
 
     return bandwidth;
 }
 
 void SpectrumVisualProcessor::setPeakHold(bool peakHold_in) {
 	
-	std::lock_guard < SpinMutex > busy_lock(busy_run);
+	std::lock_guard < std::mutex > busy_lock(busy_run);
 
     if (peakHold && peakHold_in) {
         peakReset = PEAK_RESET_COUNT;
@@ -126,20 +126,20 @@ void SpectrumVisualProcessor::setPeakHold(bool peakHold_in) {
 
 bool SpectrumVisualProcessor::getPeakHold() {
 
-	std::lock_guard < SpinMutex > busy_lock(busy_run);
+	std::lock_guard < std::mutex > busy_lock(busy_run);
 
     return peakHold;
 }
 
 int SpectrumVisualProcessor::getDesiredInputSize() {
-	std::lock_guard < SpinMutex > busy_lock(busy_run);
+	std::lock_guard < std::mutex > busy_lock(busy_run);
 
     return desiredInputSize;
 }
 
 void SpectrumVisualProcessor::setup(unsigned int fftSize_in) {
 
-    std::lock_guard < SpinMutex > busy_lock(busy_run);
+    std::lock_guard < std::mutex > busy_lock(busy_run);    
 
     fftSize = fftSize_in;
     fftSizeInternal = fftSize_in * SPECTRUM_VZM;
@@ -180,7 +180,7 @@ void SpectrumVisualProcessor::setup(unsigned int fftSize_in) {
 void SpectrumVisualProcessor::setFFTSize(unsigned int fftSize_in) {
 
 	//then get the busy_lock
-	std::lock_guard < SpinMutex > busy_lock(busy_run);
+	std::lock_guard < std::mutex > busy_lock(busy_run);
 
     if (fftSize_in == fftSize) {
         return;
@@ -192,7 +192,7 @@ void SpectrumVisualProcessor::setFFTSize(unsigned int fftSize_in) {
 unsigned int SpectrumVisualProcessor::getFFTSize() {
 
 	//then get the busy_lock
-	std::lock_guard < SpinMutex > busy_lock(busy_run);
+	std::lock_guard < std::mutex > busy_lock(busy_run);
 
     if (fftSizeChanged) {
         return newFFTSize;
@@ -203,7 +203,7 @@ unsigned int SpectrumVisualProcessor::getFFTSize() {
 
 void SpectrumVisualProcessor::setHideDC(bool hideDC) {
 
-	std::lock_guard < SpinMutex > busy_lock(busy_run);
+	std::lock_guard < std::mutex > busy_lock(busy_run);
 
     this->hideDC = hideDC;
 }
@@ -220,7 +220,7 @@ void SpectrumVisualProcessor::process() {
 	bool executeSetup = false;
 
 	{ // scoped lock here
-		std::lock_guard < SpinMutex > busy_lock(busy_run);
+		std::lock_guard < std::mutex > busy_lock(busy_run);
 		if (fftSizeChanged) {
 			executeSetup = true;
 			fftSizeChanged = false;
@@ -242,7 +242,7 @@ void SpectrumVisualProcessor::process() {
     }
 
     //then get the busy_lock for the rest of the processing.
-    std::lock_guard < SpinMutex > busy_lock(busy_run);
+    std::lock_guard < std::mutex > busy_lock(busy_run);    
    
     bool doPeak = peakHold && (peakReset == 0);
     
@@ -638,14 +638,14 @@ void SpectrumVisualProcessor::process() {
 
 
 void SpectrumVisualProcessor::setScaleFactor(float sf) {
-	std::lock_guard < SpinMutex > busy_lock(busy_run);
+	std::lock_guard < std::mutex > busy_lock(busy_run);
 
     scaleFactor = sf;
 }
 
 
 float SpectrumVisualProcessor::getScaleFactor() {
-	std::lock_guard < SpinMutex > busy_lock(busy_run);
+	std::lock_guard < std::mutex > busy_lock(busy_run);
     return scaleFactor;
 }
 
diff --git a/src/process/SpectrumVisualProcessor.h b/src/process/SpectrumVisualProcessor.h
index c364e24e..f40069c2 100644
--- a/src/process/SpectrumVisualProcessor.h
+++ b/src/process/SpectrumVisualProcessor.h
@@ -7,7 +7,6 @@
 #include "DemodDefs.h"
 #include <cmath>
 #include <memory>
-#include "SpinMutex.h"
 
 #define SPECTRUM_VZM 2
 #define PEAK_RESET_COUNT 30
@@ -66,7 +65,7 @@ class SpectrumVisualProcessor : public VisualProcessor<DemodulatorThreadIQData,
     
 private:
 	//protects all access to fields below
-	SpinMutex busy_run;
+	std::mutex busy_run;
 
 	bool is_view;
 	size_t fftSize, newFFTSize;
diff --git a/src/process/VisualProcessor.h b/src/process/VisualProcessor.h
index f7a063e9..904ca8b9 100644
--- a/src/process/VisualProcessor.h
+++ b/src/process/VisualProcessor.h
@@ -9,7 +9,6 @@
 #include <algorithm>
 #include <vector>
 #include <typeinfo>
-#include "SpinMutex.h"
 
 template<typename InputDataType, typename OutputDataType>
 class VisualProcessor {
@@ -29,7 +28,7 @@ class VisualProcessor {
 	}
     
     bool isInputEmpty() {
-        std::lock_guard < SpinMutex > busy_lock(busy_update);
+        std::lock_guard < std::mutex > busy_lock(busy_update);
 		
 		if (input) {
 			return input->empty();
@@ -39,7 +38,7 @@ class VisualProcessor {
     }
     
     bool isOutputEmpty() {
-        std::lock_guard < SpinMutex > busy_lock(busy_update);
+        std::lock_guard < std::mutex > busy_lock(busy_update);
 
         for (VisualOutputQueueTypePtr single_output :  outputs) {
             if (single_output->full()) {
@@ -50,7 +49,7 @@ class VisualProcessor {
     }
     
     bool isAnyOutputEmpty() {
-        std::lock_guard < SpinMutex > busy_lock(busy_update);
+        std::lock_guard < std::mutex > busy_lock(busy_update);
 
         for (VisualOutputQueueTypePtr single_output : outputs) {
             if (!(single_output)->full()) {
@@ -62,7 +61,7 @@ class VisualProcessor {
 
     //Set a (new) 'input' queue for incoming data.
     void setInput(VisualInputQueueTypePtr vis_in) {
-        std::lock_guard < SpinMutex > busy_lock(busy_update);
+        std::lock_guard < std::mutex > busy_lock(busy_update);
         input = vis_in;
         
     }
@@ -71,14 +70,14 @@ class VisualProcessor {
     //dispatched by distribute(). 
     void attachOutput(VisualOutputQueueTypePtr vis_out) {
         // attach an output queue
-        std::lock_guard < SpinMutex > busy_lock(busy_update);
+        std::lock_guard < std::mutex > busy_lock(busy_update);
         outputs.push_back(vis_out);
     }
     
     //reverse of attachOutput(), removed an existing attached vis_out.
     void removeOutput(VisualOutputQueueTypePtr vis_out) {
         // remove an output queue
-        std::lock_guard < SpinMutex > busy_lock(busy_update);
+        std::lock_guard < std::mutex > busy_lock(busy_update);
 
         auto it = std::find(outputs.begin(), outputs.end(), vis_out);
         if (it != outputs.end()) {
@@ -99,7 +98,7 @@ class VisualProcessor {
 		//scoped-lock: create a local copy of outputs, and work with it.
 		std::vector<VisualOutputQueueTypePtr> local_outputs;
 		{
-			std::lock_guard < SpinMutex > busy_lock(busy_update);
+			std::lock_guard < std::mutex > busy_lock(busy_update);
 			local_outputs = outputs;
 		}
 
@@ -133,17 +132,11 @@ class VisualProcessor {
     //* \param[in] errorMessage an error message written on std::cout in case pf push timeout.
     void distribute(OutputDataTypePtr item, std::uint64_t timeout = BLOCKING_INFINITE_TIMEOUT, const char* errorMessage = nullptr) {
       
-        //scoped-lock: create a local copy of outputs, and work with it.
-        std::vector<VisualOutputQueueTypePtr> local_outputs;
-        {
-            std::lock_guard < SpinMutex > busy_lock(busy_update);
-            local_outputs = outputs;
-        }
+        std::lock_guard < std::mutex > busy_lock(busy_update);
+        //We will try to distribute 'output' among all 'outputs',
+        //so 'output' will a-priori be shared among all 'outputs'.
 
-        //We will try to distribute 'output' among all 'local_outputs',
-        //so 'output' will a-priori be shared among all 'local_outputs'.
-        
-        for (VisualOutputQueueTypePtr single_output : local_outputs) {
+        for (VisualOutputQueueTypePtr single_output : outputs) {
             //'output' can fail to be given to an single_output,
             //using a blocking push, with a timeout
         	if (!(single_output)->push(item, timeout, errorMessage)) {
@@ -159,7 +152,7 @@ class VisualProcessor {
     std::vector<VisualOutputQueueTypePtr> outputs;
 
     //protects input and outputs
-    SpinMutex busy_update;
+    std::mutex busy_update;
 };
 
 //Specialization much like VisualDataReDistributor, except