Audio processors

GenSource/GenPatch.hpp

@@ -231,12 +231,22 @@ class GenPatch : public Patch {
     for(int i=0; i<PatchMetadata::parameter_count; ++i){
       const PatchMetadata::Control& ctrl = PatchMetadata::parameters[i];
       PatchParameterId pid = (PatchParameterId)ctrl.id;
-      registerParameter(pid, ctrl.name);
       if(ctrl.flags & CONTROL_OUTPUT){
 	if(outputindex < nof_outs)
 	  outputs[outputindex] = OutputParameter(pid, ctrl.name, FloatArray(buffers[channels+outputindex], getBlockSize()));
 	outputindex++;
       }
+      size_t len = strlen(ctrl.name);
+      if(ctrl.flags & CONTROL_OUTPUT && ctrl.name[len-1] != '>'){
+	// add a > at end of name
+	char name[len+2];
+	strcpy(name, ctrl.name);
+	name[len] = '>';
+	name[len+1] = '\0';
+	registerParameter(pid, name);
+      }else{
+	registerParameter(pid, ctrl.name);
+      }
     }
     for(int i=0; i<PatchMetadata::button_count; ++i){
       const PatchMetadata::Control& ctrl = PatchMetadata::buttons[i];

GenSource/genlib_ops.h

@@ -22,6 +22,9 @@ OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 #include "genlib_common.h"	// common to common code and any host code
 #include "genlib.h"			// this file is different for different "hosts"
+#ifdef clamp
+#undef clamp
+#endif
 
 //////////// genlib_ops.h ////////////
 

HISTORY.md

@@ -1,8 +1,19 @@
+* Automatically add '>' to end of gen~ output parameters
+* Updated to use C++17
+* Use std::min/max/abs/clamp instead of macros for C++
+* Refactored AdsrEnvelope to Linear and Exponential versions
 * Updated CMSIS libraries
 
 v21.2
 -----
 
+* Added FloatArray::softclip()
+* Added clamp(x, lo, hi) macro
+* Added TapTempo
+* Added DryWetProcessors
+* Added FeedbackProcessors
+* Added CrossFadingDelayProcessor
+* Added AudioBuffer::copyFrom(), copyTo(), multiply() and add()
 * Added Sample oscillator
 * Added Agnesi curve oscillator
 * Added MPE processor

LibSource/AbstractSynth.h

@@ -10,9 +10,20 @@ class AbstractSynth : public Synth, public MidiProcessor, public VelocityCurve {
 protected:
   uint8_t note = 60; // C4
   float pb = 0;
-  float pb_range = 2;
+  float pb_range = 2/8192.0f;
+  float mod_range = 0.5/127.0f;
+  float tuning = 440;
 public:
   virtual ~AbstractSynth(){}
+  /**
+   * Set frequency in Hertz for middle A (defaults to Stuttgart pitch, A440, 440 Hz)
+   */
+  void setTuning(float value){
+    tuning = value;
+  }
+  float getTuning(){
+    return tuning;
+  }
   /**
    * Set note in whole semitones
    */
@@ -50,8 +61,14 @@ class AbstractSynth : public Synth, public MidiProcessor, public VelocityCurve {
    * Does not update the frequency; effective from next pitch bend change
    */
   void setPitchBendRange(float range){
-    this->pb_range = range;
-  }  
+    this->pb_range = range/8192.0f;
+  }
+  /**
+   * Set modulation depth range, from 0 to 1.0
+   */
+  void setModulationDepthRange(float range){
+    mod_range = range / 127.0f;
+  }
   // MIDI handlers
   virtual void noteOn(MidiMessage msg) override {
     setNote(msg.getNote());
@@ -64,30 +81,34 @@ class AbstractSynth : public Synth, public MidiProcessor, public VelocityCurve {
   }
   virtual void controlChange(MidiMessage msg) override {
     if(msg.getControllerNumber() == MIDI_CC_MODULATION)
-      setModulation(msg.getControllerValue()/127.0f);
+      setModulation(msg.getControllerValue()/128.0f);
     else if(msg.getControllerNumber() == MIDI_ALL_NOTES_OFF)
       allNotesOff();
   }
   virtual void channelPressure(MidiMessage msg) override {
-    setPressure(msg.getChannelPressure()/127.0f);
+    setPressure(msg.getChannelPressure()/128.0f);
   }
   virtual void polyKeyPressure(MidiMessage msg) override {
-    setPressure(msg.getPolyKeyPressure()/127.0f);
+    setPressure(msg.getPolyKeyPressure()/128.0f);
+  }
+  virtual void modulate(MidiMessage msg) override {
+    setModulation(mod_range * msg.getControllerValue());
   }
-  virtual void setModulation(float modulation){} // default implementation does nothing
-  virtual void setPressure(float pressure){}
   virtual void pitchbend(MidiMessage msg) override {
-    setPitchBend(pb_range*msg.getPitchBend()/8192.0f);
+    setPitchBend(pb_range * msg.getPitchBend());
   }
   virtual void allNotesOff(){
     gate(false);
   }
+  // default implementations do nothing
+  virtual void setModulation(float modulation){} 
+  virtual void setPressure(float pressure){}
   // static utility methods
-  static inline float frequencyToNote(float freq){
-    return 12 * log2f(freq / 440) + 69;
+  inline float frequencyToNote(float freq){
+    return 12 * log2f(freq / tuning) + 69;
   }
-  static inline float noteToFrequency(float note){
-    return 440 * exp2f((note - 69) / 12);
+  inline float noteToFrequency(float note){
+    return tuning * exp2f((note - 69) / 12);
   }
 };
 

LibSource/AdsrEnvelope.h

@@ -0,0 +1,211 @@
+#ifndef __ADSR_ENVELOPE_H
+#define __ADSR_ENVELOPE_H
+
+#include "Envelope.h"
+
+/**
+ * ADSR Envelope, either linear or exponential
+ */
+template<bool linear>
+class AdsrEnvelope : public Envelope {
+protected:
+  static const float MINLEVEL;
+  enum EnvelopeStage { kAttack, kDecay, kSustain, kRelease, kIdle };
+  enum EnvelopeTrigger { kGate, kTrigger };
+  float calculateIncrement(float startValue, float endValue, float time);
+  float increment(float level, float amount);
+  float decrement(float level, float amount);
+public:
+  AdsrEnvelope(float sampleRate) :
+    sampleRate(sampleRate),
+    stage(kIdle),
+    trig(kGate),
+    level(MINLEVEL),
+    gateState(false),
+    gateTime(-1) {
+    setAttack(1/sampleRate);
+    setDecay(1/sampleRate);
+    setSustain(1.0);
+    setRelease(1/sampleRate);
+    setRetrigger(false);
+  }
+
+  using Envelope::process;
+  using Envelope::trigger;
+  using SignalGenerator::generate;
+  void setSampleRate(float value){
+    sampleRate = value;
+  }
+  void setAttack(float value){
+    attackIncrement = calculateIncrement(MINLEVEL, 1, value);
+  }
+  void setDecay(float value){
+    decayIncrement = calculateIncrement(1, MINLEVEL, value);
+  }
+  void setRelease(float value){
+    releaseIncrement = calculateIncrement(1, MINLEVEL, value);
+  }
+  void setSustain(float newSustain){
+    sustain = newSustain;
+  }
+  void trigger(bool state, int delay){
+    gate(state, delay);
+    trig = kTrigger;
+  }
+  void setRetrigger(bool state){
+    retrigger = state;
+  }
+  void gate(bool state){
+    gate(state, 0);
+  }
+  void gate(bool state, int delay){
+    if(gateState != state){
+      gateTime = delay;
+      gateState = state;
+    }
+    trig = kGate;
+  }
+  float getLevel(){
+    return level;
+  }
+  void setLevel(float newLevel){
+    level = newLevel;
+  }
+  /**
+   * Produce the next envelope sample.
+   */
+  float generate(){
+    if(gateTime == 0){
+      stage = kAttack;
+      if(trig == kTrigger){
+	gateState = false;
+      }
+    }
+    if(gateTime >= 0){
+      gateTime--; // this will stop at -1
+    }
+    switch (stage) {
+    case kAttack:
+      // attack ramp
+      level = increment(level, attackIncrement);
+      if(level >= 1.0){
+	level = 1.0;
+	stage = kDecay;
+      }else if(gateState == false && trig == kGate){
+	stage = kRelease;
+      }
+      break;
+    case kDecay:
+      // decay ramp
+      level = decrement(level, decayIncrement);
+      if(level <= sustain){
+	level = sustain;
+	if(trig == kGate){
+	  stage = kSustain;
+	} else { // (trig == kTrigger)
+	  stage = kRelease;
+	}
+      } else if(gateState == false && trig == kGate){
+	stage = kRelease;
+      }
+      break;
+    case kSustain:
+      level = sustain;
+      if(gateState == false){
+	stage = kRelease;
+      }
+      break;
+    case kRelease:
+      // release ramp
+      level = decrement(level, releaseIncrement);
+      if(level <= MINLEVEL){
+	level = MINLEVEL;
+	if (retrigger == true)
+	  trigger();
+	else // (retrigger == false)
+	  stage = kIdle;
+      }else if(gateState == true ){ // if during release the gate is on again, start over from the current level
+	stage = kAttack;
+      }
+      break;
+    case kIdle:
+      level = MINLEVEL;
+      if(gateState == true)
+	stage = kAttack;
+      break;
+    }
+    return level;
+  }
+  [[deprecated("use generate() instead.")]]
+  float getNextSample(){
+    return generate(); // increments envelope one step
+  }  
+  [[deprecated("use generate() instead.")]]
+  void getEnvelope(FloatArray output){
+    generate(output); // increments envelope by output buffer length
+  }
+  [[deprecated("use process() instead.")]]
+  void attenuate(FloatArray buf){
+    process(buf, buf); // increments envelope by buffer length
+  }
+  static AdsrEnvelope<linear>* create(float sampleRate){
+    return new AdsrEnvelope<linear>(sampleRate);
+  }
+  static void destroy(AdsrEnvelope<linear>* env){
+    delete env;
+  }
+protected:
+  float sampleRate;
+  EnvelopeStage stage;
+  EnvelopeTrigger trig;
+  bool retrigger;
+  float level;
+  float attackIncrement;
+  float decayIncrement;
+  float releaseIncrement;
+  float sustain;
+  bool gateState;
+  int gateTime;
+};
+
+template<>
+float AdsrEnvelope<true>::increment(float level, float amount){
+  return level + amount;
+}
+
+template<>
+float AdsrEnvelope<true>::decrement(float level, float amount){
+  return level + amount;
+}
+
+template<>
+float AdsrEnvelope<false>::increment(float level, float amount){
+  return level + (1.01-level)*amount; // aim slightly higher to ensure we reach 1.0
+}
+
+template<>
+float AdsrEnvelope<false>::decrement(float level, float amount){
+  return level + level * amount;
+}
+
+template<>
+float AdsrEnvelope<true>::calculateIncrement(float startValue, float endValue, float time){
+  return (endValue-startValue)/(sampleRate*time+1);
+}
+
+template<>
+float AdsrEnvelope<false>::calculateIncrement(float startValue, float endValue, float time) {
+  // Ref: Christian Schoenebeck http://www.musicdsp.org/showone.php?id=189
+  return (logf(endValue) - logf(startValue)) / (time*sampleRate+10);
+}
+
+template<>
+const float AdsrEnvelope<true>::MINLEVEL = 0;
+
+template<>
+const float AdsrEnvelope<false>::MINLEVEL = 0.00001; // -100dB
+
+typedef AdsrEnvelope<true> LinearAdsrEnvelope;
+typedef AdsrEnvelope<false> ExponentialAdsrEnvelope;
+
+#endif /* __ADSR_ENVELOPE_H */

LibSource/AgnesiOscillator.h

@@ -35,27 +35,31 @@ class AgnesiOscillator : public Oscillator {
   float getPhase(){
     return M_PI*x/N+M_PI;
   }
+  void reset(){
+    x = -N;
+  }
   /**
-   * Normalise offset and gain so that signal is between 0 and 1
+   * Normalise offset and gain so that signal is between -1 and 1
    */
   void normalise(){
     offset = agnesi(N, a);
-    gain = 1/(agnesi(0, a) - offset);
+    gain = 2/(agnesi(0, a) - offset);
+    offset += 0.5;
   }
   float generate(){
     float y = agnesi(x, a);
     x += incr;
     if(x > N)
       x -= 2*N;
-    return gain*(y-offset);
+    return clamp(gain*(y-offset), -1.0f, 1.0f);
   }
   float generate(float fm){
     // modulate coefficient 'a' instead of rate
-    float y = agnesi(x, a+fm);
+    float y = agnesi(x, a*(1+fm));
     x += incr;
     if(x > N)
       x -= 2*N;
-    return gain*(y-offset);
+    return clamp(gain*(y-offset), -1.0f, 1.0f);
   }
   using SignalGenerator::generate;
   static AgnesiOscillator* create(float sr, float a=0.5, float N=5){