RTState.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018-2023 pongasoft
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * 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
 */
#pragma once

#include <pongasoft/Utils/Concurrent/Concurrent.h>
#include <pongasoft/Utils/stl.h>
#include <pongasoft/VST/Parameters.h>
#include <pongasoft/VST/NormalizedState.h>
#include <pongasoft/VST/MessageProducer.h>

#include "RTParameter.h"
#include "RTJmbOutParameter.h"
#include "RTJmbInParameter.h"

#include <map>

namespace pongasoft {
namespace VST {
namespace Debug { class ParamDisplay; }
namespace RT {

using namespace Utils;

class RTState : public IMessageHandler
{
public:
  explicit RTState(Parameters const &iParameters);

  RTRawVstParam add(RawVstParam iParamDef);

  template<size_t N>
  RTRawVstParams<N> add(RawVstParams<N> const &iParamDefs);

  template<typename T>
  RTVstParam<T> add(VstParam<T> iParamDef);

  template<typename T, size_t N>
  RTVstParams<T, N> add(VstParams<T, N> const &iParamDefs);

  template<typename T>
  RTJmbOutParam<T> addJmbOut(JmbParam<T> iParamDef);

  template<typename T, size_t N>
  RTJmbOutParams<T, N> addJmbOut(JmbParams<T, N> const &iParamDefs);

  template<typename T>
  RTJmbInParam<T> addJmbIn(JmbParam<T> iParamDef);

  template<typename T, size_t N>
  RTJmbInParams<T, N> addJmbIn(JmbParams<T, N> const &iParamDefs);

  virtual tresult init();

  virtual bool beforeProcessing();

  virtual bool applyParameterChanges(IParameterChanges &inputParameterChanges);

  virtual int32 getParamUpdateSampleOffset(ProcessData &iData, ParamID iParamID) const;

  virtual void afterProcessing();

  virtual tresult readNewState(IBStreamer &iStreamer);

  virtual tresult writeLatestState(IBStreamer &oStreamer);

  bool isMessagingEnabled() const { return !fOutboundMessagingParameters.empty(); }

  virtual tresult sendPendingMessages(IMessageProducer *iMessageProducer);

  tresult handleMessage(Message const &iMessage) override;

  // getAllRegistrationOrder
  std::vector<ParamID> const &getAllRegistrationOrder() const { return fAllRegistrationOrder; }

  // gives access for debug
  friend class Debug::ParamDisplay;

protected:
  // the parameters
  Parameters const &fPluginParameters;

  // contains all the registered vst parameters (unique ID, will be checked on add)
  std::map<ParamID, std::unique_ptr<RTRawVstParameter>> fVstParameters{};

  // contains all the registered outbound message parameters (unique ID, will be checked on add)
  std::map<ParamID, std::unique_ptr<IRTJmbOutParameter>> fOutboundMessagingParameters{};

  // contains all the registered inbound message parameters (unique ID, will be checked on add)
  std::map<ParamID, std::unique_ptr<IRTJmbInParameter>> fInboundMessagingParameters{};

  // order in which the parameters were registered
  std::vector<ParamID> fAllRegistrationOrder{};

  // handles messages (receive messages)
  MessageHandler fMessageHandler{};

protected:
  // add raw parameter to the structures
  tresult addRawParameter(std::unique_ptr<RTRawVstParameter> iParameter);

  // add outbound messaging parameter
  tresult addOutboundMessagingParameter(std::unique_ptr<IRTJmbOutParameter> iParameter);

  // add inbound messaging parameter
  tresult addInboundMessagingParameter(std::unique_ptr<IRTJmbInParameter> iParameter);

  virtual bool onNewState(NormalizedState const *iLatestState);

  virtual bool resetPreviousValues();

  virtual void computeLatestState(NormalizedState *oLatestState) const;

  virtual void afterReadNewState(NormalizedState const *iState) {};

