Merge pull request #236 from sensorium/devel/mozziClass_FixMath

Specializations of Mozzi classes for FixMath

Author: tomcombriat

AudioOutput.h

@@ -57,6 +57,7 @@
 
 #ifndef AUDIOOUTPUT_H
 #define AUDIOOUTPUT_H
+#include <FixMath.h>
 
 /** The type used to store a single channel of a single frame, internally. For compatibility with earlier versions of Mozzi this is defined as int.
  *  If you do not care about keeping old sketches working, you may be able to save some RAM by using int16_t, instead (on boards where int is larger
@@ -134,8 +135,11 @@ struct MonoOutput {
   /** Construct an audio frame from a zero-centered value known to be in the 8 bit range. On AVR, if MOZZI_OUTPUT_PWM mode, this is effectively the same as calling the
    * constructor, directly (no scaling gets applied). On platforms/configs using more bits, an appropriate left-shift will be performed. */
   static inline MonoOutput from8Bit(int16_t l) { return fromNBit(8, l); }
-  /** Construct an audio frame a zero-centered value known to be in the 16 bit range. This is jsut a shortcut for fromNBit(16, ...) provided for convenience. */
+  /** Construct an audio frame from a zero-centered value known to be in the 16 bit range. This is jsut a shortcut for fromNBit(16, ...) provided for convenience. */
   static inline MonoOutput from16Bit(int16_t l) { return fromNBit(16, l); }
+  /** Construct an audio frame from a SFix type from FixMath. Mozzi will figure out how many bits are in there and performs appropriate shifting to match the output range. */
+  template<int8_t NI, int8_t NF, uint64_t RANGE>
+  static inline MonoOutput fromSFix(SFix<NI,NF,RANGE> l) { return MonoOutput(SCALE_AUDIO(l.asRaw(), (NI+NF+1))) ;}
   /** Construct an audio frame a zero-centered value known to be above at almost but not quite the N bit range, e.g. at N=8 bits and a litte. On most platforms, this is
    *  exactly the same as fromNBit(), shifting up or down to the platforms' available resolution.
    *
@@ -179,6 +183,9 @@ template<typename T> static inline StereoOutput fromNBit(uint8_t bits, T l, T r)
   static inline StereoOutput from8Bit(int16_t l, int16_t r) { return fromNBit(8, l, r); }
   /** See @ref MonoOutput::from16Bit(), stereo variant */
   static inline StereoOutput from16Bit(int16_t l, int16_t r) { return fromNBit(16, l, r); }
+/** See @ref MonoOutput::fromSFix(), stereo variant. Note that the two channels do not need to have the same number of bits. */
+  template<int8_t NI, int8_t NF, uint64_t RANGE, int8_t _NI, int8_t _NF, uint64_t _RANGE>
+  static inline StereoOutput fromSFix(SFix<NI,NF,RANGE> l, SFix<_NI,_NF,_RANGE> r) { return StereoOutput(SCALE_AUDIO(l.asRaw(), (NI+NF+1)), SCALE_AUDIO(r.asRaw(), (_NI+_NF+1))); }
   /** See @ref MonoOutput::fromAlmostNBit(), stereo variant */
   template<typename A, typename B> static inline StereoOutput fromAlmostNBit(A bits, B l, B r) { return StereoOutput(SCALE_AUDIO_NEAR(l, bits), SCALE_AUDIO_NEAR(r, bits)); }
 private:

Line.h

@@ -15,6 +15,8 @@
 
 #include <Arduino.h>
 
+#include<FixMath.h>
+
 /** For linear changes with a minimum of calculation at each step. For instance,
 you can use Line to make an oscillator glide from one frequency to another,
 pre-calculating the required phase increments for each end and then letting your
@@ -30,12 +32,15 @@ represent fractional numbers. Google "fixed point arithmetic" if this is new to
 you.
 */
 
