IPlugStructs.h

/*
 ==============================================================================
 
 This file is part of the iPlug 2 library. Copyright (C) the iPlug 2 developers. 
 
 See LICENSE.txt for  more info.
 
 ==============================================================================
*/

#pragma once

#include <algorithm>
#include "wdlstring.h"
#include "ptrlist.h"

#include "IPlugConstants.h"
#include "IPlugPlatform.h"
#include "IPlugMidi.h" // <- Midi related structs in here
#include "IPlugUtilities.h"

BEGIN_IPLUG_NAMESPACE

struct ParamTuple
{
  int idx;
  double value;
  
  ParamTuple(int idx = kNoParameter, double value = 0.)
  : idx(idx)
  , value(value)
  {}
};

struct SysExData
{
  SysExData(int offset = 0, int size = 0, const void* pData = 0)
  : mOffset(offset)
  , mSize(size)
  {
    assert(size < MAX_SYSEX_SIZE);
    
    if (pData)
      memcpy(mData, pData, size);
    else
      memset(mData, 0, MAX_SYSEX_SIZE);
  }
  
  int mOffset;
  int mSize;
  uint8_t mData[MAX_SYSEX_SIZE];
};

struct IByteGetter
{
  static inline int GetBytes(const uint8_t* pSrc, int srcSize, void* pDst, int nBytesToCopy, int startPos)
  {
    int endPos = startPos + nBytesToCopy;
    if (startPos >= 0 && endPos <= srcSize)
    {
      memcpy(pDst, pSrc + startPos, nBytesToCopy);
      return endPos;
    }
    return -1;
  }
  
  static inline int GetStr(const uint8_t* pSrc, int srcSize, WDL_String& str, int startPos)
  {
    int len;
    int strStartPos = GetBytes(pSrc, srcSize, &len, sizeof(len), startPos);
    if (strStartPos >= 0)
    {
      int strEndPos = strStartPos + len;
      if (strEndPos <= srcSize)
      {
        if (len > 0)
          str.Set((char*) (pSrc + strStartPos), len);
        else
          str.Set("");
      }
      return strEndPos;
    }
    return -1;
  }
};
  
class IByteChunk : private IByteGetter
{
public:
  IByteChunk() {}
  ~IByteChunk() {}
  
  static void InitChunkWithIPlugVer(IByteChunk& chunk)
  {
    chunk.Clear();
    int magic = IPLUG_VERSION_MAGIC;
    chunk.Put(&magic);
    int ver = IPLUG_VERSION;
    chunk.Put(&ver);
  }
  
  static int GetIPlugVerFromChunk(const IByteChunk& chunk, int& position)
  {
    int magic = 0, ver = 0;
    int magicpos = chunk.Get(&magic, position);
    
    if (magicpos > position && magic == IPLUG_VERSION_MAGIC)
      position = chunk.Get(&ver, magicpos);
    
    return ver;
  }
  
  inline int PutBytes(const void* pSrc, int nBytesToCopy)
  {
    int n = mBytes.GetSize();
    mBytes.Resize(n + nBytesToCopy);
    memcpy(mBytes.Get() + n, pSrc, nBytesToCopy);
    return mBytes.GetSize();
  }
  
  inline int GetBytes(void* pDst, int nBytesToCopy, int startPos) const
  {
    return IByteGetter::GetBytes(mBytes.Get(), Size(), pDst, nBytesToCopy, startPos);
  }
  
  template <class T>
  inline int Put(const T* pVal)
  {
    return PutBytes(pVal, sizeof(T));
  }
  
  template <class T>
  inline int Get(T* pDst, int startPos) const
  {
    return GetBytes(pDst, sizeof(T), startPos);
  }
  
  inline int PutStr(const char* str)
  {
    int slen = (int) strlen(str);
    Put(&slen);
    return PutBytes(str, slen);
  }
  
  inline int GetStr(WDL_String& str, int startPos) const
  {
    return IByteGetter::GetStr(mBytes.Get(), Size(), str, startPos);
  }
  
  inline int PutChunk(const IByteChunk* pRHS)
  {
    return PutBytes(pRHS->GetData(), pRHS->Size());
  }
  
  inline void Clear()
  {
    mBytes.Resize(0);
  }
  
  inline int Size() const
  {
    return mBytes.GetSize();
  }
  
