RTParameter.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018-2023 pongasoft
 *
 * Licensed under the Apache License, Version 2.0 or the MIT license,
 * at your option. You may not use this file except in compliance with
 * one of these licenses. You may obtain copies of the licenses at:
 *
 * https://www.apache.org/licenses/LICENSE-2.0
 * https://opensource.org/licenses/MIT
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 *
 * @author Yan Pujante
 */
 
#ifndef __PONGASOFT_VST_RT_PARAMETER_H__
#define __PONGASOFT_VST_RT_PARAMETER_H__
 
#include <pluginterfaces/vst/ivstaudioprocessor.h>
#include <pongasoft/VST/ParamDef.h>
#include <pongasoft/logging/logging.h>
#include <pongasoft/Utils/Operators.h>
 
namespace pongasoft::VST::RT {

class RTRawVstParameter
{
public:
  // Constructor
  explicit RTRawVstParameter(std::shared_ptr<RawVstParamDef> iParamDef) :
    fParamDef{std::move(iParamDef)},
    fNormalizedValue{fParamDef->fDefaultValue},
    fPreviousNormalizedValue{fNormalizedValue}
  {}

  virtual ~RTRawVstParameter() = default;
 
  // getParamID
  ParamID getParamID() const { return fParamDef->fParamID; }
 
  // getParamDef
  RawVstParamDef const *getParamDef() const { return fParamDef.get(); }

  virtual bool updateNormalizedValue(ParamValue iNormalizedValue);
 
  // getNormalizedValue
  ParamValue const &getNormalizedValue() const { return fNormalizedValue; }
 
  // getPreviousNormalizedValue
  ParamValue const &getPreviousNormalizedValue() const { return fPreviousNormalizedValue; }

  tresult addToOutput(ProcessData &oData) const;

  bool hasChanged() const { return fNormalizedValue != fPreviousNormalizedValue; }

  virtual bool resetPreviousValue();
 
protected:
  std::shared_ptr<RawVstParamDef> fParamDef;
  ParamValue fNormalizedValue;
  ParamValue fPreviousNormalizedValue;
};

template<typename T>
class RTVstParameter : public RTRawVstParameter
{
public:
  using ParamType = T;
 
  // Constructor
  explicit RTVstParameter(VstParam<T> iParamDef) :
    RTRawVstParameter(iParamDef),
    fValue{denormalize(fNormalizedValue)},
    fPreviousValue{fValue}
  {
  }
 
  // getParamDef
  VstParamDef<T> const *getParamDefT() const
  {
    return static_cast<VstParamDef<T> const *>(getParamDef());
  }
 
  // shortcut to normalize
  ParamValue normalize(ParamType const &iValue) const { return getParamDefT()->normalize(iValue); }
 
  // shortcut to denormalize
  ParamType denormalize(ParamValue iNormalizedValue) const { return getParamDefT()->denormalize(iNormalizedValue); }

  void update(ParamType const &iNewValue);
 
  // getValue
  ParamType const &getValue() const { return fValue; }
 
  // getPreviousValue
  ParamType const &getPreviousValue() const { return fPreviousValue; }
 
protected:
  // Override the base class to update the denormalized value as well
  bool updateNormalizedValue(ParamValue iNormalizedValue) override;
 
  // Override the base class to update the denormalized value as well
  bool resetPreviousValue() override;
 
protected:
  ParamType fValue;
  ParamType fPreviousValue;
};
 
//------------------------------------------------------------------------
// RTParameter::updateNormalizedValue - update fValue to the new value and return true if it changed
//------------------------------------------------------------------------
template<typename T>
bool RTVstParameter<T>::updateNormalizedValue(ParamValue iNormalizedValue)
{
  if(RTRawVstParameter::updateNormalizedValue(iNormalizedValue))
  {
    fValue = denormalize(iNormalizedValue);
    return true;
  }
 
  return false;
}
 
//------------------------------------------------------------------------
// RTParameter::resetPreviousValue
//------------------------------------------------------------------------
template<typename T>
bool RTVstParameter<T>::resetPreviousValue()
{
  if(RTRawVstParameter::resetPreviousValue())
  {
    fPreviousValue = fValue;
    return true;
  }
 
  return false;
}
 
//------------------------------------------------------------------------
// RTParameter::update
//------------------------------------------------------------------------
template<typename T>
void RTVstParameter<T>::update(const ParamType &iNewValue)
{
  fValue = iNewValue;
  fNormalizedValue = normalize(fValue);
}
 
//------------------------------------------------------------------------
// RTVstParam - wrapper to make writing the code much simpler and natural
//------------------------------------------------------------------------
template<typename T>
class RTVstParam : public Utils::Operators::Dereferenceable<RTVstParam<T>>
{
  using ParamType = T;
 
public:
  RTVstParam(RTVstParameter<T> *iPtr) : fPtr{iPtr} // NOLINT (not marked explicit on purpose)
  {
    DCHECK_F(fPtr != nullptr);
  }
 
