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.
3271 Commits
16 Branches
14GB
Tree: 8d304b885b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '8d304b885b'
${ noResults }
Carla/source/backend/CarlaUtils.cpp

828 lines
28KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

  3.  * Copyright (C) 2011-2016 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/juce_audio_formats.h"

  29. 

  30. #ifdef CARLA_OS_MAC

  31. # include "juce_audio_processors/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>VectorJuice and WobbleJuice plugin code by Andre Sklenar</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.         {

  242.             using namespace juce;

  243.             initiated = true;

  244.             AudioUnitPluginFormat auFormat;

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

  246.         }

  247. 

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

  249. #else

  250.         return 0;

  251. #endif

  252.     }

  253. 

  254.     default:

  255.         return 0;

  256.     }

  257. }

  258. 

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

  260. {

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

  262. 

  263.     static CarlaCachedPluginInfo info;

  264. 

  265.     switch (ptype)

  266.     {

  267.     case CB::PLUGIN_INTERNAL: {

  268.         uint32_t count = 0;

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

  270.         CARLA_SAFE_ASSERT_BREAK(index < count);

  271.         CARLA_SAFE_ASSERT_BREAK(descs != nullptr);

  272. 

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

  274. 

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

  276.         info.hints    = 0x0;

  277. 

  278.         if (desc.hints & NATIVE_PLUGIN_IS_RTSAFE)

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

  280.         if (desc.hints & NATIVE_PLUGIN_IS_SYNTH)

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

  282.         if (desc.hints & NATIVE_PLUGIN_HAS_UI)

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

  284.         if (desc.hints & NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS)

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

  286.         if (desc.hints & NATIVE_PLUGIN_NEEDS_UI_MAIN_THREAD)

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

  288.         if (desc.hints & NATIVE_PLUGIN_USES_MULTI_PROGS)

  289.             info.hints |= CB::PLUGIN_USES_MULTI_PROGS;

  290. 

  291.         info.audioIns      = desc.audioIns;

  292.         info.audioOuts     = desc.audioOuts;

  293.         info.midiIns       = desc.midiIns;

  294.         info.midiOuts      = desc.midiOuts;

  295.         info.parameterIns  = desc.paramIns;

  296.         info.parameterOuts = desc.paramOuts;

  297.         info.name          = desc.name;

  298.         info.label         = desc.label;

  299.         info.maker         = desc.maker;

  300.         info.copyright     = desc.copyright;

  301.         return &info;

  302.     }

  303. 

  304.     case CB::PLUGIN_LV2: {

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

  306. 

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

  308.         CARLA_SAFE_ASSERT_BREAK(cPlugin != nullptr);

  309. 

  310.         Lilv::Plugin lilvPlugin(cPlugin);

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

  312. 

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

  314. 

  315.         // features

  316.         info.hints = 0x0;

  317. 

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

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

  320. 

  321.         {

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

  323. 

  324.             LILV_FOREACH(nodes, it, lilvFeatureNodes)

  325.             {

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

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

  328.                 CARLA_SAFE_ASSERT_CONTINUE(featureURI != nullptr);

  329. 

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

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

  332.             }

  333. 

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

  335.         }

  336. 

  337.         // category

  338.         info.category = CB::PLUGIN_CATEGORY_NONE;

  339. 

  340.         {

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

  342. 

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

  344.             {

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

  346.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  348.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  350.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  352.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  354.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  356.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  358.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  360.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  362.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  364.                     info.category = CB::PLUGIN_CATEGORY_DELAY;

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

  366.                     info.category = CB::PLUGIN_CATEGORY_DISTORTION;

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

  368.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  370.                     info.category = CB::PLUGIN_CATEGORY_EQ;

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

  372.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  374.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  376.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  378.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  380.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  382.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  384.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  386.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  388.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  390.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  392.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  394.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  396.                     info.category = CB::PLUGIN_CATEGORY_EQ;

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

  398.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  400.                     info.category = CB::PLUGIN_CATEGORY_EQ;

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

  402.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  404.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  406.                     info.category = CB::PLUGIN_CATEGORY_DELAY;

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

  408.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  410.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  412.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  414.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  416.                     info.category = CB::PLUGIN_CATEGORY_DISTORTION;

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

  418.                 {

  419.                     info.category = CB::PLUGIN_CATEGORY_SYNTH;

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

  421.                 }

  422.             }

  423. 

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

  425.         }

  426. 

  427.         // number data

  428.         info.audioIns      = 0;

  429.         info.audioOuts     = 0;

  430.         info.midiIns       = 0;

  431.         info.midiOuts      = 0;

  432.         info.parameterIns  = 0;

  433.         info.parameterOuts = 0;

  434. 

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

  436.         {

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

  438. 

  439.             bool isInput;

  440. 

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

  442.                 isInput = true;

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

  444.                 isInput = false;

  445.             else

  446.                 continue;

  447. 

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

  449.             {

  450.                 // skip some control ports

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

  452.                     continue;

  453. 

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

  455.                 {

  456.                     bool skip = false;

  457. 

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

  459.                     {

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

  461.                             skip = true;

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

  463.                             skip = true;

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

  465.                             skip = true;

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

  467.                             skip = true;

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

  469.                             skip = true;

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

  471.                             skip = true;

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

  473.                             skip = true;

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

  475.                             skip = true;

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

  477.                             skip = true;

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

  479.                             skip = true;

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

  481.                             skip = true;

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

  483.                             skip = true;

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

  485.                             skip = true;

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

  487.                             skip = true;

  488.                     }

  489. 

  490.                     lilv_node_free(designationNode);

  491. 

  492.                     if (skip)

  493.                         continue;

  494.                 }

  495. 

  496.                 if (isInput)

  497.                     ++(info.parameterIns);

  498.                 else

  499.                     ++(info.parameterOuts);

  500.             }

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

  502.             {

  503.                 if (isInput)

  504.                     ++(info.audioIns);

  505.                 else

  506.                     ++(info.audioOuts);

  507.             }

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

  509.             {

  510.             }

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

  512.             {

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

  514. 

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

  516.                 {

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

  518.                     CARLA_SAFE_ASSERT_CONTINUE(node.is_uri());

  519. 

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

  521.                     {

  522.                         if (isInput)

  523.                             ++(info.midiIns);

  524.                         else

  525.                             ++(info.midiOuts);

  526.                     }

  527.                 }

  528. 

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

  530.             }

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

  532.             {

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

  534.                 {

  535.                     if (isInput)

  536.                         ++(info.midiIns);

  537.                     else

  538.                         ++(info.midiOuts);

  539.                 }

  540.             }

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

  542.             {

  543.                 if (isInput)

  544.                     ++(info.midiIns);

  545.                 else

  546.                     ++(info.midiOuts);

  547.             }

  548.         }

  549. 

  550.         // text data

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

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

  553. 

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

  555. 

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

  557.             sname = name;

  558.         else

  559.             sname.clear();

  560. 

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

  562.             smaker = author;

  563.         else

  564.             smaker.clear();

  565. 

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

  567. 

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

  569.         {

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

  571.                 slicense = license;

  572.         }

  573. 

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

  575. 

  576.         info.name      = sname;

  577.         info.label     = suri;

  578.         info.maker     = smaker;

  579.         info.copyright = slicense;

  580. 

  581.         return &info;

  582.     }

  583. 

  584.     case CB::PLUGIN_AU: {

  585. #ifdef CARLA_OS_MAC

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

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

  588. 

  589.         using namespace juce;

  590. 

  591.         String pluginId(gCachedAuPluginResults[indexi]);

  592.         OwnedArray<PluginDescription> results;

  593. 

  594.         AudioUnitPluginFormat auFormat;

  595.         auFormat.findAllTypesForFile(results, pluginId);

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

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

  598. 

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

  600.         CARLA_SAFE_ASSERT_BREAK(desc != nullptr);

  601. 

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

  603.         info.hints    = 0x0;

  604. 

  605.         if (desc->isInstrument)

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

  607.         if (true)

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

  609. 

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

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

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

  613.         info.midiOuts  = 0;

  614.         info.parameterIns  = 0;

  615.         info.parameterOuts = 0;

  616. 

  617.         static CarlaString sname, slabel, smaker;

  618. 

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

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

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

  622. 

  623.         info.name      = sname;

  624.         info.label     = slabel;

  625.         info.maker     = smaker;

  626.         info.copyright = gNullCharPtr;

  627. 

  628.         return &info;

  629. #else

  630.         break;

  631. #endif

  632.     }

  633. 

  634.     default:

  635.         break;

  636.     }

  637. 

  638.     info.category      = CB::PLUGIN_CATEGORY_NONE;

  639.     info.hints         = 0x0;

  640.     info.audioIns      = 0;

  641.     info.audioOuts     = 0;

  642.     info.midiIns       = 0;

  643.     info.midiOuts      = 0;

  644.     info.parameterIns  = 0;

  645.     info.parameterOuts = 0;

  646.     info.name          = gNullCharPtr;

  647.     info.label         = gNullCharPtr;

  648.     info.maker         = gNullCharPtr;

  649.     info.copyright     = gNullCharPtr;

  650.     return &info;

  651. }

  652. 

  653. // -------------------------------------------------------------------------------------------------------------------

  654. 

  655. void carla_set_process_name(const char* name)

  656. {

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

  658. 

  659.     CarlaThread::setCurrentThreadName(name);

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

  661. }

  662. 

  663. // -------------------------------------------------------------------------------------------------------------------

  664. 

  665. class CarlaPipeClientPlugin : public CarlaPipeClient

  666. {

  667. public:

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

  669.         : CarlaPipeClient(),

  670.           fCallbackFunc(callbackFunc),

  671.           fCallbackPtr(callbackPtr)

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