pluginparameter.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//    ASPiK Plugin Kernel File:  pluginparameter.h
//
// -----------------------------------------------------------------------------
#ifndef _PluginParameter_H_
#define _PluginParameter_H_

#include <string>
#include <vector>
#include <sstream>
#include <atomic>
#include <map>
#include <iomanip>
#include <iostream>

#include <math.h>
#include "pluginstructures.h"
#include "guiconstants.h"


class PluginParameter
{
public:
    PluginParameter(int _controlID, const char* _controlName, const char* _controlUnits,
                    controlVariableType _controlType, double _minValue, double _maxValue, double _defaultValue,
                    taper _controlTaper = taper::kLinearTaper, uint32_t _displayPrecision = 2);

    PluginParameter(int _controlID, const char* _controlName, std::vector<std::string> _stringList, std::string _defaultString);

    PluginParameter(int _controlID, const char* _controlName, const char* _commaSeparatedList, std::string _defaultString);

    PluginParameter(int _controlID, const char* _controlName, double _meterAttack_ms, double _meterRelease_ms,
                    uint32_t _detectorMode, meterCal _meterCal = meterCal::kLinearMeter);

    PluginParameter(int _controlID, const char* _controlName = "", controlVariableType _controlType = controlVariableType::kNonVariableBoundControl);

    PluginParameter();

    PluginParameter(const PluginParameter& initGuiControl);

    virtual ~PluginParameter();

    uint32_t getControlID() { return controlID; }           
    void setControlID(uint32_t cid) { controlID = cid; }    

    const char* getControlName() { return controlName.c_str(); }            
    void setControlName(const char* name) { controlName.assign(name); }     

    const char* getControlUnits() { return controlUnits.c_str(); }          
    void setControlUnits(const char* units) { controlUnits.assign(units); } 

    controlVariableType getControlVariableType() { return controlType; }                        
    void setControlVariableType(controlVariableType ctrlVarType) { controlType = ctrlVarType; } 

    double getMinValue() { return minValue; }               
    void setMinValue(double value) { minValue = value; }    

    double getMaxValue() { return maxValue; }               
    void setMaxValue(double value) { maxValue = value; }    

    double getDefaultValue() { return defaultValue; }               
    void setDefaultValue(double value) { defaultValue = value; }    

    bool getIsDiscreteSwitch() { return isDiscreteSwitch; }                                     
    void setIsDiscreteSwitch(bool _isDiscreteSwitch) { isDiscreteSwitch = _isDiscreteSwitch; }  

    taper getControlTaper() { return controlTaper; }                    
    void setControlTaper(taper ctrlTaper) { controlTaper = ctrlTaper; } 

    // -- taper getters
    bool isLinearTaper() { return controlTaper == taper::kLinearTaper ? true : false; }     
    bool isLogTaper() { return controlTaper == taper::kLogTaper ? true : false; }           
    bool isAntiLogTaper() { return controlTaper == taper::kAntiLogTaper ? true : false; }       
    bool isVoltOctaveTaper() { return controlTaper == taper::kVoltOctaveTaper ? true : false; } 

    // --- control type getters
    bool isMeterParam() { return controlType == controlVariableType::kMeter ? true : false; }                   
    bool isStringListParam() { return controlType == controlVariableType::kTypedEnumStringList ? true : false; }
    bool isFloatParam() { return controlType == controlVariableType::kFloat ? true : false; }                   
    bool isDoubleParam() { return controlType == controlVariableType::kDouble ? true : false; }                 
    bool isIntParam() { return controlType == controlVariableType::kInt ? true : false; }                       
    bool isNonVariableBoundParam() { return controlType == controlVariableType::kNonVariableBoundControl ? true : false; }

    uint32_t getDisplayPrecision() { return displayPrecision; }                     
    void setDisplayPrecision(uint32_t precision) { displayPrecision = precision; }  

    double getMeterAttack_ms() { return meterAttack_ms;}                
    void setMeterAttack_ms(double value) { meterAttack_ms = value; }    

