Diff: MyAcousticEffector_MIC/ReverbUnit.hpp

Revision:

10:56f2f01df983

Parent:

5:7de034938856

--- a/MyAcousticEffector_MIC/ReverbUnit.hpp	Fri Mar 17 01:26:25 2017 +0000
+++ b/MyAcousticEffector_MIC/ReverbUnit.hpp	Mon Apr 10 13:44:13 2017 +0000
@@ -1,106 +1,62 @@
 //--------------------------------------------------------------
-// Reverb unit
-//  2016/04/12, Copyright (c) 2016 MIKAMI, Naoki
+// Reverb unit: comb filter and all-pass filter
+//  2017/04/08, Copyright (c) 2017 MIKAMI, Naoki
 //--------------------------------------------------------------
 
 #ifndef REVERB_UNIT_HPP
 #define REVERB_UNIT_HPP
 
-#include "mbed.h"
+#include "ReverbUnitBase.hpp"
 
 namespace Mikami
 {
-    // Base class for reverb unit
-    class Reverb
-    {
-    public:
-        // Constructor
-        Reverb(int delay) : ptr_(0), delay_(delay)
-        {
-            un_ = new float[delay];
-            Clear();
-        }
-        
-        ~Reverb()
-        {   delete[] un_; }
-
-        // Execute of filter (pure virtual function)
-        virtual float Execute(float x) = 0;
-
-        // Clear internal delay elements
-        void Clear()
-        {   for (int n=0; n<delay_; n++) un_[n] = 0; }
-
-    protected:
-        float Get() { return un_[ptr_]; }
-        
-        float Get(int n)
-        {
-            int k = ptr_ + n;
-            if (k > delay_) k -= delay_;
-            if (k < 0) k += delay_;
-            return un_[k];
-        }        
-
-        void Set(float x)
-        {
-            un_[ptr_] = x;   
-            if (++ptr_ >=  delay_) ptr_ = 0;
-        }
-    private:
-        int ptr_;
-        int delay_;
-        float *un_;    // for delay
-        Reverb(const Reverb&);
-        Reverb& operator=(const Reverb&);
-    };
-
     // Reverb unit using comb filter
-    class CombFilter : public Reverb
+    class CombFilter : public ReverbBase
     {
     public:
         // Constructor
         CombFilter(float g, int delay)
-            : Reverb(delay), G0_(g) {}
-
-        // Execute comb filter 
-        virtual float Execute(float x)
-        {
-            float yn = Reverb::Get();
-            Reverb::Set(x + G0_*yn);
-            return yn;
-         }
+            : ReverbBase(delay), G_C_(g) {}
 
         // Execute comb filter with variable delay
         float Execute(float x, int n)
         {
-            float yn = Reverb::Get(n);
-            Reverb::Set(x + G0_*yn);
+            float yn = Get(n);
+            Set(x + G_C_*yn);
             return yn;
          }
 
     private:
-        const float G0_;
+        const float G_C_;
+
+        // disallow copy constructor and assignment operator
+        CombFilter(const CombFilter&);
+        CombFilter& operator=(const CombFilter&);
     };
 
     // Reverb unit using allpass filter
-    class AllPassFilter : public Reverb
+    class AllPassFilter : public ReverbBase
     {
     public:
         // Constructor
         AllPassFilter(float g, int delay)
-            : Reverb(delay), G0_(g) {}
+            : ReverbBase(delay), G_A_(g) {}
 
         // Execute allpass filter 
-        virtual float Execute(float x)
+        float Execute(float x)
         {
-            float un = x + G0_*Reverb::Get();
-            float yn = -G0_*un + Reverb::Get();
-            Reverb::Set(un);
+            float un = x + G_A_*Get();
+            float yn = -G_A_*un + Get();
+            Set(un);
             return yn;
         }
+
     private:
-        const float G0_;
+        const float G_A_;
+
+        // disallow copy constructor and assignment operator
+        AllPassFilter(const AllPassFilter&);
+        AllPassFilter& operator=(const AllPassFilter&);
     };
 }
 #endif  // REVERB_UNIT_HPP