Merge branch 'master' into MetaOsc

Author: sensorium

AudioConfigESP.h

@@ -23,7 +23,7 @@
 #error HIFI mode is not available for this CPU architecture (but check ESP_AUDIO_OUT_MODE, and PDM_RESOLUTION)
 #endif
 
-#if (STEREO_HACK == true)
+#if (AUDIO_CHANNELS > 1)
 #if (ESP_AUDIO_OUT_MODE != EXTERNAL_DAC_VIA_I2S)
 #error Stereo is not available for the configured audio output mode
 #endif

AudioConfigRP2040.h

@@ -0,0 +1,53 @@
+#ifndef AUDIOCONFIGRP2040_H
+#define AUDIOCONFIGRP2040_H
+
+#if not IS_RP2040()
+#error This header should be included for RP2040, only
+#endif
+
+
+// AUDIO output modes
+#define PWM_VIA_BARE_CHIP 1  // output using one of the gpio of the board
+#define EXTERNAL_DAC_VIA_I2S 2  // output via external DAC connected to I2S (PT8211 or similar)
+
+//******* BEGIN: These are the defines you may want to change. Best not to touch anything outside this range. ************/
+#define RP2040_AUDIO_OUT_MODE PWM_VIA_BARE_CHIP
+//******* END: These are the defines you may want to change. Best not to touch anything outside this range. ************/
+
+
+#if (RP2040_AUDIO_OUT_MODE == PWM_VIA_BARE_CHIP)  
+#define AUDIO_CHANNEL_1_PIN 0
+#if (AUDIO_CHANNELS > 1)
+// Audio channel pins for stereo or HIFI must be on the same PWM slice (which is the case for the pairs (0,1), (2,3), (4,5), etc.
+#define AUDIO_CHANNEL_2_PIN 1
+#endif
+
+// The more audio bits you use, the slower the carrier frequency of the PWM signal. 11 bits yields ~ 60kHz on a 133Mhz CPU (which appears to be a reasonable compromise)
+#define AUDIO_BITS 11
+#endif
+
+#if (RP2040_AUDIO_OUT_MODE == EXTERNAL_DAC_VIA_I2S)
+// ****** BEGIN: These are define you may want to change. Best not to touch anything outside this range. ************/
+#define BCLK_PIN 20
+#define WS_PIN (pBCLK+1)  // CANNOT BE CHANGED, HAS TO BE NEXT TO pBCLK
+#define DOUT_PIN 22
+#define LSBJ_FORMAT false   // some DAC, like the PT8211, use a variant of I2S data format called LSBJ
+                           // set this to true to use this kind of DAC or false for plain I2S.
+#define AUDIO_BITS 16   // available values are 8, 16, 24 (LEFT ALIGN in 32 bits type!!) and 32 bits
+// ****** END: These are define you may want to change. Best not to touch anything outside this range. ************/
+
+#define BYPASS_MOZZI_OUTPUT_BUFFER true
+
+// Configuration of the I2S port, especially DMA. Set in stone here as default of the library when this was written.
+// Probably do not change if you are not sure of what you are doing
+#define BUFFERS 8       // number of DMA buffers used
+#define BUFFER_SIZE 256  // total size of the buffer, in samples
+#endif
+
+
+#define AUDIO_BITS_PER_CHANNEL AUDIO_BITS
+
+#define AUDIO_BIAS ((uint16_t) 1<<(AUDIO_BITS-1))
+
+#endif        //  #ifndef AUDIOCONFIGRP2040_H
+

AudioConfigSTM32.h

@@ -22,7 +22,7 @@
 // The more audio bits you use, the slower the carrier frequency of the PWM signal. 10 bits yields ~ 70kHz on a 72Mhz CPU (which appears to be a reasonable compromise)
 #define AUDIO_BITS 10
 #define AUDIO_BITS_PER_CHANNEL AUDIO_BITS
-#if (STEREO_HACK == true)
+#if (AUDIO_CHANNELS > 1)
 #define AUDIO_CHANNEL_2_PIN PB9
 #endif
 #endif

AudioConfigTeensy3_12bit.h

@@ -1,6 +1,7 @@
 #ifndef AUDIOCONFIGTEENSY3_12BIT_H
 #define AUDIOCONFIGTEENSY3_12BIT_H
 
+#warning If you get a compilation error you should probably update Teensyduino to its latest version
 
 /** @ingroup core
 */

