VolumeStream.h

Go to the documentation of this file.

 
#pragma once
#include "AudioTools/CoreAudio/AudioStreams.h"
#include "AudioTools/CoreAudio/AudioOutput.h"
#include "AudioTools/CoreAudio/VolumeControl.h"
#include "AudioTools/CoreAudio/AudioBasic/Q1_14.h"
#include "AudioTools/CoreAudio/AudioTypes.h"
 
namespace audio_tools {
 
struct VolumeStreamConfig : public AudioInfo {
  VolumeStreamConfig(){
    bits_per_sample = 16;
    channels = 2;
  }
  bool allow_boost = false;
  float volume=1.0;  // start_volume
};
 
 
class VolumeStream : public ModifyingStream, public VolumeSupport {
    public:
        VolumeStream() = default;
 
        VolumeStream(Print &out) {
            setOutput(out);
        }
 
        VolumeStream(Stream &in) {
            setStream(in);
        }
 
        VolumeStream(AudioOutput &out) {
            Print *p_print = &out;
            setOutput(*p_print);
            addNotifyAudioChange(out);
        }
 
        VolumeStream(AudioStream &io) {
            Stream *p_stream = &io;
            setStream(*p_stream);
            addNotifyAudioChange(io);
        }
 
        void setStream(Stream &in) override {
            p_in = ∈
            p_out = p_in;
        }
 
        void setOutput(Print &out) override {
            p_out = &out;
        }
        
        void setOutput(Stream &in){
            p_in = ∈
            p_out = p_in;
        }
 
        void setStream(Print &out){
            p_out = &out;
        }
 
        VolumeStreamConfig defaultConfig() {
            VolumeStreamConfig c;
            return c;
        }
 
        bool begin() override {
          return begin(info);    
        }
 
        bool begin(AudioInfo cfg)  {
            VolumeStreamConfig cfg1 = toVolumeStreamConfig(cfg);
            return begin(cfg1);
        }
 
        bool begin(VolumeStreamConfig cfg){
            TRACED();
            setVolumeStreamConfig(cfg);
            // usually we use a exponential volume control - except if we allow values > 1.0
            if (cfg.allow_boost){
              setVolumeControl(linear_vc);
            } else {
              setVolumeControl(pot_vc);
            }
 
            // set start volume
            setVolume(cfg.volume); 
            is_started = true;
            return true;
        }
 
        void end() override {
            is_started = false;
        }
 
 
        void setVolumeControl(VolumeControl &vc){
            cached_volume.setVolumeControl(vc);
        }
 
        void resetVolumeControl(){
            cached_volume.setVolumeControl(pot_vc);
        }
 
        virtual size_t readBytes(uint8_t *data, size_t len) override { 
            TRACED();
            if (data==nullptr || p_in==nullptr){
                LOGE("NPE");
                return 0;
            }
            size_t result = p_in->readBytes(data, len);
            if (isVolumeUpdate()) applyVolume(data, result);
            return result;
        }
 
        virtual size_t write(const uint8_t *data, size_t len) override {
            LOGD("VolumeStream::write: %zu", len);
            if (data==nullptr || p_out==nullptr){
                LOGE("NPE");
                return 0;
            }
            if (isVolumeUpdate()) applyVolume(data,len);
            return p_out->write(data, len);
        }
 
        virtual int availableForWrite() override { 
            return p_out==nullptr? 0 : p_out->availableForWrite();
        }
 
        virtual int available() override { 
            return p_in==nullptr? 0 : p_in->available();
        }
 
        void setAudioInfo(AudioInfo cfg) override {
            TRACED();
            // pass on notification
            ModifyingStream::setAudioInfo(cfg);
 
            if (is_started){
                int old_n = volume_values.size();;
                resizeVectors(cfg.channels);
                // update config and max values
                VolumeStreamConfig cfg1 = toVolumeStreamConfig(cfg);
                setVolumeStreamConfig(cfg1);
                // Only set default volume for new channels if channel count increased
                int new_n = info.channels;
                for (int j = old_n; j < new_n; ++j) {
                    setVolume(info.volume, j);
                }
            } else {
                begin(cfg);
            }
        }
 
        bool setVolume(float vol) override {
            LOGI("setVolume: %f", vol);
            bool result = true;
            // just to make sure that we have a valid start volume before begin
            info.volume = vol; 
            for (int j=0; j<info.channels; j++){
              result = setVolume(vol, j);
            }
            return result;
        }
 
        bool setVolume(float vol, int channel){
            if ((vol > 1.0f && !info.allow_boost) || vol < 0.0f) {
                LOGE("Invalid volume: %f", vol);
                return false;
            }
            if (channel < info.channels){
              resizeVectors(info.channels);
              float volume_value = volumeValue(vol);
              if (volume_values[channel] != volume_value){
                LOGI("setVolume: %f at %d", volume_value, channel);
                float factor = volumeControl().getVolumeFactor(volume_value);
                volume_values[channel]=volume_value;
                #if PREFER_FIXEDPOINT
                    // q1_14_t saturates at ~1.99994 (its Q1.14 range), so boost
                    // is capped there (factor can only be >1 if allow_boost==true)
                    factor_for_channel[channel] = q1_14_t(factor);
                #else
                    factor_for_channel[channel]=factor;
                #endif
              }
              return true;
            } else {
              LOGE("Invalid channel %d - max: %d", channel, info.channels-1);
              return false;
            }
        }
 
