Arduino UNO R4

Author: pschatzmann

src/AudioAnalog/AnalogAudio.h

@@ -87,6 +87,11 @@ class AnalogAudioStream  : public AudioStream {
     int available() override {
         return driver.available();
     }
+
+    int availableForWrite() override {
+        return driver.availableForWrite();
+    }
+
 protected:
     AnalogDriver driver;
     AnalogConfig adc_config;

src/AudioAnalog/AnalogAudioArduino.h

@@ -24,28 +24,21 @@ class AnalogDriverArduino : public AnalogDriverBase {
 
   bool begin(AnalogConfig cfg) {
     TRACED();
-    if (cfg.rx_tx_mode == RXTX_MODE) {
+    config = cfg;
+    if (config.rx_tx_mode == RXTX_MODE) {
       LOGE("RXTX not supported");
       return false;
     }
-    config = cfg;
-    if (buffer == nullptr) {
-      // allocate buffer_count
-      buffer = new NBuffer<int16_t>(cfg.buffer_size, cfg.buffer_count);
-      if (buffer == nullptr) {
-        LOGE("Not enough memory for buffer");
-        return false;
-      }
-      // setup pins
-      setupPins();
-    } else {
-      timer.end();
-    }
+
+    frame_size = config.channels*(config.bits_per_sample/8);
+    result_factor = 1;
+
+    if (!setupTx()) return false;
+    
+    if (!setupBuffer()) return false;
 
     // (re)start timer
-    LOGI("sample_rate: %d", cfg.sample_rate);
-    timer.setCallbackParameter(this);
-    return timer.begin(callback, cfg.sample_rate, TimeUnit::HZ);
+    return setupTimer();
   }
 
   void end() override { timer.end(); }
@@ -59,35 +52,107 @@ class AnalogDriverArduino : public AnalogDriverBase {
   size_t readBytes(uint8_t *values, size_t len) {
     if (config.rx_tx_mode == TX_MODE) return 0;
     if (buffer == nullptr) return 0;
-    int samples = len / 2;
-    return buffer->readArray((int16_t *)values, samples) * 2;
+    int bytes = len / frame_size * frame_size;
+    return buffer->readArray(values, bytes);
   }
 
   int availableForWrite() {
     if (config.rx_tx_mode == RX_MODE) return 0;
-    return buffer == nullptr ? 0 : buffer->availableForWrite() * 2;
+    if (buffer == nullptr) return 0;
+    return config.is_blocking_write ? config.buffer_size : buffer->availableForWrite();
   }
 
   size_t write(const uint8_t *data, size_t len) {
+    LOGD("write: %d", (int)len);
     if (config.rx_tx_mode == RX_MODE) return 0;
+    // only process full frames
+    len = len / frame_size * frame_size;
+
+    if (isCombinedChannel()){
+        ChannelReducer cr(1, 2, config.bits_per_sample);
+        len = cr.convert((uint8_t*)data, len);
+        LOGD("ChannelReducer len: %d", (int) len);
+    }
+
+    if (isDecimateActive()){
+        Decimate dec(decim, 1, config.bits_per_sample);
+        len = dec.convert((uint8_t*)data, len);
+        LOGD("Decimate len: %d for factor %d", (int) len, decim);
+    }
 
     // blocking write ?
     if (config.is_blocking_write) {
       LOGD("Waiting for buffer to be available");
-      while (buffer->availableForWrite() == 0) {
+      while (buffer->availableForWrite() < len) {
         delay(10);
       }
     }
+
     // write data
-    int16_t *data_16 = (int16_t *)data;
-    return buffer->writeArray(data_16, len / 2) * 2;
+    size_t result = buffer->writeArray(data, len) * result_factor;
+    LOGD("write: -> %d / factor: %d", (int)result, result_factor);
+    return result;
   }
 
  protected:
   AnalogConfig config;
   TimerAlarmRepeating timer;
-  BaseBuffer<int16_t> *buffer = nullptr;
+  BaseBuffer<uint8_t> *buffer = nullptr;
   int avg_value, min, max, count;
+  bool is_combined_channels = false;
+  uint16_t frame_size = 0;
+  int result_factor = 1;
+  int decim = 1;
+
+  bool setupTx(){
+    if (config.rx_tx_mode == TX_MODE) {
+      // check channels
+      if (config.channels>ANALOG_MAX_OUT_CHANNELS){
+        if (config.channels == 2){
+          is_combined_channels = true;
+          config.channels = 1;
+        } else {
+          LOGE("Unsupported channels");
+          return false;
+        }
+      }
+      if (isDecimateActive()){
+          LOGI("Using reduced sample rate: %d", effectiveOutputSampleRate());
+          decim = decimation();
+          result_factor = result_factor * decim;
+      }
+      if (isCombinedChannel()){
+          LOGI("Combining channels");
+          result_factor = result_factor * 2;
+      }
+    }
+    return true;
+  }
+
+  bool setupBuffer(){
+    if (buffer == nullptr) {
+      // allocate buffer_count
+      buffer = new RingBuffer<uint8_t>(config.buffer_size * config.buffer_count);
+      if (buffer == nullptr) {
+        LOGE("Not enough memory for buffer");
+        return false;
+      }
+      // setup pins
+      setupPins();
+    } else {
+      LOGE("Not enough memory");
+      timer.end();
+      return false;
+    }
+    return true;
+  }
+
+  bool setupTimer(){
+    int sample_rate = config.rx_tx_mode == TX_MODE ?  effectiveOutputSampleRate() : config.sample_rate;
+    LOGI("sample_rate: %d", sample_rate);
+    timer.setCallbackParameter(this);
+    return timer.begin(callback, sample_rate, TimeUnit::HZ);
+  }
 
   /// Sample data and write to buffer
   static void callback(void *arg) {
@@ -163,6 +228,34 @@ class AnalogDriverArduino : public AnalogDriverBase {
     max = INT_MIN; 
     count = 0;
   }
+
+    /// The requested sampling rate is too hight: we only process half of the samples so we can half the sampling rate
+    bool isDecimateActive(){
+        return config.sample_rate >= ANALOG_MAX_SAMPLE_RATE;
+    } 
+
+    // combined stereo channel to mono
+    bool isCombinedChannel(){
+      return is_combined_channels;
+    }   
+
+    /// Returns the effective output sample rate
+    int effectiveOutputSampleRate(){
+        return config.sample_rate / decimation();
+    } 
+
+    int decimation() {
+        if (config.sample_rate <= ANALOG_MAX_SAMPLE_RATE) return 1;
+        for(int j=2;j<6;j+=2){
+            if (config.sample_rate/j <= ANALOG_MAX_SAMPLE_RATE) {
+                return j;
+            }
+        }
+        return 6;
+    }
+
+  
+
 };
 
 using AnalogDriver = AnalogDriverArduino;

src/AudioAnalog/AnalogAudioBase.h

@@ -18,8 +18,8 @@ namespace audio_tools {
  */
 class AnalogConfig : public AudioInfo {
   public:
-    int buffer_count = I2S_BUFFER_COUNT;
-    int buffer_size = I2S_BUFFER_SIZE;
+    int buffer_count = PWM_BUFFER_COUNT;
+    int buffer_size = PWM_BUFFER_SIZE;
     RxTxMode rx_tx_mode;
     bool is_blocking_write = true;
     bool is_auto_center_read = true;

src/AudioConfig.h

@@ -133,8 +133,8 @@
 #define PWM_BUFFER_SIZE 1024
 #endif
 
-#ifndef PWM_BUFFERS 
-#define PWM_BUFFERS 4
+#ifndef PWM_BUFFER_COUNT 
+#define PWM_BUFFER_COUNT 4
 #endif
 
 #ifndef PWM_AUDIO_FREQUENCY 
@@ -601,6 +601,8 @@ using WiFiServerSecure = BearSSL::WiFiServerSecure;
 #define PIN_ANALOG_START A0
 #define ANALOG_BUFFER_SIZE 512
 #define ANALOG_BUFFERS 5
+#define ANALOG_MAX_OUT_CHANNELS 1
+#define ANALOG_MAX_SAMPLE_RATE 16000
 // default pins for UNO VS1053 shield
 #define VS1053_CS 6 
 #define VS1053_DCS 7 

src/AudioHttp/AudioServer.h

@@ -132,7 +132,7 @@ class AudioServer {
         }
 
         // defines a converter that will be used when the audio is rendered
-        void setConverter(BaseConverter<int16_t>  *c){
+        void setConverter(BaseConverter  *c){
             converter_ptr = c;
         }
 
@@ -160,7 +160,7 @@ class AudioServer {
         AudioServerDataCallback callback = nullptr;
         Stream *in = nullptr;                    
         StreamCopy copier;
-        BaseConverter<int16_t> *converter_ptr = nullptr;
+        BaseConverter *converter_ptr = nullptr;
 
         void setupServer(int port) {
             WiFiServer tmp(port);
@@ -286,7 +286,7 @@ class AudioEncoderServer  : public AudioServer {
          * @param sample_rate 
          * @param channels 
          */
-        void begin(Stream &in, int sample_rate, int channels, int bits_per_sample=16, BaseConverter<int16_t> *converter=nullptr) {
+        void begin(Stream &in, int sample_rate, int channels, int bits_per_sample=16, BaseConverter *converter=nullptr) {
             TRACED();
             this->in = &in;
             audio_info.sample_rate = sample_rate;
@@ -307,7 +307,7 @@ class AudioEncoderServer  : public AudioServer {
          * @param info 
          * @param converter 
          */
-        void begin(Stream &in, AudioInfo info, BaseConverter<int16_t> *converter=nullptr) {
+        void begin(Stream &in, AudioInfo info, BaseConverter *converter=nullptr) {
             TRACED();
             this->in = &in;
             this->audio_info = info;

src/AudioI2S/I2SESP32.h

@@ -111,15 +111,15 @@ class I2SDriverESP32 {
         // convert to 1 channel
         switch(cfg.bits_per_sample){
           case 16: {
-            ChannelReducer<int16_t> reducer16(1, 2);
+            ChannelReducerT<int16_t> reducer16(1, 2);
             result = reducer16.convert((uint8_t*)dest,temp, result);
             } break;
            case 24: {
-             ChannelReducer<int24_t> reducer24(1,2);
+             ChannelReducerT<int24_t> reducer24(1,2);
              result = reducer24.convert((uint8_t*)dest,temp,result);
              } break;
           case 32: {
-            ChannelReducer<int32_t> reducer32(1, 2);
+            ChannelReducerT<int32_t> reducer32(1, 2);
             result = reducer32.convert((uint8_t*)dest, temp, result);
             } break;
           default: