IPlugProcessor.h

Go to the documentation of this file.

/*
 ==============================================================================
 
 This file is part of the iPlug 2 library. Copyright (C) the iPlug 2 developers. 
 
 See LICENSE.txt for  more info.
 
 ==============================================================================
*/
 
#pragma once
 
#include <cstring>
#include <cstdint>
#include <ctime>
#include <cmath>
#include <cstdio>
#include <cassert>
#include <memory>
#include <vector>
 
#include "ptrlist.h"
 
#include "IPlugPlatform.h"
#include "IPlugConstants.h"
#include "IPlugStructs.h"
#include "IPlugUtilities.h"
#include "NChanDelay.h"
 
BEGIN_IPLUG_NAMESPACE
 
struct Config;
 
class IPlugProcessor
{
public:
  IPlugProcessor(const Config& config, EAPI plugAPI);
  virtual ~IPlugProcessor();
 
  IPlugProcessor(const IPlugProcessor&) = delete;
  IPlugProcessor& operator=(const IPlugProcessor&) = delete;
  
#pragma mark - Methods you implement in your plug-in class - you do not call these methods
 
  virtual void ProcessBlock(sample** inputs, sample** outputs, int nFrames);
 
  virtual void ProcessMidiMsg(const IMidiMsg& msg);
 
  virtual void ProcessSysEx(ISysEx& msg) {}
 
  virtual void OnReset() { TRACE }
 
  virtual void OnActivate(bool active) { TRACE }
 
#pragma mark - Methods you can call - some of which have custom implementations in the API classes, some implemented in IPlugProcessor.cpp
 
  virtual bool SendMidiMsg(const IMidiMsg& msg) = 0;
 
  virtual bool SendMidiMsgs(WDL_TypedBuf<IMidiMsg>& msgs);
 
  virtual bool SendSysEx(const ISysEx& msg) { return false; }
 
  double GetSampleRate() const { return mSampleRate; }
 
  int GetBlockSize() const { return mBlockSize; }
 
  int GetLatency() const { return mLatency; }
 
  int GetTailSize() { return mTailSize; }
 
  bool GetBypassed() const { return mBypassed; }
 
  bool GetRenderingOffline() const { return mRenderingOffline; };
 
#pragma mark -
  double GetSamplePos() const { return mTimeInfo.mSamplePos; }
 
  double GetTempo() const { return mTimeInfo.mTempo; }
 
  double GetPPQPos() const { return mTimeInfo.mPPQPos; }
 
  bool GetTransportIsRunning() const { return mTimeInfo.mTransportIsRunning; }
  
  double GetSamplesPerBeat() const;
 
  void GetTimeSig(int& numerator, int& denominator) const { numerator = mTimeInfo.mNumerator; denominator = mTimeInfo.mDenominator; }
 
#pragma mark -
  
  virtual void GetBusName(ERoute direction, int busIdx, int nBuses, WDL_String& str) const;
  
  int NIOConfigs() const { return mIOConfigs.GetSize(); }
 
  const IOConfig* GetIOConfig(int idx) const { return mIOConfigs.Get(idx); }
 
  int GetIOConfigWithChanCounts(std::vector<int>& inputBuses, std::vector<int>& outputBuses);
  
  int MaxNBuses(ERoute direction, int* pConfigIdxWithTheMostBuses = nullptr) const;
 
  int MaxNChannelsForBus(ERoute direction, int busIdx) const;
 
  bool HasWildcardBus(ERoute direction) const { return mIOConfigs.Get(0)->ContainsWildcard(direction); } // \todo only supports a single I/O config
 
  int MaxNChannels(ERoute direction) const { return mChannelData[direction].GetSize(); }
 
  bool IsChannelConnected(ERoute direction, int chIdx) const { return (chIdx < mChannelData[direction].GetSize() && mChannelData[direction].Get(chIdx)->mConnected); }
 
  int NChannelsConnected(ERoute direction) const;
 
