iPlug2 - C++ Audio Plug-in Framework
Loading...
Searching...
No Matches
IPlugUtilities.h
Go to the documentation of this file.
1/*
2 ==============================================================================
3
4 This file is part of the iPlug 2 library. Copyright (C) the iPlug 2 developers.
5
6 See LICENSE.txt for more info.
7
8 ==============================================================================
9*/
10
11#pragma once
12
21#include <algorithm>
22#include <cmath>
23#include <cstdio>
24#include <cstdlib>
25#include <cstring>
26#include <cctype>
27
28#include "heapbuf.h"
29#include "wdlstring.h"
30
31#include "IPlugConstants.h"
32#include "IPlugPlatform.h"
33
34#ifdef OS_WIN
35#include <windows.h>
36#pragma warning(disable:4018 4267) // size_t/signed/unsigned mismatch..
37#pragma warning(disable:4800) // if (pointer) ...
38#pragma warning(disable:4805) // Compare bool and BOOL.
39#endif
40
41BEGIN_IPLUG_NAMESPACE
42
48template <typename T>
49T Clip(T x, T lo, T hi) { return std::min(std::max(x, lo), hi); }
50
55template <typename T>
56inline T Lerp(T a, T b, T f) { return ((b - a) * f + a); }
57
58static inline bool CStringHasContents(const char* str) { return str && str[0] != '\0'; }
59
60#define MAKE_QUOTE(str) #str
61#define MAKE_STR(str) MAKE_QUOTE(str)
62
64#define GET_PARAM_FROM_VARARG(paramType, vp, v) \
65{ \
66 v = 0.0; \
67 switch (paramType) { \
68 case IParam::kTypeBool: \
69 case IParam::kTypeInt: \
70 case IParam::kTypeEnum: { \
71 v = (double) va_arg(vp, int); \
72 break; \
73 } \
74 case IParam::kTypeDouble: \
75 default: { \
76 v = (double) va_arg(vp, double); \
77 break; \
78 } \
79 } \
80}
81
82#ifndef REMINDER
83#ifdef OS_WIN
84// This enables: #pragma REMINDER("change this line!") with click-through from VC++.
85#define REMINDER(msg) message(__FILE__ "(" MAKE_STR(__LINE__) "): " msg)
86#elif defined __APPLE__
87#define REMINDER(msg) WARNING msg
88#endif
89#endif
90
97static inline double DBToAmp(double dB)
98{
99 return std::exp(IAMP_DB * dB);
100}
101
105static inline double AmpToDB(double amp)
106{
107 return AMP_DB * std::log(std::fabs(amp));
108}
109
115static inline void GetVersionParts(int versionInteger, int& maj, int& min, int& pat)
116{
117 maj = (versionInteger & 0xFFFF0000) >> 16;
118 min = (versionInteger & 0x0000FF00) >> 8;
119 pat = versionInteger & 0x000000FF;
120}
121
125static inline int GetDecimalVersion(int versionInteger)
126{
127 int maj, min, pat;
128 GetVersionParts(versionInteger, maj, min, pat);
129 return 10000 * maj + 100 * min + pat;
130}
131
135static inline void GetVersionStr(int versionInteger, WDL_String& str)
136{
137 int maj, min, pat;
138 GetVersionParts(versionInteger, maj, min, pat);
139 str.SetFormatted(MAX_VERSION_STR_LEN, "v%d.%d.%d", maj, min, pat);
140}
141
148template <class SRC, class DEST>
149void CastCopy(DEST* pDest, SRC* pSrc, int n)
150{
151 for (int i = 0; i < n; ++i, ++pDest, ++pSrc)
152 {
153 *pDest = (DEST) *pSrc;
154 }
155}
156
160static void ToLower(char* cDest, const char* cSrc)
161{
162 int i, n = (int) strlen(cSrc);
163 for (i = 0; i < n; ++i)
164 {
165 cDest[i] = tolower(cSrc[i]);
166 }
167 cDest[i] = '\0';
168}
169
173static EHost LookUpHost(const char* inHost)
174{
175 char host[256];
176 ToLower(host, inHost);
177
178 // C4 is version >= 8.2
179 if (strstr(host, "reaper")) return kHostReaper;
180 if (strstr(host, "protools")) return kHostProTools;
181 if (strstr(host, "cubase")) return kHostCubase;
182 if (strstr(host, "nuendo")) return kHostNuendo;
183 if (strstr(host, "cakewalk")) return kHostSonar;
184 if (strstr(host, "vegas")) return kHostVegas;
185 if (strstr(host, "fruity")) return kHostFL;
186 if (strstr(host, "samplitude")) return kHostSamplitude;
187 if (strstr(host, "live")) return kHostAbletonLive;
188 if (strstr(host, "tracktion")) return kHostTracktion;
189 if (strstr(host, "ntracks")) return kHostNTracks;
190 if (strstr(host, "melodyne")) return kHostMelodyneStudio;
191 if (strstr(host, "vstmanlib")) return kHostVSTScanner;
192 if (strstr(host, "aulab")) return kHostAULab;
193 if (strstr(host, "forte")) return kHostForte;
194 if (strstr(host, "chainer")) return kHostChainer;
195 if (strstr(host, "audition")) return kHostAudition;
196 if (strstr(host, "orion")) return kHostOrion;
197 if (strstr(host, "bias")) return kHostBias;
198 if (strstr(host, "sawstudio")) return kHostSAWStudio;
199 if (strstr(host, "logic")) return kHostLogic;
200 if (strstr(host, "garageband")) return kHostGarageBand;
201 if (strstr(host, "digital")) return kHostDigitalPerformer;
202 if (strstr(host, "audiomulch")) return kHostAudioMulch;
203 if (strstr(host, "presonus")) return kHostStudioOne;
204 if (strstr(host, "vst3plugintesthost")) return kHostVST3TestHost;
205 if (strstr(host, "ardour")) return kHostArdour;
206 if (strstr(host, "renoise")) return kHostRenoise;
207 if (strstr(host, "openmpt")) return kHostOpenMPT;
208 if (strstr(host, "wavelab elements")) return kHostWaveLabElements; // check for wavelab elements should come before wavelab ...
209 if (strstr(host, "wavelab")) return kHostWaveLab;
210 if (strstr(host, "twistedwave")) return kHostTwistedWave;
211 if (strstr(host, "bitwig studio")) return kHostBitwig;
212 if (strstr(host, "reason")) return kHostReason;
213 if (strstr(host, "gwvst")) return kHostGoldWave5x;
214 if (strstr(host, "waveform")) return kHostWaveform;
215 if (strstr(host, "audacity")) return kHostAudacity;
216 if (strstr(host, "acoustica")) return kHostAcoustica;
217 if (strstr(host, "plugindoctor")) return kHostPluginDoctor;
218 if (strstr(host, "izotope rx")) return kHostiZotopeRX;
219 if (strstr(host, "savihost")) return kHostSAVIHost;
220 if (strstr(host, "blue cat's vst host")) return kHostBlueCat;
221 if (strstr(host, "mixbus")) return kHostMixbus32C;
222
223 if (strstr(host, "standalone")) return kHostStandalone;
224 if (strstr(host, "www")) return kHostWWW;
225
226 return kHostUnknown;
227
228}
229
238static void GetHostNameStr(EHost host, WDL_String& str)
239{
240 switch (host)
241 {
242 case kHostReaper: str.Set("reaper"); break;
243 case kHostProTools: str.Set("protools"); break;
244 case kHostCubase: str.Set("cubase"); break;
245 case kHostNuendo: str.Set("nuendo"); break;
246 case kHostSonar: str.Set("cakewalk"); break;
247 case kHostVegas: str.Set("vegas"); break;
248 case kHostFL: str.Set("fruity"); break;
249 case kHostSamplitude: str.Set("samplitude"); break;
250 case kHostAbletonLive: str.Set("live"); break;
251 case kHostTracktion: str.Set("tracktion"); break;
252 case kHostNTracks: str.Set("ntracks"); break;
253 case kHostMelodyneStudio: str.Set("melodyne"); break;
254 case kHostVSTScanner: str.Set("vstmanlib"); break;
255 case kHostAULab: str.Set("aulab"); break;
256 case kHostForte: str.Set("forte"); break;
257 case kHostChainer: str.Set("chainer"); break;
258 case kHostAudition: str.Set("audition"); break;
259 case kHostOrion: str.Set("orion"); break;
260 case kHostBias: str.Set("bias"); break;
261 case kHostSAWStudio: str.Set("sawstudio"); break;
262 case kHostLogic: str.Set("logic"); break;
263 case kHostGarageBand: str.Set("garageband"); break;
264 case kHostDigitalPerformer: str.Set("digital"); break;
265 case kHostAudioMulch: str.Set("audiomulch"); break;
266 case kHostStudioOne: str.Set("presonus"); break;
267 case kHostVST3TestHost: str.Set("vst3plugintesthost"); break;
268 case kHostArdour: str.Set("ardour"); break;
269 case kHostRenoise: str.Set("renoise"); break;
270 case kHostOpenMPT: str.Set("OpenMPT"); break;
271 case kHostWaveLabElements: str.Set("wavelab elements"); break;
272 case kHostWaveLab: str.Set("wavelab"); break;
273 case kHostTwistedWave: str.Set("twistedwave"); break;
274 case kHostBitwig: str.Set("bitwig studio"); break;
275 case kHostReason: str.Set("reason"); break;
276 case kHostGoldWave5x: str.Set("gwvst"); break;
277 case kHostWaveform: str.Set("waveform"); break;
278 case kHostAudacity: str.Set("audacity"); break;
279 case kHostAcoustica: str.Set("acoustica"); break;
280 case kHostPluginDoctor: str.Set("plugindoctor"); break;
281 case kHostiZotopeRX: str.Set("izotope rx"); break;
282 case kHostSAVIHost: str.Set("savihost"); break;
283 case kHostBlueCat: str.Set("blue cat's vst host"); break;
284 case kHostMixbus32C: str.Set("mixbus"); break;
285
286 case kHostStandalone: str.Set("standalone"); break;
287 case kHostWWW: str.Set("www"); break;
288
289 default: str.Set("Unknown"); break;
290 }
291}
292
298static void MidiNoteName(double midiPitch, WDL_String& noteName, bool cents = false, bool middleCisC4 = false)
299{
300 static const char noteNames[12][3] = {"C ","C#","D ","D#","E ","F ","F#","G ","G#","A ","A#","B "};
301
302 int midiPitchR = (int) std::round(midiPitch);
303 int pitchClass = midiPitchR % 12;
304 int octave = (midiPitchR / 12) - (middleCisC4? 1 : 2);
305
306 if (cents)
307 {
308 double frac = (midiPitch - (float) midiPitchR) * 100.;
309 noteName.SetFormatted(32, "%s%i %.0f", noteNames[pitchClass], octave, frac);
310 }
311 else
312 {
313 noteName.SetFormatted(32, "%s%i", noteNames[pitchClass], octave);
314 }
315}
316
317#if defined OS_WIN
318
319static int UTF8ToUTF16Len(const char* utf8Str)
320{
321 return std::max(MultiByteToWideChar(CP_UTF8, 0, utf8Str, -1, NULL, 0), 1);
322}
323
324static void UTF8ToUTF16(wchar_t* wideStr, const char* utf8Str, int maxLen)
325{
326 int requiredSize = UTF8ToUTF16Len(utf8Str);
327
328 if (requiredSize <= maxLen)
329 {
330 if (MultiByteToWideChar(CP_UTF8, 0, utf8Str, -1, wideStr, requiredSize))
331 return;
332 }
333
334 wideStr[0] = '\0';
335}
336
337static void UTF16ToUTF8(WDL_String& utf8Str, const wchar_t* wideStr)
338{
339 int requiredSize = WideCharToMultiByte(CP_UTF8, 0, wideStr, -1, NULL, 0, NULL, NULL);
340
341 if (requiredSize > 0 && utf8Str.SetLen(requiredSize))
342 {
343 WideCharToMultiByte(CP_UTF8, 0, wideStr, -1, utf8Str.Get(), requiredSize, NULL, NULL);
344 return;
345 }
346
347 utf8Str.Set("");
348}
349
350class UTF8AsUTF16
351{
352public:
353
354 UTF8AsUTF16(const char* utf8Str)
355 {
356 mUTF16Str.Resize(UTF8ToUTF16Len(utf8Str));
357 UTF8ToUTF16(mUTF16Str.Get(), utf8Str, mUTF16Str.GetSize());
358 }
359
360 UTF8AsUTF16(const WDL_String& utf8Str) : UTF8AsUTF16(utf8Str.Get())
361 {
362 }
363
364 const wchar_t* Get() const { return mUTF16Str.Get(); }
365 int GetLength() const { return mUTF16Str.GetSize(); }
366
367 UTF8AsUTF16& ToUpperCase()
368 {
369 _wcsupr(mUTF16Str.Get());
370 return *this;
371 }
372
373 UTF8AsUTF16& ToLowerCase()
374 {
375 _wcslwr(mUTF16Str.Get());
376 return *this;
377 }
378
379private:
380
381 WDL_TypedBuf<wchar_t> mUTF16Str;
382};
383
384class UTF16AsUTF8
385{
386public:
387
388 UTF16AsUTF8(const wchar_t* wideStr)
389 {
390 UTF16ToUTF8(mUTF8Str, wideStr);
391 }
392
393 const char* Get() const { return mUTF8Str.Get(); }
394 int GetLength() const { return mUTF8Str.GetLength(); }
395
396private:
397
398 WDL_String mUTF8Str;
399};
400#endif
401
402
403#if defined OS_WIN
404
405static FILE* fopenUTF8(const char* path, const char* mode)
406{
407 return _wfopen(UTF8AsUTF16(path).Get(), UTF8AsUTF16(mode).Get());
408}
409
410#else
411
412static FILE* fopenUTF8(const char* path, const char* mode)
413{
414 return fopen(path, mode);
415}
416
417#endif
418
419/*
420 * DOM Virtual Key Code to iPlug2 Virtual Key Code converter
421 *
422 * Virtual key code definitions adapted from Emscripten
423 * Copyright 2017 The Emscripten Authors. All rights reserved.
424 * Source: https://github.com/emscripten-core/emscripten/
425 * Licensed under MIT and University of Illinois/NCSA Open Source License
426 */
427
428// DOM Virtual Key codes (subset of most common keys)
429enum EDOMVirtualKey {
430 DOM_VK_BACK_SPACE = 0x08,
431 DOM_VK_TAB = 0x09,
432 DOM_VK_RETURN = 0x0D,
433 DOM_VK_SHIFT = 0x10,
434 DOM_VK_CONTROL = 0x11,
435 DOM_VK_ALT = 0x12,
436 DOM_VK_PAUSE = 0x13,
437 DOM_VK_CAPS_LOCK = 0x14,
438 DOM_VK_ESCAPE = 0x1B,
439 DOM_VK_SPACE = 0x20,
440 DOM_VK_PAGE_UP = 0x21,
441 DOM_VK_PAGE_DOWN = 0x22,
442 DOM_VK_END = 0x23,
443 DOM_VK_HOME = 0x24,
444 DOM_VK_LEFT = 0x25,
445 DOM_VK_UP = 0x26,
446 DOM_VK_RIGHT = 0x27,
447 DOM_VK_DOWN = 0x28,
448 DOM_VK_INSERT = 0x2D,
449 DOM_VK_DELETE = 0x2E,
450 DOM_VK_F1 = 0x70,
451 DOM_VK_F2 = 0x71,
452 DOM_VK_F3 = 0x72,
453 DOM_VK_F4 = 0x73,
454 DOM_VK_F5 = 0x74,
455 DOM_VK_F6 = 0x75,
456 DOM_VK_F7 = 0x76,
457 DOM_VK_F8 = 0x77,
458 DOM_VK_F9 = 0x78,
459 DOM_VK_F10 = 0x79,
460 DOM_VK_F11 = 0x7A,
461 DOM_VK_F12 = 0x7B,
462 DOM_VK_NUMPAD0 = 0x60,
463 DOM_VK_NUMPAD1 = 0x61,
464 DOM_VK_NUMPAD2 = 0x62,
465 DOM_VK_NUMPAD3 = 0x63,
466 DOM_VK_NUMPAD4 = 0x64,
467 DOM_VK_NUMPAD5 = 0x65,
468 DOM_VK_NUMPAD6 = 0x66,
469 DOM_VK_NUMPAD7 = 0x67,
470 DOM_VK_NUMPAD8 = 0x68,
471 DOM_VK_NUMPAD9 = 0x69
472};
473
479inline int DOMKeyToVirtualKey(uint32_t domKeyCode) {
480 switch(domKeyCode) {
481 case DOM_VK_BACK_SPACE: return kVK_BACK;
482 case DOM_VK_TAB: return kVK_TAB;
483 case DOM_VK_RETURN: return kVK_RETURN;
484 case DOM_VK_SHIFT: return kVK_SHIFT;
485 case DOM_VK_CONTROL: return kVK_CONTROL;
486 case DOM_VK_ALT: return kVK_MENU;
487 case DOM_VK_PAUSE: return kVK_PAUSE;
488 case DOM_VK_CAPS_LOCK: return kVK_CAPITAL;
489 case DOM_VK_ESCAPE: return kVK_ESCAPE;
490 case DOM_VK_SPACE: return kVK_SPACE;
491 case DOM_VK_PAGE_UP: return kVK_PRIOR;
492 case DOM_VK_PAGE_DOWN: return kVK_NEXT;
493 case DOM_VK_END: return kVK_END;
494 case DOM_VK_HOME: return kVK_HOME;
495 case DOM_VK_LEFT: return kVK_LEFT;
496 case DOM_VK_UP: return kVK_UP;
497 case DOM_VK_RIGHT: return kVK_RIGHT;
498 case DOM_VK_DOWN: return kVK_DOWN;
499 case DOM_VK_INSERT: return kVK_INSERT;
500 case DOM_VK_DELETE: return kVK_DELETE;
501
502 // Numbers (both main keyboard and numpad)
503 case 0x30: case DOM_VK_NUMPAD0: return kVK_0;
504 case 0x31: case DOM_VK_NUMPAD1: return kVK_1;
505 case 0x32: case DOM_VK_NUMPAD2: return kVK_2;
506 case 0x33: case DOM_VK_NUMPAD3: return kVK_3;
507 case 0x34: case DOM_VK_NUMPAD4: return kVK_4;
508 case 0x35: case DOM_VK_NUMPAD5: return kVK_5;
509 case 0x36: case DOM_VK_NUMPAD6: return kVK_6;
510 case 0x37: case DOM_VK_NUMPAD7: return kVK_7;
511 case 0x38: case DOM_VK_NUMPAD8: return kVK_8;
512 case 0x39: case DOM_VK_NUMPAD9: return kVK_9;
513
514 // Letters
515 case 0x41: return kVK_A;
516 case 0x42: return kVK_B;
517 case 0x43: return kVK_C;
518 case 0x44: return kVK_D;
519 case 0x45: return kVK_E;
520 case 0x46: return kVK_F;
521 case 0x47: return kVK_G;
522 case 0x48: return kVK_H;
523 case 0x49: return kVK_I;
524 case 0x4A: return kVK_J;
525 case 0x4B: return kVK_K;
526 case 0x4C: return kVK_L;
527 case 0x4D: return kVK_M;
528 case 0x4E: return kVK_N;
529 case 0x4F: return kVK_O;
530 case 0x50: return kVK_P;
531 case 0x51: return kVK_Q;
532 case 0x52: return kVK_R;
533 case 0x53: return kVK_S;
534 case 0x54: return kVK_T;
535 case 0x55: return kVK_U;
536 case 0x56: return kVK_V;
537 case 0x57: return kVK_W;
538 case 0x58: return kVK_X;
539 case 0x59: return kVK_Y;
540 case 0x5A: return kVK_Z;
541
542 // Function keys
543 case DOM_VK_F1: return kVK_F1;
544 case DOM_VK_F2: return kVK_F2;
545 case DOM_VK_F3: return kVK_F3;
546 case DOM_VK_F4: return kVK_F4;
547 case DOM_VK_F5: return kVK_F5;
548 case DOM_VK_F6: return kVK_F6;
549 case DOM_VK_F7: return kVK_F7;
550 case DOM_VK_F8: return kVK_F8;
551 case DOM_VK_F9: return kVK_F9;
552 case DOM_VK_F10: return kVK_F10;
553 case DOM_VK_F11: return kVK_F11;
554 case DOM_VK_F12: return kVK_F12;
555
556 default: return 0; // No mapping available
557 }
558}
559
560END_IPLUG_NAMESPACE
561
IPlugConstants.h
IPlug Constant definitions, Types, magic numbers.
IPlugPlatform.h
Include to get consistently named preprocessor macros for different platforms and logging functionali...
IAMP_DB
static const double IAMP_DB
Magic number for dB to gain conversion.
Definition: IPlugConstants.h:76
AMP_DB
static const double AMP_DB
Magic number for gain to dB conversion.
Definition: IPlugConstants.h:71
EHost
EHost
Host identifier.
Definition: IPlugConstants.h:194
Clip
BEGIN_IPLUG_NAMESPACE T Clip(T x, T lo, T hi)
Clips the value x between lo and hi.
Definition: IPlugUtilities.h:49
Lerp
T Lerp(T a, T b, T f)
Linear interpolate between values a and b.
Definition: IPlugUtilities.h:56
MidiNoteName
static void MidiNoteName(double midiPitch, WDL_String &noteName, bool cents=false, bool middleCisC4=false)
Definition: IPlugUtilities.h:298
AmpToDB
static double AmpToDB(double amp)
Definition: IPlugUtilities.h:105
GetDecimalVersion
static int GetDecimalVersion(int versionInteger)
Helper function to get the version number as a decimal integer.
Definition: IPlugUtilities.h:125
DOMKeyToVirtualKey
int DOMKeyToVirtualKey(uint32_t domKeyCode)
Converts a DOM virtual key code to an iPlug2 virtual key code.
Definition: IPlugUtilities.h:479
GetHostNameStr
static void GetHostNameStr(EHost host, WDL_String &str)
Gets a human-readable name from host identifier.
Definition: IPlugUtilities.h:238
CastCopy
void CastCopy(DEST *pDest, SRC *pSrc, int n)
Helper function to loop through a buffer of samples copying and casting from e.g float to double.
Definition: IPlugUtilities.h:149
GetVersionParts
static void GetVersionParts(int versionInteger, int &maj, int &min, int &pat)
Helper function to unpack the version number parts as individual integers.
Definition: IPlugUtilities.h:115
ToLower
static void ToLower(char *cDest, const char *cSrc)
Definition: IPlugUtilities.h:160
GetVersionStr
static void GetVersionStr(int versionInteger, WDL_String &str)
Helper function to get the semantic version number as a string from an integer.
Definition: IPlugUtilities.h:135
DBToAmp
static double DBToAmp(double dB)
Calculates gain from a given dB value.
Definition: IPlugUtilities.h:97
LookUpHost
static EHost LookUpHost(const char *inHost)
Gets the host ID from a human-readable name.
Definition: IPlugUtilities.h:173
Generated by doxygen 1.9.5