AudioConfigTeensy4.h

@@ -0,0 +1,17 @@
+#ifndef AUDIOCONFIGTEENSY4_H
+#define AUDIOCONFIGTEENSY4_H
+
+#warning If you get a compilation error you should probably update Teensyduino to its latest version
+
+/** @ingroup core
+*/
+/* Used internally to put the 0-biased generated audio into the centre of the output range (10 bits on Teensy 4 using PWM) */
+#define AUDIO_BIAS ((uint16_t) 512)
+#define AUDIO_BITS 10
+
+#define AUDIO_CHANNEL_1_PIN A8
+#define AUDIO_CHANNEL_2_PIN A9
+
+
+#endif        //  #ifndef AUDIOCONFIGTEENSY4_H
+

AudioOutput.h

@@ -55,9 +55,13 @@
 #define CLIP_AUDIO(x) constrain((x), (-(AudioOutputStorage_t) AUDIO_BIAS), (AudioOutputStorage_t) AUDIO_BIAS-1)
 #endif
 
+#if (AUDIO_CHANNELS == STEREO)
+#define AudioOutput StereoOutput
 #if (STEREO_HACK == true)
 #define AudioOutput_t void
-#define AudioOutput StereoOutput
+#else
+#define AudioOutput_t StereoOutput
+#endif
 #else
 /** Representation of an single audio output sample/frame. For mono output, this is really just a single zero-centered int,
  *  but for stereo it's a struct containing two ints.
@@ -87,27 +91,25 @@ struct StereoOutput {
   StereoOutput(AudioOutputStorage_t l, AudioOutputStorage_t r) : _l(l), _r(r) {};
   /** Default contstructor */
   StereoOutput() : _l(0), _r(0) {};
-#if (STEREO_HACK != true)
-  /** Conversion to int operator: If used in a mono config, returns only the left channel (and gives a compile time warning). */
-  inline operator AudioOutput_t() const __attribute__((deprecated("Sketch generates stereo output, but Mozzi is configured for mono. Check mozzi_config.h."))) { return _l; };
+#if (AUDIO_CHANNELS != STEREO)
+  /** Conversion to int operator: If used in a mono config, returns only the left channel (and gives a compile time warning). 
+      This _could_ be turned into an operator for implicit conversion in this case. For now we chose to apply conversion on demand, only, as most of the time
+      using StereoOutput in a mono config, is not intended. */
+  inline AudioOutput_t portable() const __attribute__((deprecated("Sketch generates stereo output, but Mozzi is configured for mono. Check mozzi_config.h."))) { return _l; };
 #endif
   AudioOutputStorage_t l() const { return _l; };
   AudioOutputStorage_t r() const { return _r; };
   /** @see MonoOutput::clip(). Clips both channels. */
   StereoOutput& clip() { _l = CLIP_AUDIO(_l); _r = CLIP_AUDIO(_r); return *this; };
 
   /** @see MonoOutput::fromNBit(), stereo variant */
-  static inline StereoOutput fromNBit(uint8_t bits, int16_t l, int16_t r) { return StereoOutput(SCALE_AUDIO(l, bits), SCALE_AUDIO(r, bits)); }
-  /** @see MonoOutput::fromNBit(), stereo variant, 32 bit overload */
-  static inline StereoOutput fromNBit(uint8_t bits, int32_t l, int32_t r) { return StereoOutput(SCALE_AUDIO(l, bits), SCALE_AUDIO(r, bits)); }
+template<typename T> static inline StereoOutput fromNBit(uint8_t bits, T l, T r) { return StereoOutput(SCALE_AUDIO(l, bits), SCALE_AUDIO(r, bits)); }
   /** @see MonoOutput::from8Bit(), stereo variant */
   static inline StereoOutput from8Bit(int16_t l, int16_t r) { return fromNBit(8, l, r); }
   /** @see MonoOutput::from16Bit(), stereo variant */
   static inline StereoOutput from16Bit(int16_t l, int16_t r) { return fromNBit(16, l, r); }
   /** @see MonoOutput::fromAlmostNBit(), stereo variant */