        float volume() override {
            // prevent npe
            if (volume_values.size()==0) return info.volume;
            // calculate avg
            float total = 0;
            int cnt = volume_values.size();
            for (int j=0; j<cnt; j++){
                total += volume_values[j];
            }
            return total / static_cast<float>(cnt);
        }
 
        float volume(int channel) {
            return channel>=info.channels? 0 : volume_values[channel];
        }
 
    protected:
        Print *p_out=nullptr;
        Stream *p_in=nullptr;
        VolumeStreamConfig info;
        LinearVolumeControl linear_vc{true};
        SimulatedAudioPot pot_vc;
        CachedVolumeControl cached_volume{pot_vc};
        Vector<float> volume_values;
        #if PREFER_FIXEDPOINT
            Vector<q1_14_t> factor_for_channel; // Q1.14 fixed point
        #else
            Vector<float> factor_for_channel;
        #endif
        bool is_started = false;
        // max value for clipping: integer on the fixed-point path, so the
        // per-sample clip in applyVolume16/24/32 stays pure-integer instead
        // of promoting the int32_t/int64_t result to float on every sample.
        #if PREFER_FIXEDPOINT
            int64_t max_value = 32767;
        #else
            float max_value = 32767;
        #endif
 
        // checks if volume needs to be updated
        bool isVolumeUpdate(){
            if (!is_started) return false;
            if (isAllChannelsFullVolume()) return false;
            return true;
        }
 
        bool isAllChannelsFullVolume(){
            int channels = min((int)info.channels, volume_values.size());
            for (int ch=0;ch < channels;ch++){
                if (volume_values[ch]!=1.0) return false;
            }
            return true;
        }
 
        void resizeVectors(int channels) {
            factor_for_channel.resize(channels);
            volume_values.resize(channels);
        }
 
        VolumeStreamConfig toVolumeStreamConfig(AudioInfo cfg){
            VolumeStreamConfig cfg1;
            cfg1.channels = cfg.channels;
            cfg1.sample_rate = cfg.sample_rate;
            cfg1.bits_per_sample = cfg.bits_per_sample;
            // keep volume which might habe been defined befor calling begin
            cfg1.volume = info.volume;
            cfg1.allow_boost = info.allow_boost;
            return cfg1;
        }
 
        void setVolumeStreamConfig(VolumeStreamConfig cfg){
            info = cfg;
            max_value = NumberConverter::maxValue(info.bits_per_sample);
        }
 
        float volumeValue(float vol){
            if (!info.allow_boost && vol>1.0f) vol = 1.0;
            if (vol<0.0f) vol = 0.0;
 
            // round to 2 digits
            float value = (int)(vol * 100 + .5f);
            float volume_value = (float)value / 100;
            return volume_value;
        }
 
        VolumeControl &volumeControl(){
            return cached_volume;
        }
 
        #if PREFER_FIXEDPOINT
        q1_14_t factorForChannel(int channel){
        #else
        float factorForChannel(int channel){
        #endif
            if (factor_for_channel.size()==0) return 1.0;
            if (channel >= factor_for_channel.size()) return 1.0;
            return factor_for_channel[channel];
        }
 
        void applyVolume(const uint8_t *buffer, size_t size){
            switch(info.bits_per_sample){
                case 16:
                    applyVolume16((int16_t*)buffer, size/2);
                    break;
                case 24:
                    applyVolume24((int24_t*)buffer, size/sizeof(int24_t));
                    break;
                case 32:
                    applyVolume32((int32_t*)buffer, size/4);
                    break;
                default:
                    LOGE("Unsupported bits_per_sample: %d", info.bits_per_sample);
            }
        }
 
        void applyVolume16(int16_t* data, size_t size){
            for (size_t j=0;j<size;j++){
                #if PREFER_FIXEDPOINT
                int32_t result = factorForChannel(j%info.channels).scale(data[j]);
                #else
                float result = factorForChannel(j%info.channels) * data[j];
                #endif
                if (!info.allow_boost){
                    if (result>max_value) result = max_value;
                    if (result<-max_value) result = -max_value;
                } 
                data[j]= static_cast<int16_t>(result);
            }
        }
 
        void applyVolume24(int24_t* data, size_t size) {
            for (size_t j=0;j<size;j++){
                #if PREFER_FIXEDPOINT
                int32_t result = factorForChannel(j%info.channels).scale(data[j]);
                #else
                float result = factorForChannel(j%info.channels) * data[j];
                #endif
                if (!info.allow_boost){
                    if (result>max_value) result = max_value;
                    if (result<-max_value) result = -max_value;
                } 
                int32_t result1 = result;
                data[j]= static_cast<int24_t>(result1);
            }
        }
 
        void applyVolume32(int32_t* data, size_t size) {
            for (size_t j=0;j<size;j++){
                #if PREFER_FIXEDPOINT
                int64_t result = factorForChannel(j%info.channels).scale(data[j]);
                #else
                float result = factorForChannel(j%info.channels) * data[j];
                #endif
                if (!info.allow_boost){
                    if (result>max_value) result = max_value;
                    if (result<-max_value) result = -max_value;
                } 
                data[j]= static_cast<int32_t>(result);
            }
        }
};
 
}