  inline int Resize(int newSize)
  {
    int n = mBytes.GetSize();
    mBytes.Resize(newSize);
    if (newSize > n)
    {
      memset(mBytes.Get() + n, 0, (newSize - n));
    }
    return n;
  }
  
  inline uint8_t* GetData()
  {
    return mBytes.Get();
  }
  
  inline const uint8_t* GetData() const
  {
    return mBytes.Get();
  }
  
  inline bool IsEqual(IByteChunk& otherChunk) const
  {
    return (otherChunk.Size() == Size() && !memcmp(otherChunk.mBytes.Get(), mBytes.Get(), Size()));
  }
  
private:
  WDL_TypedBuf<uint8_t> mBytes;
};

class IByteStream : private IByteGetter
{
public:
  IByteStream(const void *pData, int dataSize) : mBytes(reinterpret_cast<const uint8_t *>(pData)), mSize(dataSize) {}
  ~IByteStream() {}
  
  inline int GetBytes(void* pDst, int nBytesToCopy, int startPos) const
  {
    return IByteGetter::GetBytes(mBytes, Size(), pDst, nBytesToCopy, startPos);
  }
  
  template <class T>
  inline int Get(T* pDst, int startPos) const
  {
    return GetBytes(pDst, sizeof(T), startPos);
  }
  
  inline int GetStr(WDL_String& str, int startPos) const
  {
    return IByteGetter::GetStr(mBytes, Size(), str, startPos);
  }
  
  inline int Size() const
  {
    return mSize;
  }
  
  inline bool IsEqual(IByteStream& otherStream) const
  {
    return (otherStream.Size() == Size() && !memcmp(otherStream.mBytes, mBytes, Size()));
  }
  
  inline const uint8_t* GetData()
  {
    return mBytes;
  }
  
private:
  const uint8_t* mBytes;
  int mSize;
};

class IByteChunkReader
{
public:
  IByteChunkReader(const IByteChunk& chunk, int startPos = 0)
  : mChunk(chunk)
  , mPos(startPos)
  {
  }
  
  inline int GetBytes(void* pBuf, int nBytesToCopy)
  {
    mPos = mChunk.GetBytes(pBuf, nBytesToCopy, mPos);
    return mPos;
  }
  
  template <class T>
  inline int Get(T* pDst)
  {
    mPos = mChunk.Get(pDst, mPos);
    return mPos;
  }
  
  inline int GetStr(WDL_String& str)
  {
    mPos = mChunk.GetStr(str, mPos);
    return mPos;
  }
  
  inline int Tell() const
  {
    return mPos;
  }

  inline void Seek(int pos)
  {
    mPos = pos;
  }

private:
  const IByteChunk& mChunk;
  int mPos;
};

struct Config
{
  int nParams;
  int nPresets;
  const char* channelIOStr;
  const char* pluginName;
  const char* productName;
  const char* mfrName;
  int vendorVersion;
  int uniqueID;
  int mfrID;
  int latency;
  bool plugDoesMidiIn;
  bool plugDoesMidiOut;
  bool plugDoesMPE;
  bool plugDoesChunks;
  int plugType;
  bool plugHasUI;
  int plugWidth;
  int plugHeight;
  int plugMinWidth;
  int plugMaxWidth;
  int plugMinHeight;
  int plugMaxHeight;
  bool plugHostResize;
  const char* bundleID;
  
  Config(int nParams,
              int nPresets,
              const char* channelIOStr,
              const char* pluginName,
              const char* productName,
              const char* mfrName,
              int vendorVersion,
              int uniqueID,
              int mfrID,
              int latency,
              bool plugDoesMidiIn,
              bool plugDoesMidiOut,
              bool plugDoesMPE,
              bool plugDoesChunks,
              int plugType,
              bool plugHasUI,
              int plugWidth,
              int plugHeight,
              bool plugHostResize,
              int plugMinWidth,
              int plugMaxWidth,
              int plugMinHeight,
              int plugMaxHeight,
              const char* bundleID)
              
