VolumeStream support for indivigual channels

Author: pschatzmann

src/AudioTools/AudioPlayer.h

@@ -562,7 +562,7 @@ namespace audio_tools {
             LOGD(LOG_METHOD);
             this->p_source = &source;
             this->p_decoder = &decoder;
-            this->volume_out.begin(output);
+            this->volume_out.setTarget(output);
             this->p_out_decoding = new EncodedAudioStream(volume_out, decoder);
             this->p_final_print = &output;
 
@@ -583,7 +583,7 @@ namespace audio_tools {
             LOGD(LOG_METHOD);
             this->p_source = &source;
             this->p_decoder = &decoder;
-            this->volume_out.begin(output);
+            this->volume_out.setTarget(output);
             this->p_out_decoding = new EncodedAudioStream(volume_out, decoder);
             setNotify(notify);
         }
@@ -599,7 +599,7 @@ namespace audio_tools {
         AudioPlayer(AudioSource& source, AudioStream& output, AudioDecoder& decoder) {
             LOGD(LOG_METHOD);
             this->p_source = &source;
-            this->volume_out.begin(output);
+            this->volume_out.setTarget(output);
             this->p_out_decoding = new EncodedAudioStream(volume_out, decoder);
             this->p_final_stream = &output;
 
@@ -664,7 +664,7 @@ namespace audio_tools {
 
         /// (Re)defines the output
         void setOutput(Print& output){
-            this->volume_out.begin(output);
+            this->volume_out.setTarget(output);
         }
 
         /// (Re)defines the decoder

src/AudioTools/AudioStreams.h

@@ -608,41 +608,80 @@ class ConvertedStream : public AudioStreamX {
 
 };
 
+/**
+ * @brief Config for VolumeStream
+ * @author Phil Schatzmann
+ * @copyright GPLv3 
+ */
+struct VolumeStreamConfig : public AudioBaseInfo {
+  VolumeStreamConfig(){
+    bits_per_sample = 16;
+    channels = 2;
+  }
+  bool allow_boost = false;
+  float volume=1.0;  // start_volume
+};
+
 /**
  * @brief Output PWM object on which we can apply some volume settings. To work properly the class needs to know the 
- * bits per sample. If nothing is defined we assume 16 bits!
+ * bits per sample and number of channels!
  * @author Phil Schatzmann
  * @copyright GPLv3
  */
-//class VolumeOutput : public AudioPrint {
 class VolumeStream : public AudioStreamX {
     public:
         /// Default Constructor
         VolumeStream() = default;
 
-        VolumeStream(Print &out, bool allowBoost=false) {
-            begin(out, allowBoost);
+        ~VolumeStream() {
+          cleanup();
+        };
+
+        VolumeStream(Print &out) {
+            setTarget(out);
         }
 
         /// Constructor which automatically calls begin(Print out)!
-        VolumeStream(Stream &out, bool allowBoost=false) {
-            begin(out, allowBoost);
+        VolumeStream(Stream &in) {
+            setTarget(in);
         }
 
-        /// Assigns the final output 
-        bool begin(Print &out, bool allowBoost=true){
-            LOGD(LOG_METHOD);
+        void setTarget(Print &out){
             p_out = &out;
-            allow_boost = allowBoost;
-            return true;
         }
-
-        /// Assigns the final output 
-        bool begin(Stream &in, bool allowBoost=false){
-            LOGD(LOG_METHOD);
+        
+        void setTarget(Stream &in){
             p_in = ∈
             p_out = p_in;
-            allow_boost = allowBoost;
+        }
+
+        VolumeStreamConfig defaultConfig() {
+            VolumeStreamConfig c;
+            return c;
+        }
+
+        bool begin(AudioBaseInfo cfg){
+          VolumeStreamConfig cfg1;
+          cfg1.channels = cfg.channels;
+          cfg1.sample_rate = cfg.sample_rate;
+          cfg1.bits_per_sample = cfg.bits_per_sample;
+          return begin(cfg1);
+        }
+
+        void end() {
+            is_active = false;
+        }
+
+        /// starts the processing 
+        bool begin(VolumeStreamConfig cfg){
+            LOGD(LOG_METHOD);
+            info = cfg;
+            max_value = NumberConverter::maxValue(info.bits_per_sample);
+            if (info.channels>max_channels){
+              max_channels = info.channels;
+            }
+            // set start volume
+            setVolume(cfg.volume); 
             return true;
         }
 
@@ -664,19 +703,18 @@ class VolumeStream : public AudioStreamX {
                 return 0;
             }
             size_t result = p_in->readBytes(buffer, length);
-            if (volume_value != 1.0) applyVolume(buffer, result);
+            if (is_active) applyVolume(buffer, result);
             return result;
         }
 
-
         /// Writes raw PCM audio data, which will be the input for the volume control 
         virtual size_t write(const uint8_t *buffer, size_t size) override {
             LOGD(LOG_METHOD);
             if (buffer==nullptr || p_out==nullptr){
                 LOGE("NPE");
                 return 0;
             }
-            if (volume_value != 1.0) applyVolume(buffer,size);
+            if (is_active) applyVolume(buffer,size);
             return p_out->write(buffer, size);
         }
 
@@ -691,54 +729,95 @@ class VolumeStream : public AudioStreamX {
         }
 
         /// Detines the Audio info - The bits_per_sample are critical to work properly!
-        void setAudioInfo(AudioBaseInfo info) override {
+        void setAudioInfo(AudioBaseInfo cfg) override {
             LOGD(LOG_METHOD);
-            this->info = info;
-            max_value = NumberConverter::maxValue(info.bits_per_sample);
+            begin(cfg);
         }
 
-        /// Shortcut method to define the sample size (alternative to setAudioInfo())
-        void setBitsPerSample(int bits_per_sample){
-            info.bits_per_sample = bits_per_sample;
-            max_value = NumberConverter::maxValue(info.bits_per_sample);
-        }
-
-        /// Shortcut method to define the sample size (alternative to setAudioInfo())
-        void setBytesPerSample(int bytes_per_sample){
-            info.bits_per_sample = bytes_per_sample * 8;
-            max_value = NumberConverter::maxValue(info.bits_per_sample);
-        }
-
-        /// Decreases the volume:  needs to be in the range of 0 to 1.0
+        /// Defines the volume for all channels:  needs to be in the range of 0 to 1.0
         void setVolume(float vol){
-            if (!allow_boost && vol>1.0) vol = 1.0;
-            if (vol<0.0) vol = 0.0;
+            for (int j=0;j<info.channels;j++){
+              setVolume(vol, j);
+            }
+        }
 
-            // round to 2 digits
-            float value = (int)(vol * 100 + .5);
-            volume_value = (float)value / 100;;
-            LOGI("setVolume: %f", volume_value);
+        /// Sets the volume for one channel
+        void setVolume(float vol, int channel){
+            if (channel<info.channels){
+              setup(vol);
+              float volume_value = volumeValue(vol);
+              LOGI("setVolume: %f", volume_value);
+              float factor = volumeControl().getVolumeFactor(volume_value);
+              factor_for_channel[channel]=factor;
+            } else {
+              LOGE("Invalid channel %d - max: %d", channel, info.channels-1);
+            }
         }
 
         /// Provides the current volume setting
         float volume() {
-            return volume_value;
+            return volume_values[0];
+        }
+
+        /// Provides the current volume setting for the indicated channel
+        float volume(int channel) {
+            return channel>=info.channels? 0 : volume_values[channel];
         }
 
     protected:
         Print *p_out=nullptr;
         Stream *p_in=nullptr;
-        AudioBaseInfo info;
-        float volume_value=1.0;
+        VolumeStreamConfig info;
         SimulatedAudioPot default_volume;
         CachedVolumeControl cached_volume = CachedVolumeControl(default_volume);
-        bool allow_boost = false; // allows a factor > 1.0
-        float max_value = NumberConverter::maxValue(info.bits_per_sample); // max value for clippint
+        float *volume_values = nullptr;
+        float *factor_for_channel = nullptr;
+        bool is_active = false;
+        float max_value = 32767; // max value for clipping
+        int max_channels=0;
+
+        void setup(float vol) {
+            is_active = vol!=1.0;
+            if (info.channels>max_channels){
+              cleanup();
+            }
+            if (factor_for_channel==nullptr){
+              factor_for_channel = new float[info.channels];
+            }
+            if (volume_values==nullptr){
+              volume_values = new float[info.channels];
+            }
+        }
+
+        void cleanup() {
+          if (factor_for_channel!=nullptr) {
+            delete []factor_for_channel;
+            factor_for_channel = nullptr;
+          } 
+          if (volume_values!=nullptr) {
+            delete []volume_values;
+            volume_values = nullptr;
+          }
+        }
+
+        float volumeValue(float vol){
+            if (!info.allow_boost && vol>1.0) vol = 1.0;
+            if (vol<0.0) vol = 0.0;
+
+            // round to 2 digits
+            float value = (int)(vol * 100 + .5);
+            float volume_value = (float)value / 100;
+            return volume_value;
+        }
 
         VolumeControl &volumeControl(){
             return cached_volume;
         }
 
+        float factorForChannel(int channel){
+            return factor_for_channel==nullptr ? 1.0 : factor_for_channel[channel];
+        }
+
         void applyVolume(const uint8_t *buffer, size_t size){
             switch(info.bits_per_sample){
                 case 16:
@@ -756,10 +835,9 @@ class VolumeStream : public AudioStreamX {
         }
 
         void applyVolume16(int16_t* data, size_t size){
-            float factor = volumeControl().getVolumeFactor(volume_value);
             for (size_t j=0;j<size;j++){
-                float result = factor * data[j];
-                if (allow_boost){
+                float result = factorForChannel(j%info.channels) * data[j];
+                if (info.allow_boost){
                     if (result>max_value) result = max_value;
                     if (result<-max_value) result = -max_value;
                 } 
@@ -768,10 +846,9 @@ class VolumeStream : public AudioStreamX {
         }
 
         void applyVolume24(int24_t* data, size_t size) {
-            float factor = volumeControl().getVolumeFactor(volume_value);
             for (size_t j=0;j<size;j++){
-                float result = factor * data[j];
-                if (allow_boost){
+                float result = factorForChannel(j%info.channels) * data[j];
+                if (info.allow_boost){
                     if (result>max_value) result = max_value;
                     if (result<-max_value) result = -max_value;
                 } 
@@ -781,10 +858,9 @@ class VolumeStream : public AudioStreamX {
         }
 
         void applyVolume32(int32_t* data, size_t size) {
-            float factor = volumeControl().getVolumeFactor(volume_value);
             for (size_t j=0;j<size;j++){
-                float result = factor * data[j];
-                if (allow_boost){
+                float result = factorForChannel(j%info.channels) * data[j];
+                if (info.allow_boost){
                     if (result>max_value) result = max_value;
                     if (result<-max_value) result = -max_value;
                 }