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 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);

  //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];
protected: // these members are protected because they need to be access by the API classes, and don't want a setter/getter
  std::unique_ptr<NChanDelayLine<sample>> mLatencyDelay = nullptr;
  ITimeInfo mTimeInfo;
};

END_IPLUG_NAMESPACE