    double getMeterRelease_ms() { return meterRelease_ms; }             
    void setMeterRelease_ms(double value) { meterRelease_ms = value; }  

    uint32_t getDetectorMode() { return detectorMode; }                 
    void setMeterDetectorMode(uint32_t value) { detectorMode = value; } 

    bool getLogMeter() { return logMeter; }             
    void setLogMeter(bool value) { logMeter = value; }  

    bool getInvertedMeter() { return invertedMeter; }               
    void setInvertedMeter(bool value) { invertedMeter = value; }    

    bool isProtoolsGRMeter() { return protoolsGRMeter; }                
    void setIsProtoolsGRMeter(bool value) { protoolsGRMeter = value; }  

    bool getParameterSmoothing() { return useParameterSmoothing; }              
    void setParameterSmoothing(bool value) { useParameterSmoothing = value; }   

    double getSmoothingTimeMsec() { return smoothingTimeMsec;}                  
    void setSmoothingTimeMsec(double value) { smoothingTimeMsec = value; }      

    smoothingMethod getSmoothingMethod() { return smoothingType; }                                  
    void setSmoothingMethod(smoothingMethod smoothingMethod) { smoothingType = smoothingMethod; }   

    bool getIsWritable() { return isWritable; }             
    void setIsWritable(bool value) { isWritable = value; }  

    bool getEnableVSTSampleAccurateAutomation() { return enableVSTSampleAccurateAutomation; }           
    void setEnableVSTSampleAccurateAutomation(bool value) { enableVSTSampleAccurateAutomation = value; }

    // --- for aux attributes
    AuxParameterAttribute* getAuxAttribute(uint32_t attributeID);                                       
    uint32_t setAuxAttribute(uint32_t attributeID, const AuxParameterAttribute& auxParameterAtribute);  

    inline double getControlValue() { return getAtomicControlValueDouble(); }

    inline void setControlValue(double actualParamValue, bool ignoreSmoothing = false)
    {
        if (controlType == controlVariableType::kDouble ||
            controlType == controlVariableType::kFloat)
        {
            if (useParameterSmoothing && !ignoreSmoothing)
                setSmoothedTargetValue(actualParamValue);
            else
                setAtomicControlValueDouble(actualParamValue);
        }
        else
            setAtomicControlValueDouble(actualParamValue);
    }

    inline double setControlValueNormalized(double normalizedValue, bool applyTaper = true, bool ignoreParameterSmoothing = false)
    {
        // --- set according to smoothing option
        double actualParamValue = getControlValueWithNormalizedValue(normalizedValue, applyTaper);

        if (controlType == controlVariableType::kDouble ||
            controlType == controlVariableType::kFloat)
        {
            if (useParameterSmoothing && !ignoreParameterSmoothing)
                setSmoothedTargetValue(actualParamValue);
            else
                setAtomicControlValueDouble(actualParamValue);
        }
        else
            setAtomicControlValueDouble(actualParamValue);

        return actualParamValue;
    }

    std::string getControlValueAsString();

    size_t getStringCount(){return stringList.size();}

    const char* getCommaSeparatedStringList() {return commaSeparatedStringList.c_str();}

    void setCommaSeparatedStringList();

    void setStringList(std::vector<std::string> _stringList) {stringList = _stringList;}

    std::string getStringByIndex(uint32_t index);

    inline double getDefaultValueNormalized()
    {
        // --- apply taper as needed
        switch (controlTaper)
        {
            case taper::kLinearTaper:
                return getNormalizedDefaultValue();

            case taper::kLogTaper:
                return getNormalizedLogDefaultValue();

            case taper::kAntiLogTaper:
                return getNormalizedAntiLogDefaultValue();

            case taper::kVoltOctaveTaper:
                return getNormalizedVoltOctaveDefaultValue();

            default:
                return 0.0;
        }
    }

