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