IPlugUtilities.h

Go to the documentation of this file.

/*
 ==============================================================================
 
 This file is part of the iPlug 2 library. Copyright (C) the iPlug 2 developers. 
 
 See LICENSE.txt for  more info.
 
 ==============================================================================
*/
 
#pragma once
 
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
 
#include "heapbuf.h"
#include "wdlstring.h"
 
#include "IPlugConstants.h"
#include "IPlugPlatform.h"
 
#ifdef OS_WIN
#include <windows.h>
#pragma warning(disable:4018 4267)      // size_t/signed/unsigned mismatch..
#pragma warning(disable:4800)           // if (pointer) ...
#pragma warning(disable:4805)           // Compare bool and BOOL.
#endif
 
BEGIN_IPLUG_NAMESPACE
 
template <typename T>
T Clip(T x, T lo, T hi) { return std::min(std::max(x, lo), hi); }
 
template <typename T>
inline T Lerp(T a, T b, T f) { return ((b - a) * f + a); }
 
static inline bool CStringHasContents(const char* str) { return str && str[0] != '\0'; }
 
#define MAKE_QUOTE(str) #str
#define MAKE_STR(str) MAKE_QUOTE(str)
 
#define GET_PARAM_FROM_VARARG(paramType, vp, v) \
{ \
  v = 0.0; \
  switch (paramType) { \
    case IParam::kTypeBool: \
    case IParam::kTypeInt: \
    case IParam::kTypeEnum: { \
      v = (double) va_arg(vp, int); \
      break; \
    } \
    case IParam::kTypeDouble: \
    default: { \
      v = (double) va_arg(vp, double); \
      break; \
    } \
  } \
}
 
#ifndef REMINDER
#ifdef OS_WIN
// This enables: #pragma REMINDER("change this line!") with click-through from VC++.
#define REMINDER(msg) message(__FILE__   "(" MAKE_STR(__LINE__) "): " msg)
#elif defined __APPLE__
#define REMINDER(msg) WARNING msg
#endif
#endif
 
static inline double DBToAmp(double dB)
{
  return std::exp(IAMP_DB * dB);
}
 
static inline double AmpToDB(double amp)
{
  return AMP_DB * std::log(std::fabs(amp));
}
 
static inline void GetVersionParts(int versionInteger, int& maj, int& min, int& pat)
{
  maj = (versionInteger & 0xFFFF0000) >> 16;
  min = (versionInteger & 0x0000FF00) >> 8;
  pat = versionInteger & 0x000000FF;
}
 
static inline int GetDecimalVersion(int versionInteger)
{
  int maj, min, pat;
  GetVersionParts(versionInteger, maj, min, pat);
  return 10000 * maj + 100 * min + pat;
}
 
static inline void GetVersionStr(int versionInteger, WDL_String& str)
{
  int maj, min, pat;
  GetVersionParts(versionInteger, maj, min, pat);
  str.SetFormatted(MAX_VERSION_STR_LEN, "v%d.%d.%d", maj, min, pat);
}
 
template <class SRC, class DEST>
void CastCopy(DEST* pDest, SRC* pSrc, int n)
{
  for (int i = 0; i < n; ++i, ++pDest, ++pSrc)
  {
    *pDest = (DEST) *pSrc;
  }
}
 
static void ToLower(char* cDest, const char* cSrc)
{
  int i, n = (int) strlen(cSrc);
  for (i = 0; i < n; ++i)
  {
    cDest[i] = tolower(cSrc[i]);
  }
  cDest[i] = '\0';
}
 