  // getParamID
  ParamID getParamID() const { return fPtr->getParamID(); }
 
  // shortcut to normalize
  ParamValue normalize(ParamType const &iValue) const { return fPtr->normalize(iValue); }
 
  // shortcut to denormalize
  ParamType denormalize(ParamValue iNormalizedValue) const { return fPtr->denormalize(iNormalizedValue); }
 
  // getValue
  T const &getValue() const { return fPtr->getValue(); }
 
  // value -- synonym
  T const &value() const { return fPtr->getValue(); }

  ParamValue const &normalizedValue() const { return fPtr->getNormalizedValue(); }

  void update(ParamType const &iNewValue) { fPtr->update(iNewValue); }

  void update(ParamType const &iNewValue, ProcessData &oData)
  {
    update(iNewValue);
    addToOutput(oData);
  }

  bool hasChanged() const { return fPtr->hasChanged(); }

  tresult addToOutput(ProcessData &oData) { return fPtr->addToOutput(oData); }

  constexpr ParamType const &operator *() const { return fPtr->getValue(); }
 
  // allow writing param->xxx to access the underlying type directly (if not a primitive)
  constexpr ParamType const *operator->() const { return &fPtr->getValue(); }

  RTVstParam &operator=(ParamType const &iValue) { update(iValue); return *this; }
 
  // previous
  ParamType const &previous() const { return fPtr->getPreviousValue(); }
 
private:
  RTVstParameter<T> *fPtr;
};

template<typename T, size_t N>
using RTVstParams = std::array<RTVstParam<T>, N>;
 
//------------------------------------------------------------------------
// RTRawVstParam - wrapper to make writing the code much simpler and natural
//------------------------------------------------------------------------
class RTRawVstParam : public Utils::Operators::Dereferenceable<RTRawVstParam>
{
public:
  RTRawVstParam(RTRawVstParameter *iPtr) : fPtr{iPtr} // NOLINT (not marked explicit on purpose)
  {
    DCHECK_F(fPtr != nullptr);
  }
 
  // getParamID
  ParamID getParamID() const { return fPtr->getParamID(); }
 
  // getValue
  ParamValue const &getValue() const { return fPtr->getNormalizedValue(); }
 
  // value - synonym
  ParamValue const &value() const { return fPtr->getNormalizedValue(); }

  bool update(ParamValue const &iNewValue) { return fPtr->updateNormalizedValue(iNewValue); }

  bool update(ParamValue const &iNewValue, ProcessData &oData)
  {
    if(update(iNewValue))
    {
      addToOutput(oData);
      return true;
    }
    else
      return false;
  }

  bool hasChanged() const { return fPtr->hasChanged(); }

  tresult addToOutput(ProcessData &oData) { return fPtr->addToOutput(oData); }

  ParamValue operator *() const { return fPtr->getNormalizedValue(); }

  RTRawVstParam &operator=(ParamValue const &iValue) { update(iValue); return *this; }
 
  // previous
  ParamValue const &previous() const { return fPtr->getPreviousNormalizedValue(); }
 
private:
  RTRawVstParameter *fPtr;
};

template<size_t N>
using RTRawVstParams = std::array<RTRawVstParam, N>;
 
}
 
#endif // __PONGASOFT_VST_RT_PARAMETER_H__