WDL/IPlug/IPlugBase.cpp

   1   #include "IPlugBase.h"
   2 #ifndef OS_IOS
   3 #include "IGraphics.h"
   4 #include "IControl.h"
   5 #endif
   6 #include <math.h>
   7 #include <stdio.h>
   8 #include <time.h>
   9 #include "../wdlendian.h"
  10 #include "../base64encdec.h"
  11
  12 #ifndef VstInt32
  13   #ifdef WIN32
  14     typedef int VstInt32;
  15   #else
  16     #include <stdint.h>
  17     typedef int32_t VstInt32;
  18   #endif
  19 #endif
  20
  21 const double DEFAULT_SAMPLE_RATE = 44100.0;
  22
  23 template <class SRC, class DEST>
  24 void CastCopy(DEST* pDest, SRC* pSrc, int n)
  25 {
  26   for (int i = 0; i < n; ++i, ++pDest, ++pSrc)
  27   {
  28     *pDest = (DEST) *pSrc;
  29   }
  30 }
  31
  32 void GetVersionParts(int version, int* pVer, int* pMaj, int* pMin)
  33 {
  34   *pVer = (version & 0xFFFF0000) >> 16;
  35   *pMaj = (version & 0x0000FF00) >> 8;
  36   *pMin = version & 0x000000FF;
  37 }
  38
  39 int GetDecimalVersion(int version)
  40 {
  41   int ver, rmaj, rmin;
  42   GetVersionParts(version, &ver, &rmaj, &rmin);
  43   return 10000 * ver + 100 * rmaj + rmin;
  44 }
  45
  46 void GetVersionStr(int version, char* str)
  47 {
  48   int ver, rmaj, rmin;
  49   GetVersionParts(version, &ver, &rmaj, &rmin);
  50   sprintf(str, "v%d.%d.%d", ver, rmaj, rmin);
  51 }
  52
  53 #ifndef MAX_PATH
  54   #define MAX_PATH 1024
  55 #endif
  56
  57 IPlugBase::IPlugBase(int nParams,
  58                      const char* channelIOStr,
  59                      int nPresets,
  60                      const char* effectName,
  61                      const char* productName,
  62                      const char* mfrName,
  63                      int vendorVersion,
  64                      int uniqueID,
  65                      int mfrID,
  66                      int latency,
  67                      bool plugDoesMidi,
  68                      bool plugDoesChunks,
  69                      bool plugIsInst,
  70                      EAPI plugAPI)
  71   : mUniqueID(uniqueID)
  72   , mMfrID(mfrID)
  73   , mVersion(vendorVersion)
  74   , mSampleRate(DEFAULT_SAMPLE_RATE)
  75   , mBlockSize(0)
  76   , mLatency(latency)
  77   , mHost(kHostUninit)
  78   , mHostVersion(0)
  79   , mStateChunks(plugDoesChunks)
  80   , mGraphics(0)
  81   , mCurrentPresetIdx(0)
  82   , mIsInst(plugIsInst)
  83   , mDoesMIDI(plugDoesMidi)
  84   , mAPI(plugAPI)
  85   , mIsBypassed(false)
  86   , mDelay(0)
  87   , mTailSize(0)
  88 {
  89   Trace(TRACELOC, "%s:%s", effectName, CurrentTime());
  90
  91   for (int i = 0; i < nParams; ++i)
  92   {
  93     mParams.Add(new IParam);
  94   }
  95
  96   for (int i = 0; i < nPresets; ++i)
  97   {
  98     mPresets.Add(new IPreset(i));
  99   }
 100
 101   strcpy(mEffectName, effectName);
 102   strcpy(mProductName, productName);
 103   strcpy(mMfrName, mfrName);
 104
 105   int nInputs = 0, nOutputs = 0;
 106
 107   while (channelIOStr)
 108   {
 109     int nIn = 0, nOut = 0;
 110 #ifndef NDEBUG
 111     bool channelIOStrValid = sscanf(channelIOStr, "%d-%d", &nIn, &nOut) == 2;
 112     assert(channelIOStrValid);
 113 #else
 114     sscanf(channelIOStr, "%d-%d", &nIn, &nOut);
 115 #endif
 116     nInputs = IPMAX(nInputs, nIn);
 117     nOutputs = IPMAX(nOutputs, nOut);
 118     mChannelIO.Add(new ChannelIO(nIn, nOut));
 119     channelIOStr = strstr(channelIOStr, " ");
 120
 121     if (channelIOStr)
 122     {
 123       ++channelIOStr;
 124     }
 125   }
 126
 127   mInData.Resize(nInputs);
 128   mOutData.Resize(nOutputs);
 129
 130   double** ppInData = mInData.Get();
 131
 132   for (int i = 0; i < nInputs; ++i, ++ppInData)
 133   {
 134     InChannel* pInChannel = new InChannel;
 135     pInChannel->mConnected = false;
 136     pInChannel->mSrc = ppInData;
 137     mInChannels.Add(pInChannel);
 138   }
 139
 140   double** ppOutData = mOutData.Get();
 141
 142   for (int i = 0; i < nOutputs; ++i, ++ppOutData)
 143   {
 144     OutChannel* pOutChannel = new OutChannel;
 145     pOutChannel->mConnected = false;
 146     pOutChannel->mDest = ppOutData;
 147     pOutChannel->mFDest = 0;
 148     mOutChannels.Add(pOutChannel);
 149   }
 150 }
 151
 152 IPlugBase::~IPlugBase()
 153 {
 154   TRACE;
 155   #ifndef OS_IOS
 156   DELETE_NULL(mGraphics);
 157   #endif
 158   mParams.Empty(true);
 159   mPresets.Empty(true);
 160   mInChannels.Empty(true);
 161   mOutChannels.Empty(true);
 162   mChannelIO.Empty(true);
 163   mInputBusLabels.Empty(true);
 164   mOutputBusLabels.Empty(true);
 165
 166   if (mDelay)
 167   {
 168     DELETE_NULL(mDelay);
 169   }
 170 }
 171
 172 int IPlugBase::GetHostVersion(bool decimal)
 173 {
 174   GetHost();
 175   if (decimal)
 176   {
 177     return GetDecimalVersion(mHostVersion);
 178   }
 179   return mHostVersion;
 180 }
 181
 182 void IPlugBase::GetHostVersionStr(char* str)
 183 {
 184   GetHost();
 185   GetVersionStr(mHostVersion, str);
 186 }
 187
 188 bool IPlugBase::LegalIO(int nIn, int nOut)
 189 {
 190   bool legal = false;
 191   int i, n = mChannelIO.GetSize();
 192
 193   for (i = 0; i < n && !legal; ++i)
 194   {
 195     ChannelIO* pIO = mChannelIO.Get(i);
 196     legal = ((nIn < 0 || nIn == pIO->mIn) && (nOut < 0 || nOut == pIO->mOut));
 197   }
 198
 199   Trace(TRACELOC, "%d:%d:%s", nIn, nOut, (legal ? "legal" : "illegal"));
 200   return legal;
 201 }
 202
 203 void IPlugBase::LimitToStereoIO()
 204 {
 205   int nIn = NInChannels(), nOut = NOutChannels();
 206
 207   if (nIn > 2)
 208   {
 209     SetInputChannelConnections(2, nIn - 2, false);
 210   }
 211
 212   if (nOut > 2)
 213   {
 214     SetOutputChannelConnections(2, nOut - 2, true);
 215   }
 216 }
 217
 218 void IPlugBase::SetHost(const char* host, int version)
 219 {
 220   mHost = LookUpHost(host);
 221   mHostVersion = version;
 222
 223   char vStr[32];
 224   GetVersionStr(version, vStr);
 225   Trace(TRACELOC, "host_%sknown:%s:%s", (mHost == kHostUnknown ? "un" : ""), host, vStr);
 226 }
 227 #ifndef OS_IOS
 228 void IPlugBase::AttachGraphics(IGraphics* pGraphics)
 229 {
 230   if (pGraphics)
 231   {
 232     WDL_MutexLock lock(&mMutex);
 233     int i, n = mParams.GetSize();
 234
 235     for (i = 0; i < n; ++i)
 236     {
 237       pGraphics->SetParameterFromPlug(i, GetParam(i)->GetNormalized(), true);
 238     }
 239
 240     pGraphics->PrepDraw();
 241     mGraphics = pGraphics;
 242   }
 243 }
 244 #endif
 245
 246 // Decimal = VVVVRRMM, otherwise 0xVVVVRRMM.
 247 int IPlugBase::GetEffectVersion(bool decimal)
 248 {
 249   if (decimal)
 250   {
 251     return GetDecimalVersion(mVersion);
 252   }
 253   else
 254   {
 255     return mVersion;
 256   }
 257 }
 258
 259 void IPlugBase::GetEffectVersionStr(char* str)
 260 {
 261   GetVersionStr(mVersion, str);
 262 #if defined _DEBUG
 263   strcat(str, "D");
 264 #elif defined TRACER_BUILD
 265   strcat(str, "T");
 266 #endif
 267 }
 268
 269 const char* IPlugBase::GetAPIString()
 270 {
 271   switch (GetAPI())
 272   {
 273     case kAPIVST2: return "VST2";
 274     case kAPIVST3: return "VST3";
 275     case kAPIAU: return "AU";
 276     case kAPIRTAS: return "RTAS";
 277     case kAPIAAX: return "AAX";
 278     case kAPISA: return "Standalone";
 279     default: return "";
 280   }
 281 }
 282
 283 const char* IPlugBase::GetArchString()
 284 {
 285 #ifdef ARCH_64BIT
 286   return "x64";
 287 #else
 288   return "x86";
 289 #endif
 290 }
 291
 292 double IPlugBase::GetSamplesPerBeat()
 293 {
 294   double tempo = GetTempo();
 295
 296   if (tempo > 0.0)
 297   {
 298     return GetSampleRate() * 60.0 / tempo;
 299   }
 300
 301   return 0.0;
 302 }
 303
 304 void IPlugBase::SetSampleRate(double sampleRate)
 305 {
 306   mSampleRate = sampleRate;
 307 }
 308
 309 void IPlugBase::SetBlockSize(int blockSize)
 310 {
 311   if (blockSize != mBlockSize)
 312   {
 313     int i, nIn = NInChannels(), nOut = NOutChannels();
 314
 315     for (i = 0; i < nIn; ++i)
 316     {
 317       InChannel* pInChannel = mInChannels.Get(i);
 318       pInChannel->mScratchBuf.Resize(blockSize);
 319       memset(pInChannel->mScratchBuf.Get(), 0, blockSize * sizeof(double));
 320     }
 321
 322     for (i = 0; i < nOut; ++i)
 323     {
 324       OutChannel* pOutChannel = mOutChannels.Get(i);
 325       pOutChannel->mScratchBuf.Resize(blockSize);
 326       memset(pOutChannel->mScratchBuf.Get(), 0, blockSize * sizeof(double));
 327     }
 328
 329     mBlockSize = blockSize;
 330   }
 331 }
 332
 333 void IPlugBase::SetInputChannelConnections(int idx, int n, bool connected)
 334 {
 335   int iEnd = IPMIN(idx + n, mInChannels.GetSize());
 336
 337   for (int i = idx; i < iEnd; ++i)
 338   {
 339     InChannel* pInChannel = mInChannels.Get(i);
 340     pInChannel->mConnected = connected;
 341
 342     if (!connected)
 343     {
 344       *(pInChannel->mSrc) = pInChannel->mScratchBuf.Get();
 345     }
 346   }
 347 }
 348
 349 void IPlugBase::SetOutputChannelConnections(int idx, int n, bool connected)
 350 {
 351   int iEnd = IPMIN(idx + n, mOutChannels.GetSize());
 352
 353   for (int i = idx; i < iEnd; ++i)
 354   {
 355     OutChannel* pOutChannel = mOutChannels.Get(i);
 356     pOutChannel->mConnected = connected;
 357
 358     if (!connected)
 359     {
 360       *(pOutChannel->mDest) = pOutChannel->mScratchBuf.Get();
 361     }
 362   }
 363 }
 364
 365 bool IPlugBase::IsInChannelConnected(int chIdx)
 366 {
 367   return (chIdx < mInChannels.GetSize() && mInChannels.Get(chIdx)->mConnected);
 368 }
 369
 370 bool IPlugBase::IsOutChannelConnected(int chIdx)
 371 {
 372   return (chIdx < mOutChannels.GetSize() && mOutChannels.Get(chIdx)->mConnected);
 373 }
 374
 375 void IPlugBase::AttachInputBuffers(int idx, int n, double** ppData, int nFrames)
 376 {
 377   int iEnd = IPMIN(idx + n, mInChannels.GetSize());
 378
 379   for (int i = idx; i < iEnd; ++i)
 380   {
 381     InChannel* pInChannel = mInChannels.Get(i);
 382     if (pInChannel->mConnected)
 383     {
 384       *(pInChannel->mSrc) = *(ppData++);
 385     }
 386   }
 387 }
 388
 389 void IPlugBase::AttachInputBuffers(int idx, int n, float** ppData, int nFrames)
 390 {
 391   int iEnd = IPMIN(idx + n, mInChannels.GetSize());
 392   for (int i = idx; i < iEnd; ++i)
 393   {
 394     InChannel* pInChannel = mInChannels.Get(i);
 395     if (pInChannel->mConnected)
 396     {
 397       double* pScratch = pInChannel->mScratchBuf.Get();
 398       CastCopy(pScratch, *(ppData++), nFrames);
 399       *(pInChannel->mSrc) = pScratch;
 400     }
 401   }
 402 }
 403
 404 void IPlugBase::AttachOutputBuffers(int idx, int n, double** ppData)
 405 {
 406   int iEnd = IPMIN(idx + n, mOutChannels.GetSize());
 407   for (int i = idx; i < iEnd; ++i)
 408   {
 409     OutChannel* pOutChannel = mOutChannels.Get(i);
 410     if (pOutChannel->mConnected)
 411     {
 412       *(pOutChannel->mDest) = *(ppData++);
 413     }
 414   }
 415 }
 416
 417 void IPlugBase::AttachOutputBuffers(int idx, int n, float** ppData)
 418 {
 419   int iEnd = IPMIN(idx + n, mOutChannels.GetSize());
 420   for (int i = idx; i < iEnd; ++i)
 421   {
 422     OutChannel* pOutChannel = mOutChannels.Get(i);
 423     if (pOutChannel->mConnected)
 424     {
 425       *(pOutChannel->mDest) = pOutChannel->mScratchBuf.Get();
 426       pOutChannel->mFDest = *(ppData++);
 427     }
 428   }
 429 }
 430
 431 void IPlugBase::PassThroughBuffers(double sampleType, int nFrames)
 432 {
 433   if (mLatency && mDelay)
 434   {
 435     mDelay->ProcessBlock(mInData.Get(), mOutData.Get(), nFrames);
 436   }
 437   else
 438   {
 439     IPlugBase::ProcessDoubleReplacing(mInData.Get(), mOutData.Get(), nFrames);
 440   }
 441 }
 442
 443 void IPlugBase::PassThroughBuffers(float sampleType, int nFrames)
 444 {
 445   // for 32 bit buffers, first run the delay (if mLatency) on the 64bit IPlug buffers
 446   PassThroughBuffers(0., nFrames);
 447
 448   int i, n = NOutChannels();
 449   OutChannel** ppOutChannel = mOutChannels.GetList();
 450
 451   for (i = 0; i < n; ++i, ++ppOutChannel)
 452   {
 453     OutChannel* pOutChannel = *ppOutChannel;
 454     if (pOutChannel->mConnected)
 455     {
 456       CastCopy(pOutChannel->mFDest, *(pOutChannel->mDest), nFrames);
 457     }
 458   }
 459 }
 460
 461 void IPlugBase::ProcessBuffers(double sampleType, int nFrames)
 462 {
 463   ProcessDoubleReplacing(mInData.Get(), mOutData.Get(), nFrames);
 464 }
 465
 466 void IPlugBase::ProcessBuffers(float sampleType, int nFrames)
 467 {
 468   ProcessDoubleReplacing(mInData.Get(), mOutData.Get(), nFrames);
 469   int i, n = NOutChannels();
 470   OutChannel** ppOutChannel = mOutChannels.GetList();
 471
 472   for (i = 0; i < n; ++i, ++ppOutChannel)
 473   {
 474     OutChannel* pOutChannel = *ppOutChannel;
 475
 476     if (pOutChannel->mConnected)
 477     {
 478       CastCopy(pOutChannel->mFDest, *(pOutChannel->mDest), nFrames);
 479     }
 480   }
 481 }
 482
 483 void IPlugBase::ProcessBuffersAccumulating(float sampleType, int nFrames)
 484 {
 485   ProcessDoubleReplacing(mInData.Get(), mOutData.Get(), nFrames);
 486   int i, n = NOutChannels();
 487   OutChannel** ppOutChannel = mOutChannels.GetList();
 488
 489   for (i = 0; i < n; ++i, ++ppOutChannel)
 490   {
 491     OutChannel* pOutChannel = *ppOutChannel;
 492     if (pOutChannel->mConnected)
 493     {
 494       float* pDest = pOutChannel->mFDest;
 495       double* pSrc = *(pOutChannel->mDest);
 496
 497       for (int j = 0; j < nFrames; ++j, ++pDest, ++pSrc)
 498       {
 499         *pDest += (float) *pSrc;
 500       }
 501     }
 502   }
 503 }
 504
 505 void IPlugBase::ZeroScratchBuffers()
 506 {
 507   int i, nIn = NInChannels(), nOut = NOutChannels();
 508
 509   for (i = 0; i < nIn; ++i)
 510   {
 511     InChannel* pInChannel = mInChannels.Get(i);
 512     memset(pInChannel->mScratchBuf.Get(), 0, mBlockSize * sizeof(double));
 513   }
 514
 515   for (i = 0; i < nOut; ++i)
 516   {
 517     OutChannel* pOutChannel = mOutChannels.Get(i);
 518     memset(pOutChannel->mScratchBuf.Get(), 0, mBlockSize * sizeof(double));
 519   }
 520 }
 521
 522 // If latency changes after initialization (often not supported by the host).
 523 void IPlugBase::SetLatency(int samples)
 524 {
 525   mLatency = samples;
 526
 527   if (mDelay)
 528   {
 529     mDelay->SetDelayTime(mLatency);
 530   }
 531 }
 532
 533 // this is over-ridden for AAX
 534 void IPlugBase::SetParameterFromGUI(int idx, double normalizedValue)
 535 {
 536   Trace(TRACELOC, "%d:%f", idx, normalizedValue);
 537   WDL_MutexLock lock(&mMutex);
 538   GetParam(idx)->SetNormalized(normalizedValue);
 539   InformHostOfParamChange(idx, normalizedValue);
 540   OnParamChange(idx);
 541 }
 542
 543 void IPlugBase::OnParamReset()
 544 {
 545   for (int i = 0; i < mParams.GetSize(); ++i)
 546   {
 547     OnParamChange(i);
 548   }
 549   //Reset();
 550 }
 551
 552 // Default passthrough.
 553 void IPlugBase::ProcessDoubleReplacing(double** inputs, double** outputs, int nFrames)
 554 {
 555   // Mutex is already locked.
 556   int i, nIn = mInChannels.GetSize(), nOut = mOutChannels.GetSize();
 557   int j = 0;
 558   for (i = 0; i < nOut; ++i)
 559   {
 560     if (i < nIn)
 561     {
 562       memcpy(outputs[i], inputs[i], nFrames * sizeof(double));
 563       j++;
 564     }
 565   }
 566   // zero remaining outs
 567   for (/* same j */; j < nOut; ++j)
 568   {
 569     memset(outputs[j], 0, nFrames * sizeof(double));
 570   }
 571 }
 572
 573 // Default passthrough ONLY USED BY IOS.
 574 void IPlugBase::ProcessSingleReplacing(float** inputs, float** outputs, int nFrames)
 575 {
 576   // Mutex is already locked.
 577   int i, nIn = mInChannels.GetSize(), nOut = mOutChannels.GetSize();
 578   for (i = 0; i < nIn; ++i)
 579   {
 580     memcpy(outputs[i], inputs[i], nFrames * sizeof(float));
 581   }
 582   for (/* same i */; i < nOut; ++i)
 583   {
 584     memset(outputs[i], 0, nFrames * sizeof(float));
 585   }
 586 }
 587
 588 // Default passthrough.
 589 void IPlugBase::ProcessMidiMsg(IMidiMsg* pMsg)
 590 {
 591   SendMidiMsg(pMsg);
 592 }
 593
 594 IPreset* GetNextUninitializedPreset(WDL_PtrList<IPreset>* pPresets)
 595 {
 596   int n = pPresets->GetSize();
 597   for (int i = 0; i < n; ++i)
 598   {
 599     IPreset* pPreset = pPresets->Get(i);
 600     if (!(pPreset->mInitialized))
 601     {
 602       return pPreset;
 603     }
 604   }
 605   return 0;
 606 }
 607
 608 void IPlugBase::MakeDefaultPreset(char* name, int nPresets)
 609 {
 610   for (int i = 0; i < nPresets; ++i)
 611   {
 612     IPreset* pPreset = GetNextUninitializedPreset(&mPresets);
 613     if (pPreset)
 614     {
 615       pPreset->mInitialized = true;
 616       strcpy(pPreset->mName, (name ? name : "Empty"));
 617       SerializeState(&(pPreset->mChunk));
 618     }
 619   }
 620 }
 621
 622 #define GET_PARAM_FROM_VARARG(paramType, vp, v) \
 623 { \
 624   v = 0.0; \
 625   switch (paramType) { \
 626     case IParam::kTypeBool: \
 627     case IParam::kTypeInt: \
 628     case IParam::kTypeEnum: { \
 629       v = (double) va_arg(vp, int); \
 630       break; \
 631     } \
 632     case IParam::kTypeDouble: \
 633     default: { \
 634       v = (double) va_arg(vp, double); \
 635       break; \
 636     } \
 637   } \
 638 }
 639
 640 void IPlugBase::MakePreset(char* name, ...)
 641 {
 642   IPreset* pPreset = GetNextUninitializedPreset(&mPresets);
 643   if (pPreset)
 644   {
 645     pPreset->mInitialized = true;
 646     strcpy(pPreset->mName, name);
 647
 648     int i, n = mParams.GetSize();
 649
 650     double v = 0.0;
 651     va_list vp;
 652     va_start(vp, name);
 653     for (i = 0; i < n; ++i)
 654     {
 655       GET_PARAM_FROM_VARARG(GetParam(i)->Type(), vp, v);
 656       pPreset->mChunk.Put(&v);
 657     }
 658   }
 659 }
 660
 661 #define PARAM_UNINIT 99.99e-9
 662
 663 void IPlugBase::MakePresetFromNamedParams(char* name, int nParamsNamed, ...)
 664 {
 665   TRACE;
 666   IPreset* pPreset = GetNextUninitializedPreset(&mPresets);
 667   if (pPreset)
 668   {
 669     pPreset->mInitialized = true;
 670     strcpy(pPreset->mName, name);
 671
 672     int i = 0, n = mParams.GetSize();
 673
 674     WDL_TypedBuf<double> vals;
 675     vals.Resize(n);
 676     double* pV = vals.Get();
 677     for (i = 0; i < n; ++i, ++pV)
 678     {
 679       *pV = PARAM_UNINIT;
 680     }
 681
 682     va_list vp;
 683     va_start(vp, nParamsNamed);
 684     for (int i = 0; i < nParamsNamed; ++i)
 685     {
 686       int paramIdx = (int) va_arg(vp, int);
 687       // This assert will fire if any of the passed-in param values do not match
 688       // the type that the param was initialized with (int for bool, int, enum; double for double).
 689       assert(paramIdx >= 0 && paramIdx < n);
 690       GET_PARAM_FROM_VARARG(GetParam(paramIdx)->Type(), vp, *(vals.Get() + paramIdx));
 691     }
 692     va_end(vp);
 693
 694     pV = vals.Get();
 695     for (int i = 0; i < n; ++i, ++pV)
 696     {
 697       if (*pV == PARAM_UNINIT)        // Any that weren't explicitly set, use the defaults.
 698       {
 699         *pV = GetParam(i)->Value();
 700       }
 701       pPreset->mChunk.Put(pV);
 702     }
 703   }
 704 }
 705
 706 void IPlugBase::MakePresetFromChunk(char* name, ByteChunk* pChunk)
 707 {
 708   IPreset* pPreset = GetNextUninitializedPreset(&mPresets);
 709   if (pPreset)
 710   {
 711     pPreset->mInitialized = true;
 712     strcpy(pPreset->mName, name);
 713
 714     pPreset->mChunk.PutChunk(pChunk);
 715   }
 716 }
 717
 718 void IPlugBase::MakePresetFromBlob(char* name, const char* blob, int sizeOfChunk)
 719 {
 720   ByteChunk presetChunk;
 721   presetChunk.Resize(sizeOfChunk);
 722   base64decode(blob, presetChunk.GetBytes(), sizeOfChunk);
 723
 724   MakePresetFromChunk(name, &presetChunk);
 725 }
 726
 727 #define DEFAULT_USER_PRESET_NAME "user preset"
 728
 729 void MakeDefaultUserPresetName(WDL_PtrList<IPreset>* pPresets, char* str)
 730 {
 731   int nDefaultNames = 0;
 732   int n = pPresets->GetSize();
 733   for (int i = 0; i < n; ++i)
 734   {
 735     IPreset* pPreset = pPresets->Get(i);
 736     if (strstr(pPreset->mName, DEFAULT_USER_PRESET_NAME))
 737     {
 738       ++nDefaultNames;
 739     }
 740   }
 741   sprintf(str, "%s %d", DEFAULT_USER_PRESET_NAME, nDefaultNames + 1);
 742 }
 743
 744 void IPlugBase::EnsureDefaultPreset()
 745 {
 746   TRACE;
 747   MakeDefaultPreset("Empty", mPresets.GetSize());
 748 }
 749
 750 void IPlugBase::PruneUninitializedPresets()
 751 {
 752   TRACE;
 753   int i = 0;
 754   while (i < mPresets.GetSize())
 755   {
 756     IPreset* pPreset = mPresets.Get(i);
 757     if (pPreset->mInitialized)
 758     {
 759       ++i;
 760     }
 761     else
 762     {
 763       mPresets.Delete(i, true);
 764     }
 765   }
 766 }
 767
 768 bool IPlugBase::RestorePreset(int idx)
 769 {
 770   TRACE;
 771   bool restoredOK = false;
 772   if (idx >= 0 && idx < mPresets.GetSize())
 773   {
 774     IPreset* pPreset = mPresets.Get(idx);
 775
 776     if (!(pPreset->mInitialized))
 777     {
 778       pPreset->mInitialized = true;
 779       MakeDefaultUserPresetName(&mPresets, pPreset->mName);
 780       restoredOK = SerializeState(&(pPreset->mChunk));
 781     }
 782     else
 783     {
 784       restoredOK = (UnserializeState(&(pPreset->mChunk), 0) > 0);
 785     }
 786
 787     if (restoredOK)
 788     {
 789       mCurrentPresetIdx = idx;
 790       PresetsChangedByHost();
 791       #ifndef OS_IOS
 792       RedrawParamControls();
 793       #endif
 794     }
 795   }
 796   return restoredOK;
 797 }
 798
 799 bool IPlugBase::RestorePreset(const char* name)
 800 {
 801   if (CSTR_NOT_EMPTY(name))
 802   {
 803     int n = mPresets.GetSize();
 804     for (int i = 0; i < n; ++i)
 805     {
 806       IPreset* pPreset = mPresets.Get(i);
 807       if (!strcmp(pPreset->mName, name))
 808       {
 809         return RestorePreset(i);
 810       }
 811     }
 812   }
 813   return false;
 814 }
 815
 816 const char* IPlugBase::GetPresetName(int idx)
 817 {
 818   if (idx >= 0 && idx < mPresets.GetSize())
 819   {
 820     return mPresets.Get(idx)->mName;
 821   }
 822   return "";
 823 }
 824
 825 void IPlugBase::ModifyCurrentPreset(const char* name)
 826 {
 827   if (mCurrentPresetIdx >= 0 && mCurrentPresetIdx < mPresets.GetSize())
 828   {
 829     IPreset* pPreset = mPresets.Get(mCurrentPresetIdx);
 830     pPreset->mChunk.Clear();
 831
 832     Trace(TRACELOC, "%d %s", mCurrentPresetIdx, pPreset->mName);
 833
 834     SerializeState(&(pPreset->mChunk));
 835
 836     if (CSTR_NOT_EMPTY(name))
 837     {
 838       strcpy(pPreset->mName, name);
 839     }
 840   }
 841 }
 842
 843 bool IPlugBase::SerializePresets(ByteChunk* pChunk)
 844 {
 845   TRACE;
 846   bool savedOK = true;
 847   int n = mPresets.GetSize();
 848   for (int i = 0; i < n && savedOK; ++i)
 849   {
 850     IPreset* pPreset = mPresets.Get(i);
 851     pChunk->PutStr(pPreset->mName);
 852
 853     Trace(TRACELOC, "%d %s", i, pPreset->mName);
 854
 855     pChunk->PutBool(pPreset->mInitialized);
 856     if (pPreset->mInitialized)
 857     {
 858       savedOK &= (pChunk->PutChunk(&(pPreset->mChunk)) > 0);
 859     }
 860   }
 861   return savedOK;
 862 }
 863
 864 int IPlugBase::UnserializePresets(ByteChunk* pChunk, int startPos)
 865 {
 866   TRACE;
 867   WDL_String name;
 868   int n = mPresets.GetSize(), pos = startPos;
 869   for (int i = 0; i < n && pos >= 0; ++i)
 870   {
 871     IPreset* pPreset = mPresets.Get(i);
 872     pos = pChunk->GetStr(&name, pos);
 873     strcpy(pPreset->mName, name.Get());
 874
 875     Trace(TRACELOC, "%d %s", i, pPreset->mName);
 876
 877     pos = pChunk->GetBool(&(pPreset->mInitialized), pos);
 878     if (pPreset->mInitialized)
 879     {
 880       pos = UnserializeState(pChunk, pos);
 881       if (pos > 0)
 882       {
 883         pPreset->mChunk.Clear();
 884         SerializeState(&(pPreset->mChunk));
 885       }
 886     }
 887   }
 888   RestorePreset(mCurrentPresetIdx);
 889   return pos;
 890 }
 891
 892 bool IPlugBase::SerializeParams(ByteChunk* pChunk)
 893 {
 894   TRACE;
 895
 896   WDL_MutexLock lock(&mMutex);
 897   bool savedOK = true;
 898   int i, n = mParams.GetSize();
 899   for (i = 0; i < n && savedOK; ++i)
 900   {
 901     IParam* pParam = mParams.Get(i);
 902     Trace(TRACELOC, "%d %s %f", i, pParam->GetNameForHost(), pParam->Value());
 903     double v = pParam->Value();
 904     savedOK &= (pChunk->Put(&v) > 0);
 905   }
 906   return savedOK;
 907 }
 908
 909 int IPlugBase::UnserializeParams(ByteChunk* pChunk, int startPos)
 910 {
 911   TRACE;
 912
 913   WDL_MutexLock lock(&mMutex);
 914   int i, n = mParams.GetSize(), pos = startPos;
 915   for (i = 0; i < n && pos >= 0; ++i)
 916   {
 917     IParam* pParam = mParams.Get(i);
 918     double v = 0.0;
 919     Trace(TRACELOC, "%d %s %f", i, pParam->GetNameForHost(), pParam->Value());
 920     pos = pChunk->Get(&v, pos);
 921     pParam->Set(v);
 922   }
 923   OnParamReset();
 924   return pos;
 925 }
 926
 927 bool IPlugBase::CompareState(const unsigned char* incomingState, int startPos)
 928 {
 929   bool isEqual = true;
 930
 931   const double* data = (const double*) incomingState + startPos;
 932
 933   // dirty hack here because protools treats param values as 32 bit int and in IPlug they are 64bit float
 934   // if we memcmp() the incoming state with the current they may have tiny differences due to the quantization
 935   for (int i = 0; i < NParams(); i++)
 936   {
 937     float v = (float) GetParam(i)->Value();
 938     float vi = (float) *(data++);
 939
 940     isEqual &= (fabsf(v - vi) < 0.00001);
 941   }
 942
 943   return isEqual;
 944 }
 945
 946 #ifndef OS_IOS
 947 void IPlugBase::RedrawParamControls()
 948 {
 949   if (mGraphics)
 950   {
 951     int i, n = mParams.GetSize();
 952     for (i = 0; i < n; ++i)
 953     {
 954       double v = mParams.Get(i)->Value();
 955       mGraphics->SetParameterFromPlug(i, v, false);
 956     }
 957   }
 958 }
 959 #endif
 960 void IPlugBase::DirtyParameters()
 961 {
 962   WDL_MutexLock lock(&mMutex);
 963
 964   for (int p = 0; p < NParams(); p++)
 965   {
 966     double normalizedValue = GetParam(p)->GetNormalized();
 967     InformHostOfParamChange(p, normalizedValue);
 968   }
 969 }
 970
 971 void IPlugBase::DumpPresetSrcCode(const char* filename, const char* paramEnumNames[])
 972 {
 973 // static bool sDumped = false;
 974   bool sDumped = false;
 975
 976   if (!sDumped)
 977   {
 978     sDumped = true;
 979     int i, n = NParams();
 980     FILE* fp = fopen(filename, "w");
 981     fprintf(fp, "  MakePresetFromNamedParams(\"name\", %d", n);
 982     for (i = 0; i < n; ++i)
 983     {
 984       IParam* pParam = GetParam(i);
 985       char paramVal[32];
 986       switch (pParam->Type())
 987       {
 988         case IParam::kTypeBool:
 989           sprintf(paramVal, "%s", (pParam->Bool() ? "true" : "false"));
 990           break;
 991         case IParam::kTypeInt:
 992           sprintf(paramVal, "%d", pParam->Int());
 993           break;
 994         case IParam::kTypeEnum:
 995           sprintf(paramVal, "%d", pParam->Int());
 996           break;
 997         case IParam::kTypeDouble:
 998         default:
 999           sprintf(paramVal, "%.6f", pParam->Value());
1000           break;
1001       }
1002       fprintf(fp, ",\n    %s, %s", paramEnumNames[i], paramVal);
1003     }
1004     fprintf(fp, ");\n");
1005     fclose(fp);
1006   }
1007 }
1008
1009 #ifndef MAX_BLOB_LENGTH
1010 #define MAX_BLOB_LENGTH 2048
1011 #endif
1012
1013 void IPlugBase::DumpPresetBlob(const char* filename)
1014 {
1015   FILE* fp = fopen(filename, "w");
1016   fprintf(fp, "MakePresetFromBlob(\"name\", \"");
1017
1018   char buf[MAX_BLOB_LENGTH];
1019
1020   ByteChunk* pPresetChunk = &mPresets.Get(mCurrentPresetIdx)->mChunk;
1021   BYTE* byteStart = pPresetChunk->GetBytes();
1022
1023   base64encode(byteStart, buf, pPresetChunk->Size());
1024
1025   fprintf(fp, "%s\", %i);\n", buf, pPresetChunk->Size());
1026   fclose(fp);
1027 }
1028
1029 void IPlugBase::DumpBankBlob(const char* filename)
1030 {
1031   FILE* fp = fopen(filename, "w");
1032
1033   if (!fp)
1034     return;
1035
1036   char buf[MAX_BLOB_LENGTH] = "";
1037
1038   for (int i = 0; i< NPresets(); i++)
1039   {
1040     IPreset* pPreset = mPresets.Get(i);
1041     fprintf(fp, "MakePresetFromBlob(\"%s\", \"", pPreset->mName);
1042
1043     ByteChunk* pPresetChunk = &pPreset->mChunk;
1044     base64encode(pPresetChunk->GetBytes(), buf, pPresetChunk->Size());
1045
1046     fprintf(fp, "%s\", %i);\n", buf, pPresetChunk->Size());
1047   }
1048
1049   fclose(fp);
1050 }
1051
1052 void IPlugBase::SetInputLabel(int idx, const char* pLabel)
1053 {
1054   if (idx >= 0 && idx < NInChannels())
1055   {
1056     mInChannels.Get(idx)->mLabel.Set(pLabel);
1057   }
1058 }
1059
1060 void IPlugBase::SetOutputLabel(int idx, const char* pLabel)
1061 {
1062   if (idx >= 0 && idx < NOutChannels())
1063   {
1064     mOutChannels.Get(idx)->mLabel.Set(pLabel);
1065   }
1066 }
1067
1068 void IPlugBase::SetInputBusLabel(int idx, const char* pLabel)
1069 {
1070   if (idx >= 0 && idx < 2) // only possible to have two input buses
1071   {
1072     if (mInputBusLabels.Get(idx))
1073     {
1074       mInputBusLabels.Delete(idx, true);
1075     }
1076
1077     mInputBusLabels.Insert(idx, new WDL_String(pLabel, strlen(pLabel)));
1078   }
1079 }
1080
1081 void IPlugBase::SetOutputBusLabel(int idx, const char* pLabel)
1082 {
1083   if (idx >= 0)
1084   {
1085     if (mOutputBusLabels.Get(idx))
1086     {
1087       mOutputBusLabels.Delete(idx, true);
1088     }
1089
1090     mOutputBusLabels.Insert(idx, new WDL_String(pLabel, strlen(pLabel)));
1091   }
1092 }
1093
1094 const int kFXPVersionNum = 1;
1095 const int kFXBVersionNum = 2;
1096
1097 // confusing... bytechunk will force storage as little endian on big endian platforms,
1098 // so when we use it here, since vst fxp/fxb files are big endian, we need to swap the endianess
1099 // regardless of the endianness of the host, and on big endian hosts it will get swapped back to
1100 // big endian
1101 bool IPlugBase::SaveProgramAsFXP(WDL_String* fileName)
1102 {
1103   if (fileName->GetLength())
1104   {
1105     FILE* fp = fopen(fileName->Get(), "wb");
1106
1107     ByteChunk pgm;
1108
1109     VstInt32 chunkMagic = WDL_bswap32('CcnK');
1110     VstInt32 byteSize = 0;
1111     VstInt32 fxpMagic;
1112     VstInt32 fxpVersion = WDL_bswap32(kFXPVersionNum);
1113     VstInt32 pluginID = WDL_bswap32(GetUniqueID());
1114     VstInt32 pluginVersion = WDL_bswap32(GetEffectVersion(true));
1115     VstInt32 numParams = WDL_bswap32(NParams());
1116     char prgName[28];
1117     memset(prgName, 0, 28);
1118     strcpy(prgName, GetPresetName(GetCurrentPresetIdx()));
1119
1120     pgm.Put(&chunkMagic);
1121
1122     if (DoesStateChunks())
1123     {
1124       ByteChunk state;
1125       VstInt32 chunkSize;
1126
1127       fxpMagic = WDL_bswap32('FPCh');
1128
1129       InitChunkWithIPlugVer(&state);
1130       SerializeState(&state);
1131
1132       chunkSize = WDL_bswap32(state.Size());
1133       byteSize = WDL_bswap32(state.Size() + 60);
1134
1135       pgm.Put(&byteSize);
1136       pgm.Put(&fxpMagic);
1137       pgm.Put(&fxpVersion);
1138       pgm.Put(&pluginID);
1139       pgm.Put(&pluginVersion);
1140       pgm.Put(&numParams);
1141       pgm.PutBytes(prgName, 28); // not PutStr (we want all 28 bytes)
1142       pgm.Put(&chunkSize);
1143       pgm.PutBytes(state.GetBytes(), state.Size());
1144     }
1145     else
1146     {
1147       fxpMagic = WDL_bswap32('FxCk');
1148       //byteSize = WDL_bswap32(20 + 28 + (NParams() * 4) );
1149       pgm.Put(&byteSize);
1150       pgm.Put(&fxpMagic);
1151       pgm.Put(&fxpVersion);
1152       pgm.Put(&pluginID);
1153       pgm.Put(&pluginVersion);
1154       pgm.Put(&numParams);
1155       pgm.PutBytes(prgName, 28); // not PutStr (we want all 28 bytes)
1156
1157       for (int i = 0; i< NParams(); i++)
1158       {
1159         WDL_EndianFloat v32;
1160         v32.f = (float) mParams.Get(i)->GetNormalized();
1161         unsigned int swapped = WDL_bswap32(v32.int32);
1162         pgm.Put(&swapped);
1163       }
1164     }
1165
1166     fwrite(pgm.GetBytes(), pgm.Size(), 1, fp);
1167     fclose(fp);
1168
1169     return true;
1170   }
1171   return false;
1172 }
1173
1174 bool IPlugBase::SaveBankAsFXB(WDL_String* fileName)
1175 {
1176   if (fileName->GetLength())
1177   {
1178     FILE* fp = fopen(fileName->Get(), "wb");
1179
1180     ByteChunk bnk;
1181
1182     VstInt32 chunkMagic = WDL_bswap32('CcnK');
1183     VstInt32 byteSize = 0;
1184     VstInt32 fxbMagic;
1185     VstInt32 fxbVersion = WDL_bswap32(kFXBVersionNum);
1186     VstInt32 pluginID = WDL_bswap32(GetUniqueID());
1187     VstInt32 pluginVersion = WDL_bswap32(GetEffectVersion(true));
1188     VstInt32 numPgms =  WDL_bswap32(NPresets());
1189     VstInt32 currentPgm = WDL_bswap32(GetCurrentPresetIdx());
1190     char future[124];
1191     memset(future, 0, 124);
1192
1193     bnk.Put(&chunkMagic);
1194
1195     if (DoesStateChunks())
1196     {
1197       ByteChunk state;
1198       VstInt32 chunkSize;
1199
1200       fxbMagic = WDL_bswap32('FBCh');
1201
1202       InitChunkWithIPlugVer(&state);
1203       SerializePresets(&state);
1204
1205       chunkSize = WDL_bswap32(state.Size());
1206       byteSize = WDL_bswap32(160 + state.Size() );
1207
1208       bnk.Put(&byteSize);
1209       bnk.Put(&fxbMagic);
1210       bnk.Put(&fxbVersion);
1211       bnk.Put(&pluginID);
1212       bnk.Put(&pluginVersion);
1213       bnk.Put(&numPgms);
1214       bnk.Put(&currentPgm);
1215       bnk.PutBytes(&future, 124);
1216
1217       bnk.Put(&chunkSize);
1218       bnk.PutBytes(state.GetBytes(), state.Size());
1219     }
1220     else
1221     {
1222       fxbMagic = WDL_bswap32('FxBk');
1223
1224       bnk.Put(&byteSize);
1225       bnk.Put(&fxbMagic);
1226       bnk.Put(&fxbVersion);
1227       bnk.Put(&pluginID);
1228       bnk.Put(&pluginVersion);
1229       bnk.Put(&numPgms);
1230       bnk.Put(&currentPgm);
1231       bnk.PutBytes(&future, 124);
1232
1233       VstInt32 fxpMagic = WDL_bswap32('FxCk');
1234       VstInt32 fxpVersion = WDL_bswap32(kFXPVersionNum);
1235       VstInt32 numParams = WDL_bswap32(NParams());
1236
1237       for (int p = 0; p < NPresets(); p++)
1238       {
1239         IPreset* pPreset = mPresets.Get(p);
1240
1241         char prgName[28];
1242         memset(prgName, 0, 28);
1243         strcpy(prgName, pPreset->mName);
1244
1245         bnk.Put(&chunkMagic);
1246         //byteSize = WDL_bswap32(20 + 28 + (NParams() * 4) );
1247         bnk.Put(&byteSize);
1248         bnk.Put(&fxpMagic);
1249         bnk.Put(&fxpVersion);
1250         bnk.Put(&pluginID);
1251         bnk.Put(&pluginVersion);
1252         bnk.Put(&numParams);
1253         bnk.PutBytes(prgName, 28);
1254
1255         int pos = 0;
1256
1257         for (int i = 0; i< NParams(); i++)
1258         {
1259           double v = 0.0;
1260           pos = pPreset->mChunk.Get(&v, pos);
1261
1262           WDL_EndianFloat v32;
1263           v32.f = (float) mParams.Get(i)->GetNormalized(v);
1264           unsigned int swapped = WDL_bswap32(v32.int32);
1265           bnk.Put(&swapped);
1266         }
1267       }
1268     }
1269
1270     fwrite(bnk.GetBytes(), bnk.Size(), 1, fp);
1271     fclose(fp);
1272
1273     return true;
1274   }
1275   else
1276     return false;
1277 }
1278
1279 bool IPlugBase::LoadProgramFromFXP(WDL_String* fileName)
1280 {
1281   if (fileName->GetLength())
1282   {
1283     FILE* fp = fopen(fileName->Get(), "rb");
1284
1285     if (fp)
1286     {
1287       ByteChunk pgm;
1288       long fileSize;
1289
1290       fseek(fp , 0 , SEEK_END);
1291       fileSize = ftell(fp);
1292       rewind(fp);
1293
1294       pgm.Resize(fileSize);
1295       fread(pgm.GetBytes(), fileSize, 1, fp);
1296
1297       fclose(fp);
1298
1299       int pos = 0;
1300
1301       VstInt32 chunkMagic;
1302       VstInt32 byteSize = 0;
1303       VstInt32 fxpMagic;
1304       VstInt32 fxpVersion;
1305       VstInt32 pluginID;
1306       VstInt32 pluginVersion;
1307       VstInt32 numParams;
1308       char prgName[28];
1309
1310       pos = pgm.Get(&chunkMagic, pos);
1311       chunkMagic = WDL_bswap_if_le(chunkMagic);
1312       pos = pgm.Get(&byteSize, pos);
1313       byteSize = WDL_bswap_if_le(byteSize);
1314       pos = pgm.Get(&fxpMagic, pos);
1315       fxpMagic = WDL_bswap_if_le(fxpMagic);
1316       pos = pgm.Get(&fxpVersion, pos);
1317       fxpVersion = WDL_bswap_if_le(fxpVersion);
1318       pos = pgm.Get(&pluginID, pos);
1319       pluginID = WDL_bswap_if_le(pluginID);
1320       pos = pgm.Get(&pluginVersion, pos);
1321       pluginVersion = WDL_bswap_if_le(pluginVersion);
1322       pos = pgm.Get(&numParams, pos);
1323       numParams = WDL_bswap_if_le(numParams);
1324       pos = pgm.GetBytes(prgName, 28, pos);
1325
1326       if (chunkMagic != 'CcnK') return false;
1327       if (fxpVersion != kFXPVersionNum) return false; // TODO: what if a host saves as a different version?
1328       if (pluginID != GetUniqueID()) return false;
1329       //if (pluginVersion != GetEffectVersion(true)) return false; // TODO: provide mechanism for loading earlier versions
1330       //if (numParams != NParams()) return false; // TODO: provide mechanism for loading earlier versions with less params
1331
1332       if (DoesStateChunks() && fxpMagic == 'FPCh')
1333       {
1334         VstInt32 chunkSize;
1335         pos = pgm.Get(&chunkSize, pos);
1336         chunkSize = WDL_bswap_if_le(chunkSize);
1337
1338         GetIPlugVerFromChunk(&pgm, &pos);
1339         UnserializeState(&pgm, pos);
1340         ModifyCurrentPreset(prgName);
1341         RestorePreset(GetCurrentPresetIdx());
1342         InformHostOfProgramChange();
1343
1344         return true;
1345       }
1346       else if (fxpMagic == 'FxCk')
1347       {
1348         for (int i = 0; i< NParams(); i++)
1349         {
1350           WDL_EndianFloat v32;
1351           pos = pgm.Get(&v32.int32, pos);
1352           v32.int32 = WDL_bswap_if_le(v32.int32);
1353           mParams.Get(i)->SetNormalized((double) v32.f);
1354         }
1355
1356         ModifyCurrentPreset(prgName);
1357         RestorePreset(GetCurrentPresetIdx());
1358         InformHostOfProgramChange();
1359
1360         return true;
1361       }
1362     }
1363   }
1364
1365   return false;
1366 }
1367
1368 bool IPlugBase::LoadBankFromFXB(WDL_String* fileName)
1369 {
1370   if (fileName->GetLength())
1371   {
1372     FILE* fp = fopen(fileName->Get(), "rb");
1373
1374     if (fp)
1375     {
1376       ByteChunk bnk;
1377       long fileSize;
1378
1379       fseek(fp , 0 , SEEK_END);
1380       fileSize = ftell(fp);
1381       rewind(fp);
1382
1383       bnk.Resize(fileSize);
1384       fread(bnk.GetBytes(), fileSize, 1, fp);
1385
1386       fclose(fp);
1387
1388       int pos = 0;
1389
1390       VstInt32 chunkMagic;
1391       VstInt32 byteSize = 0;
1392       VstInt32 fxbMagic;
1393       VstInt32 fxbVersion;
1394       VstInt32 pluginID;
1395       VstInt32 pluginVersion;
1396       VstInt32 numPgms;
1397       VstInt32 currentPgm;
1398       char future[124];
1399       memset(future, 0, 124);
1400
1401       pos = bnk.Get(&chunkMagic, pos);
1402       chunkMagic = WDL_bswap_if_le(chunkMagic);
1403       pos = bnk.Get(&byteSize, pos);
1404       byteSize = WDL_bswap_if_le(byteSize);
1405       pos = bnk.Get(&fxbMagic, pos);
1406       fxbMagic = WDL_bswap_if_le(fxbMagic);
1407       pos = bnk.Get(&fxbVersion, pos);
1408       fxbVersion = WDL_bswap_if_le(fxbVersion);
1409       pos = bnk.Get(&pluginID, pos);
1410       pluginID = WDL_bswap_if_le(pluginID);
1411       pos = bnk.Get(&pluginVersion, pos);
1412       pluginVersion = WDL_bswap_if_le(pluginVersion);
1413       pos = bnk.Get(&numPgms, pos);
1414       numPgms = WDL_bswap_if_le(numPgms);
1415       pos = bnk.Get(&currentPgm, pos);
1416       currentPgm = WDL_bswap_if_le(currentPgm);
1417       pos = bnk.GetBytes(future, 124, pos);
1418
1419       if (chunkMagic != 'CcnK') return false;
1420       //if (fxbVersion != kFXBVersionNum) return false; // TODO: what if a host saves as a different version?
1421       if (pluginID != GetUniqueID()) return false;
1422       //if (pluginVersion != GetEffectVersion(true)) return false; // TODO: provide mechanism for loading earlier versions
1423       //if (numPgms != NPresets()) return false; // TODO: provide mechanism for loading earlier versions with less params
1424
1425       if (DoesStateChunks() && fxbMagic == 'FBCh')
1426       {
1427         VstInt32 chunkSize;
1428         pos = bnk.Get(&chunkSize, pos);
1429         chunkSize = WDL_bswap_if_le(chunkSize);
1430
1431         GetIPlugVerFromChunk(&bnk, &pos);
1432         UnserializePresets(&bnk, pos);
1433         //RestorePreset(currentPgm);
1434         InformHostOfProgramChange();
1435         return true;
1436       }
1437       else if (fxbMagic == 'FxBk')
1438       {
1439         VstInt32 chunkMagic;
1440         VstInt32 byteSize;
1441         VstInt32 fxpMagic;
1442         VstInt32 fxpVersion;
1443         VstInt32 pluginID;
1444         VstInt32 pluginVersion;
1445         VstInt32 numParams;
1446         char prgName[28];
1447
1448         for(int i = 0; i<numPgms; i++)
1449         {
1450           pos = bnk.Get(&chunkMagic, pos);
1451           chunkMagic = WDL_bswap_if_le(chunkMagic);
1452
1453           pos = bnk.Get(&byteSize, pos);
1454           byteSize = WDL_bswap_if_le(byteSize);
1455
1456           pos = bnk.Get(&fxpMagic, pos);
1457           fxpMagic = WDL_bswap_if_le(fxpMagic);
1458
1459           pos = bnk.Get(&fxpVersion, pos);
1460           fxpVersion = WDL_bswap_if_le(fxpVersion);
1461
1462           pos = bnk.Get(&pluginID, pos);
1463           pluginID = WDL_bswap_if_le(pluginID);
1464
1465           pos = bnk.Get(&pluginVersion, pos);
1466           pluginVersion = WDL_bswap_if_le(pluginVersion);
1467
1468           pos = bnk.Get(&numParams, pos);
1469           numParams = WDL_bswap_if_le(numParams);
1470
1471           if (chunkMagic != 'CcnK') return false;
1472           if (fxpMagic != 'FxCk') return false;
1473           if (fxpVersion != kFXPVersionNum) return false;
1474           if (numParams != NParams()) return false;
1475
1476           pos = bnk.GetBytes(prgName, 28, pos);
1477
1478           RestorePreset(i);
1479
1480           for (int j = 0; j< NParams(); j++)
1481           {
1482             WDL_EndianFloat v32;
1483             pos = bnk.Get(&v32.int32, pos);
1484             v32.int32 = WDL_bswap_if_le(v32.int32);
1485             mParams.Get(j)->SetNormalized((double) v32.f);
1486           }
1487
1488           ModifyCurrentPreset(prgName);
1489         }
1490
1491         RestorePreset(currentPgm);
1492         InformHostOfProgramChange();
1493
1494         return true;
1495       }
1496     }
1497   }
1498
1499   return false;
1500 }
1501
1502 void IPlugBase::InitChunkWithIPlugVer(ByteChunk* pChunk)
1503 {
1504   pChunk->Clear();
1505   int magic = IPLUG_VERSION_MAGIC;
1506   pChunk->Put(&magic);
1507   int ver = IPLUG_VERSION;
1508   pChunk->Put(&ver);
1509 }
1510
1511 int IPlugBase::GetIPlugVerFromChunk(ByteChunk* pChunk, int* pPos)
1512 {
1513   int magic = 0, ver = 0;
1514   int pos = pChunk->Get(&magic, *pPos);
1515   if (pos > *pPos && magic == IPLUG_VERSION_MAGIC)
1516   {
1517     *pPos = pChunk->Get(&ver, pos);
1518   }
1519   return ver;
1520 }
1521
1522 bool IPlugBase::SendMidiMsgs(WDL_TypedBuf<IMidiMsg>* pMsgs)
1523 {
1524   bool rc = true;
1525   int n = pMsgs->GetSize();
1526   IMidiMsg* pMsg = pMsgs->Get();
1527   for (int i = 0; i < n; ++i, ++pMsg) {
1528     rc &= SendMidiMsg(pMsg);
1529   }
1530   return rc;
1531 }