-  static inline StereoOutput fromAlmostNBit(uint8_t bits, int16_t l, int16_t r) { return StereoOutput(SCALE_AUDIO_NEAR(l, bits), SCALE_AUDIO_NEAR(r, bits)); }
-  /** @see MonoOutput::fromAlmostNBit(), stereo variant, 32 bit overload */
-  static inline StereoOutput fromAlmostNBit(uint8_t bits, int32_t l, int32_t r) { return StereoOutput(SCALE_AUDIO_NEAR(l, bits), SCALE_AUDIO_NEAR(r, bits)); }
+  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:
   AudioOutputStorage_t _l;
   AudioOutputStorage_t _r;
@@ -130,9 +132,11 @@ struct StereoOutput {
 struct MonoOutput {
   /** Construct an audio frame from raw values (zero-centered) */
   MonoOutput(AudioOutputStorage_t l=0) : _l(l) {};
-#if (STEREO_HACK == true)
-  /** Conversion to stereo operator: If used in a stereo config, returns identical channels (and gives a compile time warning). */
-  inline operator StereoOutput() const __attribute__((deprecated("Sketch generates mono output, but Mozzi is configured for stereo. Check mozzi_config.h."))) { return StereoOutput(_l, _l); };
+#if (AUDIO_CHANNELS > 1)
+  /** Conversion to stereo operator: If used in a stereo config, returns identical channels (and gives a compile time warning).
+      This _could_ be turned into an operator for implicit conversion in this case. For now we chose to apply conversion on demand, only, as most of the time
+      using StereoOutput in a mono config, is not intended. */
+  inline StereoOutput portable() const __attribute__((deprecated("Sketch generates mono output, but Mozzi is configured for stereo. Check mozzi_config.h."))) { return StereoOutput(_l, _l); };
 #else
   /** Conversion to int operator. */
   inline operator AudioOutput_t() const { return _l; };
@@ -146,9 +150,7 @@ struct MonoOutput {
   /** Construct an audio frame a zero-centered value known to be in the N bit range. Appropriate left- or right-shifting will be performed, based on the number of output
    *  bits available. While this function takes care of the shifting, beware of potential overflow issues, if your intermediary results exceed the 16 bit range. Use proper
    *  casts to int32_t or larger in that case (and the compiler will automatically pick the 32 bit overload in this case) */
-  static inline MonoOutput fromNBit(uint8_t bits, int16_t l) { return MonoOutput(SCALE_AUDIO(l, bits)); }
-  /** 32bit overload. See above. */
-  static inline MonoOutput fromNBit(uint8_t bits, int32_t l) { return MonoOutput(SCALE_AUDIO(l, bits)); }
+  template<typename T> static inline MonoOutput fromNBit(uint8_t bits, T l) { return MonoOutput(SCALE_AUDIO(l, bits)); }
   /** Construct an audio frame from a zero-centered value known to be in the 8 bit range. On AVR, STANDADR or STANDARD_PLUS 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); }
@@ -162,9 +164,8 @@ struct MonoOutput {
    *
    *  @example fromAlmostNBit(10, oscilA.next() + oscilB.next() + oscilC.next());
    */
-  static inline MonoOutput fromAlmostNBit(uint8_t bits, int16_t l) { return MonoOutput(SCALE_AUDIO_NEAR(l, bits)); }
-  /** 32bit overload. See above. */
-  static inline MonoOutput fromAlmostNBit(uint8_t bits, int32_t l) { return MonoOutput(SCALE_AUDIO_NEAR(l, bits)); }
+  template<typename A, typename B> static inline MonoOutput fromAlmostNBit(A bits, B l) { return MonoOutput(SCALE_AUDIO_NEAR(l, bits)); }
+
 private:
   AudioOutputStorage_t _l;
 };
@@ -211,182 +212,7 @@ inline uint32_t pdmCode32(uint16_t sample) {
   return outbits;
 }
 
-#if (EXTERNAL_AUDIO_OUTPUT != true)
-
-///////////////////// SAMD21
-#if IS_SAMD21()
-#include "AudioConfigSAMD21.h"
-inline void audioOutput(const AudioOutput f)
-{
-  analogWrite(AUDIO_CHANNEL_1_PIN, f.l()+AUDIO_BIAS);
-}
-#endif
-
-
-///////////////////// TEENSY3
-#if IS_TEENSY3()
-#include "AudioConfigTeensy3_12bit.h"
-inline void audioOutput(const AudioOutput f)
-{
-  analogWrite(AUDIO_CHANNEL_1_PIN, f.l()+AUDIO_BIAS);
-}
-#endif
-
-
-///////////////////// STM32
-#if IS_STM32()
-#include "AudioConfigSTM32.h"
-inline void audioOutput(const AudioOutput f)
-{
-#if (AUDIO_MODE == HIFI)
-  pwmWrite(AUDIO_CHANNEL_1_PIN, (f.l()+AUDIO_BIAS) & ((1 << AUDIO_BITS_PER_CHANNEL) - 1));
-  pwmWrite(AUDIO_CHANNEL_1_PIN_HIGH, (f.l()+AUDIO_BIAS) >> AUDIO_BITS_PER_CHANNEL);
-#else
-  pwmWrite(AUDIO_CHANNEL_1_PIN, f.l()+AUDIO_BIAS);
-#if (STEREO_HACK == true)
-  pwmWrite(AUDIO_CHANNEL_2_PIN, f.r()+AUDIO_BIAS);
-#endif
-#endif
-}
-#endif
-
-
-///////////////////// ESP8266
-#if IS_ESP8266()
-#include "AudioConfigESP.h"
-#if (ESP_AUDIO_OUT_MODE == PDM_VIA_I2S)
-#include <i2s.h>
-inline bool canBufferAudioOutput() {
-  return (i2s_available() >= PDM_RESOLUTION);
-}
-inline void audioOutput(const AudioOutput f) {
-  for (uint8_t words = 0; words < PDM_RESOLUTION; ++words) {
-    i2s_write_sample(pdmCode32(f.l()));
-  }
-}
-#elif (ESP_AUDIO_OUT_MODE == EXTERNAL_DAC_VIA_I2S)
-#include <i2s.h>
-inline bool canBufferAudioOutput() {
-  return (i2s_available() >= PDM_RESOLUTION);
-}
-inline void audioOutput(const AudioOutput f) {
-  i2s_write_lr(f.l(), f.r());  // Note: i2s_write expects zero-centered output
-}
-#else
-inline void audioOutput(const AudioOutput f) {
-  // optimized version of: Serial1.write(...);
-  for (uint8_t i = 0; i < PDM_RESOLUTION*4; ++i) {
-    U1F = pdmCode8(f);
-  }
-}
-#endif
-#endif
-
-
-
-///////////////////// ESP32
-#if IS_ESP32()
-#include "AudioConfigESP32.h"
-// On ESP32 we cannot test wether the DMA buffer has room. Instead, we have to use a one-sample mini buffer. In each iteration we
-// _try_ to write that sample to the DMA buffer, and if successful, we can buffer the next sample. Somewhat cumbersome, but works.
-// TODO: Should ESP32 gain an implemenation of i2s_available(), we should switch to using that, instead.
-static bool _esp32_can_buffer_next = true;
-#if (ESP32_AUDIO_OUT_MODE == INTERNAL_DAC)
-static uint16_t _esp32_prev_sample[2];
-#define ESP_SAMPLE_SIZE (2*sizeof(uint16_t))
-#elif (ESP32_AUDIO_OUT_MODE == PT8211_DAC)
-static int16_t _esp32_prev_sample[2];
-#define ESP_SAMPLE_SIZE (2*sizeof(int16_t))
-#elif (ESP32_AUDIO_OUT_MODE == PDM_VIA_I2S)
-static uint32_t _esp32_prev_sample[PDM_RESOLUTION];
-#define ESP_SAMPLE_SIZE (PDM_RESOLUTION*sizeof(uint32_t))
-#endif
-
-inline bool esp32_tryWriteSample() {
-  size_t bytes_written;
-  i2s_write(i2s_num, &_esp32_prev_sample, ESP_SAMPLE_SIZE, &bytes_written, 0);
-  return (bytes_written != 0);
-}
-
-inline bool canBufferAudioOutput() {
-  if (_esp32_can_buffer_next) return true;
-  _esp32_can_buffer_next = esp32_tryWriteSample();
-  return _esp32_can_buffer_next;
-}
-
-inline void audioOutput(const AudioOutput f) {
-#if (ESP32_AUDIO_OUT_MODE == INTERNAL_DAC)
-  _esp32_prev_sample[0] = (f.l() + AUDIO_BIAS) << 8;
-#if (STEREO_HACK == true)
-  _esp32_prev_sample[1] = (f.r() + AUDIO_BIAS) << 8;
-#else
-  // For simplicity of code, even in mono, we're writing stereo samples
-  _esp32_prev_sample[1] = _esp32_prev_sample[0];
-#endif
-#elif (ESP32_AUDIO_OUT_MODE == PDM_VIA_I2S)
-  for (uint8_t i=0; i<PDM_RESOLUTION; ++i) {
-    _esp32_prev_sample[i] = pdmCode32(f.l() + AUDIO_BIAS);
-  }
-#else
-  // PT8211 takes signed samples
-  _esp32_prev_sample[0] = f.l();
-  _esp32_prev_sample[1] = f.r();
-#endif
-  _esp32_can_buffer_next = esp32_tryWriteSample();
-}
-
-#endif
-
-
-
-///////////////////// AVR STANDARD
-#if IS_AVR() && (AUDIO_MODE == STANDARD_PLUS)
-#include "AudioConfigStandardPlus.h"
-inline void audioOutput(const AudioOutput f)
-{
-  AUDIO_CHANNEL_1_OUTPUT_REGISTER = f.l()+AUDIO_BIAS;
-#if (STEREO_HACK == true)
-  AUDIO_CHANNEL_2_OUTPUT_REGISTER = f.r()+AUDIO_BIAS;
-#endif
-}
-
-
-
-///////////////////// AVR HIFI
-#elif IS_AVR() && (AUDIO_MODE == HIFI)
-#include "AudioConfigHiSpeed14bitPwm.h"
-inline void audioOutput(const AudioOutput f)
-{
-  // read about dual pwm at
-  // http://www.openmusiclabs.com/learning/digital/pwm-dac/dual-pwm-circuits/
-  // sketches at http://wiki.openmusiclabs.com/wiki/PWMDAC,
-  // http://wiki.openmusiclabs.com/wiki/MiniArDSP
-  // if (!output_buffer.isEmpty()){
-  //unsigned int out = output_buffer.read();
-  // 14 bit, 7 bits on each pin
-  // AUDIO_CHANNEL_1_highByte_REGISTER = out >> 7; // B00111111 10000000 becomes
-  // B1111111
-  // try to avoid looping over 7 shifts - need to check timing or disassemble to
-  // see what really happens unsigned int out_high = out<<1; // B00111111
-  // 10000000 becomes B01111111 00000000
-  // AUDIO_CHANNEL_1_highByte_REGISTER = out_high >> 8; // B01111111 00000000
-  // produces B01111111 AUDIO_CHANNEL_1_lowByte_REGISTER = out & 127;
-  /* Atmega manual, p123
-  The high byte (OCR1xH) has to be written first.
-  When the high byte I/O location is written by the CPU,
-  the TEMP Register will be updated by the value written.
-  Then when the low byte (OCR1xL) is written to the lower eight bits,
-  the high byte will be copied into the upper 8-bits of
-  either the OCR1x buffer or OCR1x Compare Register in
-  the same system clock cycle.
-  */
-  AUDIO_CHANNEL_1_highByte_REGISTER = (f.l()+AUDIO_BIAS) >> AUDIO_BITS_PER_REGISTER;
-  AUDIO_CHANNEL_1_lowByte_REGISTER = (f.l()+AUDIO_BIAS) & ((1 << AUDIO_BITS_PER_REGISTER) - 1);
-}
-#endif
-
-
-#else
+#if (EXTERNAL_AUDIO_OUTPUT == true)
 #warning "Mozzi is configured to use an external void 'audioOutput(const AudioOutput f)' function. Please define one in your sketch"
 #endif
 

IntegerType.h

@@ -0,0 +1,27 @@
+
+template<uint8_t BYTES> struct IntegerType {
+    // at an odd value, such as 3 bytes? Add one more byte (up to at most 8 bytes)..
+    typedef typename IntegerType<(BYTES < 8) ? (BYTES+1) : 8>::unsigned_type unsigned_type;
+    typedef typename IntegerType<(BYTES < 8) ? (BYTES+1) : 8>::signed_type signed_type;
+};
+
+// These are the specializations for the types that we actually assume to exist:
+template<> struct IntegerType<1> {
+    typedef uint8_t unsigned_type;
+    typedef int8_t signed_type;
+};
+
+template<> struct IntegerType<2> {
+    typedef uint16_t unsigned_type;
+    typedef int16_t signed_type;
+};
+
+template<> struct IntegerType<4> {
+    typedef uint32_t unsigned_type;
+    typedef int32_t signed_type;
+};
+
+template<> struct IntegerType<8> {
+    typedef uint64_t unsigned_type;
+    typedef int64_t signed_type;
+};