Merge pull request #345 from andysheen/dev

Delay is now accessible through AudioParameters

Author: pschatzmann

src/AudioEffects/AudioEffect.h

@@ -282,51 +282,64 @@ class Tremolo : public AudioEffect  {
 class Delay : public AudioEffect  {
     public:
         /// e.g. depthPercent=50, ms=1000, sampleRate=44100
-        Delay(uint16_t duration_ms=1000, float depthPercent=50, float feedbackAmount=0.3, uint32_t sampleRate=44100) {
-            this->sampleRate = sampleRate;
-            p_feedback = feedbackAmount;
-            p_percent = depthPercent;
-            p_ms = duration_ms;
+        Delay(uint16_t duration_ms=1000, float depthPercent=0.3, float feedbackAmount=0.3, uint32_t sampleRate=44100) {
+          delayLine = new DelayLine(duration_ms,depthPercent,feedbackAmount,sampleRate);
         }
 
-        Delay(const Delay &copy) = default;
+        Delay(const Delay &ref) {
+            delayLine = new DelayLine(*(ref.delayLine));
+            copyParent((AudioEffect *)&ref);
+        };
 
-        void setDuration(int16_t ms){
-            p_ms = ms;
+        virtual ~Delay(){
+            delete delayLine;
         }
 
-        int16_t duration(){
-            return p_ms;
+        void setDuration(int16_t m){
+          delayLine->setDuration(m);
         }
 
-        void setDepth(float percent){
-            p_percent = percent;
+        int16_t getDuration(){
+            return delayLine->getDuration();
         }
 
-        uint8_t depth() {
-            return p_percent;
+        void setDepth(float p){
+            delayLine->setDepth(p);
         }
 
-        void setFeedback(float feedback){
-            p_feedback = feedback;
+        float getDepth() {
+            return delayLine->getDepth();
         }
 
-        uint8_t feedback() {
-            return p_feedback;
+        void setFeedback(float f){
+            delayLine->setFeedback(f);
+        }
+
+        float getFeedback() {
+            return delayLine->getFeedback();
+        }
+
+        void setSampleRate(int32_t s){
+            delayLine->setSampleRate(s);
+        }
+
+        float getSampleRate() {
+            return delayLine->getSampleRate();
         }
 
         effect_t process(effect_t input) {
             if (!active()) return input;
 
+            delayLine->tick();
             updateBufferSize();
             // get value from buffer
             int32_t value = (p_history->available()<sampleCount) ? input : p_history->read();
             // add feedback decay
-            int32_t delayValue = (value*p_feedback);
+            int32_t delayValue = (value*delayLine->getFeedback());
             // add input and delay to the buffer
             p_history->write(input+delayValue);
             // mix input with result
-            return (delayValue * p_percent) + (input * (1.0 - p_percent));
+            return (delayValue * delayLine->getDepth()) + (input * (1.0 - delayLine->getDepth()));
         }
 
         Delay *clone() {
@@ -335,14 +348,11 @@ class Delay : public AudioEffect  {
 
     protected:
         RingBuffer<effect_t>* p_history=nullptr;
-        float p_percent;
-        float p_feedback;
-        uint16_t p_ms;
+        DelayLine *delayLine;
         uint16_t sampleCount=0;
-        uint32_t sampleRate;
 
         void updateBufferSize(){
-            uint16_t newSampleCount = sampleRate * p_ms / 1000;
+            uint16_t newSampleCount = delayLine->getSampleRate() * delayLine->getDuration() / 1000;
             if (newSampleCount!=sampleCount){
                 if (p_history!=nullptr) delete p_history;
                 sampleCount = newSampleCount;

src/AudioEffects/AudioParameters.h

@@ -5,7 +5,7 @@ namespace audio_tools {
 
 /**
  * @brief Base class for all parameters
- * 
+ *
  */
 class AbstractParameter {
     public:
@@ -36,7 +36,7 @@ class AbstractParameter {
 
 /**
  * @brief A constant value
- * 
+ *
  */
 class Parameter : public AbstractParameter {
     public:
@@ -48,7 +48,7 @@ class Parameter : public AbstractParameter {
 
 /**
  * @brief Generates ADSR values between 0.0 and 1.0
- * 
+ *
  */
 class ADSR : public  AbstractParameter  {
     public:
@@ -85,7 +85,7 @@ class ADSR : public  AbstractParameter  {
         float sustainLevel(){
             return sustain;
         }
-        
+
         void setReleaseRate(float r){
             release = r;
         }
@@ -167,9 +167,66 @@ class ADSR : public  AbstractParameter  {
 
 };
 
+/**
+ * @brief Generates DelayLines
+ *
+ */
+class DelayLine : public  AbstractParameter  {
+    public:
+
+      DelayLine(uint16_t duration_ms=1000, float depthPercent=0.3, float feedbackAmount=0.3, uint32_t sampleRate=44100) {
+            this->sampleRate = sampleRate;
+            this->duration = duration_ms;
+            this->feedback = feedbackAmount;
+            this->depth = depthPercent;
+        }
+
+        DelayLine(DelayLine &copy) = default;
+
+        void setDuration(int16_t dur){
+            duration = dur;
+        }
+
+        int16_t getDuration(){
+            return duration;
+        }
+
+        void setDepth(float per){
+            depth = per;
+        }
+
+        float getDepth() {
+            return depth;
+        }
+
+        void setFeedback(float feed){
+            feedback = feed;
+        }
+
+        float getFeedback() {
+            return feedback;
+        }
+
+        void setSampleRate(int32_t sample){
+            sampleRate = sample;
+        }
+
+        float getSampleRate() {
+            return sampleRate;
+        }
+
+    protected:
+        float depth,feedback,duration,sampleRate;
+
+        inline float update( ) {
+          return 0;
+        }
+};
+
+
 /**
  * @brief Scales a dynamic parameter to the indicated range
- * 
+ *
  */
 class ScaledParameter : public AbstractParameter {
     public:
@@ -190,4 +247,4 @@ class ScaledParameter : public AbstractParameter {
 };
 
 
-}
+}