falkTX
/
Cadence
mirror of https://github.com/falkTX/Cadence
1
0
Fork 0
Code Releases 3 Activity
Collection of tools useful for audio production
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
671 Commits
2 Branches
142MB
Tree: d63d2f4894
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd63d2f4894'
${ noResults }
Cadence/c++/carla-backend/carla_backend_utils.hpp

521 lines
14KB
Raw Blame History 

  1. /*

  2.  * Carla Backend

  3.  * Copyright (C) 2011-2012 Filipe Coelho <falktx@falktx.com>

  4.  *

  5.  * This program is free software; you can redistribute it and/or modify

  6.  * it under the terms of the GNU General Public License as published by

  7.  * the Free Software Foundation; either version 2 of the License, or

  8.  * any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the COPYING file

  16.  */

  17. 

  18. #ifndef CARLA_BACKEND_UTILS_HPP

  19. #define CARLA_BACKEND_UTILS_HPP

  20. 

  21. #include "carla_backend.hpp"

  22. #include "carla_utils.hpp"

  23. 

  24. #include <QtCore/QString>

  25. 

  26. CARLA_BACKEND_START_NAMESPACE

  27. 

  28. static inline

  29. const char* BinaryType2Str(const BinaryType& type)

  30. {

  31.     switch (type)

  32.     {

  33.     case BINARY_NONE:

  34.         return "BINARY_NONE";

  35.     case BINARY_POSIX32:

  36.         return "BINARY_POSIX32";

  37.     case BINARY_POSIX64:

  38.         return "BINARY_POSIX64";

  39.     case BINARY_WIN32:

  40.         return "BINARY_WIN32";

  41.     case BINARY_WIN64:

  42.         return "BINARY_WIN64";

  43.     case BINARY_OTHER:

  44.         return "BINARY_OTHER";

  45.     }

  46. 

  47.     qWarning("CarlaBackend::BinaryType2Str(%i) - invalid type", type);

  48.     return nullptr;

  49. }

  50. 

  51. static inline

  52. const char* PluginType2Str(const PluginType& type)

  53. {

  54.     switch (type)

  55.     {

  56.     case PLUGIN_NONE:

  57.         return "PLUGIN_NONE";

  58.     case PLUGIN_INTERNAL:

  59.         return "PLUGIN_INTERNAL";

  60.     case PLUGIN_LADSPA:

  61.         return "PLUGIN_LADSPA";

  62.     case PLUGIN_DSSI:

  63.         return "PLUGIN_DSSI";

  64.     case PLUGIN_LV2:

  65.         return "PLUGIN_LV2";

  66.     case PLUGIN_VST:

  67.         return "PLUGIN_VST";

  68.     case PLUGIN_GIG:

  69.         return "PLUGIN_GIG";

  70.     case PLUGIN_SF2:

  71.         return "PLUGIN_SF2";

  72.     case PLUGIN_SFZ:

  73.         return "PLUGIN_SFZ";

  74.     }

  75. 

  76.     qWarning("CarlaBackend::PluginType2Str(%i) - invalid type", type);

  77.     return nullptr;

  78. }

  79. 

  80. static inline

  81. const char* PluginCategory2Str(const PluginCategory& category)

  82. {

  83.     switch (category)

  84.     {

  85.     case PLUGIN_CATEGORY_NONE:

  86.         return "PLUGIN_CATEGORY_NONE";

  87.     case PLUGIN_CATEGORY_SYNTH:

  88.         return "PLUGIN_CATEGORY_SYNTH";

  89.     case PLUGIN_CATEGORY_DELAY:

  90.         return "PLUGIN_CATEGORY_DELAY";

  91.     case PLUGIN_CATEGORY_EQ:

  92.         return "PLUGIN_CATEGORY_EQ";

  93.     case PLUGIN_CATEGORY_FILTER:

  94.         return "PLUGIN_CATEGORY_FILTER";

  95.     case PLUGIN_CATEGORY_DYNAMICS:

  96.         return "PLUGIN_CATEGORY_DYNAMICS";

  97.     case PLUGIN_CATEGORY_MODULATOR:

  98.         return "PLUGIN_CATEGORY_MODULATOR";

  99.     case PLUGIN_CATEGORY_UTILITY:

  100.         return "PLUGIN_CATEGORY_UTILITY";

  101.     case PLUGIN_CATEGORY_OTHER:

  102.         return "PLUGIN_CATEGORY_OTHER";

  103.     }

  104. 

  105.     qWarning("CarlaBackend::PluginCategory2Str(%i) - invalid category", category);

  106.     return nullptr;

  107. }

  108. 

  109. static inline

  110. const char* ParameterType2Str(const ParameterType& type)

  111. {

  112.     switch (type)

  113.     {

  114.     case PARAMETER_UNKNOWN:

  115.         return "PARAMETER_UNKNOWN";

  116.     case PARAMETER_INPUT:

  117.         return "PARAMETER_INPUT";

  118.     case PARAMETER_OUTPUT:

  119.         return "PARAMETER_OUTPUT";

  120.     case PARAMETER_LATENCY:

  121.         return "PARAMETER_LATENCY";

  122.     case PARAMETER_SAMPLE_RATE:

  123.         return "PARAMETER_SAMPLE_RATE";

  124.     case PARAMETER_LV2_FREEWHEEL:

  125.         return "PARAMETER_LV2_FREEWHEEL";

  126.     case PARAMETER_LV2_TIME:

  127.         return "PARAMETER_LV2_TIME";

  128.     }

  129. 

  130.     qWarning("CarlaBackend::ParameterType2Str(%i) - invalid type", type);

  131.     return nullptr;

  132. }

  133. 

  134. static inline

  135. const char* InternalParametersIndex2Str(const InternalParametersIndex& index)

  136. {

  137.     switch (index)

  138.     {

  139.     case PARAMETER_NULL:

  140.         return "PARAMETER_NULL";

  141.     case PARAMETER_ACTIVE:

  142.         return "PARAMETER_ACTIVE";

  143.     case PARAMETER_DRYWET:

  144.         return "PARAMETER_DRYWET";

  145.     case PARAMETER_VOLUME:

  146.         return "PARAMETER_VOLUME";

  147.     case PARAMETER_BALANCE_LEFT:

  148.         return "PARAMETER_BALANCE_LEFT";

  149.     case PARAMETER_BALANCE_RIGHT:

  150.         return "PARAMETER_BALANCE_RIGHT";

  151.     }

  152. 

  153.     qWarning("CarlaBackend::InternalParametersIndex2Str(%i) - invalid index", index);

  154.     return nullptr;

  155. }

  156. 

  157. static inline

  158. const char* CustomDataType2Str(const CustomDataType& type)

  159. {

  160.     switch (type)

  161.     {

  162.     case CUSTOM_DATA_INVALID:

  163.         return "CUSTOM_DATA_INVALID";

  164.     case CUSTOM_DATA_STRING:

  165.         return "CUSTOM_DATA_STRING";

  166.     case CUSTOM_DATA_PATH:

  167.         return "CUSTOM_DATA_PATH";

  168.     case CUSTOM_DATA_CHUNK:

  169.         return "CUSTOM_DATA_CHUNK";

  170.     case CUSTOM_DATA_BINARY:

  171.         return "CUSTOM_DATA_BINARY";

  172.     }

  173. 

  174.     qWarning("CarlaBackend::CustomDataType2Str(%i) - invalid type", type);

  175.     return nullptr;

  176. }

  177. 

  178. static inline

  179. const char* GuiType2Str(const GuiType& type)

  180. {

  181.     switch (type)

  182.     {

  183.     case GUI_NONE:

  184.         return "GUI_NONE";

  185.     case GUI_INTERNAL_QT4:

  186.         return "GUI_INTERNAL_QT4";

  187.     case GUI_INTERNAL_COCOA:

  188.         return "GUI_INTERNAL_COCOA";

  189.     case GUI_INTERNAL_HWND:

  190.         return "GUI_INTERNAL_HWND";

  191.     case GUI_INTERNAL_X11:

  192.         return "GUI_INTERNAL_X11";

  193.     case GUI_EXTERNAL_LV2:

  194.         return "GUI_EXTERNAL_LV2";

  195.     case GUI_EXTERNAL_SUIL:

  196.         return "GUI_EXTERNAL_SUIL";

  197.     case GUI_EXTERNAL_OSC:

  198.         return "GUI_EXTERNAL_OSC";

  199.     }

  200. 

  201.     qWarning("CarlaBackend::GuiType2Str(%i) - invalid type", type);

  202.     return nullptr;

  203. }

  204. 

  205. static inline

  206. const char* OptionsType2Str(const OptionsType& type)

  207. {

  208.     switch (type)

  209.     {

  210.     case OPTION_PROCESS_NAME:

  211.         return "OPTION_PROCESS_NAME";

  212.     case OPTION_PROCESS_MODE:

  213.         return "OPTION_PROCESS_MODE";

  214.     case OPTION_PROCESS_HIGH_PRECISION:

  215.         return "OPTION_PROCESS_HIGH_PRECISION";

  216.     case OPTION_MAX_PARAMETERS:

  217.         return "OPTION_MAX_PARAMETERS";

  218.     case OPTION_PREFERRED_BUFFER_SIZE:

  219.         return "OPTION_PREFERRED_BUFFER_SIZE";

  220.     case OPTION_PREFERRED_SAMPLE_RATE:

  221.         return "OPTION_PREFERRED_SAMPLE_RATE";

  222.     case OPTION_FORCE_STEREO:

  223.         return "OPTION_FORCE_STEREO";

  224.     case OPTION_USE_DSSI_VST_CHUNKS:

  225.         return "OPTION_USE_DSSI_VST_CHUNKS";

  226.     case OPTION_PREFER_PLUGIN_BRIDGES:

  227.         return "OPTION_PREFER_PLUGIN_BRIDGES";

  228.     case OPTION_PREFER_UI_BRIDGES:

  229.         return "OPTION_PREFER_UI_BRIDGES";

  230.     case OPTION_OSC_UI_TIMEOUT:

  231.         return "OPTION_OSC_UI_TIMEOUT";

  232.     case OPTION_PATH_LADSPA:

  233.         return "OPTION_PATH_LADSPA";

  234.     case OPTION_PATH_DSSI:

  235.         return "OPTION_PATH_DSSI";

  236.     case OPTION_PATH_LV2:

  237.         return "OPTION_PATH_LV2";

  238.     case OPTION_PATH_VST:

  239.         return "OPTION_PATH_VST";

  240.     case OPTION_PATH_GIG:

  241.         return "OPTION_PATH_GIG";

  242.     case OPTION_PATH_SF2:

  243.         return "OPTION_PATH_SF2";

  244.     case OPTION_PATH_SFZ:

  245.         return "OPTION_PATH_SFZ";

  246.     case OPTION_PATH_BRIDGE_POSIX32:

  247.         return "OPTION_PATH_BRIDGE_POSIX32";

  248.     case OPTION_PATH_BRIDGE_POSIX64:

  249.         return "OPTION_PATH_BRIDGE_POSIX64";

  250.     case OPTION_PATH_BRIDGE_WIN32:

  251.         return "OPTION_PATH_BRIDGE_WIN32";

  252.     case OPTION_PATH_BRIDGE_WIN64:

  253.         return "OPTION_PATH_BRIDGE_WIN64";

  254.     case OPTION_PATH_BRIDGE_LV2_GTK2:

  255.         return "OPTION_PATH_BRIDGE_LV2_GTK2";

  256.     case OPTION_PATH_BRIDGE_LV2_GTK3:

  257.         return "OPTION_PATH_BRIDGE_LV2_GTK3";

  258.     case OPTION_PATH_BRIDGE_LV2_QT4:

  259.         return "OPTION_PATH_BRIDGE_LV2_QT4";

  260.     case OPTION_PATH_BRIDGE_LV2_X11:

  261.         return "OPTION_PATH_BRIDGE_LV2_X11";

  262.     case OPTION_PATH_BRIDGE_VST_HWND:

  263.         return "OPTION_PATH_BRIDGE_VST_HWND";

  264.     case OPTION_PATH_BRIDGE_VST_X11:

  265.         return "OPTION_PATH_BRIDGE_VST_X11";

  266.     }

  267. 

  268.     qWarning("CarlaBackend::OptionsType2Str(%i) - invalid type", type);

  269.     return nullptr;

  270. }

  271. 

  272. static inline

  273. const char* CallbackType2Str(const CallbackType& type)

  274. {

  275.     switch (type)

  276.     {

  277.     case CALLBACK_DEBUG:

  278.         return "CALLBACK_DEBUG";

  279.     case CALLBACK_PARAMETER_VALUE_CHANGED:

  280.         return "CALLBACK_PARAMETER_VALUE_CHANGED";

  281.     case CALLBACK_PARAMETER_MIDI_CHANNEL_CHANGED:

  282.         return "CALLBACK_PARAMETER_MIDI_CHANNEL_CHANGED";

  283.     case CALLBACK_PARAMETER_MIDI_CC_CHANGED:

  284.         return "CALLBACK_PARAMETER_MIDI_CC_CHANGED";

  285.     case CALLBACK_PROGRAM_CHANGED:

  286.         return "CALLBACK_PROGRAM_CHANGED";

  287.     case CALLBACK_MIDI_PROGRAM_CHANGED:

  288.         return "CALLBACK_MIDI_PROGRAM_CHANGED";

  289.     case CALLBACK_NOTE_ON:

  290.         return "CALLBACK_NOTE_ON";

  291.     case CALLBACK_NOTE_OFF:

  292.         return "CALLBACK_NOTE_OFF";

  293.     case CALLBACK_SHOW_GUI:

  294.         return "CALLBACK_SHOW_GUI";

  295.     case CALLBACK_RESIZE_GUI:

  296.         return "CALLBACK_RESIZE_GUI";

  297.     case CALLBACK_UPDATE:

  298.         return "CALLBACK_UPDATE";

  299.     case CALLBACK_RELOAD_INFO:

  300.         return "CALLBACK_RELOAD_INFO";

  301.     case CALLBACK_RELOAD_PARAMETERS:

  302.         return "CALLBACK_RELOAD_PARAMETERS";

  303.     case CALLBACK_RELOAD_PROGRAMS:

  304.         return "CALLBACK_RELOAD_PROGRAMS";

  305.     case CALLBACK_RELOAD_ALL:

  306.         return "CALLBACK_RELOAD_ALL";

  307.     case CALLBACK_NSM_ANNOUNCE:

  308.         return "CALLBACK_NSM_ANNOUNCE";

  309.     case CALLBACK_NSM_OPEN1:

  310.         return "CALLBACK_NSM_OPEN1";

  311.     case CALLBACK_NSM_OPEN2:

  312.         return "CALLBACK_NSM_OPEN2";

  313.     case CALLBACK_NSM_SAVE:

  314.         return "CALLBACK_NSM_SAVE";

  315.     case CALLBACK_ERROR:

  316.         return "CALLBACK_ERROR";

  317.     case CALLBACK_QUIT:

  318.         return "CALLBACK_QUIT";

  319.     }

  320. 

  321.     qWarning("CarlaBackend::CallbackType2Str(%i) - invalid type", type);

  322.     return nullptr;

  323. }

  324. 

  325. static inline

  326. const char* ProcessMode2Str(const ProcessMode& mode)

  327. {

  328.     switch (mode)

  329.     {

  330.     case PROCESS_MODE_SINGLE_CLIENT:

  331.         return "PROCESS_MODE_SINGLE_CLIENT";

  332.     case PROCESS_MODE_MULTIPLE_CLIENTS:

  333.         return "PROCESS_MODE_MULTIPLE_CLIENTS";

  334.     case PROCESS_MODE_CONTINUOUS_RACK:

  335.         return "PROCESS_MODE_CONTINUOUS_RACK";

  336.     case PROCESS_MODE_PATCHBAY:

  337.         return "PROCESS_MODE_PATCHBAY";

  338.     }

  339. 

  340.     qWarning("CarlaBackend::ProcessModeType2Str(%i) - invalid type", mode);

  341.     return nullptr;

  342. }

  343. 

  344. // -------------------------------------------------------------------------------------------------------------------

  345. 

  346. static inline

  347. CustomDataType getCustomDataStringType(const char* const stype)

  348. {

  349.     qDebug("CarlaBackend::getCustomDataStringType(\"%s\")", stype);

  350.     CARLA_ASSERT(stype);

  351. 

  352.     if (! stype)

  353.         return CUSTOM_DATA_INVALID;

  354. 

  355.     if (strcmp(stype, "string") == 0)

  356.         return CUSTOM_DATA_STRING;

  357.     if (strcmp(stype, "path") == 0)

  358.         return CUSTOM_DATA_PATH;

  359.     if (strcmp(stype, "chunk") == 0)

  360.         return CUSTOM_DATA_CHUNK;

  361.     if (strcmp(stype, "binary") == 0)

  362.         return CUSTOM_DATA_BINARY;

  363. 

  364.     return CUSTOM_DATA_INVALID;

  365. }

  366. 

  367. static inline

  368. const char* getCustomDataTypeString(const CustomDataType& type)

  369. {

  370.     qDebug("CarlaBackend::getCustomDataTypeString(%s)", CustomDataType2Str(type));

  371. 

  372.     switch (type)

  373.     {

  374.     case CUSTOM_DATA_STRING:

  375.         return "string";

  376.     case CUSTOM_DATA_PATH:

  377.         return "path";

  378.     case CUSTOM_DATA_CHUNK:

  379.         return "chunk";

  380.     case CUSTOM_DATA_BINARY:

  381.         return "binary";

  382.     default:

  383.         return "invalid";

  384.     }

  385. }

  386. 

  387. static inline

  388. const char* getPluginTypeString(const PluginType& type)

  389. {

  390.     qDebug("CarlaBackend::getPluginTypeString(%s)", PluginType2Str(type));

  391. 

  392.     switch (type)

  393.     {

  394.     case PLUGIN_NONE:

  395.         return "NONE";

  396.     case PLUGIN_INTERNAL:

  397.         return "INTERNAL";

  398.     case PLUGIN_LADSPA:

  399.         return "LADSPA";

  400.     case PLUGIN_DSSI:

  401.         return "DSSI";

  402.     case PLUGIN_LV2:

  403.         return "LV2";

  404.     case PLUGIN_VST:

  405.         return "VST";

  406.     case PLUGIN_GIG:

  407.         return "GIG";

  408.     case PLUGIN_SF2:

  409.         return "SF2";

  410.     case PLUGIN_SFZ:

  411.         return "SFZ";

  412.     }

  413. 

  414.     return "NONE";

  415. }

  416. 

  417. // -------------------------------------------------------------------------------------------------------------------

  418. 

  419. static inline

  420. uintptr_t getAddressFromPointer(void* const ptr)

  421. {

  422.     qDebug("CarlaBackend::getAddressFromPointer(%p)", ptr);

  423.     CARLA_ASSERT(ptr != nullptr);

  424. 

  425.     uintptr_t* addr = (uintptr_t*)&ptr;

  426.     return *addr;

  427. }

  428. 

  429. static inline

  430. void* getPointerFromAddress(const uintptr_t& addr)

  431. {

  432.     qDebug("CarlaBackend::getPointerFromAddress(" P_UINTPTR ")", addr);

  433.     CARLA_ASSERT(addr != 0);

  434. 

  435.     uintptr_t** const ptr = (uintptr_t**)&addr;

  436.     return *ptr;

  437. }

  438. 

  439. static inline

  440. PluginCategory getPluginCategoryFromName(const char* const name)

  441. {

  442.     qDebug("CarlaBackend::getPluginCategoryFromName(\"%s\")", name);

  443.     CARLA_ASSERT(name);

  444. 

  445.     if (! name)

  446.         return PLUGIN_CATEGORY_NONE;

  447. 

  448.     CarlaString sname(name);

  449. 

  450.     if (sname.isEmpty())

  451.         return PLUGIN_CATEGORY_NONE;

  452. 

  453.     sname.toLower();

  454. 

  455.     // generic tags first

  456.     if (sname.contains("delay"))

  457.         return PLUGIN_CATEGORY_DELAY;

  458.     if (sname.contains("reverb"))

  459.         return PLUGIN_CATEGORY_DELAY;

  460. 

  461.     // filter

  462.     if (sname.contains("filter"))

  463.         return PLUGIN_CATEGORY_FILTER;

  464. 

  465.     // dynamics

  466.     if (sname.contains("dynamics"))

  467.         return PLUGIN_CATEGORY_DYNAMICS;

  468.     if (sname.contains("amplifier"))

  469.         return PLUGIN_CATEGORY_DYNAMICS;

  470.     if (sname.contains("compressor"))

  471.         return PLUGIN_CATEGORY_DYNAMICS;

  472.     if (sname.contains("enhancer"))

  473.         return PLUGIN_CATEGORY_DYNAMICS;

  474.     if (sname.contains("exciter"))

  475.         return PLUGIN_CATEGORY_DYNAMICS;

  476.     if (sname.contains("gate"))

  477.         return PLUGIN_CATEGORY_DYNAMICS;

  478.     if (sname.contains("limiter"))

  479.         return PLUGIN_CATEGORY_DYNAMICS;

  480. 

  481.     // modulator

  482.     if (sname.contains("modulator"))

  483.         return PLUGIN_CATEGORY_MODULATOR;

  484.     if (sname.contains("chorus"))

  485.         return PLUGIN_CATEGORY_MODULATOR;

  486.     if (sname.contains("flanger"))

  487.         return PLUGIN_CATEGORY_MODULATOR;

  488.     if (sname.contains("phaser"))

  489.         return PLUGIN_CATEGORY_MODULATOR;

  490.     if (sname.contains("saturator"))

  491.         return PLUGIN_CATEGORY_MODULATOR;

  492. 

  493.     // utility

  494.     if (sname.contains("utility"))

  495.         return PLUGIN_CATEGORY_UTILITY;

  496.     if (sname.contains("analyzer"))

  497.         return PLUGIN_CATEGORY_UTILITY;

  498.     if (sname.contains("converter"))

  499.         return PLUGIN_CATEGORY_UTILITY;

  500.     if (sname.contains("deesser"))

  501.         return PLUGIN_CATEGORY_UTILITY;

  502.     if (sname.contains("mixer"))

  503.         return PLUGIN_CATEGORY_UTILITY;

  504. 

  505.     // common tags

  506.     if (sname.contains("verb"))

  507.         return PLUGIN_CATEGORY_DELAY;

  508. 

  509.     if (sname.contains("eq"))

  510.         return PLUGIN_CATEGORY_EQ;

  511. 

  512.     if (sname.contains("tool"))

  513.         return PLUGIN_CATEGORY_UTILITY;

  514. 

  515.     return PLUGIN_CATEGORY_NONE;

  516. }

  517. 

  518. CARLA_BACKEND_END_NAMESPACE

  519. 

  520. #endif // CARLA_BACKEND_UTILS_HPP