static EHost LookUpHost(const char* inHost)
{
  char host[256];
  ToLower(host, inHost);
 
  // C4 is version >= 8.2
  if (strstr(host, "reaper"))               return kHostReaper;
  if (strstr(host, "protools"))             return kHostProTools;
  if (strstr(host, "cubase"))               return kHostCubase;
  if (strstr(host, "nuendo"))               return kHostNuendo;
  if (strstr(host, "cakewalk"))             return kHostSonar;
  if (strstr(host, "vegas"))                return kHostVegas;
  if (strstr(host, "fruity"))               return kHostFL;
  if (strstr(host, "samplitude"))           return kHostSamplitude;
  if (strstr(host, "live"))                 return kHostAbletonLive;
  if (strstr(host, "tracktion"))            return kHostTracktion;
  if (strstr(host, "ntracks"))              return kHostNTracks;
  if (strstr(host, "melodyne"))             return kHostMelodyneStudio;
  if (strstr(host, "vstmanlib"))            return kHostVSTScanner;
  if (strstr(host, "aulab"))                return kHostAULab;
  if (strstr(host, "forte"))                return kHostForte;
  if (strstr(host, "chainer"))              return kHostChainer;
  if (strstr(host, "audition"))             return kHostAudition;
  if (strstr(host, "orion"))                return kHostOrion;
  if (strstr(host, "bias"))                 return kHostBias;
  if (strstr(host, "sawstudio"))            return kHostSAWStudio;
  if (strstr(host, "logic"))                return kHostLogic;
  if (strstr(host, "garageband"))           return kHostGarageBand;
  if (strstr(host, "digital"))              return kHostDigitalPerformer;
  if (strstr(host, "audiomulch"))           return kHostAudioMulch;
  if (strstr(host, "presonus"))             return kHostStudioOne;
  if (strstr(host, "vst3plugintesthost"))   return kHostVST3TestHost;
  if (strstr(host, "ardour"))               return kHostArdour;
  if (strstr(host, "renoise"))              return kHostRenoise;
  if (strstr(host, "openmpt"))              return kHostOpenMPT;
  if (strstr(host, "wavelab elements"))     return kHostWaveLabElements; // check for wavelab elements should come before wavelab ...
  if (strstr(host, "wavelab"))              return kHostWaveLab;
  if (strstr(host, "twistedwave"))          return kHostTwistedWave;
  if (strstr(host, "bitwig studio"))        return kHostBitwig;
  if (strstr(host, "reason"))               return kHostReason;
  if (strstr(host, "gwvst"))                return kHostGoldWave5x;
  if (strstr(host, "waveform"))             return kHostWaveform;
  if (strstr(host, "audacity"))             return kHostAudacity;
  if (strstr(host, "acoustica"))            return kHostAcoustica;
  if (strstr(host, "plugindoctor"))         return kHostPluginDoctor;
  if (strstr(host, "izotope rx"))           return kHostiZotopeRX;
  if (strstr(host, "savihost"))             return kHostSAVIHost;
  if (strstr(host, "blue cat's vst host"))  return kHostBlueCat;
  if (strstr(host, "mixbus"))               return kHostMixbus32C;
 
  if (strstr(host, "standalone"))           return kHostStandalone;
  if (strstr(host, "www"))                  return kHostWWW;
 
  return kHostUnknown;
 
}
 
static void GetHostNameStr(EHost host, WDL_String& str)
{
  switch (host)
  {
      case kHostReaper:             str.Set("reaper");              break;
      case kHostProTools:           str.Set("protools");            break;
      case kHostCubase:             str.Set("cubase");              break;
      case kHostNuendo:             str.Set("nuendo");              break;
      case kHostSonar:              str.Set("cakewalk");            break;
      case kHostVegas:              str.Set("vegas");               break;
      case kHostFL:                 str.Set("fruity");              break;
      case kHostSamplitude:         str.Set("samplitude");          break;
      case kHostAbletonLive:        str.Set("live");                break;
      case kHostTracktion:          str.Set("tracktion");           break;
      case kHostNTracks:            str.Set("ntracks");             break;
      case kHostMelodyneStudio:     str.Set("melodyne");            break;
      case kHostVSTScanner:         str.Set("vstmanlib");           break;
      case kHostAULab:              str.Set("aulab");               break;
      case kHostForte:              str.Set("forte");               break;
      case kHostChainer:            str.Set("chainer");             break;
      case kHostAudition:           str.Set("audition");            break;
      case kHostOrion:              str.Set("orion");               break;
      case kHostBias:               str.Set("bias");                break;
      case kHostSAWStudio:          str.Set("sawstudio");           break;
      case kHostLogic:              str.Set("logic");               break;
      case kHostGarageBand:         str.Set("garageband");          break;
      case kHostDigitalPerformer:   str.Set("digital");             break;
      case kHostAudioMulch:         str.Set("audiomulch");          break;
      case kHostStudioOne:          str.Set("presonus");            break;
      case kHostVST3TestHost:       str.Set("vst3plugintesthost");  break;
      case kHostArdour:             str.Set("ardour");              break;
      case kHostRenoise:            str.Set("renoise");             break;
      case kHostOpenMPT:            str.Set("OpenMPT");             break;
      case kHostWaveLabElements:    str.Set("wavelab elements");    break;
      case kHostWaveLab:            str.Set("wavelab");             break;
      case kHostTwistedWave:        str.Set("twistedwave");         break;
      case kHostBitwig:             str.Set("bitwig studio");       break;
      case kHostReason:             str.Set("reason");              break;
      case kHostGoldWave5x:         str.Set("gwvst");               break;
      case kHostWaveform:           str.Set("waveform");            break;
      case kHostAudacity:           str.Set("audacity");            break;
      case kHostAcoustica:          str.Set("acoustica");           break;
      case kHostPluginDoctor:       str.Set("plugindoctor");        break;
      case kHostiZotopeRX:          str.Set("izotope rx");          break;
      case kHostSAVIHost:           str.Set("savihost");            break;
      case kHostBlueCat:            str.Set("blue cat's vst host"); break;
      case kHostMixbus32C:          str.Set("mixbus");              break;
 
      case kHostStandalone:         str.Set("standalone");          break;
      case kHostWWW:                str.Set("www");                 break;
 
      default:                      str.Set("Unknown"); break;
  }
}
 
