Merge pull request #107 from pingdynasty/feature/hwplatforms

feature/hwplatforms

Author: pingdynasty

HISTORY.md

@@ -1,5 +1,7 @@
 v22.2
 -----
+
+* Added PLATFORM=OWL1/2/3 build option
 * Added NoiseOscillator (whitenoise s+h)
 * Added PhaseShiftOscillator template
 * Added Biquad allpass filter configuration

LibSource/BiquadFilter.h

@@ -220,10 +220,15 @@ class BiquadFilter : public SignalProcessor {
     init();
   }
   virtual ~BiquadFilter(){}
+
   void setSampleRate(float sr){
     pioversr = M_PI/sr;
   }
 
+  float getSampleRate(){
+    return M_PI / pioversr;
+  }
+
   size_t getStages(){
     return stages;
   }
@@ -274,13 +279,14 @@ class BiquadFilter : public SignalProcessor {
     arm_biquad_cascade_df2T_f32(&df2, input, output, size);
 #else
     for(size_t k=0; k<stages; k++){
-      float b0=getFilterStage(k).getCoefficients()[0];
-      float b1=getFilterStage(k).getCoefficients()[1];
-      float b2=getFilterStage(k).getCoefficients()[2];
-      float a1=getFilterStage(k).getCoefficients()[3];
-      float a2=getFilterStage(k).getCoefficients()[4];
-      float d1=state[k*BIQUAD_STATE_VARIABLES_PER_STAGE];
-      float d2=state[k*BIQUAD_STATE_VARIABLES_PER_STAGE+1];
+      float* coeffs = getFilterStage(k).getCoefficients();
+      float b0 = *coeffs++;
+      float b1 = *coeffs++;
+      float b2 = *coeffs++;
+      float a1 = *coeffs++;
+      float a2 = *coeffs++;
+      float d1 = state[k*BIQUAD_STATE_VARIABLES_PER_STAGE];
+      float d2 = state[k*BIQUAD_STATE_VARIABLES_PER_STAGE+1];
       for(size_t n=0; n<size; n++){ //manually apply filter, one stage
         float out=b0 * input[n] + d1; 
         d1 = b1 * input[n] + a1 * out + d2;

LibSource/DcBlockingFilter.h

@@ -5,23 +5,35 @@
 #include "SignalProcessor.h"
 
 /**
- * DC Blocking IIR filter:
- * Leaky differentiator.
+ * DC Blocking IIR filter, aka Leaky differentiator.
+ * Ref: https://www.dsprelated.com/freebooks/filters/DC_Blocker.html
  */
 class DcBlockingFilter : public SignalProcessor {
 private:
-  const float lambda;
   float x1, y1;
+  float R;
 public:
-  DcBlockingFilter(float lambda = 0.995): lambda(lambda), x1(0), y1(0) {}
+  DcBlockingFilter(float R = 0.995): R(R), x1(0), y1(0) {}
 
+  /**
+   * Get adaptation time constant in samples.
+   */
+  float getTimeConstant(){
+    return 1/(1-R); // approximate
+  }
+  /**
+   * Set adaptation time constant in samples.
+   */
+  void setTimeConstant(float tc){
+    R = (tc - 1) / tc;
+  }
   void reset(){
     x1 = y1 = 0;
   }
 
   /* process a single sample and return the result */
   float process(float x){
-    y1 = x - x1 + lambda*y1;
+    y1 = x - x1 + R*y1;
     x1 = x;
     return y1;
   }
@@ -31,7 +43,7 @@ class DcBlockingFilter : public SignalProcessor {
     float y = y1;
     while(size--){
       x = *input++;
-      y = x - x1 + lambda*y;
+      y = x - x1 + R*y;
       x1 = x;
       *output++ = y;
     }
@@ -52,8 +64,8 @@ class DcBlockingFilter : public SignalProcessor {
     process(in, out, in.getSize());
   }
 
-  static DcBlockingFilter* create(float lambda=0.995){
-    return new DcBlockingFilter(lambda);
+  static DcBlockingFilter* create(float R=0.995){
+    return new DcBlockingFilter(R);
   }
 
   static void destroy(DcBlockingFilter* obj){
@@ -65,14 +77,29 @@ class StereoDcBlockingFilter : public MultiSignalProcessor {
 private:
   DcBlockingFilter left, right;
 public:
-  StereoDcBlockingFilter(float lambda = 0.995): left(lambda), right(lambda) {}
+  StereoDcBlockingFilter(float R = 0.995): left(R), right(R) {}
+
+  /**
+   * Get adaptation time constant in samples.
+   */
+  float getTimeConstant(){
+    return left.getTimeConstant();
+  }
+  /**
+   * Set adaptation time constant in samples.
+   */
+  void setTimeConstant(float tc){
+    left.setTimeConstant(tc);
+    right.setTimeConstant(tc);
+  }
+
   void process(AudioBuffer& input, AudioBuffer& output){
     left.process(input.getSamples(LEFT_CHANNEL), output.getSamples(LEFT_CHANNEL));
     right.process(input.getSamples(RIGHT_CHANNEL), output.getSamples(RIGHT_CHANNEL));
   }
 
-  static StereoDcBlockingFilter* create(float lambda){
-    return new StereoDcBlockingFilter(lambda);
+  static StereoDcBlockingFilter* create(float R=0.995){
+    return new StereoDcBlockingFilter(R);
   }
 
   static void destroy(StereoDcBlockingFilter* obj){

LibSource/InterpolatingCircularBuffer.h

@@ -32,8 +32,8 @@ class InterpolatingCircularFloatBuffer : public CircularBuffer<float> {
    * Interpolated read at fractional rate
    * @param rate read speed, in samples/sample
    */
-  void read(float* out, size_t len, float rate){
-    float pos = readpos; // quantizes fractional read pos from last read
+  void read(float* out, size_t len, float startpos, float rate){
+    float pos = startpos;
     while(len--){
       *out++ = readAt(pos);
       pos += rate;

LibSource/SquareWaveOscillator.h

@@ -59,6 +59,57 @@ class AntialiasedSquareWaveOscillator : public OscillatorTemplate<AntialiasedSqu
     sample -= polyblep(fmod(phase + 1 - pw, 1), incr);
     return sample;
   }
+  void generate(FloatArray output){
+    float sample;
+    if(phase < pw){
+      sample = 1;
+      if(phase < incr){
+	float t = phase / incr;
+	sample += t+t - t*t - 1;
+      }
+    }else{
+      sample = -1;
+      if(phase-pw < incr){
+	float t = fmod(phase + 1 - pw, 1) / incr;
+	sample -= t+t - t*t - 1;
+      }
+    }
+    size_t len = output.getSize();
+    float* dest = output.getData();
+    while(len--){
+      phase += incr;
+      if(phase >= pw){
+	if(phase >= 1){
+	  // wrap phase
+	  phase -= 1;
+	  // correct current sample
+	  float t = (phase - incr) / incr;
+	  sample += t*t + t+t + 1;
+	  *dest++ = sample;
+	  sample = 1;
+	  // correct next sample
+	  t = phase / incr;
+	  sample += t+t - t*t - 1;
+	}else if(sample == 1){
+	  // correct current sample
+	  float t = (fmod(phase + 1 - pw, 1) - incr) / incr;
+	  sample -= t*t + t+t + 1;
+	  *dest++ = sample;
+	  sample = -1;
+	  // correct next sample
+	  t = fmod(phase + 1 - pw, 1) / incr;
+	  sample -= t+t - t*t - 1;
+	}else{
+	  *dest++ = sample;
+	  sample = -1;
+	}
+      }else{
+	*dest++ = sample;
+	sample = 1;
+      }
+    }
+  }
+  using OscillatorTemplate<AntialiasedSquareWaveOscillator>::generate;  
 };
 
 #endif /* __SquareWaveOscillator_h */

Makefile

@@ -9,7 +9,7 @@ endif
 endif
 
 ifndef PLATFORM
-  PLATFORM=OWL
+  PLATFORM=OWL2
 endif
 
 DEPS = .FORCE

README.md

@@ -87,7 +87,7 @@ Make sure to do a `make clean` before compiling a new patch, or add `clean` to y
 * PATCHOUT: number of output channels, default 2
 * SLOT: user program slot to store patch in, default 0, use with `store`
 * TARGET: changes the output prefix, default 'patch'
-
+* PLATFORM: changes the target platform: OWL1, OWL2 (default) or OWL3
 
 All files for a patch must be copied to the `PATCHSOURCE` directory. Take care to put only files required by the patch you want to compile here.
 
@@ -158,6 +158,19 @@ Specify your patch name (and optionally the PATCHSOURCE directory) as usual, but
 * `make SOUL=Foo clean patch`
 
 
+## Target Platform
+
+Most patches will compile to run on all OWL devices by default. However there are some platform differences, notably the maximum binary size (in kilobytes):
+
+* OWL1 (Legacy OWL Pedal and OWL Modular): 64K
+* OWL2 (OWL Pedal mkII, Alchemist, Wizard, Magus, Witch, Lich): 144K
+* OWL3 (Genius, Xibeca): 80K or 512K
+
+The target platform can be selected with the `PLATFORM` option, which defaults to `OWL2`. This can create patches up to 144K in binary size. Patches over 64K will not run on OWL1 devices, and patches over 80K will not run on OWL3 devices.
+
+To verify that a patch will run on all devices you can compile with `PLATFORM=OWL1`. Patches over 64K in binary size will then fail with a link error.
+
+Alternatively, to target **exclusively** OWL3 devices you can specify `PLATFORM=OWL3`. This will primarily do two things: firstly link the binary against D1 memory allowing patches up to 512K, secondly enable double precision FPU. Both of these features are only available on the Cortex M7 microcontrollers used by OWL3 devices. Patches compiled with this option will not run on OWL1 or OWL2 devices.
 
 # Examples
 

Source/PatchProcessor.cpp

@@ -38,15 +38,6 @@ void PatchProcessor::setPatch(Patch* p, const char* n){
   name = n;
 }
 
-AudioBuffer* PatchProcessor::createMemoryBuffer(int channels, int size){
-  MemoryBuffer* buf = new ManagedMemoryBuffer(channels, size);
-  if(buf == NULL)
-    return NULL;
-  buffers[bufferCount++] = buf;
-  buf->clear();
-  return buf;
-}
-
 void PatchProcessor::setParameterValues(int16_t *params){
   if(getProgramVector()->hardware_version == OWL_MODULAR_HARDWARE){
     for(int i=0; i<4 && i<parameterCount; ++i)

Source/PatchProcessor.h

@@ -24,7 +24,6 @@ class PatchProcessor {
   }
   int getBlockSize();
   double getSampleRate();
-  AudioBuffer* createMemoryBuffer(int channels, int samples);
   void setParameterValues(int16_t* parameters);
   Patch* patch;
   uint8_t index;