[AFV} Ref T730, fixed CPPCheck issues and Artistic style applied

src/blacksound/dsp/SimpleComp.cpp

@@ -36,23 +36,24 @@ namespace chunkware_simple
     // simple compressor
     //-------------------------------------------------------------
     SimpleComp::SimpleComp()
-		: AttRelEnvelope( 10.0, 100.0 )
+        : AttRelEnvelope(10.0, 100.0)
-		, threshdB_( 0.0 )
+        , threshdB_(0.0)
-		, ratio_( 1.0 )
+        , ratio_(1.0)
-		, envdB_( DC_OFFSET )
+        , envdB_(DC_OFFSET)
+        , makeUpGain_(1.0)
     {
     }
 
     //-------------------------------------------------------------
-	void SimpleComp::setThresh( double dB )
+    void SimpleComp::setThresh(double dB)
     {
         threshdB_ = dB;
     }
 
     //-------------------------------------------------------------
-	void SimpleComp::setRatio( double ratio )
+    void SimpleComp::setRatio(double ratio)
     {
-		assert( ratio > 0.0 );
+        assert(ratio > 0.0);
         ratio_ = ratio;
     }
 
@@ -63,7 +64,7 @@ namespace chunkware_simple
     }
 
     //-------------------------------------------------------------
-	void SimpleComp::initRuntime( void )
+    void SimpleComp::initRuntime(void)
     {
         envdB_ = DC_OFFSET;
     }
@@ -72,26 +73,26 @@ namespace chunkware_simple
     // simple compressor with RMS detection
     //-------------------------------------------------------------
     SimpleCompRms::SimpleCompRms()
-		: ave_( 5.0 )
+        : ave_(5.0)
-		, aveOfSqrs_( DC_OFFSET )
+        , aveOfSqrs_(DC_OFFSET)
     {
     }
 
     //-------------------------------------------------------------
-	void SimpleCompRms::setSampleRate( double sampleRate )
+    void SimpleCompRms::setSampleRate(double sampleRate)
     {
-		SimpleComp::setSampleRate( sampleRate );
+        SimpleComp::setSampleRate(sampleRate);
-		ave_.setSampleRate( sampleRate );
+        ave_.setSampleRate(sampleRate);
     }
 
     //-------------------------------------------------------------
-	void SimpleCompRms::setWindow( double ms )
+    void SimpleCompRms::setWindow(double ms)
     {
-		ave_.setTc( ms );
+        ave_.setTc(ms);
     }
 
     //-------------------------------------------------------------
-	void SimpleCompRms::initRuntime( void )
+    void SimpleCompRms::initRuntime(void)
     {
         SimpleComp::initRuntime();
         aveOfSqrs_ = DC_OFFSET;

src/blacksound/dsp/SimpleComp.h

@@ -75,7 +75,7 @@ namespace chunkware_simple
         // runtime variables
         double envdB_;          // over-threshold envelope (dB)
 
-        double makeUpGain_;
+        double makeUpGain_ = 1.0;
 
     };  // end SimpleComp class
 
@@ -86,7 +86,7 @@ namespace chunkware_simple
     {
     public:
         SimpleCompRms();
-        virtual ~SimpleCompRms() {}
+        virtual ~SimpleCompRms() override {}
 
         // sample rate
         virtual void setSampleRate(double sampleRate) override;

src/blacksound/dsp/SimpleEnvelope.cpp

@@ -27,7 +27,6 @@
  *  DEALINGS IN THE SOFTWARE.
  */
 
-
 #include "SimpleEnvelope.h"
 
 namespace chunkware_simple
@@ -35,63 +34,66 @@ namespace chunkware_simple
     //-------------------------------------------------------------
     // envelope detector
     //-------------------------------------------------------------
-	EnvelopeDetector::EnvelopeDetector( double ms, double sampleRate )
+    EnvelopeDetector::EnvelopeDetector(double ms, double sampleRate)
     {
-		assert( sampleRate > 0.0 );
+        assert(sampleRate > 0.0);
-		assert( ms > 0.0 );
+        assert(ms > 0.0);
         sampleRate_ = sampleRate;
         ms_ = ms;
+
+        // setCoef();
+        // TODO: KB avoid virtual function call in ctor
+        coef_ = exp(-1000.0 / (ms_ * sampleRate_));
+    }
+
+    //-------------------------------------------------------------
+    void EnvelopeDetector::setTc(double ms)
+    {
+        assert(ms > 0.0);
+        ms_ = ms;
         setCoef();
     }
 
     //-------------------------------------------------------------
-	void EnvelopeDetector::setTc( double ms )
+    void EnvelopeDetector::setSampleRate(double sampleRate)
     {
-		assert( ms > 0.0 );
+        assert(sampleRate > 0.0);
-		ms_ = ms;
-		setCoef();
-	}
-
-	//-------------------------------------------------------------
-	void EnvelopeDetector::setSampleRate( double sampleRate )
-	{
-		assert( sampleRate > 0.0 );
         sampleRate_ = sampleRate;
         setCoef();
     }
 
     //-------------------------------------------------------------
-	void EnvelopeDetector::setCoef( void )
+    void EnvelopeDetector::setCoef(void)
     {
-		coef_ = exp( -1000.0 / ( ms_ * sampleRate_ ) );
+        coef_ = exp(-1000.0 / (ms_ * sampleRate_));
     }
 
     //-------------------------------------------------------------
     // attack/release envelope
     //-------------------------------------------------------------
-	AttRelEnvelope::AttRelEnvelope( double att_ms, double rel_ms, double sampleRate )
+    AttRelEnvelope::AttRelEnvelope(double att_ms, double rel_ms, double sampleRate)
-		: att_( att_ms, sampleRate )
+        : att_(att_ms, sampleRate)
-		, rel_( rel_ms, sampleRate )
+        , rel_(rel_ms, sampleRate)
     {
     }
 
     //-------------------------------------------------------------
-	void AttRelEnvelope::setAttack( double ms )
+    void AttRelEnvelope::setAttack(double ms)
     {
-		att_.setTc( ms );
+        att_.setTc(ms);
     }
 
     //-------------------------------------------------------------
-	void AttRelEnvelope::setRelease( double ms )
+    void AttRelEnvelope::setRelease(double ms)
     {
-		rel_.setTc( ms );
+        rel_.setTc(ms);
     }
 
     //-------------------------------------------------------------
-	void AttRelEnvelope::setSampleRate( double sampleRate )
+    void AttRelEnvelope::setSampleRate(double sampleRate)
     {
-		att_.setSampleRate( sampleRate );
+        att_.setSampleRate(sampleRate);
-		rel_.setSampleRate( sampleRate );
+        rel_.setSampleRate(sampleRate);
     }
 
 }   // end namespace chunkware_simple

