Replace mutex lock/unlock pairs with guards, cleanups

src/process/SpectrumVisualProcessor.cpp

@@ -54,24 +54,27 @@ bool SpectrumVisualProcessor::isView() {
 }
 
 void SpectrumVisualProcessor::setView(bool bView) {
-    busy_run.lock();
+    
+    std::lock_guard < std::mutex > busy_lock(busy_run);    
     is_view.store(bView);
-    busy_run.unlock();
+    
 }
 
 void SpectrumVisualProcessor::setView(bool bView, long long centerFreq_in, long bandwidth_in) {
-    busy_run.lock();
+    
+    std::lock_guard < std::mutex > busy_lock(busy_run);    
     is_view.store(bView);
     bandwidth.store(bandwidth_in);
     centerFreq.store(centerFreq_in);
-    busy_run.unlock();
+   
 }
 
 
 void SpectrumVisualProcessor::setFFTAverageRate(float fftAverageRate) {
-    busy_run.lock();
+   
+    std::lock_guard < std::mutex > busy_lock(busy_run);    
     this->fft_average_rate.store(fftAverageRate);
-    busy_run.unlock();
+    
 }
 
 float SpectrumVisualProcessor::getFFTAverageRate() {
@@ -79,9 +82,10 @@ float SpectrumVisualProcessor::getFFTAverageRate() {
 }
 
 void SpectrumVisualProcessor::setCenterFrequency(long long centerFreq_in) {
-    busy_run.lock();
+   
+    std::lock_guard < std::mutex > busy_lock(busy_run);    
     centerFreq.store(centerFreq_in);
-    busy_run.unlock();
+   
 }
 
 long long SpectrumVisualProcessor::getCenterFrequency() {
@@ -89,9 +93,10 @@ long long SpectrumVisualProcessor::getCenterFrequency() {
 }
 
 void SpectrumVisualProcessor::setBandwidth(long bandwidth_in) {
-    busy_run.lock();
+   
+    std::lock_guard < std::mutex > busy_lock(busy_run);    
     bandwidth.store(bandwidth_in);
-    busy_run.unlock();
+   
 }
 
 long SpectrumVisualProcessor::getBandwidth() {
@@ -99,6 +104,7 @@ long SpectrumVisualProcessor::getBandwidth() {
 }
 
 void SpectrumVisualProcessor::setPeakHold(bool peakHold_in) {
+   
     if (peakHold.load() && peakHold_in) {
         peakReset.store(PEAK_RESET_COUNT);
     } else {
@@ -116,7 +122,8 @@ int SpectrumVisualProcessor::getDesiredInputSize() {
 }
 
 void SpectrumVisualProcessor::setup(unsigned int fftSize_in) {
-    busy_run.lock();
+
+    std::lock_guard < std::mutex > busy_lock(busy_run);    
 
     fftSize = fftSize_in;
     fftSizeInternal = fftSize_in * SPECTRUM_VZM;
@@ -190,7 +197,6 @@ void SpectrumVisualProcessor::setup(unsigned int fftSize_in) {
     fftPlan = fft_create_plan(fftSizeInternal, fftInput, fftOutput, LIQUID_FFT_FORWARD, 0);
 #endif
     
-    busy_run.unlock();
 }
 
 void SpectrumVisualProcessor::setFFTSize(unsigned int fftSize_in) {
@@ -234,9 +240,16 @@ void SpectrumVisualProcessor::process() {
     if (!iqData) {
         return;
     }
-    
-    iqData->busy_rw.lock();
-    busy_run.lock();
+
+   
+    //Start by locking concurrent access to iqData
+    std::lock_guard < std::recursive_mutex > lock(iqData->getMonitor());
+
+    //then get the busy_lock
+    std::lock_guard < std::mutex > busy_lock(busy_run);    
+
+
+   
     bool doPeak = peakHold.load() && (peakReset.load() == 0);
     
     if (fft_result.size() != fftSizeInternal) {
@@ -275,8 +288,7 @@ void SpectrumVisualProcessor::process() {
         if (is_view.load()) {
             if (!iqData->frequency || !iqData->sampleRate) {
                 iqData->decRefCount();
-                iqData->busy_rw.unlock();
-                busy_run.unlock();
+               
                 return;
             }
             
@@ -706,8 +718,7 @@ void SpectrumVisualProcessor::process() {
     }
  
     iqData->decRefCount();
-    iqData->busy_rw.unlock();
-    busy_run.unlock();
+   
     
     lastView = is_view.load();
 }

src/process/SpectrumVisualProcessor.h

@@ -97,6 +97,7 @@ private:
     std::vector<liquid_float_complex> shiftBuffer;
     std::vector<liquid_float_complex> resampleBuffer;
     std::atomic_int desiredInputSize;
+   
     std::mutex busy_run;
     std::atomic_bool hideDC, peakHold;
     std::atomic_int peakReset;

src/process/VisualProcessor.h

@@ -13,10 +13,14 @@ public:
 	}
     
     bool isInputEmpty() {
+        std::lock_guard < std::recursive_mutex > busy_lock(busy_update);
+
         return input->empty();
     }
     
     bool isOutputEmpty() {
+        std::lock_guard < std::recursive_mutex > busy_lock(busy_update);
+
         for (outputs_i = outputs.begin(); outputs_i != outputs.end(); outputs_i++) {
             if ((*outputs_i)->full()) {
                 return false;
@@ -26,6 +30,8 @@ public:
     }
     
     bool isAnyOutputEmpty() {
+        std::lock_guard < std::recursive_mutex > busy_lock(busy_update);
+
         for (outputs_i = outputs.begin(); outputs_i != outputs.end(); outputs_i++) {
             if (!(*outputs_i)->full()) {
                 return true;
@@ -35,34 +41,37 @@ public:
     }
 
     void setInput(ThreadQueue<InputDataType *> *vis_in) {
-        busy_update.lock();
+        std::lock_guard < std::recursive_mutex > busy_lock(busy_update);
         input = vis_in;
-        busy_update.unlock();
+        
     }
     
     void attachOutput(ThreadQueue<OutputDataType *> *vis_out) {
         // attach an output queue
-        busy_update.lock();
+        std::lock_guard < std::recursive_mutex > busy_lock(busy_update);
         outputs.push_back(vis_out);
-        busy_update.unlock();
+       
     }
     
     void removeOutput(ThreadQueue<OutputDataType *> *vis_out) {
         // remove an output queue
-        busy_update.lock();
+        std::lock_guard < std::recursive_mutex > busy_lock(busy_update);
+
         typename std::vector<ThreadQueue<OutputDataType *> *>::iterator i = std::find(outputs.begin(), outputs.end(), vis_out);
         if (i != outputs.end()) {
             outputs.erase(i);
         }
-        busy_update.unlock();
+      
     }
     
     void run() {
-        busy_update.lock();
+        
+        std::lock_guard < std::recursive_mutex > busy_lock(busy_update);
+
         if (input && !input->empty()) {
             process();
         }
-        busy_update.unlock();
+       
     }
     
 protected:
@@ -73,6 +82,8 @@ protected:
 
     void distribute(OutputDataType *output) {
         // distribute outputs
+        std::lock_guard < std::recursive_mutex > busy_lock(busy_update);
+
         output->setRefCount(outputs.size());
         for (outputs_i = outputs.begin(); outputs_i != outputs.end(); outputs_i++) {
         	if ((*outputs_i)->full()) {
@@ -86,7 +97,9 @@ protected:
     ThreadQueue<InputDataType *> *input;
     std::vector<ThreadQueue<OutputDataType *> *> outputs;
 	typename std::vector<ThreadQueue<OutputDataType *> *>::iterator outputs_i;
-    std::mutex busy_update;
+
+    //protects input and outputs, must be recursive because ao reentrance
+    std::recursive_mutex busy_update;
 };