Resample

Author: pschatzmann

examples/examples-audiokit/streams-generator-audiokit/streams-generator-audiokit.ino

@@ -0,0 +1,40 @@
+/**
+ * @file streams-generator-audiokit.ino
+ * @brief Tesing I2S output on audiokit
+ * @author Phil Schatzmann
+ * @copyright GPLv3
+ */
+ 
+#include "AudioTools.h"
+#include "AudioLibs/AudioKit.h"
+
+uint16_t sample_rate=44100;
+uint8_t channels = 2;                                      // The stream will have 2 channels 
+SineWaveGenerator<int16_t> sineWave(32000);                // subclass of SoundGenerator with max amplitude of 32000
+GeneratedSoundStream<int16_t> sound(sineWave);             // Stream generated from sine wave
+AudioKitStream out; 
+StreamCopy copier(out, sound);                             // copies sound into i2s
+
+// Arduino Setup
+void setup(void) {  
+  // Open Serial 
+  Serial.begin(115200);
+  AudioLogger::instance().begin(Serial, AudioLogger::Info);
+
+  // start I2S
+  Serial.println("starting I2S...");
+  auto config = out.defaultConfig(TX_MODE);
+  config.sample_rate = sample_rate; 
+  config.channels = channels;
+  config.bits_per_sample = 16;
+  out.begin(config);
+
+  // Setup sine wave
+  sineWave.begin(channels, sample_rate, N_B4);
+  Serial.println("started...");
+}
+
+// Arduino loop - copy sound to out 
+void loop() {
+  copier.copy();
+}

examples/examples-basic-api/basic-a2dp-i2s/AudioConfigLocal.h

@@ -0,0 +1,4 @@
+#pragma once
+
+#define I2S_BUFFER_COUNT 8
+#define I2S_BUFFER_SIZE 256

examples/examples-basic-api/basic-a2dp-i2s/basic-a2dp-i2s.ino

@@ -0,0 +1,54 @@
+/**
+ * @file basic-a2dp-audioi2s.ino
+ * @brief A2DP Sink with output to SPDIFStream
+ * 
+ * @author Phil Schatzmann
+ * @copyright GPLv3
+ */
+
+/**
+ * @file basic-a2dp-audioi2s.ino
+ * @brief A2DP Sink with output to SPDIFStream
+ * 
+ * @author Phil Schatzmann
+ * @copyright GPLv3
+ */
+
+#define USE_A2DP
+#include "AudioConfigLocal.h"
+#include "AudioTools.h"
+#include "AudioExperiments/Resample.h"
+
+BluetoothA2DPSink a2dp_sink;
+I2SStream i2s;
+Resample<int16_t> out(i2s, 2, 2);
+
+// Write data to SPDIF in callback
+void read_data_stream(const uint8_t *data, uint32_t length) {
+    out.write(data, length);
+}
+
+void setup() {
+  Serial.begin(115200);
+  AudioLogger::instance().begin(Serial, AudioLogger::Warning);
+  
+  // register callback
+  a2dp_sink.set_stream_reader(read_data_stream, false);
+
+  // Start Bluetooth Audio Receiver
+  a2dp_sink.set_auto_reconnect(false);
+  a2dp_sink.start("a2dp-i2s");
+
+  // setup output
+  auto cfg = i2s.defaultConfig();
+  cfg.pin_data = 23;
+  cfg.sample_rate = a2dp_sink.sample_rate()*2;
+  cfg.channels = 2;
+  cfg.bits_per_sample = 16;
+  i2s.begin(cfg);
+
+}
+
+void loop() {
+  delay(100);
+}

examples/examples-maximilian/04-AM2/04-AM2.ino

@@ -31,7 +31,7 @@ void play(double *output) {
     //The frequency of the second new wave is the difference of the two original waves.
     //So you hear two new waves, one going up, one going down.
 
-    output[0]=mySine.sinewave(440)*myOtherSine.sinewave(myPhasor.phasor(0.01,0,440));
+    output[0]=mySine.sinewave(440)*myOtherSine.sinewave(myPhasor.phasorBetween(0.01,0,440));
     output[1]=output[0];
 
 }

examples/examples-maximilian/08-Counting2/08-Counting2.ino

