extended Mozzi support

Author: pschatzmann

README.md

@@ -185,6 +185,7 @@ This is currently work in progress:
 |------------------------|---------|
 | Analog input - ADC     | tested  |
 | I2S                    | tested  |
+| PWM Output             | tested  |
 | Files (RAW, MP3...)    | tested  |
 | Streams                | tested  |
 | WAV encoding/deconding | tested  |          

src/AudioMozzi.h

@@ -5,10 +5,23 @@
 #include "mozzi_analog.h"
 #include "Mozzi.h"
 
-
 namespace audio_tools {
 
+/**
+ * @brief Mozzi Configuration for input or output stream
+ * 
+ */
+struct MozziConfig : AudioBaseInfo {
+    uint16_t control_rate=0;
+    void (*updateControl)() = nullptr; //&::updateControl;
+    AudioOutput_t (*updateAudio)() = nullptr; // = &::updateAudio;
 
+    MozziConfig(){
+        channels = AUDIO_CHANNELS;
+        sample_rate = AUDIO_RATE;
+        bits_per_sample = sizeof(AudioOutputStorage_t)*8;
+    }
+};
 /**
  * @brief Support for  https://sensorium.github.io/Mozzi/ 
  * Define your updateControl() method.
@@ -18,42 +31,226 @@ namespace audio_tools {
 
  * @author Phil Schatzmann
  * @copyright GPLv3
- * 
  */
-class MozziGenerator : public SoundGenerator<int16_t> {
+ 
+class MozziGenerator : public SoundGenerator<AudioOutputStorage_t> {
     public:
-        MozziGenerator(int control_rate){
-            info.sample_rate = AUDIO_RATE; 
-            info.bits_per_sample = 16;
-            info.channels = 2;
-            control_counter_max = info.sample_rate / control_rate;
+        MozziGenerator(){   
+	 		LOGD(__FUNCTION__);
+        }
+
+        MozziGenerator(MozziConfig config){
+            begin(config);
+        }
+
+        virtual ~MozziGenerator() {
+            end();
+        }
+
+        void begin(MozziConfig config){
+            info = config;
+            if (info.control_rate==0){
+                info.control_rate = CONTROL_RATE;
+            }
+            control_counter_max = info.sample_rate / info.control_rate;
             if (control_counter_max <= 0){
                 control_counter_max = 1;
             }
             control_counter = control_counter_max;
         }
 
         /// Provides some key audio information
-        AudioBaseInfo config() {
+        MozziConfig config() {
             return info;
         }
 
         /// Provides a single sample
-        virtual int16_t readSample() {
+        virtual AudioOutputStorage_t readSample() {
+            if (is_read_buffer_filled){
+                // for stereo output we might have the value already
+                is_read_buffer_filled = false;
+                return read_buffer;
+            }
+
             if (--control_counter<0){
                 control_counter = control_counter_max;
-                ::updateControl();
+                info.updateControl();
             }
-            int result = (int) ::updateAudio();
-            samples_written_to_buffer++;
+            
+            AudioOutput out = info.updateAudio();
+            // requested mono
+            AudioOutputStorage_t result = 0;
+            #if (AUDIO_CHANNELS == MONO)
+                // generated stereo
+                if (sizeof(out) == sizeof(AudioOutputStorage_t)*2){
+                    result = out[0]/2 + out[1]/2;
+                // generated mono
+                } else  if (sizeof(out) == sizeof(AudioOutputStorage_t)){
+                    result = out[0];
+                }
+
+            // requested stereo
+            #elif (AUDIO_CHANNELS == STEREO)
+                result = out[0];
+                // generated stereo
+                if (sizeof(out) == sizeof(AudioOutputStorage_t)*2){
+                    read_buffer = out[1];
+                    is_read_buffer_filled = true;
+                // generated mono
+                } else if (sizeof(out) == sizeof(AudioOutputStorage_t)){
+                    read_buffer = out[0];
+                    is_read_buffer_filled = true;
+                }
+            #endif
             return result;
         }
 
     protected:
-        AudioBaseInfo info;
+        MozziConfig info;
         int control_counter_max;
         int control_counter;
-        uint64_t samples_written_to_buffer;
+        int read_buffer;
+        bool is_read_buffer_filled = false;
+
+};
+
+
+
+/**
+ * @brief We use the output functionality of Mozzi to output audio data. We expect the data as array of int16_t with
+ * one or two channels. Though we support the setting of a sample rate, we recommend to use the default sample rate
+ * from Mozzi which is available with the AUDIO_RATE define.
+ */
+class MozziStream : public Stream {
+
+    public:
+        MozziStream(){
+	 		LOGD(__FUNCTION__);
+        }
+
+        ~MozziStream(){
+	 		LOGD(__FUNCTION__);
+            end();
+            if (input_ptr!=nullptr){
+                delete input_ptr;
+                input_ptr = nullptr;
+            }
+        }
+
+        MozziConfig defaultConfig() {
+            MozziConfig default_config;
+            return default_config;
+        }
+
+        /// Starts Mozzi with its default parameters
+        void begin(){
+            begin(defaultConfig());
+        }
+
+        // Start Mozzi -  if controlRate > 0 we actiavate the sound generation (=>allow reads); the parameters describe the values if the
+        // provided input stream or resulting output stream;
+        void begin(MozziConfig cfg){
+ 	 		LOGD(__FUNCTION__);
+            config = cfg;
+            Mozzi.setAudioRate(config.sample_rate);
+            // in output mode we do not allocate any unnecessary functionality
+            if (input_ptr == nullptr && config.control_rate>0){
+                input_ptr = new MozziGenerator(config);
+            }
+            Mozzi.start(0);
+        }
+
+        void end(){
+	 		LOGD(__FUNCTION__);
+            Mozzi.stop();
+        }
+
+        /// unsupported operations
+        virtual int availableForWrite() {       
+            return Mozzi.canWrite() ? sizeof(int) : 0;
+        }
+
+        /// write an individual byte - if the frame is complete we pass it to Mozzi
+        virtual size_t write(uint8_t c) {
+            if (Mozzi.canWrite()){
+                writeChar(c);
+                return 1;
+            } else {
+                return 0;
+            }
+        }
+
+        virtual size_t write(const uint8_t *buffer, size_t size) {
+            for (size_t j=0;j<size;j++){
+                if (write(buffer[j])<=0){
+                    return j;
+                }
+            }
+            return size;
+        }
+
+        virtual int available(){
+            return 100000;  // just a random big number
+        }
+
+        virtual size_t readBytes(char *buffer, size_t length){
+            return input_ptr==nullptr ? 0 : input_ptr->readBytes((uint8_t*)buffer, length);
+        }
+
+        virtual int read(){
+            LOGE("read() not supported -  use readBytes!");
+            return -1;            
+        }
+
+        virtual int peek(){
+            LOGE("peek() not supported!");
+            return -1;            
+        }
+
+        virtual void flush(){
+        };
+
+    protected:
+        MozziConfig config;
+        MozziGenerator *input_ptr = nullptr;
+        NumberReader numberReader;
+        int32_t frame[2];
+        uint8_t buffer[64];
+        int buffer_pos;
+
+        // writes individual bytes and puts them together as MonoOutput or StereoOutput
+        void writeChar(uint8_t c){
+            buffer[buffer_pos++] = c;
+
+            #if (AUDIO_CHANNELS == MONO)
+                #warning "Mozzi is configured for Mono Output (to one channel only)"
+                if (config.channels == 1 && buffer_pos==config.bits_per_sample/8){
+                    numberReader.toNumbers(buffer, config.bits_per_sample,sizeof(AudioOutputStorage_t) * 8, true, 1, frame );
+                    MonoOutput out = MonoOutput(frame[0]);
+                    Mozzi.write(out);
+                    buffer_pos = 0;
+                } else if (config.channels == 2 && buffer_pos==config.bits_per_sample/8*2){
+                    numberReader.toNumbers(buffer, config.bits_per_sample,sizeof(AudioOutputStorage_t) * 8, true, 2, frame );
+                    MonoOutput out = MonoOutput(frame[0]/2 + frame[1]/2);
+                    Mozzi.write(out);
+                    buffer_pos = 0;
+                }
+            
+            #elif (AUDIO_CHANNELS == STEREO)
+                if (config.channels == 1 && buffer_pos==config.bits_per_sample/8){
+                    numberReader.toNumbers(buffer, config.bits_per_sample,sizeof(AudioOutputStorage_t) * 8, true, 1, frame );
+                    StereoOutput out = StereoOutput(frame[0],frame[0]);
+                    Mozzi.write(out);
+                    buffer_pos = 0;
+                } else if (config.channels == 2 && buffer_pos==config.bits_per_sample/8*2){
+                    numberReader.toNumbers(buffer, config.bits_per_sample,sizeof(AudioOutputStorage_t) * 8, true, 2, frame );
+                    StereoOutput out = StereoOutput(frame[0],frame[1]);
+                    Mozzi.write(out);
+                    buffer_pos = 0;
+                }
+            
+            #endif
+        }
 
 };
 

src/AudioPWM/PWMAudioStreamBase.h

@@ -173,6 +173,7 @@ class PWMAudioStreamBase : public Stream {
             LOGI("->Buffer available: %d", buffer->available());
             LOGI("->Buffer available for write: %d", buffer->availableToWrite());
             LOGI("->is_timer_started: %s ", is_timer_started ? "true" : "false");
+            return true;
         } 
 
         virtual void end(){

src/AudioTools/AudioCopy.h

@@ -130,7 +130,9 @@ class StreamCopyT {
                     break;
                 }
 
-                if (retry>1) LOGI("try write - %d ",retry);
+                if (retry>1) {
+                    LOGI("try write - %d ",retry);
+                }
 
             }
             return total;

src/AudioTools/Converter.h

@@ -308,5 +308,76 @@ class CallbackConverter {
 };
 
 
+/**
+ * @brief Reads n numbers from an Arduino Stream
+ * 
+ */
+class NumberReader {
+    public:
+        NumberReader(Stream &in) {
+            stream_ptr = ∈
+        }
+
+        NumberReader() {
+        }
+
+        bool read(int inBits, int outBits, bool outSigned, int n, int32_t *result){
+            bool result_bool = false;
+            int len = inBits/8 * n;
+            if (stream_ptr!=nullptr && stream_ptr->available()>len){
+                uint8_t buffer[len];
+                stream_ptr->readBytes((uint8_t*)buffer, n * len);
+                result_bool = toNumbers((void*)buffer, inBits, outBits, outSigned, n, result);
+            }
+            return result_bool;
+        }
+
+        /// converts a buffer to a number array
+        bool toNumbers(void *bufferIn, int inBits, int outBits, bool outSigned, int n, int32_t *result){
+            bool result_bool = false;
+            switch(inBits){
+                case 8: {
+                        int8_t *buffer=(int8_t *)bufferIn;
+                        for (int j=0;j<n;j++){
+                            result[j] = scale(buffer[j],inBits,outBits,outSigned);
+                        }
+                        result_bool = true;
+                    }
+                    break;
+                case 16: {
+                        int16_t *buffer=(int16_t *)bufferIn;
+                        for (int j=0;j<n;j++){
+                            result[j] = scale(buffer[j],inBits,outBits,outSigned);
+                        }
+                        result_bool = true;
+                    }
+                    break;
+                case 32: {
+                        int32_t *buffer=(int32_t*)bufferIn;
+                        for (int j=0;j<n;j++){
+                            result[j] = scale(buffer[j],inBits,outBits,outSigned);
+                        }
+                        result_bool = true;
+                    }
+                    break;
+            }
+            return result_bool;
+
+        }
+
+    protected:
+        Stream *stream_ptr=nullptr;
+
+        /// scale the value
+        int32_t scale(int32_t value, int inBits, int outBits, bool outSigned=true){
+            int32_t result = static_cast<float>(value) / maxValue(inBits) * maxValue(outBits);
+            if (!outSigned){
+                result += (maxValue(outBits) / 2);
+            }
+            return result;
+        }
+
+};
+
 
 }

src/AudioTools/I2S_ESP8266.h

@@ -2,7 +2,7 @@
 
 #ifdef ESP8266
 #include "AudioTools/AudioLogger.h"
-#include "i2s.h"
+#include <I2S.h>
 
 namespace audio_tools {
 

src/AudioTools/SoundGenerator.h

@@ -14,9 +14,16 @@ namespace audio_tools {
 template <class T>
 class SoundGenerator  {
     public:
+        SoundGenerator() {
+        }
+
+        virtual ~SoundGenerator() {
+            end();
+        }
+
         /// Provides the samples into simple array - which represents 1 channel
         virtual size_t readSamples(T* data, size_t sampleCount=512){
-            for (int j=0;j<sampleCount;j++){
+            for (size_t j=0;j<sampleCount;j++){
                 data[j] = readSample();
             }
             return sampleCount;