  inline int NInChansConnected() const { return NChannelsConnected(ERoute::kInput); }
 
  inline int NOutChansConnected() const { return NChannelsConnected(ERoute::kOutput); }
 
  bool LegalIO(int NInputChans, int NOutputChans) const; //TODO: this should be updated
 
  bool HasSidechainInput() const { return MaxNBuses(ERoute::kInput) > 1; }
 
  void LimitToStereoIO();//TODO: this should be updated
 
  bool IsInstrument() const { return mPlugType == EIPlugPluginType::kInstrument; }
 
  bool IsMidiEffect() const { return mPlugType == EIPlugPluginType::kMIDIEffect; }
  
  int GetAUPluginType() const;
 
  bool DoesMIDIIn() const { return mDoesMIDIIn; }
 
  bool DoesMIDIOut() const { return mDoesMIDIOut; }
  
  bool DoesMPE() const { return mDoesMPE; }
 
  void SetChannelLabel(ERoute direction, int idx, const char* formatStr, bool zeroBased = false);
 
  virtual void SetLatency(int latency);
 
  void SetTailSize(int tailSize) { mTailSize = tailSize; }
 
  static int ParseChannelIOStr(const char* IOStr, WDL_PtrList<IOConfig>& channelIOList, int& totalNInChans, int& totalNOutChans, int& totalNInBuses, int& totalNOutBuses);
 
protected:
#pragma mark - Methods called by the API class - you do not call these methods in your plug-in class
  void SetChannelConnections(ERoute direction, int idx, int n, bool connected);
  void InitLatencyDelay();
  
  //The following methods are duplicated, in order to deal with either single or double precision processing,
  //depending on the value of arguments passed in
  void AttachBuffers(ERoute direction, int idx, int n, PLUG_SAMPLE_DST** ppData, int nFrames);
  void AttachBuffers(ERoute direction, int idx, int n, PLUG_SAMPLE_SRC** ppData, int nFrames);
  void PassThroughBuffers(PLUG_SAMPLE_SRC type, int nFrames);
  void PassThroughBuffers(PLUG_SAMPLE_DST type, int nFrames);
  void ProcessBuffers(PLUG_SAMPLE_SRC type, int nFrames);
  void ProcessBuffers(PLUG_SAMPLE_DST type, int nFrames);
  void ProcessBuffersAccumulating(int nFrames); // only for VST2 deprecated method single precision
  void ZeroScratchBuffers();
  void SetSampleRate(double sampleRate) { mSampleRate = sampleRate; }
  void SetBlockSize(int blockSize);
  void SetBypassed(bool bypassed) { mBypassed = bypassed; }
  void SetTimeInfo(const ITimeInfo& timeInfo) { mTimeInfo = timeInfo; }
  void SetRenderingOffline(bool renderingOffline) { mRenderingOffline = renderingOffline; }
  const WDL_String& GetChannelLabel(ERoute direction, int idx) { return mChannelData[direction].Get(idx)->mLabel; }
 
private:
  EIPlugPluginType mPlugType;
  bool mDoesMIDIIn;
  bool mDoesMIDIOut;
  bool mDoesMPE;
  int mLatency;
  double mSampleRate = DEFAULT_SAMPLE_RATE;
  int mBlockSize = 0;
  int mTailSize = 0;
  bool mBypassed = false;
  bool mRenderingOffline = false;
  WDL_PtrList<IOConfig> mIOConfigs;
  /* Manages pointers to the actual data for each channel */
  WDL_TypedBuf<sample*> mScratchData[2];
  /* A list of IChannelData structures corresponding to every input/output channel */
  WDL_PtrList<IChannelData<>> mChannelData[2];
  std::unique_ptr<NChanDelayLine<sample>> mLatencyDelay = nullptr;
protected: // protected because it needs to be access by the API classes, and don't want a setter/getter
  ITimeInfo mTimeInfo;
};
 
END_IPLUG_NAMESPACE