static void MidiNoteName(double midiPitch, WDL_String& noteName, bool cents = false, bool middleCisC4 = false)
{
  static const char noteNames[12][3] = {"C ","C#","D ","D#","E ","F ","F#","G ","G#","A ","A#","B "};
  
  int midiPitchR = (int) std::round(midiPitch);
  int pitchClass = midiPitchR % 12;
  int octave = (midiPitchR / 12) - (middleCisC4? 1 : 2);
  
  if (cents)
  {
    double frac = (midiPitch - (float) midiPitchR) * 100.;
    noteName.SetFormatted(32, "%s%i %.0f", noteNames[pitchClass], octave, frac);
  }
  else
  {
    noteName.SetFormatted(32, "%s%i", noteNames[pitchClass], octave);
  }
}
 
#if defined OS_WIN
 
static int UTF8ToUTF16Len(const char* utf8Str)
{
  return std::max(MultiByteToWideChar(CP_UTF8, 0, utf8Str, -1, NULL, 0), 1);
}
 
static void UTF8ToUTF16(wchar_t* wideStr, const char* utf8Str, int maxLen)
{
  int requiredSize = UTF8ToUTF16Len(utf8Str);
 
  if (requiredSize <= maxLen)
  {
    if (MultiByteToWideChar(CP_UTF8, 0, utf8Str, -1, wideStr, requiredSize))
      return;
  }
 
  wideStr[0] = '\0';
}
 
static void UTF16ToUTF8(WDL_String& utf8Str, const wchar_t* wideStr)
{
  int requiredSize = WideCharToMultiByte(CP_UTF8, 0, wideStr, -1, NULL, 0, NULL, NULL);
 
  if (requiredSize > 0 && utf8Str.SetLen(requiredSize))
  {
    WideCharToMultiByte(CP_UTF8, 0, wideStr, -1, utf8Str.Get(), requiredSize, NULL, NULL);
    return;
  }
 
  utf8Str.Set("");
}
 
class UTF8AsUTF16
{
public:
 
  UTF8AsUTF16(const char* utf8Str)
  {
    mUTF16Str.Resize(UTF8ToUTF16Len(utf8Str));
    UTF8ToUTF16(mUTF16Str.Get(), utf8Str, mUTF16Str.GetSize());
  }
 
  UTF8AsUTF16(const WDL_String& utf8Str) : UTF8AsUTF16(utf8Str.Get())
  {
  }
 
  const wchar_t* Get() const { return mUTF16Str.Get(); }
  int GetLength() const { return mUTF16Str.GetSize(); }
 
  UTF8AsUTF16& ToUpperCase()
  {
    _wcsupr(mUTF16Str.Get());
    return *this;
  }
 
  UTF8AsUTF16& ToLowerCase()
  {
    _wcslwr(mUTF16Str.Get());
    return *this;
  }
 
private:
 
  WDL_TypedBuf<wchar_t> mUTF16Str;
};
 
class UTF16AsUTF8
{
public:
 
  UTF16AsUTF8(const wchar_t* wideStr)
  {
    UTF16ToUTF8(mUTF8Str, wideStr);
  }
 
  const char* Get() const { return mUTF8Str.Get(); }
  int GetLength() const { return mUTF8Str.GetLength(); }
 
private:
 
  WDL_String mUTF8Str;
};
#endif
 
 
#if defined OS_WIN
 
static FILE* fopenUTF8(const char* path, const char* mode)
{
  return _wfopen(UTF8AsUTF16(path).Get(), UTF8AsUTF16(mode).Get());
}
 
#else
 
static FILE* fopenUTF8(const char* path, const char* mode)
{
  return fopen(path, mode);
}
 
#endif
 
END_IPLUG_NAMESPACE