LV2Ports.h

Go to the documentation of this file.

/**********************************************************************
 
  Audacity: A Digital Audio Editor
 
  @file LV2Ports.h
  @brief Immutable descriptions of LV2 ports; associated state structures
 
  Paul Licameli split from LV2Effect.h
 
  Audacity(R) is copyright (c) 1999-2013 Audacity Team.
  License: GPL v2 or later.  See License.txt.
 
*********************************************************************/
 
#ifndef __AUDACITY_LV2_PORTS__
#define __AUDACITY_LV2_PORTS__
 
#if USE_LV2
 
#include <functional>
#include <optional>
#include <unordered_map>
 
#include "LV2Utils.h"
#include "EffectInterface.h"
#include "MemoryX.h"
#include "TranslatableString.h"
#include <wx/arrstr.h>
#include "lv2/atom/forge.h"
#include "zix/ring.h"
 
using Floats = ArrayOf<float>;
 
class LV2Port {
public:
   LV2Port(const LilvPort *port, int index, bool isInput,
      const wxString &symbol, const wxString &name,
      const TranslatableString &group
   )  : mPort(port), mIndex(index), mIsInput(isInput)
      , mSymbol(symbol), mName(name), mGroup(group)
   {}
   const LilvPort *const mPort;
   const uint32_t mIndex;
   const bool mIsInput;
   const wxString mSymbol;
   const wxString mName;
   const TranslatableString mGroup;
};
 
class LV2AudioPort final : public LV2Port {
public:
   using LV2Port::LV2Port;
};
using LV2AudioPortPtr = std::shared_ptr<LV2AudioPort>;
using LV2AudioPortArray = std::vector<LV2AudioPortPtr>;
 
class LV2AtomPort final : public LV2Port {
public:
   LV2AtomPort(const LilvPort *port, int index, bool isInput,
      const wxString & symbol, const wxString & name,
      const TranslatableString & group,
      uint32_t minimumSize, bool isMidi, bool wantsPosition
   )  : LV2Port{ port, index, isInput, symbol, name, group }
      , mMinimumSize{ minimumSize }
      , mIsMidi{ isMidi }
      , mWantsPosition{ wantsPosition }
   {}
   const uint32_t mMinimumSize;
   const bool mIsMidi;
   const bool mWantsPosition;
};
using LV2AtomPortPtr = std::shared_ptr<LV2AtomPort>;
using LV2AtomPortArray = std::vector<LV2AtomPortPtr>;
 
struct LV2AtomPortState final {
   explicit LV2AtomPortState(LV2AtomPortPtr pPort)
      : mpPort{ move(pPort) }
      , mRing{ zix_ring_new(mpPort->mMinimumSize) }
      , mBuffer{ safenew uint8_t[mpPort->mMinimumSize] }
   {
      assert(mpPort);
      /*
       There is no complementary munlock anywhere in the library!
       Are we mis-using a class meant for plugin implementation?
       Do we make a resource leak of physical memory pages?
       Should we just skip this call?
       Or is mlock a good idea we should implement in our own RingBuffer,
       which we can also munlock in its destructor?
       */
      zix_ring_mlock(mRing.get());
 
      ResetForInstanceOutput();
   }
 
 
   void SendToInstance(LV2_Atom_Forge &forge, int64_t frameTime, float speed);
   void ResetForInstanceOutput();
 
   void ReceiveFromInstance();
 
 
   void SendToDialog(
      std::function<void(const LV2_Atom *atom, uint32_t size)> handler);
 
   void ReceiveFromDialog(const void *buffer, uint32_t buffer_size);
 
   const LV2AtomPortPtr mpPort;
   const Lilv_ptr<ZixRing, zix_ring_free> mRing;
   const std::unique_ptr<uint8_t[]> mBuffer;
};
using LV2AtomPortStatePtr = std::shared_ptr<LV2AtomPortState>;
using LV2AtomPortStateArray = std::vector<LV2AtomPortStatePtr>;
 
class LV2CVPort final : public LV2Port {
public:
   LV2CVPort(const LilvPort *port, int index, bool isInput,
      const wxString & symbol, const wxString & name,
      const TranslatableString & group,
      float min, float max, float def, bool hasLo, bool hasHi
   )  : LV2Port(port, index, isInput, symbol, name, group)
      , mMin{ min }, mMax{ max }, mDef{ def }, mHasLo{ hasLo }, mHasHi{ hasHi }
   {}
   const float mMin;
   const float mMax;
   const float mDef;
   const bool mHasLo;
   const bool mHasHi;
};
using LV2CVPortPtr = std::shared_ptr<LV2CVPort>;
using LV2CVPortArray = std::vector<LV2CVPortPtr>;
 