    inline double getControlValueNormalized()
    {
        // --- apply taper as needed
        switch (controlTaper)
        {
            case taper::kLinearTaper:
                return getNormalizedControlValue();

            case taper::kLogTaper:
                return getNormalizedLogControlValue();

            case taper::kAntiLogTaper:
                return getNormalizedAntiLogControlValue();

            case taper::kVoltOctaveTaper:
                return getNormalizedVoltOctaveControlValue();

            default:
                return 0.0;
        }
    }

    inline double getControlValueWithNormalizedValue(double normalizedValue, bool applyTaper = true)
    {
        if(!applyTaper)
            return getControlValueFromNormalizedValue(normalizedValue);

        double newValue = 0;

        // --- apply taper as needed
        switch (controlTaper)
        {
            case taper::kLinearTaper:
                newValue = getControlValueFromNormalizedValue(normalizedValue);
                break;

            case taper::kLogTaper:
                newValue = getControlValueFromNormalizedValue(normToLogNorm(normalizedValue));
                break;

            case taper::kAntiLogTaper:
                newValue = getControlValueFromNormalizedValue(normToAntiLogNorm(normalizedValue));
                break;

            case taper::kVoltOctaveTaper:
                newValue = getVoltOctaveControlValueFromNormValue(normalizedValue);
                break;

            default:
                break; // --- no update
        }

        return newValue;
    }

    inline double getNormalizedControlValueWithActualValue(double actualValue) { return getNormalizedControlValueWithActual(actualValue); }

    double getGUIMin() { return 0.0; }

    double getGUIMax()
    {
        if(controlType == controlVariableType::kTypedEnumStringList)
            return (double)getStringCount() - 1;

        return 1.0;
    }

    int findStringIndex(std::string searchString)
    {
        auto it = std::find(stringList.begin (), stringList.end (), searchString);

        if (it == stringList.end())
        {
            return -1;
        }
        else
        {
            return (int)std::distance(stringList.begin(), it);
        }

        return -1;
    }

    inline double normToLogNorm(double normalizedValue)
    {
        return 1.0 + kCTCoefficient*log10(normalizedValue);
    }

    inline double logNormToNorm(double logNormalizedValue)
    {
        return pow(10.0, (logNormalizedValue - 1.0) / kCTCoefficient);
    }

    inline double normToAntiLogNorm(double normalizedValue)
    {
        if (normalizedValue == 1.0)
            return 1.0;

        double aln = -kCTCoefficient*log10(1.0 - normalizedValue);
        aln = fmin(1.0, aln);
        return aln;
    }

    inline double antiLogNormToNorm(double aLogNormalizedValue)
    {
        return -pow(10.0, (-aLogNormalizedValue / kCTCoefficient)) + 1.0;
    }

    void initParamSmoother(double sampleRate)
    {
        paramSmoother.initParamSmoother(smoothingTimeMsec,
                                        sampleRate,
                                        getAtomicControlValueDouble(),
                                        minValue,
                                        maxValue,
                                        smoothingType);
    }

    void updateSampleRate(double sampleRate)
    {
        paramSmoother.setSampleRate(sampleRate);
    }

    bool smoothParameterValue()
    {
        if(!useParameterSmoothing) return false;
        double smoothedValue = 0.0;
        bool smoothed = paramSmoother.smoothParameter(getSmoothedTargetValue(), smoothedValue);
        if(smoothed)
            setAtomicControlValueDouble(smoothedValue);
        return smoothed;
    }

    void setBoundVariable(void* boundVariable, boundVariableType dataType)
    {
        boundVariableDataType = dataType;

        if(dataType == boundVariableType::kDouble)
            boundVariableDouble = (double*)boundVariable;
        else if(dataType == boundVariableType::kFloat)
            boundVariableFloat = (float*)boundVariable;
        else if(dataType == boundVariableType::kInt)
            boundVariableInt = (int*)boundVariable;
        else if(dataType == boundVariableType::kUInt)
            boundVariableUInt = (uint32_t*)boundVariableUInt;

        // --- initialize it
        updateInBoundVariable();
    }

