MidiSynth.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 <array>
#include <vector>
#include <stdint.h>
 
#include "ptrlist.h"
 
#include "IPlugConstants.h"
#include "IPlugMidi.h"
#include "IPlugLogger.h"
 
#include "SynthVoice.h"
#include "VoiceAllocator.h"
 
#define DEBUG_VOICE_COUNT 0
 
BEGIN_IPLUG_NAMESPACE
 
class MidiSynth
{
public:
  static constexpr int kDefaultBlockSize = 32;
  static constexpr int kDefaultPitchBendRange = 12;
 
#pragma mark - MidiSynth class
 
  MidiSynth(VoiceAllocator::EPolyMode mode, int blockSize = kDefaultBlockSize);
  ~MidiSynth();
 
  MidiSynth(const MidiSynth&) = delete;
  MidiSynth& operator=(const MidiSynth&) = delete;
    
  void Reset()
  {
    mSampleTime = 0;
    mVoiceAllocator.Clear();
  }
 
  void SetSampleRateAndBlockSize(double sampleRate, int blockSize);
 
  void SetVoicesActive(bool active)
  {
    mVoicesAreActive = active;
  }
  
  void InitBasicMPE()
  {
    SetMPEZones(0, 16);
  }
  
  void SetPitchBendRange(int pitchBendRange)
  {
    mNonMPEPitchBendRange = pitchBendRange;
    
    if(!mMPEMode)
    {
      for(int i=0; i<16; ++i)
      {
        mChannelStates[i].pitchBendRange = pitchBendRange;
      }
    }
  }
 
  void SetPolyMode(VoiceAllocator::EPolyMode mode)
  {
    mVoiceAllocator.mPolyMode = mode;
  }
 
  void SetATMode(VoiceAllocator::EATMode mode)
  {
    mVoiceAllocator.mATMode = mode;
  }
 
  void SetKeyToPitchFn(const std::function<float(int)>& fn)
  {
    mVoiceAllocator.SetKeyToPitchFunction(fn);
  }
 
  void SetNoteOffset(double offset)
  {
    mVoiceAllocator.SetPitchOffset(static_cast<float>(offset));
  }
 
  void SetNoteGlideTime(double t)
  {
    mVoiceAllocator.SetNoteGlideTime(t);
  }
 
  void SetControlGlideTime(double t)
  {
    mVoiceAllocator.SetControlGlideTime(t);
  }
 
  SynthVoice* GetVoice(int voiceIdx)
  {
    return mVoiceAllocator.GetVoice(voiceIdx);
  }
  
  void ForEachVoice(std::function<void(SynthVoice& voice)> func)
  {
    for (auto v = 0; v < NVoices(); v++)
      func(*GetVoice(v));
  }
  
  size_t NVoices() const
  {
    return mVoiceAllocator.GetNVoices();
  }
 
  void AddVoice(SynthVoice* pVoice, uint8_t zone)
  {
    mVoiceAllocator.AddVoice(pVoice, zone);
  }
 
  void AddMidiMsgToQueue(const IMidiMsg& msg)
  {
    mMidiQueue.Add(msg);
  }
 
  bool ProcessBlock(sample** inputs, sample** outputs, int nInputs, int nOutputs, int nFrames);
 
private:
 
  // maintain the state for one MIDI channel including RPN receipt state and pitch bend range.
  struct ChannelState
  {
    uint8_t paramMSB;
    uint8_t paramLSB;
    uint8_t valueMSB;
    uint8_t valueLSB;
    uint8_t pitchBendRange; // in semitones
    float pitchBend;
    float pressure;
    float timbre;
  };
 
  // MPE helper functions
  const int kMPELowerZoneMasterChannel = 0;
  const int kMPEUpperZoneMasterChannel = 15;
  inline bool IsMasterChannel(int c) const { return ((c == 0)||(c == 15)); }
  bool IsInLowerZone(int c) const { return ((c > 0)&&(c < mMPELowerZoneChannels)); }
  bool IsInUpperZone(int c) const { return ((c < 15)&&(c > 15 - mMPEUpperZoneChannels)); }
  int MasterChannelFor(int memberChan) const { return IsInUpperZone(memberChan) ? kMPEUpperZoneMasterChannel : kMPELowerZoneMasterChannel; }
  int MasterZoneFor(int memberChan) const { return IsInUpperZone(memberChan) ? 1 : 0; }
 
  // handy functions for writing loops on lower and upper Zone member channels
  int LowerZoneStart() const { return 1; }
  int LowerZoneEnd() const { return mMPELowerZoneChannels - 1; }
  int UpperZoneStart() const {  return 15 - mMPEUpperZoneChannels; }
  int UpperZoneEnd() const { return 15; }
 
  void SetMPEZones(int channel, int nChans);
  void SetChannelPitchBendRange(int channel, int range);
 
  VoiceInputEvent MidiMessageToEventBasic(const IMidiMsg& msg);
  VoiceInputEvent MidiMessageToEventMPE(const IMidiMsg& msg);
  VoiceInputEvent MidiMessageToEvent(const IMidiMsg& msg);
  void HandleRPN(IMidiMsg msg);
 
  // basic MIDI data
  VoiceAllocator mVoiceAllocator;
  uint16_t mUnisonVoices{1};
  IMidiQueue mMidiQueue;
  float mVelocityLUT[128];
  float mAfterTouchLUT[128];
  ChannelState mChannelStates[16]{};
  int mBlockSize;
  int64_t mSampleTime{0};
  double mSampleRate = DEFAULT_SAMPLE_RATE;
  bool mVoicesAreActive = false;
  int mNonMPEPitchBendRange = kDefaultPitchBendRange;
  
  // the synth will startup in basic MIDI mode. When an MPE Zone setup message is received, MPE mode is entered.
  // To leave MPE mode, use RPNs to set all MPE zone channel counts to 0 as per the MPE spec.
  bool mMPEMode{false};
 
  // MPE state - channels in zone including master channels.
  int mMPELowerZoneChannels{0};
  int mMPEUpperZoneChannels{0};
};
 
END_IPLUG_NAMESPACE