@@ -37,7 +37,7 @@ void play(double *output) {
     // Once every second, CurrentCount counts from 1 until it gets to 9, then resets itself.
     // When it reaches 9 it resets, so the values you get are 1-8.
 
-    CurrentCount=myCounter.phasor(1, 1, 9);//phasor can take three arguments; frequency, start value and end value.
+    CurrentCount=myCounter.phasor(1.0, 1.0, 9.0);//phasor can take three arguments; frequency, start value and end value.
 
     // If we multiply the output of CurrentCount by 100, we get 100,200,300,400,500,600,700,800 in that order.
     // These become the frequency of the oscillator.

examples/examples-stream/streams-generator-i2s/streams-generator-i2s.ino

@@ -2,14 +2,11 @@
  * @file streams-generator-i2s.ino
  * @author Phil Schatzmann
  * @brief see https://github.com/pschatzmann/arduino-audio-tools/blob/main/examples/examples-stream/streams-generator-i2s/README.md 
- * @author Phil Schatzmann
  * @copyright GPLv3
  */
 
 #include "AudioTools.h"
 
-
-
 typedef int16_t sound_t;                                   // sound will be represented as int16_t (with 2 bytes)
 uint16_t sample_rate=44100;
 uint8_t channels = 2;                                      // The stream will have 2 channels 
@@ -22,7 +19,7 @@ StreamCopy copier(out, sound);                             // copies sound into
 void setup(void) {  
   // Open Serial 
   Serial.begin(115200);
-  AudioLogger::instance().begin(Serial, AudioLogger::Info);
+  AudioLogger::instance().begin(Serial, AudioLogger::Warning);
 
   // start I2S
   Serial.println("starting I2S...");

src/AudioExperiments/Resample.h

@@ -0,0 +1,156 @@
+#pragma once
+
+#include "AudioTools/AudioStreams.h"
+/**
+ * @brief A simple implementation which changes the sample rate by the indicated factor. 
+ * To downlample we calculate the avarage of n (=factor) samples. To upsample we interpolate
+ * the missing samples. If the indicated factor is positive we upsample if it is negative
+ * we downsample.
+ * 
+ * @tparam T 
+ */
+template<typename T>
+class Resample : public AudioStreamX {
+    public:
+        /**
+         * @brief Construct a new Converter Resample object
+         * 
+         * @param channels number of channels (default 2)
+         * @param factor use a negative value to downsample
+         */
+        Resample(Print &out, int channels=2, int factor=2 ){
+            this->channels = channels;
+            this->factor = factor;
+            this->p_out = &out;
+        }
+
+        Resample(Stream &in, int channels=2, int factor=2 ){
+            this->channels = channels;
+            this->factor = factor;
+            this->p_out = &in;
+            this->p_in = &in;
+        }
+
+        int availableForWrite() override { return p_out->availableForWrite(); }
+
+        /// Writes the data up or downsampled to the final destination
+        size_t write(const uint8_t *src, size_t byte_count) override {
+            if (byte_count%channels!=0){
+                LOGE("Invalid buffer size: It must be multiple of %d", channels);
+                return 0;
+            }
+            size_t bytes = 0;
+            int sample_count = byte_count / sizeof(T);
+            if (factor>1){
+                allocateBuffer(sample_count*factor);
+                bytes = upsample((T*)src, buffer, sample_count, channels, factor) * sizeof(T);
+                p_out->write((uint8_t*)buffer, bytes);
+            } else if (factor<1){
+                allocateBuffer(sample_count/abs(factor));
+                bytes = downsample((T*)src, buffer , sample_count, channels, abs(factor)) * sizeof(T);
+                p_out->write((uint8_t*)buffer, bytes);
+            } else {
+                bytes = p_out->write(src, byte_count);
+            }
+            return bytes;
+        }
+
+        int available() override { return p_in!=nullptr ? p_in->available() : 0; }
+
+        size_t readBytes(uint8_t *src, size_t length) override { 
+            if (p_in==nullptr) return 0;
+            if (length%channels!=0){
+                length = length / channels * channels;
+            }
+            size_t bytes = 0;
+            int size = length / channels / sizeof(T);
+            if (factor>1){
+                int read_len = length/factor;
+                allocateBuffer(read_len);
+                read_len = p_in->readBytes((uint8_t*)buffer, read_len);
+                bytes = upsample(buffer,(T*)src, read_len, channels, factor) * sizeof(T);
+            } else if (factor<1){
+                int abs_factor = abs(factor);
+                int read_len = length*factor;
+                allocateBuffer(read_len);
+                read_len = p_in->readBytes((uint8_t*)buffer, read_len);
+                bytes = downsample(buffer,(T*)src, read_len, channels, abs_factor) * sizeof(T);
+            } else {
+                bytes = p_in->readBytes(src, length);
+            }
+            return bytes;
+        }
+   
+
+    protected:
+        Print *p_out=nullptr;
+        Stream *p_in=nullptr;
+        T *buffer=nullptr;
+        T *last_end=nullptr;
+        int channels = 2;
+        int factor = 1;
+        int buffer_size = 0;
+
+        void allocateBuffer(int len) {
+            if (len>buffer_size){
+                if (buffer!=nullptr) delete []buffer;
+                buffer = new T[len];
+            }
+            if (last_end==nullptr){
+                last_end = new T[channels];
+            }
+        }
+
+        size_t downsample(T *from,T *to, int size, int channels, int factor ){
+            if (size%factor!=0){
+                LOGE("Incompatible buffer length for down sampling. If must be a factor of %d", factor);
+                return 0;
+            }
+            for (int16_t j=0; j<size-factor; j+=channels){
+                long total[channels];
+                for (int8_t ch=0; ch<channels; ch++){
+                    for (int16_t f=0;f<factor;f++){
+                        total[j+ch] += from[j+ch+(f*channels)];
+                    }
+                    to[j+ch] = total[j+ch] / factor;
+                }
+            }
+            return size/factor;
+        }
+
+        /// We interpolate the missing samples
+        size_t upsample(T *from, T* to, int sample_count, int channels, int factor ){
+            int frame_count = sample_count/channels;
+            size_t result = 0;
+            int pos = 0;
+            // we start with the last saved frame
+            for (int16_t frame_pos=-1; frame_pos<frame_count-1; frame_pos++){
+                for (int8_t ch=0; ch<channels; ch++){
+                    T actual_data = *p_data(frame_pos, ch, from);
+                    T next_data = *p_data(frame_pos+1, ch, from);
+                    float diff = (next_data - actual_data) / factor;
+                    pos =(frame_pos+1)*factor; 
+                    *p_data(pos, ch, to) = actual_data; 
+                    result++;
+                    for (int16_t f=1;f<factor;f++){
+                        pos = ((frame_pos+1)*factor)+f; 
+                        *p_data(pos, ch, to) = actual_data + (diff*f); 
+                        result++;
+                    }
+                }
+            }
+            // save last frame_pos data
+            pos = frame_count*factor;
+            for (int8_t ch=0; ch<channels; ch++){
+                T tmp = *p_data(frame_count-1, ch, from); 
+                last_end[ch] = tmp;
+            }
+            return pos*channels;
+        }
+
+        // provide access to data
+        T* p_data(int frame_pos, int channel, T*start){
+            return frame_pos>=0 ? start+(frame_pos*channels)+channel : last_end+channel;
+        }
+
+};

src/AudioLibs/MaximilianDSP.h

@@ -1,6 +1,7 @@
 #pragma once
 #include "AudioConfig.h"
 #include "maximilian.h"
+#include "libs/maxiClock.h"
 
 // Maximilian play function - return an array of 2 channels
 void play(double *channels);//run dac! 
@@ -26,6 +27,7 @@ class Maximilian {
 
         /// Setup Maximilian with audio parameters
         void begin(AudioBaseInfo cfg){
+            this->cfg = cfg;
             maxiSettings::setup(cfg.sample_rate, cfg.channels, DEFAULT_BUFFER_SIZE);
         }
 
@@ -43,14 +45,15 @@ class Maximilian {
         /// Copies the audio data from maximilian to the audio sink, Call this method from the Arduino Loop. 
         void copy() {
             // fill buffer with data
-            double out[2];
+            double out[cfg.channels];
             uint16_t samples = buffer_size / sizeof(uint16_t);
             int16_t *p_samples = (int16_t *)p_buffer;
-            for (uint16_t j=0;j<samples;j+=2){
+            for (uint16_t j=0;j<samples;j+=cfg.channels){
                 play(out);
-                // convert to int16
-                p_samples[j] = out[0]*32767*volume;
-                p_samples[j+1] = out[1]*32767*volume;
+                // convert all channels to int16
+                for (int ch=0;ch<cfg.channels;ch++){
+                    p_samples[j+ch] = out[ch]*32767*volume;
+                }
             }
             // write buffer to audio sink
             unsigned int result = p_sink->write(p_buffer, buffer_size);
@@ -62,6 +65,7 @@ class Maximilian {
         float volume=1.0;
         int buffer_size=256;
         Print *p_sink=nullptr;
+        AudioBaseInfo cfg;
 };
 
 

src/AudioTools/AudioOutput.h

@@ -63,7 +63,7 @@ class CsvStream : public AudioPrint, public AudioBaseInfoDependent {
         }
 
         /// Constructor
-        CsvStream(Print &out, int channels, int buffer_size=DEFAULT_BUFFER_SIZE, bool active=true) {
+        CsvStream(Print &out, int channels=2, int buffer_size=DEFAULT_BUFFER_SIZE, bool active=true) {
             this->channels = channels;
             this->out_ptr = &out;
             this->active = active;
@@ -73,7 +73,6 @@ class CsvStream : public AudioPrint, public AudioBaseInfoDependent {
         void begin(){
              LOGD(LOG_METHOD);
             this->active = true;
-            this->channels = 2;
         }
 
         /// Provides the default configuration
@@ -135,7 +134,7 @@ class CsvStream : public AudioPrint, public AudioBaseInfoDependent {
     protected:
         T *data_ptr;
         Print *out_ptr = &Serial;
-        int channels = 1;
+        int channels = 2;
         bool active = false;
 
 };

src/AudioTools/Converter.h

@@ -479,6 +479,7 @@ class FormatConverter {
 };
 
 
+
 /**
  * @brief Reads n numbers from an Arduino Stream
  *