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.
661 Commits
2 Branches
16MB
Tree: b2da053ebf
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b2da053ebf'
${ noResults }
Cadence/c++/carla-backend/carla_backend_utils.hpp

503 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. 

  23. #include <QtCore/QString>

  24. 

  25. CARLA_BACKEND_START_NAMESPACE

  26. 

  27. class CarlaEngine;

  28. class CarlaPlugin;

  29. 

  30. static inline

  31. const char* BinaryType2Str(const BinaryType type)

  32. {

  33.     switch (type)

  34.     {

  35.     case BINARY_NONE:

  36.         return "BINARY_NONE";

  37.     case BINARY_POSIX32:

  38.         return "BINARY_POSIX32";

  39.     case BINARY_POSIX64:

  40.         return "BINARY_POSIX64";

  41.     case BINARY_WIN32:

  42.         return "BINARY_WIN32";

  43.     case BINARY_WIN64:

  44.         return "BINARY_WIN64";

  45.     case BINARY_OTHER:

  46.         return "BINARY_OTHER";

  47.     }

  48. 

  49.     qWarning("CarlaBackend::BinaryType2str(%i) - invalid type", type);

  50.     return nullptr;

  51. }

  52. 

  53. static inline

  54. const char* PluginType2Str(const PluginType type)

  55. {

  56.     switch (type)

  57.     {

  58.     case PLUGIN_NONE:

  59.         return "PLUGIN_NONE";

  60.     case PLUGIN_INTERNAL:

  61.         return "PLUGIN_INTERNAL";

  62.     case PLUGIN_LADSPA:

  63.         return "PLUGIN_LADSPA";

  64.     case PLUGIN_DSSI:

  65.         return "PLUGIN_DSSI";

  66.     case PLUGIN_LV2:

  67.         return "PLUGIN_LV2";

  68.     case PLUGIN_VST:

  69.         return "PLUGIN_VST";

  70.     case PLUGIN_GIG:

  71.         return "PLUGIN_GIG";

  72.     case PLUGIN_SF2:

  73.         return "PLUGIN_SF2";

  74.     case PLUGIN_SFZ:

  75.         return "PLUGIN_SFZ";

  76.     }

  77. 

  78.     qWarning("CarlaBackend::PluginType2str(%i) - invalid type", type);

  79.     return nullptr;

  80. }

  81. 

  82. static inline

  83. const char* PluginCategory2Str(const PluginCategory category)

  84. {

  85.     switch (category)

  86.     {

  87.     case PLUGIN_CATEGORY_NONE:

  88.         return "PLUGIN_CATEGORY_NONE";

  89.     case PLUGIN_CATEGORY_SYNTH:

  90.         return "PLUGIN_CATEGORY_SYNTH";

  91.     case PLUGIN_CATEGORY_DELAY:

  92.         return "PLUGIN_CATEGORY_DELAY";

  93.     case PLUGIN_CATEGORY_EQ:

  94.         return "PLUGIN_CATEGORY_EQ";

  95.     case PLUGIN_CATEGORY_FILTER:

  96.         return "PLUGIN_CATEGORY_FILTER";

  97.     case PLUGIN_CATEGORY_DYNAMICS:

  98.         return "PLUGIN_CATEGORY_DYNAMICS";

  99.     case PLUGIN_CATEGORY_MODULATOR:

  100.         return "PLUGIN_CATEGORY_MODULATOR";

  101.     case PLUGIN_CATEGORY_UTILITY:

  102.         return "PLUGIN_CATEGORY_UTILITY";

  103.     case PLUGIN_CATEGORY_OTHER:

  104.         return "PLUGIN_CATEGORY_OTHER";

  105.     }

  106. 

  107.     qWarning("CarlaBackend::PluginCategory2str(%i) - invalid category", category);

  108.     return nullptr;

  109. }

  110. 

  111. static inline

  112. const char* ParameterType2Str(const ParameterType type)

  113. {

  114.     switch (type)

  115.     {

  116.     case PARAMETER_UNKNOWN:

  117.         return "PARAMETER_UNKNOWN";

  118.     case PARAMETER_INPUT:

  119.         return "PARAMETER_INPUT";

  120.     case PARAMETER_OUTPUT:

  121.         return "PARAMETER_OUTPUT";

  122.     case PARAMETER_LATENCY:

  123.         return "PARAMETER_LATENCY";

  124.     case PARAMETER_SAMPLE_RATE:

  125.         return "PARAMETER_SAMPLE_RATE";

  126.     case PARAMETER_LV2_FREEWHEEL:

  127.         return "PARAMETER_LV2_FREEWHEEL";

  128.     case PARAMETER_LV2_TIME:

  129.         return "PARAMETER_LV2_TIME";

  130.     }

  131. 

  132.     qWarning("CarlaBackend::ParameterType2str(%i) - invalid type", type);

  133.     return nullptr;

  134. }

  135. 

  136. static inline

  137. const char* InternalParametersIndex2Str(const InternalParametersIndex index)

  138. {

  139.     switch (index)

  140.     {

  141.     case PARAMETER_NULL:

  142.         return "PARAMETER_NULL";

  143.     case PARAMETER_ACTIVE:

  144.         return "PARAMETER_ACTIVE";

  145.     case PARAMETER_DRYWET:

  146.         return "PARAMETER_DRYWET";

  147.     case PARAMETER_VOLUME:

  148.         return "PARAMETER_VOLUME";

  149.     case PARAMETER_BALANCE_LEFT:

  150.         return "PARAMETER_BALANCE_LEFT";

  151.     case PARAMETER_BALANCE_RIGHT:

  152.         return "PARAMETER_BALANCE_RIGHT";

  153.     }

  154. 

  155.     qWarning("CarlaBackend::InternalParametersIndex2str(%i) - invalid index", index);

  156.     return nullptr;

  157. }

  158. 

  159. static inline

  160. const char* CustomDataType2Str(const CustomDataType type)

  161. {

  162.     switch (type)

  163.     {

  164.     case CUSTOM_DATA_INVALID:

  165.         return "CUSTOM_DATA_INVALID";

  166.     case CUSTOM_DATA_STRING:

  167.         return "CUSTOM_DATA_STRING";

  168.     case CUSTOM_DATA_PATH:

  169.         return "CUSTOM_DATA_PATH";

  170.     case CUSTOM_DATA_CHUNK:

  171.         return "CUSTOM_DATA_CHUNK";

  172.     case CUSTOM_DATA_BINARY:

  173.         return "CUSTOM_DATA_BINARY";

  174.     }

  175. 

  176.     qWarning("CarlaBackend::CustomDataType2str(%i) - invalid type", type);

  177.     return nullptr;

  178. }

  179. 

  180. static inline

  181. const char* GuiType2Str(const GuiType type)

  182. {

  183.     switch (type)

  184.     {

  185.     case GUI_NONE:

  186.         return "GUI_NONE";

  187.     case GUI_INTERNAL_QT4:

  188.         return "GUI_INTERNAL_QT4";

  189.     case GUI_INTERNAL_COCOA:

  190.         return "GUI_INTERNAL_COCOA";

  191.     case GUI_INTERNAL_HWND:

  192.         return "GUI_INTERNAL_HWND";

  193.     case GUI_INTERNAL_X11:

  194.         return "GUI_INTERNAL_X11";

  195.     case GUI_EXTERNAL_LV2:

  196.         return "GUI_EXTERNAL_LV2";

  197.     case GUI_EXTERNAL_SUIL:

  198.         return "GUI_EXTERNAL_SUIL";

  199.     case GUI_EXTERNAL_OSC:

  200.         return "GUI_EXTERNAL_OSC";

  201.     }

  202. 

  203.     qWarning("CarlaBackend::GuiType2str(%i) - invalid type", type);

  204.     return nullptr;

  205. }

  206. 

  207. static inline

  208. const char* OptionsType2Str(const OptionsType type)

  209. {

  210.     switch (type)

  211.     {

  212.     case OPTION_PROCESS_NAME:

  213.         return "OPTION_PROCESS_NAME";

  214.     case OPTION_PROCESS_MODE:

  215.         return "OPTION_PROCESS_MODE";

  216.     case OPTION_PROCESS_HIGH_PRECISION:

  217.         return "OPTION_PROCESS_HIGH_PRECISION";

  218.     case OPTION_MAX_PARAMETERS:

  219.         return "OPTION_MAX_PARAMETERS";

  220.     case OPTION_PREFERRED_BUFFER_SIZE:

  221.         return "OPTION_PREFERRED_BUFFER_SIZE";

  222.     case OPTION_PREFERRED_SAMPLE_RATE:

  223.         return "OPTION_PREFERRED_SAMPLE_RATE";

  224.     case OPTION_FORCE_STEREO:

  225.         return "OPTION_FORCE_STEREO";

  226.     case OPTION_USE_DSSI_VST_CHUNKS:

  227.         return "OPTION_USE_DSSI_VST_CHUNKS";

  228.     case OPTION_PREFER_PLUGIN_BRIDGES:

  229.         return "OPTION_PREFER_PLUGIN_BRIDGES";

  230.     case OPTION_PREFER_UI_BRIDGES:

  231.         return "OPTION_PREFER_UI_BRIDGES";

  232.     case OPTION_OSC_UI_TIMEOUT:

  233.         return "OPTION_OSC_UI_TIMEOUT";

  234.     case OPTION_PATH_LADSPA:

  235.         return "OPTION_PATH_LADSPA";

  236.     case OPTION_PATH_DSSI:

  237.         return "OPTION_PATH_DSSI";

  238.     case OPTION_PATH_LV2:

  239.         return "OPTION_PATH_LV2";

  240.     case OPTION_PATH_VST:

  241.         return "OPTION_PATH_VST";

  242.     case OPTION_PATH_GIG:

  243.         return "OPTION_PATH_GIG";

  244.     case OPTION_PATH_SF2:

  245.         return "OPTION_PATH_SF2";

  246.     case OPTION_PATH_SFZ:

  247.         return "OPTION_PATH_SFZ";

  248.     case OPTION_PATH_BRIDGE_POSIX32:

  249.         return "OPTION_PATH_BRIDGE_POSIX32";

  250.     case OPTION_PATH_BRIDGE_POSIX64:

  251.         return "OPTION_PATH_BRIDGE_POSIX64";

  252.     case OPTION_PATH_BRIDGE_WIN32:

  253.         return "OPTION_PATH_BRIDGE_WIN32";

  254.     case OPTION_PATH_BRIDGE_WIN64:

  255.         return "OPTION_PATH_BRIDGE_WIN64";

  256.     case OPTION_PATH_BRIDGE_LV2_GTK2:

  257.         return "OPTION_PATH_BRIDGE_LV2_GTK2";

  258.     case OPTION_PATH_BRIDGE_LV2_GTK3:

  259.         return "OPTION_PATH_BRIDGE_LV2_GTK3";

  260.     case OPTION_PATH_BRIDGE_LV2_QT4:

  261.         return "OPTION_PATH_BRIDGE_LV2_QT4";

  262.     case OPTION_PATH_BRIDGE_LV2_X11:

  263.         return "OPTION_PATH_BRIDGE_LV2_X11";

  264.     case OPTION_PATH_BRIDGE_VST_HWND:

  265.         return "OPTION_PATH_BRIDGE_VST_HWND";

  266.     case OPTION_PATH_BRIDGE_VST_X11:

  267.         return "OPTION_PATH_BRIDGE_VST_X11";

  268.     }

  269. 

  270.     qWarning("CarlaBackend::OptionsType2str(%i) - invalid type", type);

  271.     return nullptr;

  272. }

  273. 

  274. static inline

  275. const char* CallbackType2Str(const CallbackType type)

  276. {

  277.     switch (type)

  278.     {

  279.     case CALLBACK_DEBUG:

  280.         return "CALLBACK_DEBUG";

  281.     case CALLBACK_PARAMETER_VALUE_CHANGED:

  282.         return "CALLBACK_PARAMETER_VALUE_CHANGED";

  283.     case CALLBACK_PARAMETER_MIDI_CHANNEL_CHANGED:

  284.         return "CALLBACK_PARAMETER_MIDI_CHANNEL_CHANGED";

  285.     case CALLBACK_PARAMETER_MIDI_CC_CHANGED:

  286.         return "CALLBACK_PARAMETER_MIDI_CC_CHANGED";

  287.     case CALLBACK_PROGRAM_CHANGED:

  288.         return "CALLBACK_PROGRAM_CHANGED";

  289.     case CALLBACK_MIDI_PROGRAM_CHANGED:

  290.         return "CALLBACK_MIDI_PROGRAM_CHANGED";

  291.     case CALLBACK_NOTE_ON:

  292.         return "CALLBACK_NOTE_ON";

  293.     case CALLBACK_NOTE_OFF:

  294.         return "CALLBACK_NOTE_OFF";

  295.     case CALLBACK_SHOW_GUI:

  296.         return "CALLBACK_SHOW_GUI";

  297.     case CALLBACK_RESIZE_GUI:

  298.         return "CALLBACK_RESIZE_GUI";

  299.     case CALLBACK_UPDATE:

  300.         return "CALLBACK_UPDATE";

  301.     case CALLBACK_RELOAD_INFO:

  302.         return "CALLBACK_RELOAD_INFO";

  303.     case CALLBACK_RELOAD_PARAMETERS:

  304.         return "CALLBACK_RELOAD_PARAMETERS";

  305.     case CALLBACK_RELOAD_PROGRAMS:

  306.         return "CALLBACK_RELOAD_PROGRAMS";

  307.     case CALLBACK_RELOAD_ALL:

  308.         return "CALLBACK_RELOAD_ALL";

  309.     case CALLBACK_NSM_ANNOUNCE:

  310.         return "CALLBACK_NSM_ANNOUNCE";

  311.     case CALLBACK_NSM_OPEN1:

  312.         return "CALLBACK_NSM_OPEN1";

  313.     case CALLBACK_NSM_OPEN2:

  314.         return "CALLBACK_NSM_OPEN2";

  315.     case CALLBACK_NSM_SAVE:

  316.         return "CALLBACK_NSM_SAVE";

  317.     case CALLBACK_ERROR:

  318.         return "CALLBACK_ERROR";

  319.     case CALLBACK_QUIT:

  320.         return "CALLBACK_QUIT";

  321.     }

  322. 

  323.     qWarning("CarlaBackend::CallbackType2str(%i) - invalid type", type);

  324.     return nullptr;

  325. }

  326. 

  327. static inline

  328. const char* ProcessModeType2Str(const ProcessModeType type)

  329. {

  330.     switch (type)

  331.     {

  332.     case PROCESS_MODE_SINGLE_CLIENT:

  333.         return "PROCESS_MODE_SINGLE_CLIENT";

  334.     case PROCESS_MODE_MULTIPLE_CLIENTS:

  335.         return "PROCESS_MODE_MULTIPLE_CLIENTS";

  336.     case PROCESS_MODE_CONTINUOUS_RACK:

  337.         return "PROCESS_MODE_CONTINUOUS_RACK";

  338.     }

  339. 

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

  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. 

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

  352.         return CUSTOM_DATA_STRING;

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

  354.         return CUSTOM_DATA_PATH;

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

  356.         return CUSTOM_DATA_CHUNK;

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

  358.         return CUSTOM_DATA_BINARY;

  359.     return CUSTOM_DATA_INVALID;

  360. }

  361. 

  362. static inline

  363. const char* getCustomDataTypeString(const CustomDataType type)

  364. {

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

  366. 

  367.     switch (type)

  368.     {

  369.     case CUSTOM_DATA_STRING:

  370.         return "string";

  371.     case CUSTOM_DATA_PATH:

  372.         return "path";

  373.     case CUSTOM_DATA_CHUNK:

  374.         return "chunk";

  375.     case CUSTOM_DATA_BINARY:

  376.         return "binary";

  377.     default:

  378.         return "invalid";

  379.     }

  380. }

  381. 

  382. static inline

  383. const char* getPluginTypeString(const PluginType type)

  384. {

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

  386. 

  387.     switch (type)

  388.     {

  389.     case PLUGIN_NONE:

  390.         return "NONE";

  391.     case PLUGIN_INTERNAL:

  392.         return "INTERNAL";

  393.     case PLUGIN_LADSPA:

  394.         return "LADSPA";

  395.     case PLUGIN_DSSI:

  396.         return "DSSI";

  397.     case PLUGIN_LV2:

  398.         return "LV2";

  399.     case PLUGIN_VST:

  400.         return "VST";

  401.     case PLUGIN_GIG:

  402.         return "GIG";

  403.     case PLUGIN_SF2:

  404.         return "SF2";

  405.     case PLUGIN_SFZ:

  406.         return "SFZ";

  407.     }

  408. 

  409.     return "NONE";

  410. }

  411. 

  412. // -------------------------------------------------------------------------------------------------------------------

  413. 

  414. static inline

  415. void* getPointer(const uintptr_t addr)

  416. {

  417.     CARLA_ASSERT(addr != 0);

  418.     qDebug("CarlaBackend::getPointer(" P_UINTPTR ")", addr);

  419. 

  420.     uintptr_t* const ptr = (uintptr_t*)addr;

  421.     return (void*)ptr;

  422. }

  423. 

  424. static inline

  425. PluginCategory getPluginCategoryFromName(const char* const name)

  426. {

  427.     CARLA_ASSERT(name);

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

  429. 

  430.     QString qname(name);

  431. 

  432.     if (qname.isEmpty())

  433.         return PLUGIN_CATEGORY_NONE;

  434. 

  435.     qname = qname.toLower();

  436. 

  437.     // generic tags first

  438.     if (qname.contains("delay", Qt::CaseSensitive))

  439.         return PLUGIN_CATEGORY_DELAY;

  440.     if (qname.contains("reverb", Qt::CaseSensitive))

  441.         return PLUGIN_CATEGORY_DELAY;

  442. 

  443.     // filter

  444.     if (qname.contains("filter", Qt::CaseSensitive))

  445.         return PLUGIN_CATEGORY_FILTER;

  446. 

  447.     // dynamics

  448.     if (qname.contains("dynamics", Qt::CaseSensitive))

  449.         return PLUGIN_CATEGORY_DYNAMICS;

  450.     if (qname.contains("amplifier", Qt::CaseSensitive))

  451.         return PLUGIN_CATEGORY_DYNAMICS;

  452.     if (qname.contains("compressor", Qt::CaseSensitive))

  453.         return PLUGIN_CATEGORY_DYNAMICS;

  454.     if (qname.contains("enhancer", Qt::CaseSensitive))

  455.         return PLUGIN_CATEGORY_DYNAMICS;

  456.     if (qname.contains("exciter", Qt::CaseSensitive))

  457.         return PLUGIN_CATEGORY_DYNAMICS;

  458.     if (qname.contains("gate", Qt::CaseSensitive))

  459.         return PLUGIN_CATEGORY_DYNAMICS;

  460.     if (qname.contains("limiter", Qt::CaseSensitive))

  461.         return PLUGIN_CATEGORY_DYNAMICS;

  462. 

  463.     // modulator

  464.     if (qname.contains("modulator", Qt::CaseSensitive))

  465.         return PLUGIN_CATEGORY_MODULATOR;

  466.     if (qname.contains("chorus", Qt::CaseSensitive))

  467.         return PLUGIN_CATEGORY_MODULATOR;

  468.     if (qname.contains("flanger", Qt::CaseSensitive))

  469.         return PLUGIN_CATEGORY_MODULATOR;

  470.     if (qname.contains("phaser", Qt::CaseSensitive))

  471.         return PLUGIN_CATEGORY_MODULATOR;

  472.     if (qname.contains("saturator", Qt::CaseSensitive))

  473.         return PLUGIN_CATEGORY_MODULATOR;

  474. 

  475.     // unitily

  476.     if (qname.contains("utility", Qt::CaseSensitive))

  477.         return PLUGIN_CATEGORY_UTILITY;

  478.     if (qname.contains("analyzer", Qt::CaseSensitive))

  479.         return PLUGIN_CATEGORY_UTILITY;

  480.     if (qname.contains("converter", Qt::CaseSensitive))

  481.         return PLUGIN_CATEGORY_UTILITY;

  482.     if (qname.contains("deesser", Qt::CaseSensitive))

  483.         return PLUGIN_CATEGORY_UTILITY;

  484.     if (qname.contains("mixer", Qt::CaseSensitive))

  485.         return PLUGIN_CATEGORY_UTILITY;

  486. 

  487.     // common tags

  488.     if (qname.contains("verb", Qt::CaseSensitive))

  489.         return PLUGIN_CATEGORY_DELAY;

  490. 

  491.     if (qname.contains("eq", Qt::CaseSensitive))

  492.         return PLUGIN_CATEGORY_EQ;

  493. 

  494.     if (qname.contains("tool", Qt::CaseSensitive))

  495.         return PLUGIN_CATEGORY_UTILITY;

  496. 

  497.     return PLUGIN_CATEGORY_NONE;

  498. }

  499. 

  500. CARLA_BACKEND_END_NAMESPACE

  501. 

  502. #endif // CARLA_BACKEND_UTILS_HPP