    boundVariableType getBoundVariableType() { return boundVariableDataType; }

    bool updateInBoundVariable()
    {
        if (boundVariableUInt)
        {
            *boundVariableUInt = (uint32_t)getControlValue();
            return true;
        }
        else if (boundVariableInt)
        {
            *boundVariableInt = (int)getControlValue();
            return true;
        }
        else if (boundVariableFloat)
        {
            *boundVariableFloat = (float)getControlValue();
            return true;
        }
        else if (boundVariableDouble)
        {
            *boundVariableDouble = getControlValue();
            return true;
        }
        return false;
    }

    bool updateOutBoundVariable()
    {
        if (boundVariableUInt)
        {
            setControlValue((double)*boundVariableUInt);
            return true;
        }
        else if (boundVariableInt)
        {
            setControlValue((double)*boundVariableInt);
            return true;
        }
        else if (boundVariableFloat)
        {
            setControlValue((double)*boundVariableFloat);
            return true;
        }
        else if (boundVariableDouble)
        {
            setControlValue(*boundVariableDouble);
            return true;
        }
        return false;
    }

    void setParameterUpdateQueue(IParameterUpdateQueue* _parameterUpdateQueue) { parameterUpdateQueue = _parameterUpdateQueue; }

    IParameterUpdateQueue* getParameterUpdateQueue() { return parameterUpdateQueue; } // may be NULL - that is OK

    PluginParameter& operator=(const PluginParameter& aPluginParameter) // need this override for collections to work
    {
        if (this == &aPluginParameter)
            return *this;

        controlID = aPluginParameter.controlID;
        controlName = aPluginParameter.controlName;
        controlUnits = aPluginParameter.controlUnits;
        commaSeparatedStringList = aPluginParameter.commaSeparatedStringList;
        controlType = aPluginParameter.controlType;
        minValue = aPluginParameter.minValue;
        maxValue = aPluginParameter.maxValue;
        defaultValue = aPluginParameter.defaultValue;
        controlTaper = aPluginParameter.controlTaper;
        controlValueAtomic = aPluginParameter.getAtomicControlValueFloat();
        displayPrecision = aPluginParameter.displayPrecision;
        stringList = aPluginParameter.stringList;
        useParameterSmoothing = aPluginParameter.useParameterSmoothing;
        smoothingType = aPluginParameter.smoothingType;
        smoothingTimeMsec = aPluginParameter.smoothingTimeMsec;
        meterAttack_ms = aPluginParameter.meterAttack_ms;
        meterRelease_ms = aPluginParameter.meterRelease_ms;
        detectorMode = aPluginParameter.detectorMode;
        logMeter = aPluginParameter.logMeter;
        isWritable = aPluginParameter.isWritable;
        isDiscreteSwitch = aPluginParameter.isDiscreteSwitch;
        invertedMeter = aPluginParameter.invertedMeter;

        return *this;
    }

protected:
    int controlID = -1;                         
    std::string controlName = "ControlName";    
    std::string controlUnits = "Units";         
    controlVariableType controlType = controlVariableType::kDouble; 

    // --- min/max/def
    double minValue = 0.0;          
    double maxValue = 1.0;          
    double defaultValue = 0.0;      

    // --- *the* control value
    // --- atomic float as control value
    //     atomic double will not behave properly between 32/64 bit
    std::atomic<float> controlValueAtomic;      

    float getAtomicControlValueFloat() const { return controlValueAtomic.load(std::memory_order_relaxed); }         
    void setAtomicControlValueFloat(float value) { controlValueAtomic.store(value, std::memory_order_relaxed); }    

    double getAtomicControlValueDouble() const { return (double)controlValueAtomic.load(std::memory_order_relaxed); }       
    void setAtomicControlValueDouble(double value) { controlValueAtomic.store((float)value, std::memory_order_relaxed); }   

    std::atomic<float> smoothedTargetValueAtomic;   
    void setSmoothedTargetValue(double value){ smoothedTargetValueAtomic.store((float)value); } 
    double getSmoothedTargetValue() const { return (double)smoothedTargetValueAtomic.load(); }  