  : nParams(nParams)
  , nPresets(nPresets)
  , channelIOStr(channelIOStr)
  , pluginName(pluginName)
  , productName(productName)
  , mfrName(mfrName)
  , vendorVersion(vendorVersion)
  , uniqueID(uniqueID)
  , mfrID(mfrID)
  , latency(latency)
  , plugDoesMidiIn(plugDoesMidiIn)
  , plugDoesMidiOut(plugDoesMidiOut)
  , plugDoesMPE(plugDoesMPE)
  , plugDoesChunks(plugDoesChunks)
  , plugType(plugType)
  , plugHasUI(plugHasUI)
  , plugWidth(plugWidth)
  , plugHeight(plugHeight)
  , plugMinWidth(plugMinWidth)
  , plugMaxWidth(plugMaxWidth)
  , plugMinHeight(plugMinHeight)
  , plugMaxHeight(plugMaxHeight)
  , plugHostResize(plugHostResize)
  , bundleID(bundleID)
  {};
};

template<class TIN = PLUG_SAMPLE_SRC, class TOUT = PLUG_SAMPLE_DST>
struct IChannelData
{
  bool mConnected = false;
  TOUT** mData = nullptr; // If this is for an input channel, points into IPlugProcessor::mInData, if it's for an output channel points into IPlugProcessor::mOutData
  TIN* mIncomingData = nullptr;
  WDL_TypedBuf<TOUT> mScratchBuf;
  WDL_String mLabel;
};

class IBusInfo
{
public:
  IBusInfo(ERoute direction, int nchans = 0)
  : mDirection(direction)
  , mNChans(nchans)
  {
  }
  
  int NChans() const { return mNChans; }

  ERoute GetDirection() const { return mDirection; }

private:
  ERoute mDirection;
  int mNChans;
};

struct IOConfig
{
  WDL_PtrList<IBusInfo> mBusInfo[2];  // A particular valid io config may have multiple input buses or output busses
  
  ~IOConfig()
  {
    mBusInfo[0].Empty(true);
    mBusInfo[1].Empty(true);
  }
  
  void AddBusInfo(ERoute direction, int NChans)
  {
    mBusInfo[direction].Add(new IBusInfo(direction, NChans));
  }
  
  const IBusInfo* GetBusInfo(ERoute direction, int index) const
  {
    assert(index >= 0 && index < mBusInfo[direction].GetSize());
    return mBusInfo[direction].Get(index);
  }
  
  int NChansOnBusSAFE(ERoute direction, int index) const
  {
    int NChans = 0;
    
    if(index >= 0 && index < mBusInfo[direction].GetSize())
      NChans = mBusInfo[direction].Get(index)->NChans();

    return NChans;
  }
  
  int NBuses(ERoute direction) const
  {
    return mBusInfo[direction].GetSize();
  }
  
  int GetTotalNChannels(ERoute direction) const
  {
    int total = 0;
    
    for(int i = 0; i < mBusInfo[direction].GetSize(); i++)
      total += mBusInfo[direction].Get(i)->NChans();
    
    return total;
  }
  
  bool ContainsWildcard(ERoute direction) const
  {
    for(auto i = 0; i < mBusInfo[direction].GetSize(); i++)
    {
      if(mBusInfo[direction].Get(i)->NChans() < 0)
        return true;
    }

    return false;
  }
};

struct ITimeInfo
{
  double mTempo = DEFAULT_TEMPO;
  double mSamplePos = -1.0;
  double mPPQPos = -1.0;
  double mLastBar = -1.0;
  double mCycleStart = -1.0;
  double mCycleEnd = -1.0;

  int mNumerator = 4;
  int mDenominator = 4;

  bool mTransportIsRunning = false;
  bool mTransportLoopEnabled = false;
};

struct IPreset
{
  bool mInitialized = false;
  char mName[MAX_PRESET_NAME_LEN];

  IByteChunk mChunk;

  IPreset()
  {
    sprintf(mName, "%s", UNUSED_PRESET_NAME);
  }
};

struct IKeyPress
{
  int VK; // Windows VK_XXX
  char utf8[5] = { 0 }; // UTF8 key
  bool S, C, A; // SHIFT / CTRL(WIN) or CMD (MAC) / ALT

  IKeyPress(const char* _utf8, int vk, bool s = false, bool c = false, bool a = false)
    : VK(vk)
    , S(s), C(c), A(a)
  {
    strcpy(utf8, _utf8);
  }

  void DBGPrint() const { DBGMSG("VK: %i\n", VK); }
};

END_IPLUG_NAMESPACE