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.
2556 Commits
17 Branches
116MB
Tree: 649b5c2923
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '649b5c2923'
${ noResults }
Carla/source/backend/CarlaUtils.cpp

971 lines
34KB
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. namespace CB = CarlaBackend;

  35. 

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

  37. 

  38. #ifdef CARLA_OS_MAC

  39. static juce::StringArray gCachedAuPluginResults;

  40. #endif

  41. 

  42. // -------------------------------------------------------------------------------------------------------------------

  43. 

  44. _CarlaCachedPluginInfo::_CarlaCachedPluginInfo() noexcept

  45.     : category(CB::PLUGIN_CATEGORY_NONE),

  46.       hints(0x0),

  47.       audioIns(0),

  48.       audioOuts(0),

  49.       midiIns(0),

  50.       midiOuts(0),

  51.       parameterIns(0),

  52.       parameterOuts(0),

  53.       name(gNullCharPtr),

  54.       label(gNullCharPtr),

  55.       maker(gNullCharPtr),

  56.       copyright(gNullCharPtr) {}

  57. 

  58. // -------------------------------------------------------------------------------------------------------------------

  59. 

  60. static const NativePluginDescriptor carlaRackDesc = {

  61.     /* category  */ NATIVE_PLUGIN_CATEGORY_OTHER,

  62.     /* hints     */ static_cast<NativePluginHints>(NATIVE_PLUGIN_IS_SYNTH

  63.                                                   |NATIVE_PLUGIN_HAS_UI

  64.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS

  65.                                                   |NATIVE_PLUGIN_NEEDS_SINGLE_THREAD

  66.                                                   |NATIVE_PLUGIN_USES_STATE

  67.                                                   |NATIVE_PLUGIN_USES_TIME),

  68.     /* supports  */ static_cast<NativePluginSupports>(NATIVE_PLUGIN_SUPPORTS_EVERYTHING),

  69.     /* audioIns  */ 2,

  70.     /* audioOuts */ 2,

  71.     /* midiIns   */ 1,

  72.     /* midiOuts  */ 1,

  73.     /* paramIns  */ 0,

  74.     /* paramOuts */ 0,

  75.     /* name      */ "Carla-Rack",

  76.     /* label     */ "carlarack",

  77.     /* maker     */ "falkTX",

  78.     /* copyright */ "GNU GPL v2+",

  79.     nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  80.     nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  81.     nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  82.     nullptr, nullptr, nullptr, nullptr,

  83. };

  84. 

  85. static const NativePluginDescriptor carlaPatchbayDesc = {

  86.     /* category  */ NATIVE_PLUGIN_CATEGORY_OTHER,

  87.     /* hints     */ static_cast<NativePluginHints>(NATIVE_PLUGIN_IS_SYNTH

  88.                                                   |NATIVE_PLUGIN_HAS_UI

  89.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS

  90.                                                   |NATIVE_PLUGIN_NEEDS_SINGLE_THREAD

  91.                                                   |NATIVE_PLUGIN_USES_STATE

  92.                                                   |NATIVE_PLUGIN_USES_TIME),

  93.     /* supports  */ static_cast<NativePluginSupports>(NATIVE_PLUGIN_SUPPORTS_EVERYTHING),

  94.     /* audioIns  */ 2,

  95.     /* audioOuts */ 2,

  96.     /* midiIns   */ 1,

  97.     /* midiOuts  */ 1,

  98.     /* paramIns  */ 0,

  99.     /* paramOuts */ 0,

  100.     /* name      */ "Carla-Patchbay",

  101.     /* label     */ "carlapatchbay",

  102.     /* maker     */ "falkTX",

  103.     /* copyright */ "GNU GPL v2+",

  104.     nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  105.     nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  106.     nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  107.     nullptr, nullptr, nullptr, nullptr,

  108. };

  109. 

  110. static const NativePluginDescriptor carlaPatchbay3sDesc = {

  111.     /* category  */ NATIVE_PLUGIN_CATEGORY_OTHER,

  112.     /* hints     */ static_cast<NativePluginHints>(NATIVE_PLUGIN_IS_SYNTH

  113.                                                   |NATIVE_PLUGIN_HAS_UI

  114.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS

  115.                                                   |NATIVE_PLUGIN_NEEDS_SINGLE_THREAD

  116.                                                   |NATIVE_PLUGIN_USES_STATE

  117.                                                   |NATIVE_PLUGIN_USES_TIME),

  118.     /* supports  */ static_cast<NativePluginSupports>(NATIVE_PLUGIN_SUPPORTS_EVERYTHING),

  119.     /* audioIns  */ 3,

  120.     /* audioOuts */ 2,

  121.     /* midiIns   */ 1,

  122.     /* midiOuts  */ 1,

  123.     /* paramIns  */ 0,

  124.     /* paramOuts */ 0,

  125.     /* name      */ "Carla-Patchbay (sidechain)",

  126.     /* label     */ "carlapatchbay3s",

  127.     /* maker     */ "falkTX",

  128.     /* copyright */ "GNU GPL v2+",

  129.     nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  130.     nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  131.     nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  132.     nullptr, nullptr, nullptr, nullptr,

  133. };

  134. 

  135. static const NativePluginDescriptor carlaPatchbay16Desc = {

  136.     /* category  */ NATIVE_PLUGIN_CATEGORY_OTHER,

  137.     /* hints     */ static_cast<NativePluginHints>(NATIVE_PLUGIN_IS_SYNTH

  138.                                                   |NATIVE_PLUGIN_HAS_UI

  139.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS

  140.                                                   |NATIVE_PLUGIN_NEEDS_SINGLE_THREAD

  141.                                                   |NATIVE_PLUGIN_USES_STATE

  142.                                                   |NATIVE_PLUGIN_USES_TIME),

  143.     /* supports  */ static_cast<NativePluginSupports>(NATIVE_PLUGIN_SUPPORTS_EVERYTHING),

  144.     /* audioIns  */ 16,

  145.     /* audioOuts */ 16,

  146.     /* midiIns   */ 1,

  147.     /* midiOuts  */ 1,

  148.     /* paramIns  */ 0,

  149.     /* paramOuts */ 0,

  150.     /* name      */ "Carla-Patchbay (16chan)",

  151.     /* label     */ "carlapatchbay16",

  152.     /* maker     */ "falkTX",

  153.     /* copyright */ "GNU GPL v2+",

  154.     nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  155.     nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  156.     nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  157.     nullptr, nullptr, nullptr, nullptr,

  158. };

  159. 

  160. static const NativePluginDescriptor carlaPatchbay32Desc = {

  161.     /* category  */ NATIVE_PLUGIN_CATEGORY_OTHER,

  162.     /* hints     */ static_cast<NativePluginHints>(NATIVE_PLUGIN_IS_SYNTH

  163.                                                   |NATIVE_PLUGIN_HAS_UI

  164.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS

  165.                                                   |NATIVE_PLUGIN_NEEDS_SINGLE_THREAD

  166.                                                   |NATIVE_PLUGIN_USES_STATE

  167.                                                   |NATIVE_PLUGIN_USES_TIME),

  168.     /* supports  */ static_cast<NativePluginSupports>(NATIVE_PLUGIN_SUPPORTS_EVERYTHING),

  169.     /* audioIns  */ 32,

  170.     /* audioOuts */ 32,

  171.     /* midiIns   */ 1,

  172.     /* midiOuts  */ 1,

  173.     /* paramIns  */ 0,

  174.     /* paramOuts */ 0,

  175.     /* name      */ "Carla-Patchbay (32chan)",

  176.     /* label     */ "carlapatchbay32",

  177.     /* maker     */ "falkTX",

  178.     /* copyright */ "GNU GPL v2+",

  179.     nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  180.     nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  181.     nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  182.     nullptr, nullptr, nullptr, nullptr,

  183. };

  184. 

  185. static LinkedList<const NativePluginDescriptor*> gPluginDescriptors;

  186. 

  187. static const

  188. struct ScopedInitializer {

  189.     ScopedInitializer()

  190.     {

  191.         carla_register_all_plugins();

  192.     }

  193. 

  194.     ~ScopedInitializer()

  195.     {

  196.         gPluginDescriptors.clear();

  197.     }

  198. } _si;

  199. 

  200. // -------------------------------------------------------------------------------------------------------------------

  201. 

  202. CARLA_EXTERN_C

  203. void carla_register_native_plugin_carla();

  204. 

  205. void carla_register_native_plugin_carla()

  206. {

  207.     gPluginDescriptors.append(&carlaRackDesc);

  208.     gPluginDescriptors.append(&carlaPatchbayDesc);

  209.     gPluginDescriptors.append(&carlaPatchbay3sDesc);

  210.     gPluginDescriptors.append(&carlaPatchbay16Desc);

  211.     gPluginDescriptors.append(&carlaPatchbay32Desc);

  212. }

  213. 

  214. void carla_register_native_plugin(const NativePluginDescriptor* desc)

  215. {

  216.     gPluginDescriptors.append(desc);

  217. }

  218. 

  219. // -------------------------------------------------------------------------------------------------------------------

  220. 

  221. const char* carla_get_complete_license_text()

  222. {

  223.     carla_debug("carla_get_complete_license_text()");

  224. 

  225.     static CarlaString retText;

  226. 

  227.     if (retText.isEmpty())

  228.     {

  229.         retText =

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

  231.         "<ul>"

  232. 

  233.         // Plugin formats

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

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

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

  237. #ifdef VESTIGE_HEADER

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

  239. #else

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

  241. #endif

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

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

  244. #endif

  245. #ifdef CARLA_OS_MAC

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

  247. #endif

  248. 

  249.         // Sample kit libraries

  250. #ifdef HAVE_FLUIDSYNTH

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

  252. #endif

  253. #ifdef HAVE_LINUXSAMPLER

  254.         "<li>LinuxSampler library for GIG and SFZ support [2]</li>"

  255. #endif

  256. 

  257.         // Internal plugins

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

  259. #ifdef WANT_ZYNADDSUBFX

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

  261. #endif

  262. 

  263.         // misc libs

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

  265. #ifdef CARLA_OS_MAC

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

  267. #endif

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

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

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

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

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

  273. #endif

  274. 

  275.         // end

  276.         "</ul>"

  277. 

  278.         "<p>"

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

  280.         // Required by VST SDK

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

  282. #endif

  283. #ifdef HAVE_LINUXSAMPLER

  284.         // LinuxSampler GPL exception

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

  286. #endif

  287.         "</p>"

  288.         ;

  289.     }

  290. 

  291.     return retText;

  292. }

  293. 

  294. const char* carla_get_juce_version()

  295. {

  296.     carla_debug("carla_get_juce_version()");

  297. 

  298.     static CarlaString retVersion;

  299. 

  300.     if (retVersion.isEmpty())

  301.     {

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

  303.             retVersion = version+6;

  304.         else

  305.             retVersion = "3.0";

  306.     }

  307. 

  308.     return retVersion;

  309. }

  310. 

  311. const char* carla_get_supported_file_extensions()

  312. {

  313.     carla_debug("carla_get_supported_file_extensions()");

  314. 

  315.     static CarlaString retText;

  316. 

  317.     if (retText.isEmpty())

  318.     {

  319.         retText =

  320.         // Base types

  321.         "*.carxp;*.carxs"

  322.         // MIDI files

  323.         ";*.mid;*.midi"

  324. #ifdef HAVE_FLUIDSYNTH

  325.         // fluidsynth (sf2)

  326.         ";*.sf2"

  327. #endif

  328. #ifdef HAVE_LINUXSAMPLER

  329.         // linuxsampler (gig and sfz)

  330.         ";*.gig;*.sfz"

  331. #endif

  332. #ifdef WANT_ZYNADDSUBFX

  333.         // zynaddsubfx presets

  334.         ";*.xmz;*.xiz"

  335. #endif

  336.         ;

  337. 

  338.         // Audio files

  339.         {

  340.             using namespace juce;

  341. 

  342.             AudioFormatManager afm;

  343.             afm.registerBasicFormats();

  344. 

  345.             String juceFormats;

  346. 

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

  348.             {

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

  350. 

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

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

  353.             }

  354. 

  355.             retText += juceFormats.toRawUTF8();

  356.         }

  357.     }

  358. 

  359.     return retText;

  360. }

  361. 

  362. // -------------------------------------------------------------------------------------------------------------------

  363. 

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

  365. {

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

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

  368. 

  369.     switch (ptype)

  370.     {

  371.     case CB::PLUGIN_INTERNAL: {

  372.         return static_cast<uint>(gPluginDescriptors.count());

  373.     }

  374. 

  375.     case CB::PLUGIN_LV2: {

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

  377.         lv2World.initIfNeeded(pluginPath);

  378.         return lv2World.getPluginCount();

  379.     }

  380. 

  381.     case CB::PLUGIN_AU: {

  382. #ifdef CARLA_OS_MAC

  383.         static bool initiated = false;

  384. 

  385.         if (initiated)

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

  387. 

  388.         using namespace juce;

  389. 

  390.         initiated = true;

  391.         AudioUnitPluginFormat auFormat;

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

  393. 

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

  395. #else

  396.         return 0;

  397. #endif

  398.     }

  399. 

  400.     default:

  401.         return 0;

  402.     }

  403. }

  404. 

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

  406. {

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

  408. 

  409.     static CarlaCachedPluginInfo info;

  410. 

  411.     switch (ptype)

  412.     {

  413.     case CB::PLUGIN_INTERNAL: {

  414.         const NativePluginDescriptor* const desc(gPluginDescriptors.getAt(index, nullptr));

  415.         CARLA_SAFE_ASSERT_BREAK(desc != nullptr);

  416. 

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

  418.         info.hints    = 0x0;

  419. 

  420.         if (desc->hints & NATIVE_PLUGIN_IS_RTSAFE)

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

  422.         if (desc->hints & NATIVE_PLUGIN_IS_SYNTH)

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

  424.         if (desc->hints & NATIVE_PLUGIN_HAS_UI)

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

  426.         if (desc->hints & NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS)

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

  428.         if (desc->hints & NATIVE_PLUGIN_NEEDS_SINGLE_THREAD)

  429.             info.hints |= CB::PLUGIN_NEEDS_SINGLE_THREAD;

  430. 

  431.         info.audioIns      = desc->audioIns;

  432.         info.audioOuts     = desc->audioOuts;

  433.         info.midiIns       = desc->midiIns;

  434.         info.midiOuts      = desc->midiOuts;

  435.         info.parameterIns  = desc->paramIns;

  436.         info.parameterOuts = desc->paramOuts;

  437.         info.name          = desc->name;

  438.         info.label         = desc->label;

  439.         info.maker         = desc->maker;

  440.         info.copyright     = desc->copyright;

  441.         return &info;

  442.     }

  443. 

  444.     case CB::PLUGIN_LV2: {

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

  446. 

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

  448.         CARLA_SAFE_ASSERT_BREAK(cPlugin != nullptr);

  449. 

  450.         Lilv::Plugin lilvPlugin(cPlugin);

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

  452. 

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

  454. 

  455.         // features

  456.         info.hints = 0x0;

  457. 

  458. #if 0

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

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

  461. #endif

  462. 

  463.         {

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

  465. 

  466.             LILV_FOREACH(nodes, it, lilvFeatureNodes)

  467.             {

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

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

  470.                 CARLA_SAFE_ASSERT_CONTINUE(featureURI != nullptr);

  471. 

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

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

  474.             }

  475. 

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

  477.         }

  478. 

  479.         // category

  480.         info.category = CB::PLUGIN_CATEGORY_NONE;

  481. 

  482.         {

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

  484. 

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

  486.             {

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

  488.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  490.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  492.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  494.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  496.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  498.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  500.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  502.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  504.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  506.                     info.category = CB::PLUGIN_CATEGORY_DELAY;

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

  508.                     info.category = CB::PLUGIN_CATEGORY_DISTORTION;

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

  510.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  512.                     info.category = CB::PLUGIN_CATEGORY_EQ;

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

  514.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  516.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  518.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  520.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  522.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  524.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  526.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  528.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  530.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  532.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  534.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  536.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  538.                     info.category = CB::PLUGIN_CATEGORY_EQ;

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

  540.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  542.                     info.category = CB::PLUGIN_CATEGORY_EQ;

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

  544.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  546.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  548.                     info.category = CB::PLUGIN_CATEGORY_DELAY;

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

  550.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  552.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  554.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  556.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  558.                     info.category = CB::PLUGIN_CATEGORY_DISTORTION;

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

  560.                 {

  561.                     info.category = CB::PLUGIN_CATEGORY_SYNTH;

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

  563.                 }

  564.             }

  565. 

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

  567.         }

  568. 

  569.         // number data

  570.         info.audioIns      = 0;

  571.         info.audioOuts     = 0;

  572.         info.midiIns       = 0;

  573.         info.midiOuts      = 0;

  574.         info.parameterIns  = 0;

  575.         info.parameterOuts = 0;

  576. 

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

  578.         {

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

  580. 

  581.             bool isInput;

  582. 

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

  584.                 isInput = true;

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

  586.                 isInput = false;

  587.             else

  588.                 continue;

  589. 

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

  591.             {

  592.                 // skip some control ports

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

  594.                     continue;

  595. 

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

  597.                 {

  598.                     bool skip = false;

  599. 

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

  601.                     {

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

  603.                             skip = true;

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

  605.                             skip = true;

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

  607.                             skip = true;

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

  609.                             skip = true;

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

  611.                             skip = true;

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

  613.                             skip = true;

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

  615.                             skip = true;

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

  617.                             skip = true;

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

  619.                             skip = true;

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

  621.                             skip = true;

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

  623.                             skip = true;

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

  625.                             skip = true;

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

  627.                             skip = true;

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

  629.                             skip = true;

  630.                     }

  631. 

  632.                     lilv_node_free(designationNode);

  633. 

  634.                     if (skip)

  635.                         continue;

  636.                 }

  637. 

  638.                 if (isInput)

  639.                     ++(info.parameterIns);

  640.                 else

  641.                     ++(info.parameterOuts);

  642.             }

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

  644.             {

  645.                 if (isInput)

  646.                     ++(info.audioIns);

  647.                 else

  648.                     ++(info.audioOuts);

  649.             }

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

  651.             {

  652.             }

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

  654.             {

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

  656. 

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

  658.                 {

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

  660.                     CARLA_SAFE_ASSERT_CONTINUE(node.is_uri());

  661. 

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

  663.                     {

  664.                         if (isInput)

  665.                             ++(info.midiIns);

  666.                         else

  667.                             ++(info.midiOuts);

  668.                     }

  669.                 }

  670. 

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

  672.             }

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

  674.             {

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

  676.                 {

  677.                     if (isInput)

  678.                         ++(info.midiIns);

  679.                     else

  680.                         ++(info.midiOuts);

  681.                 }

  682.             }

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

  684.             {

  685.                 if (isInput)

  686.                     ++(info.midiIns);

  687.                 else

  688.                     ++(info.midiOuts);

  689.             }

  690.         }

  691. 

  692.         // text data

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

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

  695. 

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

  697. 

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

  699.             sname = name;

  700.         else

  701.             sname.clear();

  702. 

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

  704.             smaker = author;

  705.         else

  706.             smaker.clear();

  707. 

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

  709. 

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

  711.         {

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

  713.                 slicense = license;

  714.         }

  715. 

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

  717. 

  718.         info.name      = sname;

  719.         info.label     = suri;

  720.         info.maker     = smaker;

  721.         info.copyright = slicense;

  722. 

  723.         return &info;

  724.     }

  725. 

  726.     case CB::PLUGIN_AU: {

  727. #ifdef CARLA_OS_MAC

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

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

  730. 

  731.         using namespace juce;

  732. 

  733.         String pluginId(gCachedAuPluginResults[indexi]);

  734.         OwnedArray<PluginDescription> results;

  735. 

  736.         AudioUnitPluginFormat auFormat;

  737.         auFormat.findAllTypesForFile(results, pluginId);

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

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

  740. 

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

  742.         CARLA_SAFE_ASSERT_BREAK(desc != nullptr);

  743. 

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

  745.         info.hints    = 0x0;

  746. 

  747.         if (desc->isInstrument)

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

  749.         if (true)

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

  751. 

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

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

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

  755.         info.midiOuts  = 0;

  756.         info.parameterIns  = 0;

  757.         info.parameterOuts = 0;

  758. 

  759.         static CarlaString sname, slabel, smaker;

  760. 

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

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

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

  764. 

  765.         info.name      = sname;

  766.         info.label     = slabel;

  767.         info.maker     = smaker;

  768.         info.copyright = gNullCharPtr;

  769. 

  770.         return &info;

  771. #else

  772.         break;

  773. #endif

  774.     }

  775. 

  776.     default:

  777.         break;

  778.     }

  779. 

  780.     info.category      = CB::PLUGIN_CATEGORY_NONE;

  781.     info.hints         = 0x0;

  782.     info.audioIns      = 0;

  783.     info.audioOuts     = 0;

  784.     info.midiIns       = 0;

  785.     info.midiOuts      = 0;

  786.     info.parameterIns  = 0;

  787.     info.parameterOuts = 0;

  788.     info.name          = gNullCharPtr;

  789.     info.label         = gNullCharPtr;

  790.     info.maker         = gNullCharPtr;

  791.     info.copyright     = gNullCharPtr;

  792.     return &info;

  793. }

  794. 

  795. // -------------------------------------------------------------------------------------------------------------------

  796. 

  797. void carla_set_process_name(const char* name)

  798. {

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

  800. 

  801.     CarlaThread::setCurrentThreadName(name);

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

  803. }

  804. 

  805. // -------------------------------------------------------------------------------------------------------------------

  806. 

  807. class CarlaPipeClientPlugin : public CarlaPipeClient

  808. {

  809. public:

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

  811.         : CarlaPipeClient(),

  812.           fCallbackFunc(callbackFunc),

  813.           fCallbackPtr(callbackPtr),

  814.           leakDetector_CarlaPipeClientPlugin()

  815.     {

  816.         CARLA_SAFE_ASSERT(fCallbackFunc != nullptr);

  817.     }

  818. 

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

  820.     {

  821.         return CarlaPipeClient::_readlineblock(timeout);

  822.     }

  823. 

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

  825.     {

  826.         if (fCallbackFunc != nullptr)

  827.         {

  828.             try {

  829.                 fCallbackFunc(fCallbackPtr, msg);

  830.             } CARLA_SAFE_EXCEPTION("msgReceived");

  831.         }

  832. 

  833.         return true;

  834.     }

  835. 

  836. private:

  837.     const CarlaPipeCallbackFunc fCallbackFunc;

  838.     void* const fCallbackPtr;

  839. 

  840.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaPipeClientPlugin)

  841. };

  842. 

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

  844. {

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

  846. 

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

  848. 

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

  850.     {

  851.         delete pipe;

  852.         return nullptr;

  853.     }

  854. 

  855.     return pipe;

  856. }

  857. 

  858. void carla_pipe_client_idle(CarlaPipeClientHandle handle)

  859. {

  860.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  861. 

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

  863. }

  864. 

  865. bool carla_pipe_client_is_running(CarlaPipeClientHandle handle)

  866. {

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

  868. 

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

  870. }

  871. 

  872. void carla_pipe_client_lock(CarlaPipeClientHandle handle)

  873. {

  874.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  875. 

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

  877. }

  878. 

  879. void carla_pipe_client_unlock(CarlaPipeClientHandle handle)

  880. {

  881.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  882. 

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

  884. }

  885. 

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

  887. {

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

  889. 

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

  891. }

  892. 

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

  894. {

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

  896. 

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

  898. }

  899. 

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

  901. {

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

  903. 

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

  905. }

  906. 

  907. bool carla_pipe_client_flush(CarlaPipeClientHandle handle)

  908. {

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

  910. 

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

  912. }

  913. 

  914. bool carla_pipe_client_flush_and_unlock(CarlaPipeClientHandle handle)

  915. {

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

  917. 

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

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

  920.     pipe->unlockPipe();

  921.     return ret;

  922. }

  923. 

  924. void carla_pipe_client_destroy(CarlaPipeClientHandle handle)

  925. {

  926.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

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

  928. 

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

  930.     pipe->closePipeClient();

  931.     delete pipe;

  932. }

  933. 

  934. // -------------------------------------------------------------------------------------------------------------------

  935. 

  936. const char* carla_get_library_filename()

  937. {

  938.     carla_debug("carla_get_library_filename()");

  939. 

  940.     static CarlaString ret;

  941. 

  942.     if (ret.isEmpty())

  943.     {

  944.         using juce::File;

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

  946.     }

  947. 

  948.     return ret;

  949. }

  950. 

  951. const char* carla_get_library_folder()

  952. {

  953.     carla_debug("carla_get_library_folder()");

  954. 

  955.     static CarlaString ret;

  956. 

  957.     if (ret.isEmpty())

  958.     {

  959.         using juce::File;

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

  961.     }

  962. 

  963.     return ret;

  964. }

  965. 

  966. // -------------------------------------------------------------------------------------------------------------------

  967. 

  968. #include "CarlaPipeUtils.cpp"

  969. 

  970. // -------------------------------------------------------------------------------------------------------------------