falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 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.
2758 Commits
17 Branches
116MB
Tree: b7e7960855
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b7e7960855'
${ noResults }
Carla/source/backend/CarlaUtils.cpp

822 lines
27KB
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.         // Internal plugins

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

  106. #ifdef HAVE_ZYN_DEPS

  107.         "<li>ZynAddSubFX plugin code</li>"

  108. #endif

  109. 

  110.         // misc libs

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

  112. #ifdef CARLA_OS_MAC

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

  114. #endif

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

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

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

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

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

  120. #endif

  121. 

  122.         // end

  123.         "</ul>"

  124. 

  125.         "<p>"

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

  127.         // Required by VST SDK

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

  129. #endif

  130. #ifdef HAVE_LINUXSAMPLER

  131.         // LinuxSampler GPL exception

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

  133. #endif

  134.         "</p>"

  135.         ;

  136.     }

  137. 

  138.     return retText;

  139. }

  140. 

  141. const char* carla_get_juce_version()

  142. {

  143.     carla_debug("carla_get_juce_version()");

  144. 

  145.     static CarlaString retVersion;

  146. 

  147.     if (retVersion.isEmpty())

  148.     {

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

  150.             retVersion = version+6;

  151.         else

  152.             retVersion = "3.0";

  153.     }

  154. 

  155.     return retVersion;

  156. }

  157. 

  158. const char* carla_get_supported_file_extensions()

  159. {

  160.     carla_debug("carla_get_supported_file_extensions()");

  161. 

  162.     static CarlaString retText;

  163. 

  164.     if (retText.isEmpty())

  165.     {

  166.         retText =

  167.         // Base types

  168.         "*.carxp;*.carxs"

  169.         // MIDI files

  170.         ";*.mid;*.midi"

  171. #ifdef HAVE_FLUIDSYNTH

  172.         // fluidsynth (sf2)

  173.         ";*.sf2"

  174. #endif

  175. #ifdef HAVE_LINUXSAMPLER

  176.         // linuxsampler (gig and sfz)

  177.         ";*.gig;*.sfz"

  178. #endif

  179. #ifdef HAVE_ZYN_DEPS

  180.         // zynaddsubfx presets

  181.         ";*.xmz;*.xiz"

  182. #endif

  183.         ;

  184. 

  185.         // Audio files

  186.         {

  187.             using namespace juce;

  188. 

  189.             AudioFormatManager afm;

  190.             afm.registerBasicFormats();

  191. 

  192.             String juceFormats;

  193. 

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

  195.             {

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

  197. 

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

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

  200.             }

  201. 

  202.             retText += juceFormats.toRawUTF8();

  203.         }

  204.     }

  205. 

  206.     return retText;

  207. }

  208. 

  209. // -------------------------------------------------------------------------------------------------------------------

  210. 

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

  212. {

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

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

  215. 

  216.     switch (ptype)

  217.     {

  218.     case CB::PLUGIN_INTERNAL: {

  219.         uint32_t count = 0;

  220.         carla_get_native_plugins_data(&count);

  221.         return count;

  222.     }

  223. 

  224.     case CB::PLUGIN_LV2: {

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

  226.         lv2World.initIfNeeded(pluginPath);

  227.         return lv2World.getPluginCount();

  228.     }

  229. 

  230.     case CB::PLUGIN_AU: {

  231. #ifdef CARLA_OS_MAC

  232.         static bool initiated = false;

  233. 

  234.         if (initiated)

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

  236. 

  237.         using namespace juce;

  238. 

  239.         initiated = true;

  240.         AudioUnitPluginFormat auFormat;

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

  242. 

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

  244. #else

  245.         return 0;

  246. #endif

  247.     }

  248. 

  249.     default:

  250.         return 0;

  251.     }

  252. }

  253. 

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

  255. {

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

  257. 

  258.     static CarlaCachedPluginInfo info;

  259. 

  260.     switch (ptype)

  261.     {

  262.     case CB::PLUGIN_INTERNAL: {

  263.         uint32_t count = 0;

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

  265.         CARLA_SAFE_ASSERT_BREAK(index < count);

  266.         CARLA_SAFE_ASSERT_BREAK(descs != nullptr);

  267. 

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

  269. 

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

  271.         info.hints    = 0x0;

  272. 

  273.         if (desc.hints & NATIVE_PLUGIN_IS_RTSAFE)

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

  275.         if (desc.hints & NATIVE_PLUGIN_IS_SYNTH)

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

  277.         if (desc.hints & NATIVE_PLUGIN_HAS_UI)

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

  279.         if (desc.hints & NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS)

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

  281.         if (desc.hints & NATIVE_PLUGIN_NEEDS_UI_MAIN_THREAD)

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

  283. 

  284.         info.audioIns      = desc.audioIns;

  285.         info.audioOuts     = desc.audioOuts;

  286.         info.midiIns       = desc.midiIns;

  287.         info.midiOuts      = desc.midiOuts;

  288.         info.parameterIns  = desc.paramIns;

  289.         info.parameterOuts = desc.paramOuts;

  290.         info.name          = desc.name;

  291.         info.label         = desc.label;

  292.         info.maker         = desc.maker;

  293.         info.copyright     = desc.copyright;

  294.         return &info;

  295.     }

  296. 

  297.     case CB::PLUGIN_LV2: {

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

  299. 

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

  301.         CARLA_SAFE_ASSERT_BREAK(cPlugin != nullptr);

  302. 

  303.         Lilv::Plugin lilvPlugin(cPlugin);

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

  305. 

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

  307. 

  308.         // features

  309.         info.hints = 0x0;

  310. 

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

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

  313. 

  314.         {

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

  316. 

  317.             LILV_FOREACH(nodes, it, lilvFeatureNodes)

  318.             {

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

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

  321.                 CARLA_SAFE_ASSERT_CONTINUE(featureURI != nullptr);

  322. 

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

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

  325.             }

  326. 

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

  328.         }

  329. 

  330.         // category

  331.         info.category = CB::PLUGIN_CATEGORY_NONE;

  332. 

  333.         {

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

  335. 

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

  337.             {

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

  339.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  341.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  343.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  345.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  347.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  349.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  351.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  353.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  355.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  357.                     info.category = CB::PLUGIN_CATEGORY_DELAY;

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

  359.                     info.category = CB::PLUGIN_CATEGORY_DISTORTION;

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

  361.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  363.                     info.category = CB::PLUGIN_CATEGORY_EQ;

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

  365.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  367.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  369.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  371.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  373.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  375.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  377.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  379.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  381.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  383.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  385.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  387.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  389.                     info.category = CB::PLUGIN_CATEGORY_EQ;

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

  391.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  393.                     info.category = CB::PLUGIN_CATEGORY_EQ;

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

  395.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  397.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  399.                     info.category = CB::PLUGIN_CATEGORY_DELAY;

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

  401.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  403.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  405.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  407.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  409.                     info.category = CB::PLUGIN_CATEGORY_DISTORTION;

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

  411.                 {

  412.                     info.category = CB::PLUGIN_CATEGORY_SYNTH;

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

  414.                 }

  415.             }

  416. 

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

  418.         }

  419. 

  420.         // number data

  421.         info.audioIns      = 0;

  422.         info.audioOuts     = 0;

  423.         info.midiIns       = 0;

  424.         info.midiOuts      = 0;

  425.         info.parameterIns  = 0;

  426.         info.parameterOuts = 0;

  427. 

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

  429.         {

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

  431. 

  432.             bool isInput;

  433. 

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

  435.                 isInput = true;

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

  437.                 isInput = false;

  438.             else

  439.                 continue;

  440. 

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

  442.             {

  443.                 // skip some control ports

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

  445.                     continue;

  446. 

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

  448.                 {

  449.                     bool skip = false;

  450. 

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

  452.                     {

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

  454.                             skip = true;

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

  456.                             skip = true;

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

  458.                             skip = true;

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

  460.                             skip = true;

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

  462.                             skip = true;

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

  464.                             skip = true;

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

  466.                             skip = true;

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

  468.                             skip = true;

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

  470.                             skip = true;

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

  472.                             skip = true;

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

  474.                             skip = true;

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

  476.                             skip = true;

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

  478.                             skip = true;

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

  480.                             skip = true;

  481.                     }

  482. 

  483.                     lilv_node_free(designationNode);

  484. 

  485.                     if (skip)

  486.                         continue;

  487.                 }

  488. 

  489.                 if (isInput)

  490.                     ++(info.parameterIns);

  491.                 else

  492.                     ++(info.parameterOuts);

  493.             }

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

  495.             {

  496.                 if (isInput)

  497.                     ++(info.audioIns);

  498.                 else

  499.                     ++(info.audioOuts);

  500.             }

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

  502.             {

  503.             }

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

  505.             {

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

  507. 

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

  509.                 {

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

  511.                     CARLA_SAFE_ASSERT_CONTINUE(node.is_uri());

  512. 

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

  514.                     {

  515.                         if (isInput)

  516.                             ++(info.midiIns);

  517.                         else

  518.                             ++(info.midiOuts);

  519.                     }

  520.                 }

  521. 

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

  523.             }

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

  525.             {

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

  527.                 {

  528.                     if (isInput)

  529.                         ++(info.midiIns);

  530.                     else

  531.                         ++(info.midiOuts);

  532.                 }

  533.             }

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

  535.             {

  536.                 if (isInput)

  537.                     ++(info.midiIns);

  538.                 else

  539.                     ++(info.midiOuts);

  540.             }

  541.         }

  542. 

  543.         // text data

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

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

  546. 

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

  548. 

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

  550.             sname = name;

  551.         else

  552.             sname.clear();

  553. 

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

  555.             smaker = author;

  556.         else

  557.             smaker.clear();

  558. 

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

  560. 

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

  562.         {

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

  564.                 slicense = license;

  565.         }

  566. 

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

  568. 

  569.         info.name      = sname;

  570.         info.label     = suri;

  571.         info.maker     = smaker;

  572.         info.copyright = slicense;

  573. 

  574.         return &info;

  575.     }

  576. 

  577.     case CB::PLUGIN_AU: {

  578. #ifdef CARLA_OS_MAC

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

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

  581. 

  582.         using namespace juce;

  583. 

  584.         String pluginId(gCachedAuPluginResults[indexi]);

  585.         OwnedArray<PluginDescription> results;

  586. 

  587.         AudioUnitPluginFormat auFormat;

  588.         auFormat.findAllTypesForFile(results, pluginId);

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

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

  591. 

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

  593.         CARLA_SAFE_ASSERT_BREAK(desc != nullptr);

  594. 

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

  596.         info.hints    = 0x0;

  597. 

  598.         if (desc->isInstrument)

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

  600.         if (true)

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

  602. 

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

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

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

  606.         info.midiOuts  = 0;

  607.         info.parameterIns  = 0;

  608.         info.parameterOuts = 0;

  609. 

  610.         static CarlaString sname, slabel, smaker;

  611. 

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

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

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

  615. 

  616.         info.name      = sname;

  617.         info.label     = slabel;

  618.         info.maker     = smaker;

  619.         info.copyright = gNullCharPtr;

  620. 

  621.         return &info;

  622. #else

  623.         break;

  624. #endif

  625.     }

  626. 

  627.     default:

  628.         break;

  629.     }

  630. 

  631.     info.category      = CB::PLUGIN_CATEGORY_NONE;

  632.     info.hints         = 0x0;

  633.     info.audioIns      = 0;

  634.     info.audioOuts     = 0;

  635.     info.midiIns       = 0;

  636.     info.midiOuts      = 0;

  637.     info.parameterIns  = 0;

  638.     info.parameterOuts = 0;

  639.     info.name          = gNullCharPtr;

  640.     info.label         = gNullCharPtr;

  641.     info.maker         = gNullCharPtr;

  642.     info.copyright     = gNullCharPtr;

  643.     return &info;

  644. }

  645. 

  646. // -------------------------------------------------------------------------------------------------------------------

  647. 

  648. void carla_set_process_name(const char* name)

  649. {

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

  651. 

  652.     CarlaThread::setCurrentThreadName(name);

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

  654. }

  655. 

  656. // -------------------------------------------------------------------------------------------------------------------

  657. 

  658. class CarlaPipeClientPlugin : public CarlaPipeClient

  659. {

  660. public:

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

  662.         : CarlaPipeClient(),

  663.           fCallbackFunc(callbackFunc),

  664.           fCallbackPtr(callbackPtr),

  665.           leakDetector_CarlaPipeClientPlugin()

  666.     {

  667.         CARLA_SAFE_ASSERT(fCallbackFunc != nullptr);

  668.     }

  669. 

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

  671.     {

  672.         return CarlaPipeClient::_readlineblock(timeout);

  673.     }

  674. 

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

  676.     {

  677.         if (fCallbackFunc != nullptr)

  678.         {

  679.             try {

  680.                 fCallbackFunc(fCallbackPtr, msg);

  681.             } CARLA_SAFE_EXCEPTION("msgReceived");

  682.         }

  683. 

  684.         return true;

  685.     }

  686. 

  687. private:

  688.     const CarlaPipeCallbackFunc fCallbackFunc;

  689.     void* const fCallbackPtr;

  690. 

  691.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaPipeClientPlugin)

  692. };

  693. 

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

  695. {

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

  697. 

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

  699. 

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

  701.     {

  702.         delete pipe;

  703.         return nullptr;

  704.     }

  705. 

  706.     return pipe;

  707. }

  708. 

  709. void carla_pipe_client_idle(CarlaPipeClientHandle handle)

  710. {

  711.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  712. 

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

  714. }

  715. 

  716. bool carla_pipe_client_is_running(CarlaPipeClientHandle handle)

  717. {

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

  719. 

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

  721. }

  722. 

  723. void carla_pipe_client_lock(CarlaPipeClientHandle handle)

  724. {

  725.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  726. 

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

  728. }

  729. 

  730. void carla_pipe_client_unlock(CarlaPipeClientHandle handle)

  731. {

  732.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  733. 

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

  735. }

  736. 

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

  738. {

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

  740. 

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

  742. }

  743. 

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

  745. {

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

  747. 

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

  749. }

  750. 

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

  752. {

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

  754. 

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

  756. }

  757. 

  758. bool carla_pipe_client_flush(CarlaPipeClientHandle handle)

  759. {

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

  761. 

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

  763. }

  764. 

  765. bool carla_pipe_client_flush_and_unlock(CarlaPipeClientHandle handle)

  766. {

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

  768. 

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

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

  771.     pipe->unlockPipe();

  772.     return ret;

  773. }

  774. 

  775. void carla_pipe_client_destroy(CarlaPipeClientHandle handle)

  776. {

  777.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

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

  779. 

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

  781.     pipe->closePipeClient();

  782.     delete pipe;

  783. }

  784. 

  785. // -------------------------------------------------------------------------------------------------------------------

  786. 

  787. const char* carla_get_library_filename()

  788. {

  789.     carla_debug("carla_get_library_filename()");

  790. 

  791.     static CarlaString ret;

  792. 

  793.     if (ret.isEmpty())

  794.     {

  795.         using juce::File;

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

  797.     }

  798. 

  799.     return ret;

  800. }

  801. 

  802. const char* carla_get_library_folder()

  803. {

  804.     carla_debug("carla_get_library_folder()");

  805. 

  806.     static CarlaString ret;

  807. 

  808.     if (ret.isEmpty())

  809.     {

  810.         using juce::File;

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

  812.     }

  813. 

  814.     return ret;

  815. }

  816. 

  817. // -------------------------------------------------------------------------------------------------------------------

  818. 

  819. #include "CarlaPipeUtils.cpp"

  820. 

  821. // -------------------------------------------------------------------------------------------------------------------