Merge branch 'master' of github.com:pingdynasty/OwlProgram

Conflicts:
	common.mk

Author: mars

HeavySource/HvMessage.c

@@ -20,7 +20,7 @@
 HvMessage *msg_init(HvMessage *m, hv_size_t numElements, hv_uint32_t timestamp) {
   m->timestamp = timestamp;
   m->numElements = (hv_uint16_t) numElements;
-  m->numBytes = (hv_uint16_t) msg_getByteSize(numElements);
+  m->numBytes = (hv_uint16_t) msg_getCoreSize(numElements);
   return m;
 }
 
@@ -43,7 +43,7 @@ HvMessage *msg_initWithBang(HvMessage *m, hv_uint32_t timestamp) {
 HvMessage *msg_initWithSymbol(HvMessage *m, hv_uint32_t timestamp, char *s) {
   m->timestamp = timestamp;
   m->numElements = 1;
-  m->numBytes = sizeof(HvMessage);
+  m->numBytes = sizeof(HvMessage) + (hv_uint16_t) hv_strlen(s);
   msg_setSymbol(m, 0, s);
   return m;
 }
@@ -56,51 +56,18 @@ HvMessage *msg_initWithHash(HvMessage *m, hv_uint32_t timestamp, hv_uint32_t h)
   return m;
 }
 
-HvMessage *msg_initV(HvMessage *const m, const hv_uint32_t timestamp, const char *format, ...) {
-  va_list ap;
-  va_start(ap, format);
-
-  const int numElem = (int) hv_strlen(format);
-  msg_init(m, numElem, timestamp);
-  for (int i = 0; i < numElem; i++) {
-    switch (format[i]) {
-      case 'b': msg_setBang(m,i); break;
-      case 'f': msg_setFloat(m, i, (float) va_arg(ap, double)); break;
-      case 's': msg_setSymbol(m, i, (char *) va_arg(ap, char *)); break;
-      case 'h': // hash not supported
-      default: break;
-    }
-  }
-  va_end(ap);
-
-  return m;
-}
-
-hv_size_t msg_getNumHeapBytes(const HvMessage *m) {
-  // get the size of all symbol elements
-  hv_size_t rsizeofsym = 0;
-  for (int i = 0; i < msg_getNumElements(m); ++i) {
-    if (msg_isSymbol(m,i)) {
-      rsizeofsym += (hv_size_t) hv_strlen(msg_getSymbol(m,i)) + 1; // +1 to allow for trailing '\0'
-    }
-  }
-
-  // the total byte size on the heap
-  return (msg_getByteSize(msg_getNumElements(m)) + rsizeofsym);
-}
-
 void msg_copyToBuffer(const HvMessage *m, char *buffer, hv_size_t len) {
   HvMessage *r = (HvMessage *) buffer;
 
+  hv_size_t len_r = msg_getCoreSize(msg_getNumElements(m));
+
   // assert that the message is not already larger than the length of the buffer
-  hv_assert(msg_getNumBytes(m) <= len);
+  hv_assert(len_r <= len);
 
   // copy the basic message to the buffer
-  hv_memcpy(r, m, msg_getNumBytes(m));
+  hv_memcpy(r, m, len_r);
 
-  hv_size_t len_r = msg_getNumBytes(m);
-
-  char *p = buffer + msg_getByteSize(msg_getNumElements(m)); // points to the end of the base message
+  char *p = buffer + len_r; // points to the end of the base message
   for (int i = 0; i < msg_getNumElements(m); ++i) {
     if (msg_isSymbol(m,i)) {
       const hv_size_t symLen = (hv_size_t) hv_strlen(msg_getSymbol(m,i)) + 1; // include the trailing null char
@@ -117,7 +84,7 @@ void msg_copyToBuffer(const HvMessage *m, char *buffer, hv_size_t len) {
 
 // the message is serialised such that all symbol elements are placed in order at the end of the buffer
 HvMessage *msg_copy(const HvMessage *m) {
-  const hv_size_t heapSize = msg_getNumHeapBytes(m);
+  const hv_uint32_t heapSize = msg_getSize(m);
   char *r = (char *) hv_malloc(heapSize);
   hv_assert(r != NULL);
   msg_copyToBuffer(m, r, heapSize);
@@ -184,6 +151,7 @@ hv_uint32_t msg_symbolToHash(const char *s) {
   static const hv_int32_t r = 24;
 
   if (s == NULL) return 0;
+
   hv_uint32_t len = (hv_uint32_t) hv_strlen(s);
   hv_uint32_t x = len; // seed (0) ^ len
 

HeavySource/HvUtils.h

@@ -207,6 +207,7 @@ static inline hv_size_t __hv_utils_max_ui(hv_size_t x, hv_size_t y) { return (x
 static inline hv_size_t __hv_utils_min_ui(hv_size_t x, hv_size_t y) { return (x < y) ? x : y; }
 static inline hv_int32_t __hv_utils_max_i(hv_int32_t x, hv_int32_t y) { return (x > y) ? x : y; }
 static inline hv_int32_t __hv_utils_min_i(hv_int32_t x, hv_int32_t y) { return (x < y) ? x : y; }
+
 #define hv_max_ui(a, b) __hv_utils_max_ui(a, b)
 #define hv_min_ui(a, b) __hv_utils_min_ui(a, b)
 #define hv_max_i(a, b) __hv_utils_max_i(a, b)
@@ -238,7 +239,12 @@ static inline hv_int32_t __hv_utils_min_i(hv_int32_t x, hv_int32_t y) { return (
 #define hv_exp_f(a) expf(a)
 #define hv_abs_f(a) fabsf(a)
 #define hv_log_f(a) logf(a)
-#define hv_log2_f(a) log2f(a)
+#if HV_ANDROID
+  // NOTE(mhroth): for whatever silly reason, log2f is not defined!
+  #define hv_log2_f(a) (1.44269504088896f*logf(a))
+#else
+  #define hv_log2_f(a) log2f(a)
+#endif // HV_ANDROID
 #define hv_log10_f(a) log10f(a)
 #define hv_ceil_f(a) ceilf(a)
 #define hv_floor_f(a) floorf(a)
@@ -260,4 +266,31 @@ static inline hv_int32_t __hv_utils_min_i(hv_int32_t x, hv_int32_t y) { return (
 #endif
 #define hv_min_max_log2(a) __hv_utils_min_max_log2(a)
 
+// Atomics
+#if HV_WIN
+#include <Windows.h>
+#define hv_atomic_bool volatile LONG
+#define HV_SPINLOCK_ACQUIRE(_x) \
+while (InterlockedCompareExchange(&_x, true, false)) { }
+#define HV_SPINLOCK_RELEASE(_x) (_x = false)
+#elif defined(__has_include)
+#if __has_include(<stdatomic.h>)
+#include <stdatomic.h>
+#define hv_atomic_bool volatile atomic_bool
+#define HV_SPINLOCK_ACQUIRE(_x) \
+bool expected = false; \
+while (!atomic_compare_exchange_strong(&_x, &expected, true)) { expected = false; }
+#define HV_SPINLOCK_RELEASE(_x) atomic_store(&_x, false)
+#else
+#define hv_atomic_bool volatile bool
+#define HV_SPINLOCK_ACQUIRE(_x) _x = true;
+#define HV_SPINLOCK_RELEASE(_x) _x = false;
+#endif
+#else
+#define hv_atomic_bool volatile bool
+#define HV_SPINLOCK_ACQUIRE(_x) _x = true;
+#define HV_SPINLOCK_RELEASE(_x) _x = false;
+#endif
+
+
 #endif // _HEAVY_UTILS_H_

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();