src/blacksound/dsp/SimpleLimit.cpp

@@ -34,69 +34,69 @@ namespace chunkware_simple
 {
     //-------------------------------------------------------------
     SimpleLimit::SimpleLimit()
-		: threshdB_( 0.0 )
+        : threshdB_(0.0)
-		, thresh_( 1.0 )
+        , thresh_(1.0)
-		, peakHold_( 0 )
+        , peakHold_(0)
-		, peakTimer_( 0 )
+        , peakTimer_(0)
-		, maxPeak_( 1.0 )
+        , maxPeak_(1.0)
-		, att_( 1.0 )
+        , att_(1.0)
-		, rel_( 10.0 )
+        , rel_(10.0)
-		, env_( 1.0 )
+        , env_(1.0)
-		, mask_( BUFFER_SIZE - 1 )
+        , mask_(BUFFER_SIZE - 1)
-		, cur_( 0 )
+        , cur_(0)
     {
-		setAttack( 1.0 );
+        setAttack(1.0);
-		outBuffer_[ 0 ].resize( BUFFER_SIZE, 0.0 );
+        outBuffer_[ 0 ].resize(BUFFER_SIZE, 0.0);
-		outBuffer_[ 1 ].resize( BUFFER_SIZE, 0.0 );
+        outBuffer_[ 1 ].resize(BUFFER_SIZE, 0.0);
     }
 
     //-------------------------------------------------------------
-	void SimpleLimit::setThresh( double dB )
+    void SimpleLimit::setThresh(double dB)
     {
         threshdB_ = dB;
-		thresh_ = dB2lin( dB );
+        thresh_ = dB2lin(dB);
     }
 
     //-------------------------------------------------------------
-	void SimpleLimit::setAttack( double ms )
+    void SimpleLimit::setAttack(double ms)
     {
-		unsigned int samp = int( 0.001 * ms * att_.getSampleRate() );
+        unsigned int samp = static_cast<unsigned>(0.001 * ms * att_.getSampleRate());
 
-		assert( samp < BUFFER_SIZE );
+        assert(samp < BUFFER_SIZE);
 
         peakHold_ = samp;
-		att_.setTc( ms );
+        att_.setTc(ms);
     }
 
     //-------------------------------------------------------------
-	void SimpleLimit::setRelease( double ms )
+    void SimpleLimit::setRelease(double ms)
     {
-		rel_.setTc( ms );
+        rel_.setTc(ms);
     }
 
     //-------------------------------------------------------------
-	void SimpleLimit::setSampleRate( double sampleRate )
+    void SimpleLimit::setSampleRate(double sampleRate)
     {
-		att_.setSampleRate( sampleRate );
+        att_.setSampleRate(sampleRate);
-		rel_.setSampleRate( sampleRate );
+        rel_.setSampleRate(sampleRate);
     }
 
     //-------------------------------------------------------------
-	void SimpleLimit::initRuntime( void )
+    void SimpleLimit::initRuntime(void)
     {
         peakTimer_ = 0;
         maxPeak_ = thresh_;
         env_ = thresh_;
         cur_ = 0;
-		outBuffer_[ 0 ].assign( BUFFER_SIZE, 0.0 );
+        outBuffer_[ 0 ].assign(BUFFER_SIZE, 0.0);
-		outBuffer_[ 1 ].assign( BUFFER_SIZE, 0.0 );
+        outBuffer_[ 1 ].assign(BUFFER_SIZE, 0.0);
     }
 
     //-------------------------------------------------------------
-	void SimpleLimit::FastEnvelope::setCoef( void )
+    void SimpleLimit::FastEnvelope::setCoef(void)
     {
         // rises to 99% of in value over duration of time constant
-		coef_ = pow( 0.01, (1000.0 / (ms_ * sampleRate_) ) );
+        coef_ = pow(0.01, (1000.0 / (ms_ * sampleRate_)));
     }
 
 }   // end namespace chunkware_simple