Merge pull request #106 from pingdynasty/feature/circularbuffer-updates

CircularBuffer updates

Author: pingdynasty

HISTORY.md

@@ -1,3 +1,14 @@
+v22.2
+-----
+* Added NoiseOscillator (whitenoise s+h)
+* Added PhaseShiftOscillator template
+* Added Biquad allpass filter configuration
+* Fixed Antialiased oscillators (Triangle, SquareWave, Ramp)
+* Added MorphingOscillator
+* AdjustableTapTempo interface changes
+* CircularBuffer improvements, added isFull()
+* Added InvertedRampOscillator
+* Added StateVariableFilter::setAllpass() and processLowMidHighBand()
 * Improved realloc implementation
 * Block based SineOscillator::generate() with FM
 * Added test patches for automatic CI builds

LibSource/BiquadFilter.h

@@ -9,9 +9,9 @@ class FilterStage {
 public:
   FloatArray coefficients;
   FloatArray state;
-  static const float BESSEL_Q;
-  static const float SALLEN_KEY_Q;
-  static const float BUTTERWORTH_Q;
+  static constexpr float BESSEL_Q = 0.57735026919f; // 1/sqrt(3)
+  static constexpr float SALLEN_KEY_Q = 0.5f; // 1/2
+  static constexpr float BUTTERWORTH_Q = 0.70710678118f; // 1/sqrt(2)
 
   FilterStage(FloatArray co, FloatArray st) : coefficients(co), state(st){}
 
@@ -27,6 +27,10 @@ class FilterStage {
     setBandPass(coefficients, fc*M_PI/sr, q);
   }
 
+  void setAllPass(float fc, float q, float sr){
+    setAllPass(coefficients, fc*M_PI/sr, q);
+  }
+  
   void setNotch(float fc, float q, float sr){
     setNotch(coefficients, fc*M_PI/sr, q);
   }
@@ -82,6 +86,16 @@ class FilterStage {
     coefficients[4] = - (1 - K / q + K * K) * norm;
   }
 
+  static void setAllPass(float* coefficients, float omega, float q){
+    float K = tanf(omega);
+    float norm = 1 / (1 + K / q + K * K);
+    coefficients[0] = (1 - K / q + K * K) * norm;
+    coefficients[1] = 2 * (K * K - 1) * norm;
+    coefficients[2] = 1;
+    coefficients[3] = coefficients[1];
+    coefficients[4] = coefficients[0];
+  }
+
   static void setNotch(float* coefficients, float omega, float q){
     float K = tanf(omega);
     float norm = 1 / (1 + K / q + K * K);
@@ -310,6 +324,13 @@ class BiquadFilter : public SignalProcessor {
     }
   }
 
+  void processAllPass(FloatArray in, FloatArray fc, float q, FloatArray out){
+    for(size_t i = 0; i < in.getSize(); i++){
+      setAllPass(fc[i], q);
+      out[i] = process(in[i]);
+    }
+  }
+
   /* process a single sample and return the result */
   float process(float input){
     float output;
@@ -332,6 +353,11 @@ class BiquadFilter : public SignalProcessor {
     copyCoefficients();
   }
 
+  void setAllPass(float fc, float q){
+    FilterStage::setAllPass(coefficients, fc*pioversr, q);
+    copyCoefficients();
+  }
+
   void setNotch(float fc, float q){
     FilterStage::setNotch(coefficients, fc*pioversr, q);
     copyCoefficients();
@@ -463,8 +489,4 @@ class StereoBiquadFilter : public MultiBiquadFilter {
   }
 };
 
-const float FilterStage::BESSEL_Q = 1/sqrtf(3); // 1/sqrt(3)
-const float FilterStage::SALLEN_KEY_Q = 0.5f; // 1/2
-const float FilterStage::BUTTERWORTH_Q = 1/sqrtf(2); // 1/sqrt(2)
-
 #endif // __BiquadFilter_h__

LibSource/CircularBuffer.h

@@ -8,96 +8,108 @@
 #define FLOW_ASSERT(x, y)
 #endif
 
-template<typename T>
+template<typename DataType, typename IndexType = size_t>
 class CircularBuffer {
 protected:
-  T* data;
-  size_t size;
-  size_t writepos = 0;
-  size_t readpos = 0;
+  DataType* data;
+  IndexType size;
+  IndexType writepos = 0;
+  IndexType readpos = 0;
+  bool empty = true;
 public:
   CircularBuffer(): data(NULL), size(0){}
-  CircularBuffer(T* data, size_t size): data(data), size(size){}
+  CircularBuffer(DataType* data, IndexType size): data(data), size(size){}
 
-  void setData(T* data, size_t len) {
+  void setData(DataType* data, IndexType len) {
     this->data = data;
     size = len;
   }
 
-  size_t getSize() const {
+  IndexType getSize() const {
     return size;
   }
 
-  T* getData() {
+  DataType* getData() {
     return data;
   }
 
   bool isEmpty() const {
-    return writepos == readpos;
+    return empty;
+  }
+  
+  bool isFull() const {
+    return (writepos == readpos) && !empty;
   }
 
-  void write(T c){
+  void write(DataType c){
+    FLOW_ASSERT(getWriteCapacity() > 0, "overflow");
     data[writepos++] = c;
     if(writepos >= size)
       writepos = 0;
+    empty = false;
   }
 
-  void write(T* source, size_t len){
+  void write(DataType* source, IndexType len){
     FLOW_ASSERT(getWriteCapacity() >= len, "overflow");
-    T* dest = getWriteHead();
-    size_t rem = size-writepos;
-    if(len > rem){
-      memcpy(dest, source, rem*sizeof(T));
+    DataType* dest = getWriteHead();
+    IndexType rem = size-writepos;
+    if(len >= rem){
+      memcpy(dest, source, rem*sizeof(DataType));
       writepos = len-rem;
-      memcpy(data, source+rem, writepos*sizeof(T));
+      memcpy(data, source+rem, writepos*sizeof(DataType));
     }else{
-      memcpy(dest, source, len*sizeof(T));
+      memcpy(dest, source, len*sizeof(DataType));
       writepos += len;
     }
+    empty = false;
   }
 
-  void writeAt(size_t index, T value){
+  void writeAt(IndexType index, DataType value){
     data[index % size] = value;
   }
 
-  void overdub(T c){
+  void overdub(DataType c){
     data[writepos++] += c;
     if(writepos >= size)
       writepos = 0;
+    empty = false;
   }
 
-  void overdubAt(size_t index, T value){
+  void overdubAt(IndexType index, DataType value){
     data[index % size] += value;
   }
 
-  T read(){
-    T c = data[readpos++];
+  DataType read(){
+    FLOW_ASSERT(getReadCapacity() > 0, "underflow");
+    DataType c = data[readpos++];
     if(readpos >= size)
       readpos = 0;
+    empty = readpos == writepos;
     return c;
   }
 
-  void read(T* dst, size_t len){
+  void read(DataType* dst, IndexType len){
     FLOW_ASSERT(getReadCapacity() >= len, "underflow");
-    T* src = getReadHead();
-    size_t rem = size-readpos;
+    DataType* src = getReadHead();
+    IndexType rem = size-readpos;
     if(len > rem){
-      memcpy(dst, src, rem*sizeof(T));
+      memcpy(dst, src, rem*sizeof(DataType));
       readpos = len-rem;
-      memcpy(dst+rem, data, readpos*sizeof(T));
+      memcpy(dst+rem, data, readpos*sizeof(DataType));
     }else{
-      memcpy(dst, src, len*sizeof(T));
+      memcpy(dst, src, len*sizeof(DataType));
       readpos += len;
     }
+    empty = readpos == writepos;
   }
 
-  T readAt(size_t index){
+  DataType readAt(IndexType index){
     return data[index % size];
   }
 
   void skipUntilLast(char c){
-    T* src = getReadHead();
-    size_t rem = size-readpos;
+    DataType* src = getReadHead();
+    IndexType rem = size-readpos;
     for(int i=0; i<rem; ++i){
       if(src[i] != c){
 	readpos += i;
@@ -111,40 +123,43 @@ class CircularBuffer {
 	return;
       }
     }
+    empty = readpos == writepos;
   }
 
-  size_t getWriteIndex(){
+  IndexType getWriteIndex(){
     return writepos;
   }
 
-  void setWriteIndex(size_t pos){
+  void setWriteIndex(IndexType pos){
     writepos = pos % size;
   }
 
-  T* getWriteHead(){
+  DataType* getWriteHead(){
     return data+writepos;
   }
 
   void moveWriteHead(int32_t samples){
     FLOW_ASSERT(getWriteCapacity() >= samples, "overflow");
     writepos = (writepos + samples) % size;
+    empty = false;
   }
 
-  size_t getReadIndex(){
+  IndexType getReadIndex(){
     return readpos;
   }
 
-  void setReadIndex(size_t pos){
+  void setReadIndex(IndexType pos){
     readpos = pos % size;
   }
 
-  T* getReadHead(){
+  DataType* getReadHead(){
     return data+readpos;
   }
 
   void moveReadHead(int32_t samples){
     FLOW_ASSERT(getReadCapacity() < samples, "underflow");
     readpos = (readpos + samples) % size;
+    empty = readpos == writepos;
   }
 
   /**
@@ -157,61 +172,62 @@ class CircularBuffer {
   /**
    * Get the read index expressed as delay behind the write index.
    */
-  int getDelay(){
+  IndexType getDelay() const {
     return (writepos-readpos+size) % size;
   }
 
   /**
    * Write to buffer and read with a delay
    */
-  void delay(T* in, T* out, size_t len, int delay_samples){
+  void delay(DataType* in, DataType* out, IndexType len, int delay_samples){
     setDelay(delay_samples); // set delay relative to where we start writing
     write(in, len);
     read(out, len);
   }
 
-  size_t getReadCapacity(){
-    return (writepos + size - readpos) % size;
+  IndexType getReadCapacity() const {
+    return size - getWriteCapacity();
   }
 
-  size_t getWriteCapacity(){
-    return size - getReadCapacity();
+  IndexType getWriteCapacity() const {
+    return size*empty + (readpos + size - writepos) % size;
   }
 
-  size_t getContiguousWriteCapacity(){
+  IndexType getContiguousWriteCapacity() const {
     if(writepos < readpos)
       return readpos - writepos;
     else
       return size - writepos;
   }
 
-  size_t getContiguousReadCapacity(){
+  IndexType getContiguousReadCapacity() const {
     if(writepos < readpos)
       return size - readpos;
     else
       return writepos - readpos;
   }
 
-  void setAll(const T value){
-    for(size_t i=0; i<size; ++i)
+  void setAll(const DataType value){
+    for(IndexType i=0; i<size; ++i)
       data[i] = value;
   }
 
   void reset(){
     readpos = writepos = 0;
+    empty = true;
   }
 
   void clear(){
     setAll(0);
   }
 
-  static CircularBuffer<T>* create(size_t len){
-    CircularBuffer<T>* obj = new CircularBuffer<T>(new T[len], len);
+  static CircularBuffer<DataType>* create(IndexType len){
+    CircularBuffer<DataType>* obj = new CircularBuffer<DataType>(new DataType[len], len);
     obj->clear();
     return obj;
   }
 
-  static void destroy(CircularBuffer<T>* obj){
+  static void destroy(CircularBuffer<DataType>* obj){
     delete[] obj->data;
     delete obj;
   }

LibSource/DelayProcessor.h

@@ -64,9 +64,9 @@ class FractionalDelayProcessor : public SignalProcessor {
     buffer.clear();
   }
   float process(float input){
-    float sample = buffer.readAt(buffer.getWriteIndex() - delay);
+    buffer.setDelay(delay);
     buffer.write(input);
-    return sample;
+    return buffer.read();
   }
   /**
    * Delay smoothly from the previous delay time to @param newDelay
@@ -129,7 +129,10 @@ class FastFractionalDelayProcessor : public SignalProcessor {
 };
 
 /**
- * Delay line signal processor that crossfades to smooth changes in delay time.
+ * Delay line signal processor that crossfades to ensure smooth changes in delay time.
+ * Cross fade time in samples is equal to one block size.
+ * Delay time should be updated at block rate, before calling the block-based process() method.
+ * Sample based processing should not be used with this class.
  */
 class CrossFadingDelayProcessor : public SignalProcessor {
 protected:
@@ -147,13 +150,6 @@ class CrossFadingDelayProcessor : public SignalProcessor {
   void clear(){
     ringbuffer->clear();
   }
-  float process(float input){
-    ringbuffer->write(input);
-    float sample = ringbuffer->read();
-    ringbuffer->setDelay(delay);
-    sample += ringbuffer->read();
-    return sample*0.5;
-  }
   void process(FloatArray input, FloatArray output){
     ringbuffer->delay(input, output, input.getSize(), delay);
   }