  virtual void beforeWriteNewState(NormalizedState const *iState) {};

private:
  // computeLatestState
  void computeLatestState();

private:
  // this queue is used to propagate a Processor::setState call (made from the UI thread) to this state
  // the check happens in beforeProcessing
  Concurrent::LockFree::SingleElementQueue<NormalizedState> fStateUpdate;

  // this atomic value always hold the most current (and consistent) version of this state so that the UI thread
  // can access it in Processor::getState. It is updated in afterProcessing.
  Concurrent::LockFree::AtomicValue<NormalizedState> fLatestState;
};

//------------------------------------------------------------------------
// RTState::add
//------------------------------------------------------------------------
template<typename T>
RTVstParam<T> RTState::add(VstParam<T> iParamDef)
{
  // YP Impl note: this method exports the raw pointer on purpose. The map fVstParameters is storing unique_ptr so that
  // when the map gets deleted, all the parameters get deleted as well. The raw pointer is wrapped inside the RTVstParam
  // wrapper and the normal usage is that it will not outlive the map. Using shared_ptr would be the safest approach
  // but in the RT code, we want to make sure that we do not pay the penalty of managing a ref counter (which may
  // use a lock...)
  auto rawPtr = new RTVstParameter<T>(std::move(iParamDef));
  std::unique_ptr<RTRawVstParameter> rtParam{rawPtr};
  addRawParameter(std::move(rtParam));
  return rawPtr;
}

//------------------------------------------------------------------------
// RTState::add
//------------------------------------------------------------------------
template<size_t N>
RTRawVstParams<N> RTState::add(RawVstParams<N> const &iParamDefs)
{
  return stl::transform<RTRawVstParam, RawVstParam>(iParamDefs, [this](auto &p) { return add(p); });
}

//------------------------------------------------------------------------
// RTState::add
//------------------------------------------------------------------------
template<typename T, size_t N>
RTVstParams<T, N> RTState::add(VstParams<T, N> const &iParamDefs)
{
  return stl::transform<VstParam<T>, RTVstParam<T>>(iParamDefs, [this](auto &p) { return add(p); });
}

//------------------------------------------------------------------------
// RTState::addJmbOut
//------------------------------------------------------------------------
template<typename T>
RTJmbOutParam<T> RTState::addJmbOut(JmbParam<T> iParamDef)
{
  // YP Impl note: see add for similar impl note
  auto rawPtr = new RTJmbOutParameter<T>(std::move(iParamDef));
  std::unique_ptr<IRTJmbOutParameter> rtParam{rawPtr};
  addOutboundMessagingParameter(std::move(rtParam));
  return rawPtr;
}

//------------------------------------------------------------------------
// RTState::addJmbOut
//------------------------------------------------------------------------
template<typename T, size_t N>
RTJmbOutParams<T, N> RTState::addJmbOut(JmbParams<T, N> const &iParamDefs)
{
  return stl::transform<RTJmbOutParam<T>, JmbParam<T>>(iParamDefs, [this](auto &p) { return addJmbOut(p); });
}

//------------------------------------------------------------------------
// RTState::addJmbIn
//------------------------------------------------------------------------
template<typename T>
RTJmbInParam<T> RTState::addJmbIn(JmbParam<T> iParamDef)
{
  // YP Impl note: see add for similar impl note
  auto rawPtr = new RTJmbInParameter<T>(iParamDef);
  std::unique_ptr<IRTJmbInParameter> rtParam{rawPtr};
  addInboundMessagingParameter(std::move(rtParam));
  fMessageHandler.registerHandler(iParamDef->fParamID, rawPtr);
  return rawPtr;
}

//------------------------------------------------------------------------
// RTState::addJmbIn
//------------------------------------------------------------------------
template<typename T, size_t N>
RTJmbInParams<T, N> RTState::addJmbIn(JmbParams<T, N> const &iParamDefs)
{
  return stl::transform<RTJmbInParam<T>, JmbParam<T>>(iParamDefs, [this](auto &p) { return addJmbIn(p); });
}

}
}
}