+
+
+
 template <class T>
 class Line
 {
 private:
-	volatile T current_value; // volatile because it could be set in control interrupt and updated in audio
-	volatile T step_size;
+	T current_value;
+	T step_size;
 
 public:
 	/** Constructor. Use the template parameter to set the type of numbers you
@@ -109,7 +114,7 @@ template <>
 class Line <unsigned char>
 {
 private:
-	volatile unsigned char current_value; // volatile because it could be set in control interrupt and updated in audio
+	unsigned char current_value;
 	char step_size;
 
 public:
@@ -178,7 +183,7 @@ template <>
 class Line <unsigned int>
 {
 private:
-	volatile unsigned int current_value; // volatile because it could be set in control interrupt and updated in audio
+	unsigned int current_value;
 	int step_size;
 
 public:
@@ -250,7 +255,7 @@ template <>
 class Line <unsigned long>
 {
 private:
-	volatile unsigned long current_value; // volatile because it could be set in control interrupt and updated in audio
+	unsigned long current_value;
 	long step_size;
 
 public:
@@ -312,6 +317,174 @@ class Line <unsigned long>
 	}
 };
 
+
+/* UFix specialisation */
+template<int8_t NI, int8_t NF>
+class Line<UFix<NI, NF>>
+{
+private:
+  typedef UFix<NI, NF> internal_type;
+  internal_type current_value;
+  SFix<NI,NF> step_size;
+
+public:
+  /** Constructor. Use the template parameter to set the type of numbers you
+      want to use. For example, Line \<int\> myline; makes a Line which uses ints.
+  */
+  Line (){;}
+
+  /** Increments one step along the line.
+      @return the next value.
+  */
+  inline
+  internal_type next()
+  {
+    current_value = current_value + step_size;
+    return current_value;
+  }
+
+  /** Set the current value of the line. 
+      The Line will continue incrementing from this
+      value using any previously calculated step size.
+      @param value the number to set the Line's current_value to.
+  */
+  inline
+  void set(internal_type value)
+  {
+    current_value=value;
+  }
+
+  /** Given a target value and the number of steps to take on the way, this calculates the step size needed to get there from the current value.
+      @param targetvalue the value to move towards.
+      @param num_steps how many steps to take to reach the target as a UFix<_NI,0>
+  */
+  template<int8_t _NI>
+  void set(internal_type targetvalue, UFix<_NI,0> num_steps)
+  {
+    if(num_steps.asRaw()) {
+      auto numerator = targetvalue-current_value;
+      step_size = numerator*num_steps.invAccurate();
+    } else {
+      step_size = 0;
+      current_value = targetvalue;
+    }
+  }
+
+
+  /** Given a target value and the number of steps to take on the way, this calculates the step size needed to get there from the current value.
+      @param targetvalue the value to move towards.
+      @param num_steps how many steps to take to reach the target.
+  */
+  template<typename T>
+  void set(internal_type targetvalue, T num_steps)
+  {
+    if(num_steps) {
+      auto numerator = targetvalue-current_value;
+      step_size = internal_type(numerator.asRaw()/num_steps,true);
+    } else {
+      step_size = 0;
+      current_value = targetvalue;
+    }
+  }
+
+  /** Given a new starting value, target value and the number of steps to take on the way, this sets the step size needed to get there.
+      @param startvalue the number to set the Line's current_value to.
+      @param targetvalue the value to move towards.
+      @param num_steps how many steps to take to reach the target.
+  */
+  template<typename T>
+  void set(internal_type startvalue, internal_type targetvalue, T num_steps)
+  {
+    set(startvalue);
+    set(targetvalue, num_steps);
+  }  
+};
+
+
+/* SFix specialisation (if someone has an idea to avoid duplication with UFix) */
+template<int8_t NI, int8_t NF>
+class Line<SFix<NI, NF>>
+{
+private:
+  typedef SFix<NI, NF> internal_type;
+  internal_type current_value;
+  SFix<NI+1, NF> step_size;
+
+public:
+  /** Constructor. Use the template parameter to set the type of numbers you
+      want to use. For example, Line \<int\> myline; makes a Line which uses ints.
+  */
+  Line (){;}
+
+  /** Increments one step along the line.
+      @return the next value.
+  */
+  inline
+  internal_type next()
+  {
+    current_value = current_value + step_size;
+    return current_value;
+  }
+
+  /** Set the current value of the line. 
+      The Line will continue incrementing from this
+      value using any previously calculated step size.
+      @param value the number to set the Line's current_value to.
+  */
+  inline
+  void set(internal_type value)
+  {
+    current_value=value;
+  }
+
+  /** Given a target value and the number of steps to take on the way, this calculates the step size needed to get there from the current value.
+      @param targetvalue the value to move towards.
+      @param num_steps how many steps to take to reach the target as a UFix<_NI,0>
+  */
+  template<int8_t _NI>
+  void set(internal_type targetvalue, UFix<_NI,0> num_steps)
+  {
+    if(num_steps.asRaw()) {
+      auto numerator = targetvalue-current_value;
+      step_size = numerator*num_steps.invAccurate();
+    } else {
+      step_size = 0;
+      current_value = targetvalue;
+    }
+  }
+
+
+  /** Given a target value and the number of steps to take on the way, this calculates the step size needed to get there from the current value.
+      @param targetvalue the value to move towards.
+      @param num_steps how many steps to take to reach the target.
+  */
+  template<typename T>
+  void set(internal_type targetvalue, T num_steps)
+  {
+    if(num_steps) {
+      auto numerator = targetvalue-current_value;
+      step_size = internal_type(numerator.asRaw()/num_steps,true);
+    } else {
+      step_size = 0;
+      current_value = targetvalue;
+    }
+  }
+
+  /** Given a new starting value, target value and the number of steps to take on the way, this sets the step size needed to get there.
+      @param startvalue the number to set the Line's current_value to.
+      @param targetvalue the value to move towards.
+      @param num_steps how many steps to take to reach the target.
+  */
+  template<typename T>
+  void set(internal_type startvalue, internal_type targetvalue, T num_steps)
+  {
+    set(startvalue);
+    set(targetvalue, num_steps);
+  }  
+};
+
+
+
 /**
 @example 02.Control/Control_Tremelo/Control_Tremelo.ino
 This example demonstrates the Line class.

Oscil.h

@@ -159,9 +159,9 @@ class Oscil
 	each direction. This fixed point math number is interpreted as a SFix<15,16> internally.
 	@return a sample from the table.
 	*/
-  template <byte NI, byte NF>
+  template <int8_t NI, int8_t NF, uint8_t RANGE>
 	inline
-	int8_t phMod(SFix<NI,NF> phmod_proportion)
+  int8_t phMod(SFix<NI,NF,RANGE> phmod_proportion)
 	{
 	  return phMod(SFix<15,16>(phmod_proportion).asRaw());
 	}
@@ -216,11 +216,11 @@ class Oscil
 	@note This didn't run faster than float last time it was tested, after 2014 code changes.  Need to see if 2014 changes improved or worsened performance.
 	@param frequency in UFix<NI,NF> fixed-point number format.
 	*/
-  template <int8_t NI, int8_t NF>
+        template <int8_t NI, int8_t NF, uint64_t RANGE>
         inline
-  	void setFreq(UFix<NI,NF> frequency)
+        void setFreq(UFix<NI,NF,RANGE> frequency)
         {
-	  setFreq_Q16n16(UFix<16,16>(frequency).asRaw());
+        setFreq_Q16n16(UFix<16,16>(frequency).asRaw());
         }
 
 
@@ -256,8 +256,9 @@ class Oscil
 	less than 64 Hz.
 	@param frequency in UFix<24,8> fixed-point number format.
 	*/
+  template <uint64_t RANGE>
   inline
-	void setFreq(UFix<24,8> frequency)
+  void setFreq(UFix<24,8,RANGE> frequency)
         {
 	  setFreq_Q24n8(frequency.asRaw());
 	  }
@@ -295,8 +296,9 @@ class Oscil
 	@note This didn't run faster than float last time it was tested, after 2014 code changes.  Need to see if 2014 changes improved or worsened performance.
 	@param frequency in UFix<16,16> fixed-point number format.
 	*/
+  template <uint64_t RANGE>
    inline
-	void setFreq(UFix<16,16> frequency)
+  void setFreq(UFix<16,16,RANGE> frequency)
         {
 	  setFreq_Q16n16(frequency.asRaw());
 	  }
@@ -309,9 +311,9 @@ class Oscil
 	@note This didn't run faster than float last time it was tested, after 2014 code changes.  Need to see if 2014 changes improved or worsened performance.
 	@param frequency in SFix<16,16> fixed-point number format.
 	*/
-        template <byte NI, byte NF>
+  template <int8_t NI, int8_t NF, uint64_t RANGE>
         inline
-  	void setFreq(SFix<NI,NF> frequency)
+  void setFreq(SFix<NI,NF,RANGE> frequency)
         {
 	  setFreq_Q16n16(UFix<16,16>(frequency).asRaw());
         }