    // --- control tweakers
    taper controlTaper = taper::kLinearTaper;   
    uint32_t displayPrecision = 2;              

    // --- for enumerated string list
    std::vector<std::string> stringList;        
    std::string commaSeparatedStringList;       

    // --- gui specific
    bool appendUnits = true;                    
    bool isWritable = false;                    
    bool isDiscreteSwitch = false;              

    // --- for VU meters
    double meterAttack_ms = 10.0;               
    double meterRelease_ms = 500.0;             
    uint32_t detectorMode = ENVELOPE_DETECT_MODE_RMS;
    bool logMeter = false;                      
    bool invertedMeter = false;                 
    bool protoolsGRMeter = false;               

    // --- parameter smoothing
    bool useParameterSmoothing = false;         
    smoothingMethod smoothingType = smoothingMethod::kLPFSmoother;  
    double smoothingTimeMsec = 100.0;           
    ParamSmoother<double> paramSmoother;        

    // --- variable binding
    boundVariableType boundVariableDataType = boundVariableType::kFloat;    

    // --- our sample accurate interface for VST3
    IParameterUpdateQueue* parameterUpdateQueue = nullptr;                  

    // --- default is enabled; you can disable this for controls that have a long postUpdate cooking time
    bool enableVSTSampleAccurateAutomation = true;                          

    inline double getVoltOctaveControlValueFromNormValue(double normalizedValue)
    {
        double octaves = log2(maxValue / minValue);
        if (normalizedValue == 0)
            return minValue;

        return minValue*pow(2.0, normalizedValue*octaves);
    }

    inline double getNormalizedLogControlValue()
    {
        return logNormToNorm(getNormalizedControlValue());
    }

    inline double getNormalizedAntiLogControlValue()
    {
        return antiLogNormToNorm(getNormalizedControlValue());
    }

    inline double getNormalizedVoltOctaveControlValue()
    {
        if (minValue == 0)
            return getAtomicControlValueDouble();

        return log2(getAtomicControlValueDouble() / minValue) / (log2(maxValue / minValue));
    }

    inline double getNormalizedControlValueWithActual(double actualValue)
    {
        // --- calculate normalized value from actual
        return (actualValue - minValue) / (maxValue - minValue);
    }

    inline double getNormalizedControlValue()
    {
        // --- calculate normalized value from actual
        //double d = (getAtomicControlValueDouble() - minValue) / (maxValue - minValue);
        return (getAtomicControlValueDouble() - minValue) / (maxValue - minValue);
    }

    inline double getControlValueFromNormalizedValue(double normalizedValue)
    {
        // --- calculate the control Value using normalized input
        //double d = (maxValue - minValue)*normalizedValue + minValue;
        return (maxValue - minValue)*normalizedValue + minValue;
    }

    inline double getNormalizedDefaultValue()
    {
        // --- calculate normalized value from actual
        //double d = (defaultValue - minValue) / (maxValue - minValue);
        return (defaultValue - minValue) / (maxValue - minValue);
    }

    inline double getNormalizedLogDefaultValue()
    {
        return logNormToNorm(getNormalizedDefaultValue());
    }

    inline double getNormalizedAntiLogDefaultValue()
    {
        return antiLogNormToNorm(getNormalizedDefaultValue());
    }

    inline double getNormalizedVoltOctaveDefaultValue()
    {
        if (minValue == 0)
            return defaultValue;

        return log2(defaultValue / minValue) / (log2(maxValue / minValue));
    }

private:
    // --- for variable-binding support
    uint32_t* boundVariableUInt = nullptr;          
    int* boundVariableInt = nullptr;                
    float* boundVariableFloat = nullptr;            
    double* boundVariableDouble = nullptr;          

    typedef std::map<uint32_t, AuxParameterAttribute*> auxParameterAttributeMap; 
    auxParameterAttributeMap auxAttributeMap;       

};

#endif