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.
340 Commits
2 Branches
131MB
Tree: 8265ff638f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '8265ff638f'
${ noResults }
Cadence/c++/carla-backend/carla_shared.cpp

587 lines
17KB
Raw Blame History 

  1. /*

  2.  * Carla Backend

  3.  * Copyright (C) 2011-2012 Filipe Coelho <falktx@gmail.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. #include "carla_shared.h"

  19. 

  20. #include <cassert>

  21. #include <QtCore/QString>

  22. 

  23. CARLA_BACKEND_START_NAMESPACE

  24. 

  25. #if 0

  26. } /* adjust editor indent */

  27. #endif

  28. 

  29. static const char* carlaLastError = nullptr;

  30. 

  31. #ifndef BUILD_BRIDGE

  32. // Global options

  33. carla_options_t carlaOptions;

  34. #endif

  35. 

  36. // -------------------------------------------------------------------------------------------------------------------

  37. 

  38. const char* BinaryType2str(const BinaryType type)

  39. {

  40.     switch (type)

  41.     {

  42.     case BINARY_NONE:

  43.         return "BINARY_NONE";

  44.     case BINARY_UNIX32:

  45.         return "BINARY_UNIX32";

  46.     case BINARY_UNIX64:

  47.         return "BINARY_UNIX64";

  48.     case BINARY_WIN32:

  49.         return "BINARY_WIN32";

  50.     case BINARY_WIN64:

  51.         return "BINARY_WIN64";

  52.     }

  53. 

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

  55.     return nullptr;

  56. }

  57. 

  58. const char* PluginType2str(const PluginType type)

  59. {

  60.     switch (type)

  61.     {

  62.     case PLUGIN_NONE:

  63.         return "PLUGIN_NONE";

  64.     case PLUGIN_LADSPA:

  65.         return "PLUGIN_LADSPA";

  66.     case PLUGIN_DSSI:

  67.         return "PLUGIN_DSSI";

  68.     case PLUGIN_LV2:

  69.         return "PLUGIN_LV2";

  70.     case PLUGIN_VST:

  71.         return "PLUGIN_VST";

  72.     case PLUGIN_GIG:

  73.         return "PLUGIN_GIG";

  74.     case PLUGIN_SF2:

  75.         return "PLUGIN_SF2";

  76.     case PLUGIN_SFZ:

  77.         return "PLUGIN_SFZ";

  78.     }

  79. 

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

  81.     return nullptr;

  82. }

  83. 

  84. const char* PluginCategory2str(const PluginCategory category)

  85. {

  86.     switch (category)

  87.     {

  88.     case PLUGIN_CATEGORY_NONE:

  89.         return "PLUGIN_CATEGORY_NONE";

  90.     case PLUGIN_CATEGORY_SYNTH:

  91.         return "PLUGIN_CATEGORY_SYNTH";

  92.     case PLUGIN_CATEGORY_DELAY:

  93.         return "PLUGIN_CATEGORY_DELAY";

  94.     case PLUGIN_CATEGORY_EQ:

  95.         return "PLUGIN_CATEGORY_EQ";

  96.     case PLUGIN_CATEGORY_FILTER:

  97.         return "PLUGIN_CATEGORY_FILTER";

  98.     case PLUGIN_CATEGORY_DYNAMICS:

  99.         return "PLUGIN_CATEGORY_DYNAMICS";

  100.     case PLUGIN_CATEGORY_MODULATOR:

  101.         return "PLUGIN_CATEGORY_MODULATOR";

  102.     case PLUGIN_CATEGORY_UTILITY:

  103.         return "PLUGIN_CATEGORY_UTILITY";

  104.     case PLUGIN_CATEGORY_OTHER:

  105.         return "PLUGIN_CATEGORY_OTHER";

  106.     }

  107. 

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

  109.     return nullptr;

  110. }

  111. 

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

  125. 

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

  127.     return nullptr;

  128. }

  129. 

  130. const char* InternalParametersIndex2str(const InternalParametersIndex index)

  131. {

  132.     switch (index)

  133.     {

  134.     case PARAMETER_ACTIVE:

  135.         return "PARAMETER_ACTIVE";

  136.     case PARAMETER_DRYWET:

  137.         return "PARAMETER_DRYWET";

  138.     case PARAMETER_VOLUME:

  139.         return "PARAMETER_VOLUME";

  140.     case PARAMETER_BALANCE_LEFT:

  141.         return "PARAMETER_BALANCE_LEFT";

  142.     case PARAMETER_BALANCE_RIGHT:

  143.         return "PARAMETER_BALANCE_RIGHT";

  144.     }

  145. 

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

  147.     return nullptr;

  148. }

  149. 

  150. const char* CustomDataType2str(const CustomDataType type)

  151. {

  152.     switch (type)

  153.     {

  154.     case CUSTOM_DATA_INVALID:

  155.         return "CUSTOM_DATA_INVALID";

  156.     case CUSTOM_DATA_STRING:

  157.         return "CUSTOM_DATA_STRING";

  158.     case CUSTOM_DATA_PATH:

  159.         return "CUSTOM_DATA_PATH";

  160.     case CUSTOM_DATA_CHUNK:

  161.         return "CUSTOM_DATA_CHUNK";

  162.     case CUSTOM_DATA_BINARY:

  163.         return "CUSTOM_DATA_BINARY";

  164.     }

  165. 

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

  167.     return nullptr;

  168. }

  169. 

  170. const char* GuiType2str(const GuiType type)

  171. {

  172.     switch (type)

  173.     {

  174.     case GUI_NONE:

  175.         return "GUI_NONE";

  176.     case GUI_INTERNAL_QT4:

  177.         return "GUI_INTERNAL_QT4";

  178.     case GUI_INTERNAL_COCOA:

  179.         return "GUI_INTERNAL_COCOA";

  180.     case GUI_INTERNAL_HWND:

  181.         return "GUI_INTERNAL_HWND";

  182.     case GUI_INTERNAL_X11:

  183.         return "GUI_INTERNAL_X11";

  184.     case GUI_EXTERNAL_LV2:

  185.         return "GUI_EXTERNAL_LV2";

  186.     case GUI_EXTERNAL_SUIL:

  187.         return "GUI_EXTERNAL_SUIL";

  188.     case GUI_EXTERNAL_OSC:

  189.         return "GUI_EXTERNAL_OSC";

  190.     }

  191. 

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

  193.     return nullptr;

  194. }

  195. 

  196. const char* OptionsType2str(const OptionsType type)

  197. {

  198.     switch (type)

  199.     {

  200.     case OPTION_PROCESS_MODE:

  201.         return "OPTION_PROCESS_MODE";

  202.     case OPTION_MAX_PARAMETERS:

  203.         return "OPTION_MAX_PARAMETERS";

  204.     case OPTION_PREFER_UI_BRIDGES:

  205.         return "OPTION_PREFER_UI_BRIDGES";

  206.     case OPTION_FORCE_STEREO:

  207.         return "OPTION_FORCE_STEREO";

  208.     case OPTION_PROCESS_HIGH_PRECISION:

  209.         return "OPTION_PROCESS_HIGH_PRECISION";

  210.     case OPTION_OSC_GUI_TIMEOUT:

  211.         return "OPTION_OSC_GUI_TIMEOUT";

  212.     case OPTION_USE_DSSI_CHUNKS:

  213.         return "OPTION_USE_DSSI_CHUNKS";

  214.     case OPTION_PATH_LADSPA:

  215.         return "OPTION_PATH_LADSPA";

  216.     case OPTION_PATH_DSSI:

  217.         return "OPTION_PATH_DSSI";

  218.     case OPTION_PATH_LV2:

  219.         return "OPTION_PATH_LV2";

  220.     case OPTION_PATH_VST:

  221.         return "OPTION_PATH_VST";

  222.     case OPTION_PATH_GIG:

  223.         return "OPTION_PATH_GIG";

  224.     case OPTION_PATH_SF2:

  225.         return "OPTION_PATH_SF2";

  226.     case OPTION_PATH_SFZ:

  227.         return "OPTION_PATH_SFZ";

  228.     case OPTION_PATH_BRIDGE_UNIX32:

  229.         return "OPTION_PATH_BRIDGE_UNIX32";

  230.     case OPTION_PATH_BRIDGE_UNIX64:

  231.         return "OPTION_PATH_BRIDGE_UNIX64";

  232.     case OPTION_PATH_BRIDGE_WIN32:

  233.         return "OPTION_PATH_BRIDGE_WIN32";

  234.     case OPTION_PATH_BRIDGE_WIN64:

  235.         return "OPTION_PATH_BRIDGE_WIN64";

  236.     case OPTION_PATH_BRIDGE_LV2_GTK2:

  237.         return "OPTION_PATH_BRIDGE_LV2_GTK2";

  238.     case OPTION_PATH_BRIDGE_LV2_QT4:

  239.         return "OPTION_PATH_BRIDGE_LV2_QT4";

  240.     case OPTION_PATH_BRIDGE_LV2_X11:

  241.         return "OPTION_PATH_BRIDGE_LV2_X11";

  242.     case OPTION_PATH_BRIDGE_VST_X11:

  243.         return "OPTION_PATH_BRIDGE_VST_X11";

  244.     }

  245. 

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

  247.     return nullptr;

  248. }

  249. 

  250. const char* CallbackType2str(const CallbackType type)

  251. {

  252.     switch (type)

  253.     {

  254.     case CALLBACK_DEBUG:

  255.         return "CALLBACK_DEBUG";

  256.     case CALLBACK_PARAMETER_CHANGED:

  257.         return "CALLBACK_PARAMETER_CHANGED";

  258.     case CALLBACK_PROGRAM_CHANGED:

  259.         return "CALLBACK_PROGRAM_CHANGED";

  260.     case CALLBACK_MIDI_PROGRAM_CHANGED:

  261.         return "CALLBACK_MIDI_PROGRAM_CHANGED";

  262.     case CALLBACK_NOTE_ON:

  263.         return "CALLBACK_NOTE_ON";

  264.     case CALLBACK_NOTE_OFF:

  265.         return "CALLBACK_NOTE_OFF";

  266.     case CALLBACK_SHOW_GUI:

  267.         return "CALLBACK_SHOW_GUI";

  268.     case CALLBACK_RESIZE_GUI:

  269.         return "CALLBACK_RESIZE_GUI";

  270.     case CALLBACK_UPDATE:

  271.         return "CALLBACK_UPDATE";

  272.     case CALLBACK_RELOAD_INFO:

  273.         return "CALLBACK_RELOAD_INFO";

  274.     case CALLBACK_RELOAD_PARAMETERS:

  275.         return "CALLBACK_RELOAD_PARAMETERS";

  276.     case CALLBACK_RELOAD_PROGRAMS:

  277.         return "CALLBACK_RELOAD_PROGRAMS";

  278.     case CALLBACK_RELOAD_ALL:

  279.         return "CALLBACK_RELOAD_ALL";

  280.     case CALLBACK_QUIT:

  281.         return "CALLBACK_QUIT";

  282.     }

  283. 

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

  285.     return nullptr;

  286. }

  287. 

  288. const char* ProcessModeType2str(const ProcessModeType type)

  289. {

  290.     switch (type)

  291.     {

  292.     case PROCESS_MODE_SINGLE_CLIENT:

  293.         return "PROCESS_MODE_SINGLE_CLIENT";

  294.     case PROCESS_MODE_MULTIPLE_CLIENTS:

  295.         return "PROCESS_MODE_MULTIPLE_CLIENTS";

  296.     case PROCESS_MODE_CONTINUOUS_RACK:

  297.         return "PROCESS_MODE_CONTINUOUS_RACK";

  298.     }

  299. 

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

  301.     return nullptr;

  302. }

  303. 

  304. // -------------------------------------------------------------------------------------------------------------------

  305. 

  306. CustomDataType getCustomDataStringType(const char* const stype)

  307. {

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

  309. 

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

  311.         return CUSTOM_DATA_STRING;

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

  313.         return CUSTOM_DATA_PATH;

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

  315.         return CUSTOM_DATA_CHUNK;

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

  317.         return CUSTOM_DATA_BINARY;

  318.     return CUSTOM_DATA_INVALID;

  319. }

  320. 

  321. const char* getCustomDataTypeString(const CustomDataType type)

  322. {

  323.     qDebug("CarlaBackend::getCustomDataTypeString(%s)", CustomDataType2str(type));

  324. 

  325.     switch (type)

  326.     {

  327.     case CUSTOM_DATA_STRING:

  328.         return "string";

  329.     case CUSTOM_DATA_PATH:

  330.         return "path";

  331.     case CUSTOM_DATA_CHUNK:

  332.         return "chunk";

  333.     case CUSTOM_DATA_BINARY:

  334.         return "binary";

  335.     default:

  336.         return "invalid";

  337.     }

  338. }

  339. 

  340. const char* getBinaryBidgePath(const BinaryType type)

  341. {

  342.     qDebug("CarlaBackend::getBinaryBidgePath(%s)", BinaryType2str(type));

  343. 

  344.     switch (type)

  345.     {

  346. #ifndef BUILD_BRIDGE

  347.     case BINARY_UNIX32:

  348.         return carlaOptions.bridge_unix32;

  349.     case BINARY_UNIX64:

  350.         return carlaOptions.bridge_unix64;

  351.     case BINARY_WIN32:

  352.         return carlaOptions.bridge_win32;

  353.     case BINARY_WIN64:

  354.         return carlaOptions.bridge_win64;

  355. #endif

  356.     default:

  357.         return nullptr;

  358.     }

  359. }

  360. 

  361. // -------------------------------------------------------------------------------------------------------------------

  362. 

  363. void* getPointer(const quintptr addr)

  364. {

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

  366. 

  367.     quintptr* const ptr = (quintptr*)addr;

  368.     return (void*)ptr;

  369. }

  370. 

  371. PluginCategory getPluginCategoryFromName(const char* const name)

  372. {

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

  374.     assert(name);

  375. 

  376.     QString qname(name);

  377. 

  378.     if (qname.isEmpty())

  379.         return PLUGIN_CATEGORY_NONE;

  380. 

  381.     qname = qname.toLower();

  382. 

  383.     // generic tags first

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

  385.         return PLUGIN_CATEGORY_DELAY;

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

  387.         return PLUGIN_CATEGORY_DELAY;

  388. 

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

  390.         return PLUGIN_CATEGORY_FILTER;

  391. 

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

  393.         return PLUGIN_CATEGORY_DYNAMICS;

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

  395.         return PLUGIN_CATEGORY_DYNAMICS;

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

  397.         return PLUGIN_CATEGORY_DYNAMICS;

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

  399.         return PLUGIN_CATEGORY_DYNAMICS;

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

  401.         return PLUGIN_CATEGORY_DYNAMICS;

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

  403.         return PLUGIN_CATEGORY_DYNAMICS;

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

  405.         return PLUGIN_CATEGORY_DYNAMICS;

  406. 

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

  408.         return PLUGIN_CATEGORY_MODULATOR;

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

  410.         return PLUGIN_CATEGORY_MODULATOR;

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

  412.         return PLUGIN_CATEGORY_MODULATOR;

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

  414.         return PLUGIN_CATEGORY_MODULATOR;

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

  416.         return PLUGIN_CATEGORY_MODULATOR;

  417. 

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

  419.         return PLUGIN_CATEGORY_UTILITY;

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

  421.         return PLUGIN_CATEGORY_UTILITY;

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

  423.         return PLUGIN_CATEGORY_UTILITY;

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

  425.         return PLUGIN_CATEGORY_UTILITY;

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

  427.         return PLUGIN_CATEGORY_UTILITY;

  428. 

  429.     // common tags

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

  431.         return PLUGIN_CATEGORY_DELAY;

  432. 

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

  434.         return PLUGIN_CATEGORY_EQ;

  435. 

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

  437.         return PLUGIN_CATEGORY_UTILITY;

  438. 

  439.     return PLUGIN_CATEGORY_NONE;

  440. }

  441. 

  442. // -------------------------------------------------------------------------------------------------------------------

  443. 

  444. const char* getLastError()

  445. {

  446.     qDebug("CarlaBackend::getLastError()");

  447. 

  448.     return carlaLastError;

  449. }

  450. 

  451. void setLastError(const char* const error)

  452. {

  453.     qDebug("CarlaBackend::setLastError(\"%s\")", error);

  454. 

  455.     if (carlaLastError)

  456.         free((void*)carlaLastError);

  457. 

  458.     carlaLastError = error ? strdup(error) : nullptr;

  459. }

  460. 

  461. // -------------------------------------------------------------------------------------------------------------------

  462. 

  463. #ifndef BUILD_BRIDGE

  464. void setOption(const OptionsType option, const int value, const char* const valueStr)

  465. {

  466.     qDebug("CarlaBackend::setOption(%s, %i, \"%s\")", OptionsType2str(option), value, valueStr);

  467. 

  468.     switch (option)

  469.     {

  470.     case OPTION_PROCESS_MODE:

  471.         if (value < PROCESS_MODE_SINGLE_CLIENT || value > PROCESS_MODE_CONTINUOUS_RACK)

  472.             return qCritical("CarlaBackend::setOption(%s, %i, \"%s\") - invalid value", OptionsType2str(option), value, valueStr);

  473.         carlaOptions.process_mode = (ProcessModeType)value;

  474.         break;

  475.     case OPTION_MAX_PARAMETERS:

  476.         carlaOptions.max_parameters = (value > 0) ? value : MAX_PARAMETERS;

  477.         break;

  478.     case OPTION_PREFER_UI_BRIDGES:

  479.         carlaOptions.prefer_ui_bridges = value;

  480.         break;

  481.     case OPTION_FORCE_STEREO:

  482.         carlaOptions.force_stereo = value;

  483.         break;

  484.     case OPTION_PROCESS_HIGH_PRECISION:

  485.         carlaOptions.proccess_hp = value;

  486.         break;

  487.     case OPTION_OSC_GUI_TIMEOUT:

  488.         carlaOptions.osc_gui_timeout = value/100;

  489.         break;

  490.     case OPTION_USE_DSSI_CHUNKS:

  491.         carlaOptions.use_dssi_chunks = value;

  492.         break;

  493.     case OPTION_PATH_LADSPA:

  494.         carla_setenv("LADSPA_PATH", valueStr);

  495.         break;

  496.     case OPTION_PATH_DSSI:

  497.         carla_setenv("DSSI_PATH", valueStr);

  498.         break;

  499.     case OPTION_PATH_LV2:

  500.         carla_setenv("LV2_PATH", valueStr);

  501.         break;

  502.     case OPTION_PATH_VST:

  503.         carla_setenv("VST_PATH", valueStr);

  504.         break;

  505.     case OPTION_PATH_GIG:

  506.         carla_setenv("GIG_PATH", valueStr);

  507.         break;

  508.     case OPTION_PATH_SF2:

  509.         carla_setenv("SF2_PATH", valueStr);

  510.         break;

  511.     case OPTION_PATH_SFZ:

  512.         carla_setenv("SFZ_PATH", valueStr);

  513.         break;

  514.     case OPTION_PATH_BRIDGE_UNIX32:

  515.         carlaOptions.bridge_unix32 = strdup(valueStr);

  516.         break;

  517.     case OPTION_PATH_BRIDGE_UNIX64:

  518.         carlaOptions.bridge_unix64 = strdup(valueStr);

  519.         break;

  520.     case OPTION_PATH_BRIDGE_WIN32:

  521.         carlaOptions.bridge_win32 = strdup(valueStr);

  522.         break;

  523.     case OPTION_PATH_BRIDGE_WIN64:

  524.         carlaOptions.bridge_win64 = strdup(valueStr);

  525.         break;

  526.     case OPTION_PATH_BRIDGE_LV2_GTK2:

  527.         carlaOptions.bridge_lv2gtk2 = strdup(valueStr);

  528.         break;

  529.     case OPTION_PATH_BRIDGE_LV2_QT4:

  530.         carlaOptions.bridge_lv2qt4 = strdup(valueStr);

  531.         break;

  532.     case OPTION_PATH_BRIDGE_LV2_X11:

  533.         carlaOptions.bridge_lv2x11 = strdup(valueStr);

  534.         break;

  535.     case OPTION_PATH_BRIDGE_VST_X11:

  536.         carlaOptions.bridge_vstx11 = strdup(valueStr);

  537.         break;

  538.     }

  539. }

  540. 

  541. void resetOptions()

  542. {

  543.     qDebug("CarlaBackend::resetOptions()");

  544. 

  545.     if (carlaOptions.bridge_unix32)

  546.         free((void*)carlaOptions.bridge_unix32);

  547. 

  548.     if (carlaOptions.bridge_unix64)

  549.         free((void*)carlaOptions.bridge_unix64);

  550. 

  551.     if (carlaOptions.bridge_win32)

  552.         free((void*)carlaOptions.bridge_win32);

  553. 

  554.     if (carlaOptions.bridge_win64)

  555.         free((void*)carlaOptions.bridge_win64);

  556. 

  557.     if (carlaOptions.bridge_lv2gtk2)

  558.         free((void*)carlaOptions.bridge_lv2gtk2);

  559. 

  560.     if (carlaOptions.bridge_lv2qt4)

  561.         free((void*)carlaOptions.bridge_lv2qt4);

  562. 

  563.     if (carlaOptions.bridge_lv2x11)

  564.         free((void*)carlaOptions.bridge_lv2x11);

  565. 

  566.     if (carlaOptions.bridge_vstx11)

  567.         free((void*)carlaOptions.bridge_vstx11);

  568. 

  569.     carlaOptions.process_mode      = PROCESS_MODE_MULTIPLE_CLIENTS;

  570.     carlaOptions.max_parameters    = MAX_PARAMETERS;

  571.     carlaOptions.prefer_ui_bridges = true;

  572.     carlaOptions.proccess_hp       = false;

  573.     carlaOptions.osc_gui_timeout   = 4000/100;

  574.     carlaOptions.use_dssi_chunks   = false;

  575.     carlaOptions.bridge_unix32     = nullptr;

  576.     carlaOptions.bridge_unix64     = nullptr;

  577.     carlaOptions.bridge_win32      = nullptr;

  578.     carlaOptions.bridge_win64      = nullptr;

  579.     carlaOptions.bridge_lv2gtk2    = nullptr;

  580.     carlaOptions.bridge_lv2qt4     = nullptr;

  581.     carlaOptions.bridge_lv2x11     = nullptr;

  582.     carlaOptions.bridge_vstx11     = nullptr;

  583. }

  584. #endif

  585. 

  586. CARLA_BACKEND_END_NAMESPACE