VolumeControl.h

#pragma once
 
#include "AudioTools/CoreAudio/AudioTypes.h"
 
namespace audio_tools {
 
class VolumeControl {
    public:
        virtual float getVolumeFactor(float volume) = 0;
 
    protected:
 
        virtual float limit(float in){
            float result = in;
            if (result<0.0f) result = 0;
            if (result>1.0f) result = 1;
            return result;
        }
        virtual float limit(float in) {…}
 
};
class VolumeControl {…};
 
class CachedVolumeControl : public VolumeControl {
    public:
        CachedVolumeControl(VolumeControl &vc){
            setVolumeControl(vc);
        }
 
        CachedVolumeControl(VolumeControl *vc){
            if (vc!=nullptr) setVolumeControl(*vc);
        }
 
        void setVolumeControl(VolumeControl &vc){
            p_vc = &vc;
        }
 
        virtual float getVolumeFactor(float volume) {
            if (p_vc==nullptr) return 1.0f; // prevent NPE
            if (fabs(volume-in)<0.01f){
                return out;
            } 
            in = volume;
            out = p_vc->getVolumeFactor(volume);
            return out;            
        }
        virtual float getVolumeFactor(float volume) {…}
 
    protected:
        VolumeControl *p_vc=nullptr;
        float in=1.0, out=1.0;
 
};
class CachedVolumeControl : public VolumeControl {…};
 
 
class LogarithmicVolumeControl : public VolumeControl {
    public:
        LogarithmicVolumeControl(float ym=0.1){
            this->ym = ym;
        }
 
        // provides a factor in the range of 0.0 to 1.0
        virtual float getVolumeFactor(float input) {
            float b = powf(((1/ym)-1), 2);
            float a = 1.0f / (b - 1.0f);
            float volumeFactor = powf(b,input) * a - a;
            return limit(volumeFactor);
        }
        virtual float getVolumeFactor(float input) {…}
 
    protected:
        float ym;
};
class LogarithmicVolumeControl : public VolumeControl {…};
 
class ExponentialVolumeControl : public VolumeControl {
    public:
        // provides a factor in the range of 0.0 to 1.0
        virtual float getVolumeFactor(float volume) {
            float volumeFactor = pow(2.0, volume) - 1.0;
            return limit(volumeFactor);
        }
        virtual float getVolumeFactor(float volume) {…}
};
class ExponentialVolumeControl : public VolumeControl {…};
 
class SimulatedAudioPot : public VolumeControl {
    public:
        SimulatedAudioPot(float x=0.5, float y=0.1){
            this->x = x;
            this->y = y;
        }
        virtual float getVolumeFactor(float volume) {
            float result = 0;
            if (volume<=x){
                result = mapT<float>(volume, 0.0, x, 0, y );
            } else {
                result = mapT<float>(volume, x, 1.0, y, 1.0);
            }
            return limit(result);
        }
        virtual float getVolumeFactor(float volume) {…}
    protected:
        float x, y;
};
class SimulatedAudioPot : public VolumeControl {…};
 
class LinearVolumeControl : public VolumeControl {
    public:
        LinearVolumeControl(bool allowBoost=false){
            is_limited = !allowBoost;
        }
        // provides a factor in the range of 0.0 to 1.0
        virtual float getVolumeFactor(float volume) {
            return is_limited ? limit(volume) : volume;
        }
        virtual float getVolumeFactor(float volume) {…}
    protected:
        bool is_limited;
};
class LinearVolumeControl : public VolumeControl {…};
 
 
class CallbackVolumeControl : public VolumeControl {
    public:
        CallbackVolumeControl(float(*cb)(float in)){
            callback = cb;
        }
        // provides a factor in the range of 0.0 to 1.0
        virtual float getVolumeFactor(float volume) {
            return limit(callback(volume));
        }
        virtual float getVolumeFactor(float volume) {…}
    protected:
        float (*callback)(float in) = nullptr;
 
};
class CallbackVolumeControl : public VolumeControl {…};
 
} // namespace