Merge branch 'events'

Author: mars

LibSource/ComplexFloatArray.cpp

@@ -70,7 +70,7 @@ void ComplexFloatArray::complexByComplexMultiplication(ComplexFloatArray& operan
   ASSERT(size==operand2.getSize(), "Wrong size");
 /// @note When built for ARM Cortex-M processor series, this method uses the optimized <a href="http://www.keil.com/pack/doc/CMSIS/General/html/index.html">CMSIS library</a>
 #ifdef ARM_CORTEX
-  arm_cmplx_mult_cmplx_f32 ( (float*)data, (float*)operand2, (float*)result, size );  
+  arm_cmplx_mult_cmplx_f32( (float*)data, (float*)operand2, (float*)result, size );  
 #else
   float *pSrcA=(float*)data;
   float *pSrcB=(float*)operand2;

LibSource/ComplexFloatArray.h

@@ -107,6 +107,10 @@ class ComplexFloatArray {
     return data[i].im;
   }
 
+  void clear(){
+    setAll(0);
+  }
+
   /**
     The magnitude of an element of the array.
     @param i The index of the element

LibSource/FloatArray.cpp

@@ -299,7 +299,7 @@ void FloatArray::setAll(float value){
 }
 
 void FloatArray::add(FloatArray operand2, FloatArray destination){ //allows in-place
-  ASSERT(operand2.size == size &&  destination.size==size, "Arrays must be same size");
+  ASSERT(operand2.size >= size &&  destination.size<=size, "Arrays must be matching size");
 /// @note When built for ARM Cortex-M processor series, this method uses the optimized <a href="http://www.keil.com/pack/doc/CMSIS/General/html/index.html">CMSIS library</a>
 #ifdef ARM_CORTEX
   /* despite not explicitely documented in the CMSIS documentation,

LibSource/FloatArray.h

@@ -264,7 +264,7 @@ class FloatArray {
   /**
    * Array-scalar multiplication.
    * Multiplies the values in the array by **scalar**.
-   * @param scalar to be subtracted from the array
+   * @param scalar to be multiplied with the array elements
   */
   void multiply(float scalar);
 

LibSource/PatchParameter.cpp

@@ -0,0 +1,45 @@
+#include "PatchParameter.h"
+#include "PatchProcessor.h"
+#include "SmoothValue.h"
+#include "message.h"
+
+PatchProcessor* getInitialisingPatchProcessor();
+
+#define PATCH_PARAMETER_NO_PID -1
+
+template<typename T>
+PatchParameter<T>::PatchParameter() : pid(PATCH_PARAMETER_NO_PID){}
+
+// copy ctors: superceded by assignment operators
+/* PatchParameter(PatchParameter<T>& other); */
+/* PatchParameter(const PatchParameter<T>& other); */
+
+// template<typename T>
+// PatchParameter<T>::PatchParameter(PatchParameter<T>& other) :
+//   pid(other.pid), value(other.value) {
+//   // copy ctor
+//   // register for update callback in copy constructor
+//   if(pid != PATCH_PARAMETER_NO_PID)
+//     getInitialisingPatchProcessor()->setPatchParameter(pid, this);
+// }
+
+// template<typename T>
+// PatchParameter<T>::PatchParameter(const PatchParameter<T>& other) :
+//   pid(other.pid), value(other.value) {
+//   // copy ctor
+//   // register for update callback in copy constructor
+//   if(pid != PATCH_PARAMETER_NO_PID)
+//     getInitialisingPatchProcessor()->setPatchParameter(pid, this);
+// }
+
+template<typename T>
+PatchParameter<T>& PatchParameter<T>::operator=(const PatchParameter<T>& other){
+  pid = other.pid;
+  value = other.value;
+  if(pid != PATCH_PARAMETER_NO_PID)
+    getInitialisingPatchProcessor()->setPatchParameter(pid, this);
+  return *this;
+}
+
+template class PatchParameter<int>;
+template class PatchParameter<float>;

LibSource/PatchParameter.h

@@ -1,95 +1,28 @@
 #ifndef __PatchParameter_h__
 #define __PatchParameter_h__
 
-
-#include "SmoothValue.h"
-
+template<typename T>
 class PatchParameter {
-public:
-  virtual void update(uint16_t value){}
-};
-
-template<type T, type V>
-class GenericParameter : public PatchParameter {
 private:
-  PatchParameterId pid;
-  T min, max;
-  V value;
+  int pid;
+  T value;
 public:
-  PatchParameter(){}
-  PatchParameter(PatchParameterId pid, T min, T max, V initialValue);
-  // called when requestParameter() returns to patch constructor
-  PatchParameter(const PatchParameter<T>& other);
-  void update(uint16_t value);
-  /*
+  PatchParameter();
+  PatchParameter(int parameterId) : pid(parameterId){}
+  /* assignment operator */
+  PatchParameter<T>& operator=( const PatchParameter<T>& other );
   void update(T newValue){
     value = newValue;
-  } */
-  operator V(){
+  }
+  T getValue(){
     return value;
   }
-};
-
-template<type T, type V>
-GenericParameter<T, V> Patch::requestParameter(const char* name, T min, T max, V defaultValue = V()){
-  int pid = 0;
-  if(nextPid < 5){
-    pid = nextPid++;
-    registerParameter(pid, name);
+  operator T(){
+    return getValue();
   }
-  return GenericParameter<T, V>(PatchParameterId(pid), min, max, defaultValue);
-}
-
-template<type T>
-GenericParameter<T, SmoothValue<T>> Patch::requestParameter(const char* name, T min, T max, T defaultValue, T lambda){
-  requestParameter(name, min, max, SmoothValue<T>(defaultValue, lambda));
-}
-
-// Patch {
-// FloatParameter requestParameter(const char* name, float min, float max, float defaultValue);
-// SmoothFloatParameter requestParameter(const char* name, float min, float max, float defaultValue, float lambda); // lambda between 0.5 and 0.99 - compensate for rate/blocksize
-// IntParameter requestParameter(const char* name, int min, int max, int defaultValue);
-// StiffIntParameter requestParameter(const char* name, int min, int max, int defaultValue, float delta); // delta between 0 and 1 for 0 to 4095
-// };
-
-// exponentially averaged float parameter with hysteresis:
-// won't work!
-// StiffSmoothFloatParameter spread; spread = requestParameter("spread", 0.0, 1.0, 0.5, 0.9); // how to set stiff delta?
-// should be GenericParameter<float, SmoothValue<StiffFloat>> but whole of stiff gets assigned to value of smooth
-// typedef StiffSmoothFloatParameter GenericParameter<float, SmoothValue<StiffFloat>>
-
-// default in patch processor to StiffSmoothIntParameter
-
-typedef IntParameter GenericParameter<int, int>;
-typedef StiffIntParameter GenericParameter<int, StiffInt>;
-typedef SmoothIntParameter GenericParameter<int, SmoothInt>;
-typedef FloatParameter GenericParameter<float, float;
-typedef StiffFloatParameter GenericParameter<float, StiffFloat>;
-typedef SmoothFloatParameter GenericParameter<float, SmoothFloat>;
-//FloatParameter spread = requestParameter("Spread", 0.0, 1.0, 0.5);
-//SmoothFloatParameter spread = requestParameter("Spread", 0.0, 1.0, SmoothFloat(0.9, 0.5));
-//SmoothFloatParameter spread = requestParameter("Spread", 0.0, 1.0, 0.5, 0.9);
-
-template<type T, type V>
-GenericParameter<T,V>::GenericParameter<T,V>(PatchParameterId p, T mn, T mx, T v)
-: pid(p), min(mn), max(mx), value(v) {}
-
-template<type T, type V>
-GenericParameter(const GenericParameter<T,V>& other){
-  // register for update callback in copy constructor
-  if(pid != NO_PID)
-    getCurrentPatchProcessor()->setPatchParameter(pid, this);
-}
-
-template<V>
-void GenericParameter<int,V>::update(uint16_t newValue){
-  value = (newValue*(max-min)+min)/4095;
-}
+};
 
-template<V>
-void GenericParameter<float,V>::update(uint16_t value){
-  value = newValue/4096.0f;
-  // should work for <float, float>, <float, SmoothFloat>, and <float, StiffFloat>
-}
+typedef PatchParameter<float> FloatParameter;
+typedef PatchParameter<int> IntParameter;
 
 #endif /* __PatchParameter_h__ */

LibSource/PolyBlepOscillator.cpp

@@ -3,7 +3,7 @@
 
 PolyBlepOscillator::PolyBlepOscillator(float sr):
   multiplier(1.0/sr),
-  frequency(440.0), 
+  frequency(440.0*multiplier), 
   shape(0.5), 
   pw(0.5) {
   osc.Init();

LibSource/SmoothValue.cpp

@@ -0,0 +1,71 @@
+#include "SmoothValue.h"
+#include "basicmaths.h"
+
+template<>
+SmoothFloat::SmoothValue()
+  : lambda(0.9), value(0.0){}
+
+template<>
+SmoothFloat::SmoothValue(float l)
+  : lambda(l), value(0.0){}
+
+template<>
+SmoothFloat::SmoothValue(float l, float initialValue)
+  : lambda(l), value(initialValue){}
+
+template<>
+SmoothInt::SmoothValue(int divider) : lambda(divider) {
+// lambda = 1 - 1/divider
+// divider 4:0.75, 5:0.8, 6:0.833, 7:0.857, 8:0.875, 9:0.888, 10:0.9 et c
+}
+
+template<>
+SmoothInt::SmoothValue(int divider, int initialValue) 
+  : lambda(divider), value(initialValue) {}
+
+template<>
+void SmoothFloat::update(float newValue){
+  value = value*lambda + newValue*(1.0f - lambda);
+}
+
+template<>
+void SmoothInt::update(int newValue){
+  value = (value*lambda + newValue)/(lambda+1);
+}
+
+template<>
+void SmoothStiffFloat::update(float newValue){
+  if(abs(value-newValue) >= delta)
+    value = value*lambda + newValue*(1.0f - lambda);
+}
+
+template<>
+void SmoothStiffInt::update(int newValue){
+  if(abs(value-newValue) >= delta)
+    value = (value*lambda + newValue)/(lambda+1);
+}
+
+template<>
+float SmoothValue<float>::normal(float lambda, int blocksize){
+  return lambda*128.0f/blocksize;
+}
+
+template<>
+int SmoothValue<int>::normal(float lambda, int blocksize){
+  return (1.0f/(1.0-lambda))*128.0f/blocksize;
+}
+
+template<>
+float StiffValue<float>::normal(float delta){
+  return delta;
+}
+
+template<>
+int StiffValue<int>::normal(float delta){
+  return delta;
+}
+
+template class SmoothValue<int>;
+template class SmoothValue<float>;
+template class SmoothStiffValue<int>;
+template class SmoothStiffValue<float>;