falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
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.
2763 Commits
16 Branches
231MB
Tree: a280f69534
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a280f69534'
${ noResults }
Carla/source/backend/CarlaUtils.cpp

828 lines
28KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

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

  4.  *

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

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

  7.  * published by the Free Software Foundation; either version 2 of

  8.  * the License, or 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 doc/GPL.txt file.

  16.  */

  17. 

  18. #include "CarlaUtils.h"

  19. 

  20. #include "CarlaNative.h"

  21. 

  22. #include "CarlaBackendUtils.hpp"

  23. #include "CarlaLv2Utils.hpp"

  24. #include "CarlaPipeUtils.hpp"

  25. #include "CarlaThread.hpp"

  26. #include "LinkedList.hpp"

  27. 

  28. #include "juce_audio_formats.h"

  29. 

  30. #ifdef CARLA_OS_MAC

  31. # include "juce_audio_processors.h"

  32. #endif

  33. 

  34. #include "../native-plugins/_data.cpp"

  35. 

  36. namespace CB = CarlaBackend;

  37. 

  38. static const char* const gNullCharPtr = "";

  39. 

  40. #ifdef CARLA_OS_MAC

  41. static juce::StringArray gCachedAuPluginResults;

  42. #endif

  43. 

  44. // -------------------------------------------------------------------------------------------------------------------

  45. 

  46. _CarlaCachedPluginInfo::_CarlaCachedPluginInfo() noexcept

  47.     : category(CB::PLUGIN_CATEGORY_NONE),

  48.       hints(0x0),

  49.       audioIns(0),

  50.       audioOuts(0),

  51.       midiIns(0),

  52.       midiOuts(0),

  53.       parameterIns(0),

  54.       parameterOuts(0),

  55.       name(gNullCharPtr),

  56.       label(gNullCharPtr),

  57.       maker(gNullCharPtr),

  58.       copyright(gNullCharPtr) {}

  59. 

  60. // -------------------------------------------------------------------------------------------------------------------

  61. 

  62. const char* carla_get_complete_license_text()

  63. {

  64.     carla_debug("carla_get_complete_license_text()");

  65. 

  66.     static CarlaString retText;

  67. 

  68.     if (retText.isEmpty())

  69.     {

  70.         retText =

  71.         "<p>This current Carla build is using the following features and 3rd-party code:</p>"

  72.         "<ul>"

  73. 

  74. #if defined(CARLA_OS_MAC) || defined(CARLA_OS_WIN) || ! defined(VESTIGE_HEADER)

  75. # define LS_NOTE_NO "2"

  76. #else

  77. # define LS_NOTE_NO "1"

  78. #endif

  79. 

  80.         // Plugin formats

  81.         "<li>LADSPA plugin support</li>"

  82.         "<li>DSSI plugin support</li>"

  83.         "<li>LV2 plugin support</li>"

  84. #ifdef VESTIGE_HEADER

  85.         "<li>VST2 plugin support using VeSTige header by Javier Serrano Polo</li>"

  86. #else

  87.         "<li>VST2 plugin support using official VST SDK 2.4 [1]</li>"

  88. #endif

  89. #if defined(CARLA_OS_MAC) || defined(CARLA_OS_WIN)

  90.         "<li>VST3 plugin support using official VST SDK 3.6 [1]</li>"

  91. #endif

  92. #ifdef CARLA_OS_MAC

  93.         "<li>AU plugin support</li>"

  94. #endif

  95. 

  96.         // Sample kit libraries

  97. #ifdef HAVE_FLUIDSYNTH

  98.         "<li>FluidSynth library for SF2 support</li>"

  99. #endif

  100. #ifdef HAVE_LINUXSAMPLER

  101.         "<li>LinuxSampler library for GIG and SFZ support [" LS_NOTE_NO "]</li>"

  102. #endif

  103. 

  104.         // misc libs

  105.         "<li>base64 utilities based on code by Ren\u00E9 Nyffenegger</li>"

  106. #ifdef CARLA_OS_MAC

  107.         "<li>sem_timedwait for Mac OS by Keith Shortridge</li>"

  108. #endif

  109.         "<li>liblo library for OSC support</li>"

  110.         "<li>rtmempool library by Nedko Arnaudov"

  111.         "<li>serd, sord, sratom and lilv libraries for LV2 discovery</li>"

  112. #if ! (defined(CARLA_OS_MAC) || defined(CARLA_OS_WIN))

  113.         "<li>RtAudio and RtMidi libraries for extra Audio and MIDI support</li>"

  114. #endif

  115. 

  116.         // Internal plugins

  117. #ifdef HAVE_EXPERIMENTAL_PLUGINS

  118.         "<li>AT1, BLS1 and REV1 plugin code by Fons Adriaensen</li>"

  119. #endif

  120.         "<li>MIDI Sequencer UI code by Perry Nguyen</li>"

  121.         "<li>MVerb plugin code by Martin Eastwood</li>"

  122.         "<li>Nekobi plugin code based on nekobee by Sean Bolton and others</li>"

  123.         "<li>NekoFilter plugin code based on lv2fil by Nedko Arnaudov and Fons Adriaensen</li>"

  124. #ifdef HAVE_ZYN_DEPS

  125.         "<li>ZynAddSubFX plugin code by Mark McCurry and Nasca Octavian Paul</li>"

  126. #endif

  127. 

  128.         // end

  129.         "</ul>"

  130. 

  131.         "<p>"

  132. #if defined(CARLA_OS_MAC) || defined(CARLA_OS_WIN) || ! defined(VESTIGE_HEADER)

  133.         // Required by VST SDK

  134.         "&nbsp;[1] Trademark of Steinberg Media Technologies GmbH.<br/>"

  135. #endif

  136. #ifdef HAVE_LINUXSAMPLER

  137.         // LinuxSampler GPL exception

  138.         "&nbsp;[" LS_NOTE_NO "] Using LinuxSampler code in commercial hardware or software products is not allowed without prior written authorization by the authors."

  139. #endif

  140.         "</p>"

  141.         ;

  142.     }

  143. 

  144.     return retText;

  145. }

  146. 

  147. const char* carla_get_juce_version()

  148. {

  149.     carla_debug("carla_get_juce_version()");

  150. 

  151.     static CarlaString retVersion;

  152. 

  153.     if (retVersion.isEmpty())

  154.     {

  155.         if (const char* const version = juce::SystemStats::getJUCEVersion().toRawUTF8())

  156.             retVersion = version+6;

  157.         else

  158.             retVersion = "3.0";

  159.     }

  160. 

  161.     return retVersion;

  162. }

  163. 

  164. const char* carla_get_supported_file_extensions()

  165. {

  166.     carla_debug("carla_get_supported_file_extensions()");

  167. 

  168.     static CarlaString retText;

  169. 

  170.     if (retText.isEmpty())

  171.     {

  172.         retText =

  173.         // Base types

  174.         "*.carxp;*.carxs"

  175.         // MIDI files

  176.         ";*.mid;*.midi"

  177. #ifdef HAVE_FLUIDSYNTH

  178.         // fluidsynth (sf2)

  179.         ";*.sf2"

  180. #endif

  181. #ifdef HAVE_LINUXSAMPLER

  182.         // linuxsampler (gig and sfz)

  183.         ";*.gig;*.sfz"

  184. #endif

  185. #ifdef HAVE_ZYN_DEPS

  186.         // zynaddsubfx presets

  187.         ";*.xmz;*.xiz"

  188. #endif

  189.         ;

  190. 

  191.         // Audio files

  192.         {

  193.             using namespace juce;

  194. 

  195.             AudioFormatManager afm;

  196.             afm.registerBasicFormats();

  197. 

  198.             String juceFormats;

  199. 

  200.             for (AudioFormat **it=afm.begin(), **end=afm.end(); it != end; ++it)

  201.             {

  202.                 const StringArray& exts((*it)->getFileExtensions());

  203. 

  204.                 for (String *eit=exts.begin(), *eend=exts.end(); eit != eend; ++eit)

  205.                     juceFormats += String(";*" + (*eit)).toRawUTF8();

  206.             }

  207. 

  208.             retText += juceFormats.toRawUTF8();

  209.         }

  210.     }

  211. 

  212.     return retText;

  213. }

  214. 

  215. // -------------------------------------------------------------------------------------------------------------------

  216. 

  217. uint carla_get_cached_plugin_count(CB::PluginType ptype, const char* pluginPath)

  218. {

  219.     CARLA_SAFE_ASSERT_RETURN(ptype == CB::PLUGIN_INTERNAL || ptype == CB::PLUGIN_LV2 || ptype == CB::PLUGIN_AU, 0);

  220.     carla_debug("carla_get_cached_plugin_count(%i:%s)", ptype, CB::PluginType2Str(ptype));

  221. 

  222.     switch (ptype)

  223.     {

  224.     case CB::PLUGIN_INTERNAL: {

  225.         uint32_t count = 0;

  226.         carla_get_native_plugins_data(&count);

  227.         return count;

  228.     }

  229. 

  230.     case CB::PLUGIN_LV2: {

  231.         Lv2WorldClass& lv2World(Lv2WorldClass::getInstance());

  232.         lv2World.initIfNeeded(pluginPath);

  233.         return lv2World.getPluginCount();

  234.     }

  235. 

  236.     case CB::PLUGIN_AU: {

  237. #ifdef CARLA_OS_MAC

  238.         static bool initiated = false;

  239. 

  240.         if (initiated)

  241.             return static_cast<uint>(gCachedAuPluginResults.size());

  242. 

  243.         using namespace juce;

  244. 

  245.         initiated = true;

  246.         AudioUnitPluginFormat auFormat;

  247.         gCachedAuPluginResults = auFormat.searchPathsForPlugins(juce::FileSearchPath(), false);

  248. 

  249.         return static_cast<uint>(gCachedAuPluginResults.size());

  250. #else

  251.         return 0;

  252. #endif

  253.     }

  254. 

  255.     default:

  256.         return 0;

  257.     }

  258. }

  259. 

  260. const CarlaCachedPluginInfo* carla_get_cached_plugin_info(CB::PluginType ptype, uint index)

  261. {

  262.     carla_debug("carla_get_cached_plugin_info(%i:%s, %i)", ptype, CB::PluginType2Str(ptype), index);

  263. 

  264.     static CarlaCachedPluginInfo info;

  265. 

  266.     switch (ptype)

  267.     {

  268.     case CB::PLUGIN_INTERNAL: {

  269.         uint32_t count = 0;

  270.         const NativePluginDescriptor* const descs(carla_get_native_plugins_data(&count));

  271.         CARLA_SAFE_ASSERT_BREAK(index < count);

  272.         CARLA_SAFE_ASSERT_BREAK(descs != nullptr);

  273. 

  274.         const NativePluginDescriptor& desc(descs[index]);

  275. 

  276.         info.category = static_cast<CB::PluginCategory>(desc.category);

  277.         info.hints    = 0x0;

  278. 

  279.         if (desc.hints & NATIVE_PLUGIN_IS_RTSAFE)

  280.             info.hints |= CB::PLUGIN_IS_RTSAFE;

  281.         if (desc.hints & NATIVE_PLUGIN_IS_SYNTH)

  282.             info.hints |= CB::PLUGIN_IS_SYNTH;

  283.         if (desc.hints & NATIVE_PLUGIN_HAS_UI)

  284.             info.hints |= CB::PLUGIN_HAS_CUSTOM_UI;

  285.         if (desc.hints & NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS)

  286.             info.hints |= CB::PLUGIN_NEEDS_FIXED_BUFFERS;

  287.         if (desc.hints & NATIVE_PLUGIN_NEEDS_UI_MAIN_THREAD)

  288.             info.hints |= CB::PLUGIN_NEEDS_UI_MAIN_THREAD;

  289. 

  290.         info.audioIns      = desc.audioIns;

  291.         info.audioOuts     = desc.audioOuts;

  292.         info.midiIns       = desc.midiIns;

  293.         info.midiOuts      = desc.midiOuts;

  294.         info.parameterIns  = desc.paramIns;

  295.         info.parameterOuts = desc.paramOuts;

  296.         info.name          = desc.name;

  297.         info.label         = desc.label;

  298.         info.maker         = desc.maker;

  299.         info.copyright     = desc.copyright;

  300.         return &info;

  301.     }

  302. 

  303.     case CB::PLUGIN_LV2: {

  304.         Lv2WorldClass& lv2World(Lv2WorldClass::getInstance());

  305. 

  306.         const LilvPlugin* const cPlugin(lv2World.getPluginFromIndex(index));

  307.         CARLA_SAFE_ASSERT_BREAK(cPlugin != nullptr);

  308. 

  309.         Lilv::Plugin lilvPlugin(cPlugin);

  310.         CARLA_SAFE_ASSERT_BREAK(lilvPlugin.get_uri().is_uri());

  311. 

  312.         carla_stdout("Filling info for LV2 with URI '%s'", lilvPlugin.get_uri().as_uri());

  313. 

  314.         // features

  315.         info.hints = 0x0;

  316. 

  317.         if (lilvPlugin.get_uis().size() > 0 || lilvPlugin.get_modgui_resources_directory().as_uri() != nullptr)

  318.             info.hints |= CB::PLUGIN_HAS_CUSTOM_UI;

  319. 

  320.         {

  321.             Lilv::Nodes lilvFeatureNodes(lilvPlugin.get_supported_features());

  322. 

  323.             LILV_FOREACH(nodes, it, lilvFeatureNodes)

  324.             {

  325.                 Lilv::Node lilvFeatureNode(lilvFeatureNodes.get(it));

  326.                 const char* const featureURI(lilvFeatureNode.as_uri());

  327.                 CARLA_SAFE_ASSERT_CONTINUE(featureURI != nullptr);

  328. 

  329.                 if (std::strcmp(featureURI, LV2_CORE__hardRTCapable) == 0)

  330.                     info.hints |= CB::PLUGIN_IS_RTSAFE;

  331.             }

  332. 

  333.             lilv_nodes_free(const_cast<LilvNodes*>(lilvFeatureNodes.me));

  334.         }

  335. 

  336.         // category

  337.         info.category = CB::PLUGIN_CATEGORY_NONE;

  338. 

  339.         {

  340.             Lilv::Nodes typeNodes(lilvPlugin.get_value(lv2World.rdf_type));

  341. 

  342.             if (typeNodes.size() > 0)

  343.             {

  344.                 if (typeNodes.contains(lv2World.class_allpass))

  345.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

  346.                 if (typeNodes.contains(lv2World.class_amplifier))

  347.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

  348.                 if (typeNodes.contains(lv2World.class_analyzer))

  349.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

  350.                 if (typeNodes.contains(lv2World.class_bandpass))

  351.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

  352.                 if (typeNodes.contains(lv2World.class_chorus))

  353.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

  354.                 if (typeNodes.contains(lv2World.class_comb))

  355.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

  356.                 if (typeNodes.contains(lv2World.class_compressor))

  357.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

  358.                 if (typeNodes.contains(lv2World.class_constant))

  359.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

  360.                 if (typeNodes.contains(lv2World.class_converter))

  361.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

  362.                 if (typeNodes.contains(lv2World.class_delay))

  363.                     info.category = CB::PLUGIN_CATEGORY_DELAY;

  364.                 if (typeNodes.contains(lv2World.class_distortion))

  365.                     info.category = CB::PLUGIN_CATEGORY_DISTORTION;

  366.                 if (typeNodes.contains(lv2World.class_dynamics))

  367.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

  368.                 if (typeNodes.contains(lv2World.class_eq))

  369.                     info.category = CB::PLUGIN_CATEGORY_EQ;

  370.                 if (typeNodes.contains(lv2World.class_envelope))

  371.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

  372.                 if (typeNodes.contains(lv2World.class_expander))

  373.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

  374.                 if (typeNodes.contains(lv2World.class_filter))

  375.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

  376.                 if (typeNodes.contains(lv2World.class_flanger))

  377.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

  378.                 if (typeNodes.contains(lv2World.class_function))

  379.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

  380.                 if (typeNodes.contains(lv2World.class_gate))

  381.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

  382.                 if (typeNodes.contains(lv2World.class_generator))

  383.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

  384.                 if (typeNodes.contains(lv2World.class_highpass))

  385.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

  386.                 if (typeNodes.contains(lv2World.class_limiter))

  387.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

  388.                 if (typeNodes.contains(lv2World.class_lowpass))

  389.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

  390.                 if (typeNodes.contains(lv2World.class_mixer))

  391.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

  392.                 if (typeNodes.contains(lv2World.class_modulator))

  393.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

  394.                 if (typeNodes.contains(lv2World.class_multiEQ))

  395.                     info.category = CB::PLUGIN_CATEGORY_EQ;

  396.                 if (typeNodes.contains(lv2World.class_oscillator))

  397.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

  398.                 if (typeNodes.contains(lv2World.class_paraEQ))

  399.                     info.category = CB::PLUGIN_CATEGORY_EQ;

  400.                 if (typeNodes.contains(lv2World.class_phaser))

  401.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

  402.                 if (typeNodes.contains(lv2World.class_pitch))

  403.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

  404.                 if (typeNodes.contains(lv2World.class_reverb))

  405.                     info.category = CB::PLUGIN_CATEGORY_DELAY;

  406.                 if (typeNodes.contains(lv2World.class_simulator))

  407.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

  408.                 if (typeNodes.contains(lv2World.class_spatial))

  409.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

  410.                 if (typeNodes.contains(lv2World.class_spectral))

  411.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

  412.                 if (typeNodes.contains(lv2World.class_utility))

  413.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

  414.                 if (typeNodes.contains(lv2World.class_waveshaper))

  415.                     info.category = CB::PLUGIN_CATEGORY_DISTORTION;

  416.                 if (typeNodes.contains(lv2World.class_instrument))

  417.                 {

  418.                     info.category = CB::PLUGIN_CATEGORY_SYNTH;

  419.                     info.hints |= CB::PLUGIN_IS_SYNTH;

  420.                 }

  421.             }

  422. 

  423.             lilv_nodes_free(const_cast<LilvNodes*>(typeNodes.me));

  424.         }

  425. 

  426.         // number data

  427.         info.audioIns      = 0;

  428.         info.audioOuts     = 0;

  429.         info.midiIns       = 0;

  430.         info.midiOuts      = 0;

  431.         info.parameterIns  = 0;

  432.         info.parameterOuts = 0;

  433. 

  434.         for (uint i=0, count=lilvPlugin.get_num_ports(); i<count; ++i)

  435.         {

  436.             Lilv::Port lilvPort(lilvPlugin.get_port_by_index(i));

  437. 

  438.             bool isInput;

  439. 

  440.             /**/ if (lilvPort.is_a(lv2World.port_input))

  441.                 isInput = true;

  442.             else if (lilvPort.is_a(lv2World.port_output))

  443.                 isInput = false;

  444.             else

  445.                 continue;

  446. 

  447.             /**/ if (lilvPort.is_a(lv2World.port_control))

  448.             {

  449.                 // skip some control ports

  450.                 if (lilvPort.has_property(lv2World.reportsLatency))

  451.                     continue;

  452. 

  453.                 if (LilvNode* const designationNode = lilv_port_get(lilvPort.parent, lilvPort.me, lv2World.designation.me))

  454.                 {

  455.                     bool skip = false;

  456. 

  457.                     if (const char* const designation = lilv_node_as_string(designationNode))

  458.                     {

  459.                         /**/ if (std::strcmp(designation, LV2_CORE__control) == 0)

  460.                             skip = true;

  461.                         else if (std::strcmp(designation, LV2_CORE__freeWheeling) == 0)

  462.                             skip = true;

  463.                         else if (std::strcmp(designation, LV2_CORE__latency) == 0)

  464.                             skip = true;

  465.                         else if (std::strcmp(designation, LV2_PARAMETERS__sampleRate) == 0)

  466.                             skip = true;

  467.                         else if (std::strcmp(designation, LV2_TIME__bar) == 0)

  468.                             skip = true;

  469.                         else if (std::strcmp(designation, LV2_TIME__barBeat) == 0)

  470.                             skip = true;

  471.                         else if (std::strcmp(designation, LV2_TIME__beat) == 0)

  472.                             skip = true;

  473.                         else if (std::strcmp(designation, LV2_TIME__beatUnit) == 0)

  474.                             skip = true;

  475.                         else if (std::strcmp(designation, LV2_TIME__beatsPerBar) == 0)

  476.                             skip = true;

  477.                         else if (std::strcmp(designation, LV2_TIME__beatsPerMinute) == 0)

  478.                             skip = true;

  479.                         else if (std::strcmp(designation, LV2_TIME__frame) == 0)

  480.                             skip = true;

  481.                         else if (std::strcmp(designation, LV2_TIME__framesPerSecond) == 0)

  482.                             skip = true;

  483.                         else if (std::strcmp(designation, LV2_TIME__speed) == 0)

  484.                             skip = true;

  485.                         else if (std::strcmp(designation, LV2_KXSTUDIO_PROPERTIES__TimePositionTicksPerBeat) == 0)

  486.                             skip = true;

  487.                     }

  488. 

  489.                     lilv_node_free(designationNode);

  490. 

  491.                     if (skip)

  492.                         continue;

  493.                 }

  494. 

  495.                 if (isInput)

  496.                     ++(info.parameterIns);

  497.                 else

  498.                     ++(info.parameterOuts);

  499.             }

  500.             else if (lilvPort.is_a(lv2World.port_audio))

  501.             {

  502.                 if (isInput)

  503.                     ++(info.audioIns);

  504.                 else

  505.                     ++(info.audioOuts);

  506.             }

  507.             else if (lilvPort.is_a(lv2World.port_cv))

  508.             {

  509.             }

  510.             else if (lilvPort.is_a(lv2World.port_atom))

  511.             {

  512.                 Lilv::Nodes supportNodes(lilvPort.get_value(lv2World.atom_supports));

  513. 

  514.                 for (LilvIter *it = lilv_nodes_begin(supportNodes.me); ! lilv_nodes_is_end(supportNodes.me, it); it = lilv_nodes_next(supportNodes.me, it))

  515.                 {

  516.                     const Lilv::Node node(lilv_nodes_get(supportNodes.me, it));

  517.                     CARLA_SAFE_ASSERT_CONTINUE(node.is_uri());

  518. 

  519.                     if (node.equals(lv2World.midi_event))

  520.                     {

  521.                         if (isInput)

  522.                             ++(info.midiIns);

  523.                         else

  524.                             ++(info.midiOuts);

  525.                     }

  526.                 }

  527. 

  528.                 lilv_nodes_free(const_cast<LilvNodes*>(supportNodes.me));

  529.             }

  530.             else if (lilvPort.is_a(lv2World.port_event))

  531.             {

  532.                 if (lilvPort.supports_event(lv2World.midi_event))

  533.                 {

  534.                     if (isInput)

  535.                         ++(info.midiIns);

  536.                     else

  537.                         ++(info.midiOuts);

  538.                 }

  539.             }

  540.             else if (lilvPort.is_a(lv2World.port_midi))

  541.             {

  542.                 if (isInput)

  543.                     ++(info.midiIns);

  544.                 else

  545.                     ++(info.midiOuts);

  546.             }

  547.         }

  548. 

  549.         // text data

  550.         static CarlaString suri, sname, smaker, slicense;

  551.         suri.clear(); sname.clear(); smaker.clear(); slicense.clear();

  552. 

  553.         suri = lilvPlugin.get_uri().as_uri();

  554. 

  555.         if (const char* const name = lilvPlugin.get_name().as_string())

  556.             sname = name;

  557.         else

  558.             sname.clear();

  559. 

  560.         if (const char* const author = lilvPlugin.get_author_name().as_string())

  561.             smaker = author;

  562.         else

  563.             smaker.clear();

  564. 

  565.         Lilv::Nodes licenseNodes(lilvPlugin.get_value(lv2World.doap_license));

  566. 

  567.         if (licenseNodes.size() > 0)

  568.         {

  569.             if (const char* const license = licenseNodes.get_first().as_string())

  570.                 slicense = license;

  571.         }

  572. 

  573.         lilv_nodes_free(const_cast<LilvNodes*>(licenseNodes.me));

  574. 

  575.         info.name      = sname;

  576.         info.label     = suri;

  577.         info.maker     = smaker;

  578.         info.copyright = slicense;

  579. 

  580.         return &info;

  581.     }

  582. 

  583.     case CB::PLUGIN_AU: {

  584. #ifdef CARLA_OS_MAC

  585.         const int indexi(static_cast<int>(index));

  586.         CARLA_SAFE_ASSERT_BREAK(indexi < gCachedAuPluginResults.size());

  587. 

  588.         using namespace juce;

  589. 

  590.         String pluginId(gCachedAuPluginResults[indexi]);

  591.         OwnedArray<PluginDescription> results;

  592. 

  593.         AudioUnitPluginFormat auFormat;

  594.         auFormat.findAllTypesForFile(results, pluginId);

  595.         CARLA_SAFE_ASSERT_BREAK(results.size() > 0);

  596.         CARLA_SAFE_ASSERT(results.size() == 1);

  597. 

  598.         PluginDescription* const desc(results[0]);

  599.         CARLA_SAFE_ASSERT_BREAK(desc != nullptr);

  600. 

  601.         info.category = CB::getPluginCategoryFromName(desc->category.toRawUTF8());

  602.         info.hints    = 0x0;

  603. 

  604.         if (desc->isInstrument)

  605.             info.hints |= CB::PLUGIN_IS_SYNTH;

  606.         if (true)

  607.             info.hints |= CB::PLUGIN_HAS_CUSTOM_UI;

  608. 

  609.         info.audioIns  = static_cast<uint32_t>(desc->numInputChannels);

  610.         info.audioOuts = static_cast<uint32_t>(desc->numOutputChannels);

  611.         info.midiIns   = desc->isInstrument ? 1 : 0;

  612.         info.midiOuts  = 0;

  613.         info.parameterIns  = 0;

  614.         info.parameterOuts = 0;

  615. 

  616.         static CarlaString sname, slabel, smaker;

  617. 

  618.         sname  = desc->name.toRawUTF8();

  619.         slabel = desc->fileOrIdentifier.toRawUTF8();

  620.         smaker = desc->manufacturerName.toRawUTF8();

  621. 

  622.         info.name      = sname;

  623.         info.label     = slabel;

  624.         info.maker     = smaker;

  625.         info.copyright = gNullCharPtr;

  626. 

  627.         return &info;

  628. #else

  629.         break;

  630. #endif

  631.     }

  632. 

  633.     default:

  634.         break;

  635.     }

  636. 

  637.     info.category      = CB::PLUGIN_CATEGORY_NONE;

  638.     info.hints         = 0x0;

  639.     info.audioIns      = 0;

  640.     info.audioOuts     = 0;

  641.     info.midiIns       = 0;

  642.     info.midiOuts      = 0;

  643.     info.parameterIns  = 0;

  644.     info.parameterOuts = 0;

  645.     info.name          = gNullCharPtr;

  646.     info.label         = gNullCharPtr;

  647.     info.maker         = gNullCharPtr;

  648.     info.copyright     = gNullCharPtr;

  649.     return &info;

  650. }

  651. 

  652. // -------------------------------------------------------------------------------------------------------------------

  653. 

  654. void carla_set_process_name(const char* name)

  655. {

  656.     carla_debug("carla_set_process_name(\"%s\")", name);

  657. 

  658.     CarlaThread::setCurrentThreadName(name);

  659.     juce::Thread::setCurrentThreadName(name);

  660. }

  661. 

  662. // -------------------------------------------------------------------------------------------------------------------

  663. 

  664. class CarlaPipeClientPlugin : public CarlaPipeClient

  665. {

  666. public:

  667.     CarlaPipeClientPlugin(const CarlaPipeCallbackFunc callbackFunc, void* const callbackPtr) noexcept

  668.         : CarlaPipeClient(),

  669.           fCallbackFunc(callbackFunc),

  670.           fCallbackPtr(callbackPtr),

  671.           leakDetector_CarlaPipeClientPlugin()

  672.     {

  673.         CARLA_SAFE_ASSERT(fCallbackFunc != nullptr);

  674.     }

  675. 

  676.     const char* readlineblock(const uint timeout) noexcept

  677.     {

  678.         return CarlaPipeClient::_readlineblock(timeout);

  679.     }

  680. 

  681.     bool msgReceived(const char* const msg) noexcept

  682.     {

  683.         if (fCallbackFunc != nullptr)

  684.         {

  685.             try {

  686.                 fCallbackFunc(fCallbackPtr, msg);

  687.             } CARLA_SAFE_EXCEPTION("msgReceived");

  688.         }

  689. 

  690.         return true;

  691.     }

  692. 

  693. private:

  694.     const CarlaPipeCallbackFunc fCallbackFunc;

  695.     void* const fCallbackPtr;

  696. 

  697.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaPipeClientPlugin)

  698. };

  699. 

  700. CarlaPipeClientHandle carla_pipe_client_new(const char* argv[], CarlaPipeCallbackFunc callbackFunc, void* callbackPtr)

  701. {

  702.     carla_debug("carla_pipe_client_new(%p, %p, %p)", argv, callbackFunc, callbackPtr);

  703. 

  704.     CarlaPipeClientPlugin* const pipe(new CarlaPipeClientPlugin(callbackFunc, callbackPtr));

  705. 

  706.     if (! pipe->initPipeClient(argv))

  707.     {

  708.         delete pipe;

  709.         return nullptr;

  710.     }

  711. 

  712.     return pipe;

  713. }

  714. 

  715. void carla_pipe_client_idle(CarlaPipeClientHandle handle)

  716. {

  717.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  718. 

  719.     ((CarlaPipeClientPlugin*)handle)->idlePipe();

  720. }

  721. 

  722. bool carla_pipe_client_is_running(CarlaPipeClientHandle handle)

  723. {

  724.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr, false);

  725. 

  726.     return ((CarlaPipeClientPlugin*)handle)->isPipeRunning();

  727. }

  728. 

  729. void carla_pipe_client_lock(CarlaPipeClientHandle handle)

  730. {

  731.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  732. 

  733.     return ((CarlaPipeClientPlugin*)handle)->lockPipe();

  734. }

  735. 

  736. void carla_pipe_client_unlock(CarlaPipeClientHandle handle)

  737. {

  738.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  739. 

  740.     return ((CarlaPipeClientPlugin*)handle)->unlockPipe();

  741. }

  742. 

  743. const char* carla_pipe_client_readlineblock(CarlaPipeClientHandle handle, uint timeout)

  744. {

  745.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr, nullptr);

  746. 

  747.     return ((CarlaPipeClientPlugin*)handle)->readlineblock(timeout);

  748. }

  749. 

  750. bool carla_pipe_client_write_msg(CarlaPipeClientHandle handle, const char* msg)

  751. {

  752.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr, false);

  753. 

  754.     return ((CarlaPipeClientPlugin*)handle)->writeMessage(msg);

  755. }

  756. 

  757. bool carla_pipe_client_write_and_fix_msg(CarlaPipeClientHandle handle, const char* msg)

  758. {

  759.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr, false);

  760. 

  761.     return ((CarlaPipeClientPlugin*)handle)->writeAndFixMessage(msg);

  762. }

  763. 

  764. bool carla_pipe_client_flush(CarlaPipeClientHandle handle)

  765. {

  766.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr, false);

  767. 

  768.     return ((CarlaPipeClientPlugin*)handle)->flushMessages();

  769. }

  770. 

  771. bool carla_pipe_client_flush_and_unlock(CarlaPipeClientHandle handle)

  772. {

  773.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr, false);

  774. 

  775.     CarlaPipeClientPlugin* const pipe((CarlaPipeClientPlugin*)handle);

  776.     const bool ret(pipe->flushMessages());

  777.     pipe->unlockPipe();

  778.     return ret;

  779. }

  780. 

  781. void carla_pipe_client_destroy(CarlaPipeClientHandle handle)

  782. {

  783.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  784.     carla_debug("carla_pipe_client_destroy(%p)", handle);

  785. 

  786.     CarlaPipeClientPlugin* const pipe((CarlaPipeClientPlugin*)handle);

  787.     pipe->closePipeClient();

  788.     delete pipe;

  789. }

  790. 

  791. // -------------------------------------------------------------------------------------------------------------------

  792. 

  793. const char* carla_get_library_filename()

  794. {

  795.     carla_debug("carla_get_library_filename()");

  796. 

  797.     static CarlaString ret;

  798. 

  799.     if (ret.isEmpty())

  800.     {

  801.         using juce::File;

  802.         ret = File(File::getSpecialLocation(File::currentExecutableFile)).getFullPathName().toRawUTF8();

  803.     }

  804. 

  805.     return ret;

  806. }

  807. 

  808. const char* carla_get_library_folder()

  809. {

  810.     carla_debug("carla_get_library_folder()");

  811. 

  812.     static CarlaString ret;

  813. 

  814.     if (ret.isEmpty())

  815.     {

  816.         using juce::File;

  817.         ret = File(File::getSpecialLocation(File::currentExecutableFile).getParentDirectory()).getFullPathName().toRawUTF8();

  818.     }

  819. 

  820.     return ret;

  821. }

  822. 

  823. // -------------------------------------------------------------------------------------------------------------------

  824. 

  825. #include "CarlaPipeUtils.cpp"

  826. 

  827. // -------------------------------------------------------------------------------------------------------------------