struct LV2CVPortState final {
   explicit LV2CVPortState(LV2CVPortPtr pPort) : mpPort{ move(pPort) } {
      assert(mpPort);
   }
   const LV2CVPortPtr mpPort;
   Floats mBuffer;
};
using LV2CVPortStateArray = std::vector<LV2CVPortState>;
 
class LV2ControlPort final : public LV2Port
{
public:
   LV2ControlPort(const LilvPort *port, int index, bool isInput,
      const wxString & symbol, const wxString & name,
      const TranslatableString & group,
      std::vector<double> scaleValues, wxArrayString scaleLabels,
      const wxString &units,
      float min, float max, float def, bool hasLo, bool hasHi,
      bool toggle, bool enumeration, bool integer, bool sampleRate,
      bool trigger, bool logarithmic
   )  : LV2Port{ port, index, isInput, symbol, name, group }
      , mScaleValues{ move(scaleValues) }
      , mScaleLabels{ std::move(scaleLabels) }
      , mUnits{ units }
      , mMin{ min }, mMax{ max }, mDef{ def }
      , mHasLo{ hasLo }, mHasHi{ hasHi }
      , mToggle{ toggle }, mEnumeration{ enumeration }, mInteger{ integer }
      , mSampleRate{ sampleRate }
      , mTrigger{ trigger }, mLogarithmic{ logarithmic }
   {}
 
   // ScalePoints
   const std::vector<double> mScaleValues;
   const wxArrayString mScaleLabels;
 
   const wxString mUnits;
   const float mMin;
   const float mMax;
   const float mDef;
   const bool mHasLo;
   const bool mHasHi;
   const bool mToggle;
   const bool mEnumeration;
   const bool mInteger;
   const bool mSampleRate;
   const bool mTrigger;
   const bool mLogarithmic;
 
   size_t Discretize(float value) const;
};
using LV2ControlPortPtr = std::shared_ptr<LV2ControlPort>;
using LV2ControlPortArray = std::vector<LV2ControlPortPtr>;
 
struct LV2EffectSettings final {
   std::vector<float> values;
   mutable std::shared_ptr<const LilvState> mpState;
};
 
inline LV2EffectSettings &GetSettings(EffectSettings &settings)
{
   auto pSettings = settings.cast<LV2EffectSettings>();
   assert(pSettings);
   return *pSettings;
}
 
inline const LV2EffectSettings &GetSettings(const EffectSettings &settings)
{
   return GetSettings(const_cast<EffectSettings &>(settings));
}
 
struct LV2EffectOutputs : EffectOutputs {
   ~LV2EffectOutputs() override;
   std::unique_ptr<EffectOutputs> Clone() const override;
   void Assign(EffectOutputs &&src) override;
   std::vector<float> values;
};
 
struct LV2ControlPortState final {
   explicit LV2ControlPortState(LV2ControlPortPtr pPort)
      : mpPort{ move(pPort) }
   {
      assert(mpPort);
   }
   const LV2ControlPortPtr mpPort;
   float mLst{ 0.0 };
   float mTmp{ 0.0 };
   float mLo{ 0.0 };
   float mHi{ 0.0 };
};
using LV2ControlPortStateArray = std::vector<LV2ControlPortState>;
 
class LV2Ports {
public:
   explicit LV2Ports(const LilvPlugin &plug);
 
   void EmitPortValues(
      const LilvState &state, LV2EffectSettings &settings) const;
 
   const void *GetPortValue(const LV2EffectSettings &settings,
      const char *port_symbol, uint32_t *size, uint32_t *type) const;
 
   void SetPortValue(LV2EffectSettings &settings, const char *port_symbol,
      const void *value, uint32_t size, uint32_t type) const;
 
   LV2AudioPortArray mAudioPorts;
   unsigned mAudioIn{ 0 };
   unsigned mAudioOut{ 0 };
 
   LV2AtomPortArray mAtomPorts;
   std::optional<size_t> mControlInIdx{};
   std::optional<size_t> mControlOutIdx{};
   unsigned mMidiIn{ 0 };
   unsigned mMidiOut{ 0 };
 
   LV2CVPortArray mCVPorts;
 
   LV2ControlPortArray mControlPorts;
   TranslatableStrings mGroups;
   std::unordered_map<TranslatableString, std::vector<int>> mGroupMap;
   std::unordered_map<uint32_t, size_t> mControlPortMap;
   int mLatencyPort{ -1 };
};
 
class LV2PortStates {
public:
   explicit LV2PortStates(const LV2Ports &ports);
   LV2AtomPortStateArray mAtomPortStates;
   LV2CVPortStateArray mCVPortStates;
};
 
class LV2PortUIStates {
public:
   LV2PortUIStates(const LV2PortStates &states, const LV2Ports &ports);
   LV2AtomPortStatePtr mControlIn;
   LV2AtomPortStatePtr mControlOut;
   LV2ControlPortStateArray mControlPortStates;
};
 
#endif
#endif