IPlugExamples/IPlugPolySynth/IPlugPolySynth.cpp

   1 #include "IPlugPolySynth.h"
   2 #include "IPlug_include_in_plug_src.h"
   3 #include "resource.h"
   4
   5 #include "IControl.h"
   6 #include "IKeyboardControl.h"
   7
   8
   9 const int kNumPrograms = 8;
  10
  11 #define PITCH 440.
  12 #define TABLE_SIZE 512
  13
  14 #ifndef M_PI
  15 #define M_PI 3.14159265
  16 #endif
  17
  18 #define GAIN_FACTOR 0.2;
  19
  20 enum EParams
  21 {
  22   kAttack = 0,
  23   kDecay,
  24   kSustain,
  25   kRelease,
  26   kNumParams
  27 };
  28
  29 IPlugPolySynth::IPlugPolySynth(IPlugInstanceInfo instanceInfo)
  30   : IPLUG_CTOR(kNumParams, kNumPrograms, instanceInfo),
  31     mSampleRate(44100.),
  32     mNumHeldKeys(0),
  33     mKey(-1),
  34     mActiveVoices(0)
  35
  36 {
  37   TRACE;
  38
  39   mTable = new double[TABLE_SIZE];
  40
  41   for (int i = 0; i < TABLE_SIZE; i++)
  42   {
  43     mTable[i] = sin( i/double(TABLE_SIZE) * 2. * M_PI);
  44     //printf("mTable[%i] %f\n", i, mTable[i]);
  45   }
  46
  47   mOsc = new CWTOsc(mTable, TABLE_SIZE);
  48   mEnv = new CADSREnvL();
  49
  50   memset(mKeyStatus, 0, 128 * sizeof(bool));
  51
  52   //arguments are: name, defaultVal, minVal, maxVal, step, label
  53   GetParam(kAttack)->InitDouble("Amp Attack", ATTACK_DEFAULT, TIME_MIN, TIME_MAX, 0.001);
  54   GetParam(kDecay)->InitDouble("Amp Decay", DECAY_DEFAULT, TIME_MIN, TIME_MAX, 0.001);
  55   GetParam(kSustain)->InitDouble("Amp Sustain", 1., 0., 1., 0.001);
  56   GetParam(kRelease)->InitDouble("Amp Release", RELEASE_DEFAULT, TIME_MIN, TIME_MAX, 0.001);
  57
  58   IGraphics* pGraphics = MakeGraphics(this, kWidth, kHeight);
  59   pGraphics->AttachBackground(BG_ID, BG_FN);
  60
  61   IBitmap knob = pGraphics->LoadIBitmap(KNOB_ID, KNOB_FN, kKnobFrames);
  62   IText text = IText(14);
  63   IBitmap regular = pGraphics->LoadIBitmap(WHITE_KEY_ID, WHITE_KEY_FN, 6);
  64   IBitmap sharp   = pGraphics->LoadIBitmap(BLACK_KEY_ID, BLACK_KEY_FN);
  65
  66   //                    C#     D#          F#      G#      A#
  67   int coords[12] = { 0, 7, 12, 20, 24, 36, 43, 48, 56, 60, 69, 72 };
  68   mKeyboard = new IKeyboardControl(this, kKeybX, kKeybY, 48, 5, &regular, &sharp, coords);
  69
  70   pGraphics->AttachControl(mKeyboard);
  71
  72   IBitmap about = pGraphics->LoadIBitmap(ABOUTBOX_ID, ABOUTBOX_FN);
  73   mAboutBox = new IBitmapOverlayControl(this, 100, 100, &about, IRECT(540, 250, 680, 290));
  74   pGraphics->AttachControl(mAboutBox);
  75   AttachGraphics(pGraphics);
  76
  77   //MakePreset("preset 1", ... );
  78   MakeDefaultPreset((char *) "-", kNumPrograms);
  79 }
  80
  81 IPlugPolySynth::~IPlugPolySynth()
  82 {
  83   delete mOsc;
  84   delete mEnv;
  85   delete [] mTable;
  86 }
  87
  88 int IPlugPolySynth::FindFreeVoice()
  89 {
  90   int v;
  91
  92   for(v = 0; v < MAX_VOICES; v++)
  93   {
  94     if(!mVS[v].GetBusy())
  95       return v;
  96   }
  97
  98   int quietestVoice = 0;
  99   double level = 2.;
 100
 101   for(v = 0; v < MAX_VOICES; v++)
 102   {
 103     double summed = mVS[v].mEnv_ctx.mPrev;
 104
 105     if (summed < level)
 106     {
 107       level = summed;
 108       quietestVoice = v;
 109     }
 110
 111   }
 112
 113   DBGMSG("stealing voice %i\n", quietestVoice);
 114   return quietestVoice;
 115 }
 116
 117 void IPlugPolySynth::NoteOnOff(IMidiMsg* pMsg)
 118 {
 119   int v;
 120
 121   int status = pMsg->StatusMsg();
 122   int velocity = pMsg->Velocity();
 123   int note = pMsg->NoteNumber();
 124
 125   if (status == IMidiMsg::kNoteOn && velocity) // Note on
 126   {
 127     v = FindFreeVoice(); // or quietest
 128     mVS[v].mKey = note;
 129     mVS[v].mOsc_ctx.mPhaseIncr = (1./mSampleRate) * midi2CPS(note);
 130     mVS[v].mEnv_ctx.mLevel = (double) velocity / 127.;
 131     mVS[v].mEnv_ctx.mStage = kStageAttack;
 132
 133     mActiveVoices++;
 134   }
 135   else  // Note off
 136   {
 137     for (v = 0; v < MAX_VOICES; v++)
 138     {
 139       if (mVS[v].mKey == note)
 140       {
 141         if (mVS[v].GetBusy())
 142         {
 143           mVS[v].mKey = -1;
 144           mVS[v].mEnv_ctx.mStage = kStageRelease;
 145           mVS[v].mEnv_ctx.mReleaseLevel = mVS[v].mEnv_ctx.mPrev;
 146
 147           return;
 148         }
 149       }
 150     }
 151   }
 152
 153 }
 154
 155 void IPlugPolySynth::ProcessDoubleReplacing(double** inputs, double** outputs, int nFrames)
 156 {
 157   // Mutex is already locked for us
 158   IKeyboardControl* pKeyboard = (IKeyboardControl*) mKeyboard;
 159
 160   if (pKeyboard->GetKey() != mKey)
 161   {
 162     IMidiMsg msg;
 163
 164     if (mKey >= 0)
 165     {
 166       msg.MakeNoteOffMsg(mKey + 48, 0, 0);
 167       mMidiQueue.Add(&msg);
 168     }
 169
 170     mKey = pKeyboard->GetKey();
 171
 172     if (mKey >= 0)
 173     {
 174       msg.MakeNoteOnMsg(mKey + 48, pKeyboard->GetVelocity(), 0, 0);
 175       mMidiQueue.Add(&msg);
 176     }
 177   }
 178
 179   if (mActiveVoices > 0 || !mMidiQueue.Empty()) // block not empty
 180   {
 181     double* out1 = outputs[0];
 182     double* out2 = outputs[1];
 183
 184     double output;
 185     CVoiceState* vs;
 186
 187     for (int s = 0; s < nFrames; ++s)
 188     {
 189       while (!mMidiQueue.Empty())
 190       {
 191         IMidiMsg* pMsg = mMidiQueue.Peek();
 192
 193         if (pMsg->mOffset > s) break;
 194
 195         int status = pMsg->StatusMsg(); // get the MIDI status byte
 196
 197         switch (status)
 198         {
 199           case IMidiMsg::kNoteOn:
 200           case IMidiMsg::kNoteOff:
 201           {
 202             NoteOnOff(pMsg);
 203             break;
 204           }
 205           case IMidiMsg::kPitchWheel:
 206           {
 207             //TODO
 208             break;
 209           }
 210         }
 211
 212         mMidiQueue.Remove();
 213       }
 214
 215       output = 0.;
 216
 217       for(int v = 0; v < MAX_VOICES; v++) // for each vs
 218       {
 219         vs = &mVS[v];
 220
 221         if (vs->GetBusy())
 222         {
 223           output += mOsc->process(&vs->mOsc_ctx) * mEnv->process(&vs->mEnv_ctx);
 224         }
 225       }
 226
 227       output *= GAIN_FACTOR;
 228
 229       *out1++ = output;
 230       *out2++ = output;
 231     }
 232
 233     mMidiQueue.Flush(nFrames);
 234   }
 235 //  else // empty block
 236 //  {
 237 //  }
 238 }
 239
 240 void IPlugPolySynth::Reset()
 241 {
 242   TRACE;
 243   IMutexLock lock(this);
 244
 245   mSampleRate = GetSampleRate();
 246   mMidiQueue.Resize(GetBlockSize());
 247   mEnv->setSampleRate(mSampleRate);
 248 }
 249
 250 void IPlugPolySynth::OnParamChange(int paramIdx)
 251 {
 252   IMutexLock lock(this);
 253
 254   switch (paramIdx)
 255   {
 256     case kAttack:
 257       mEnv->setStageTime(kStageAttack, GetParam(kAttack)->Value());
 258       break;
 259     case kDecay:
 260       mEnv->setStageTime(kStageDecay, GetParam(kDecay)->Value());
 261       break;
 262     case kSustain:
 263       mEnv->setSustainLevel( GetParam(kSustain)->Value() );
 264       break;
 265     case kRelease:
 266       mEnv->setStageTime(kStageRelease, GetParam(kRelease)->Value());
 267       break;
 268     default:
 269       break;
 270   }
 271 }
 272
 273 void IPlugPolySynth::ProcessMidiMsg(IMidiMsg* pMsg)
 274 {
 275   int status = pMsg->StatusMsg();
 276   int velocity = pMsg->Velocity();
 277
 278   switch (status)
 279   {
 280     case IMidiMsg::kNoteOn:
 281     case IMidiMsg::kNoteOff:
 282       // filter only note messages
 283       if (status == IMidiMsg::kNoteOn && velocity)
 284       {
 285         mKeyStatus[pMsg->NoteNumber()] = true;
 286         mNumHeldKeys += 1;
 287       }
 288       else
 289       {
 290         mKeyStatus[pMsg->NoteNumber()] = false;
 291         mNumHeldKeys -= 1;
 292       }
 293       break;
 294     default:
 295       return; // if !note message, nothing gets added to the queue
 296   }
 297
 298
 299   mKeyboard->SetDirty();
 300   mMidiQueue.Add(pMsg);
 301 }
 302
 303 // Should return non-zero if one or more keys are playing.
 304 int IPlugPolySynth::GetNumKeys()
 305 {
 306   IMutexLock lock(this);
 307   return mNumHeldKeys;
 308 }
 309
 310 // Should return true if the specified key is playing.
 311 bool IPlugPolySynth::GetKeyStatus(int key)
 312 {
 313   IMutexLock lock(this);
 314   return mKeyStatus[key];
 315 }
 316
 317 //Called by the standalone wrapper if someone clicks about
 318 bool IPlugPolySynth::HostRequestingAboutBox()
 319 {
 320   IMutexLock lock(this);
 321   if(GetGUI())
 322   {
 323     // get the IBitmapOverlay to show
 324     mAboutBox->SetValueFromPlug(1.);
 325     mAboutBox->Hide(false);
 326   }
 327   return true;
 328 }