Diff: MyAcousticEffector_MIC/ReverbUnit.hpp

Revision:

5:7de034938856

Parent:

0:f064b50f238e

Child:

10:56f2f01df983

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/MyAcousticEffector_MIC/ReverbUnit.hpp	Mon Aug 15 06:53:47 2016 +0000
@@ -0,0 +1,106 @@
+//--------------------------------------------------------------
+// Reverb unit
+//  2016/04/12, Copyright (c) 2016 MIKAMI, Naoki
+//--------------------------------------------------------------
+
+#ifndef REVERB_UNIT_HPP
+#define REVERB_UNIT_HPP
+
+#include "mbed.h"
+
+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
+    {
+    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;
+         }
+
+        // Execute comb filter with variable delay
+        float Execute(float x, int n)
+        {
+            float yn = Reverb::Get(n);
+            Reverb::Set(x + G0_*yn);
+            return yn;
+         }
+
+    private:
+        const float G0_;
+    };
+
+    // Reverb unit using allpass filter
+    class AllPassFilter : public Reverb
+    {
+    public:
+        // Constructor
+        AllPassFilter(float g, int delay)
+            : Reverb(delay), G0_(g) {}
+
+        // Execute allpass filter 
+        virtual float Execute(float x)
+        {
+            float un = x + G0_*Reverb::Get();
+            float yn = -G0_*un + Reverb::Get();
+            Reverb::Set(un);
+            return yn;
+        }
+    private:
+        const float G0_;
+    };
+}
+#endif  // REVERB_UNIT_HPP