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

969 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_UI_MAIN_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_UI_MAIN_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_UI_MAIN_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_UI_MAIN_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_UI_MAIN_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_UI_MAIN_THREAD)

  429.             info.hints |= CB::PLUGIN_NEEDS_UI_MAIN_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 (lilvPlugin.get_uis().size() > 0 /*|| lilvPlugin.get_modgui_resources_directory().as_uri() != nullptr*/)

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

  460. 

  461.         {

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

  463. 

  464.             LILV_FOREACH(nodes, it, lilvFeatureNodes)

  465.             {

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

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

  468.                 CARLA_SAFE_ASSERT_CONTINUE(featureURI != nullptr);

  469. 

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

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

  472.             }

  473. 

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

  475.         }

  476. 

  477.         // category

  478.         info.category = CB::PLUGIN_CATEGORY_NONE;

  479. 

  480.         {

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

  482. 

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

  484.             {

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

  486.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  488.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  490.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  492.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  494.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  496.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  498.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  500.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  502.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  504.                     info.category = CB::PLUGIN_CATEGORY_DELAY;

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

  506.                     info.category = CB::PLUGIN_CATEGORY_DISTORTION;

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

  508.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  510.                     info.category = CB::PLUGIN_CATEGORY_EQ;

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

  512.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  514.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  516.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  518.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  520.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  522.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  524.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  526.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  528.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  530.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  532.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  534.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  536.                     info.category = CB::PLUGIN_CATEGORY_EQ;

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

  538.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  540.                     info.category = CB::PLUGIN_CATEGORY_EQ;

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

  542.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  544.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  546.                     info.category = CB::PLUGIN_CATEGORY_DELAY;

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

  548.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  550.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  552.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  554.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  556.                     info.category = CB::PLUGIN_CATEGORY_DISTORTION;

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

  558.                 {

  559.                     info.category = CB::PLUGIN_CATEGORY_SYNTH;

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

  561.                 }

  562.             }

  563. 

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

  565.         }

  566. 

  567.         // number data

  568.         info.audioIns      = 0;

  569.         info.audioOuts     = 0;

  570.         info.midiIns       = 0;

  571.         info.midiOuts      = 0;

  572.         info.parameterIns  = 0;

  573.         info.parameterOuts = 0;

  574. 

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

  576.         {

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

  578. 

  579.             bool isInput;

  580. 

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

  582.                 isInput = true;

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

  584.                 isInput = false;

  585.             else

  586.                 continue;

  587. 

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

  589.             {

  590.                 // skip some control ports

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

  592.                     continue;

  593. 

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

  595.                 {

  596.                     bool skip = false;

  597. 

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

  599.                     {

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

  601.                             skip = true;

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

  603.                             skip = true;

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

  605.                             skip = true;

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

  607.                             skip = true;

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

  609.                             skip = true;

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

  611.                             skip = true;

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

  613.                             skip = true;

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

  615.                             skip = true;

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

  617.                             skip = true;

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

  619.                             skip = true;

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

  621.                             skip = true;

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

  623.                             skip = true;

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

  625.                             skip = true;

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

  627.                             skip = true;

  628.                     }

  629. 

  630.                     lilv_node_free(designationNode);

  631. 

  632.                     if (skip)

  633.                         continue;

  634.                 }

  635. 

  636.                 if (isInput)

  637.                     ++(info.parameterIns);

  638.                 else

  639.                     ++(info.parameterOuts);

  640.             }

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

  642.             {

  643.                 if (isInput)

  644.                     ++(info.audioIns);

  645.                 else

  646.                     ++(info.audioOuts);

  647.             }

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

  649.             {

  650.             }

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

  652.             {

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

  654. 

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

  656.                 {

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

  658.                     CARLA_SAFE_ASSERT_CONTINUE(node.is_uri());

  659. 

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

  661.                     {

  662.                         if (isInput)

  663.                             ++(info.midiIns);

  664.                         else

  665.                             ++(info.midiOuts);

  666.                     }

  667.                 }

  668. 

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

  670.             }

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

  672.             {

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

  674.                 {

  675.                     if (isInput)

  676.                         ++(info.midiIns);

  677.                     else

  678.                         ++(info.midiOuts);

  679.                 }

  680.             }

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

  682.             {

  683.                 if (isInput)

  684.                     ++(info.midiIns);

  685.                 else

  686.                     ++(info.midiOuts);

  687.             }

  688.         }

  689. 

  690.         // text data

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

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

  693. 

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

  695. 

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

  697.             sname = name;

  698.         else

  699.             sname.clear();

  700. 

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

  702.             smaker = author;

  703.         else

  704.             smaker.clear();

  705. 

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

  707. 

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

  709.         {

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

  711.                 slicense = license;

  712.         }

  713. 

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

  715. 

  716.         info.name      = sname;

  717.         info.label     = suri;

  718.         info.maker     = smaker;

  719.         info.copyright = slicense;

  720. 

  721.         return &info;

  722.     }

  723. 

  724.     case CB::PLUGIN_AU: {

  725. #ifdef CARLA_OS_MAC

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

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

  728. 

  729.         using namespace juce;

  730. 

  731.         String pluginId(gCachedAuPluginResults[indexi]);

  732.         OwnedArray<PluginDescription> results;

  733. 

  734.         AudioUnitPluginFormat auFormat;

  735.         auFormat.findAllTypesForFile(results, pluginId);

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

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

  738. 

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

  740.         CARLA_SAFE_ASSERT_BREAK(desc != nullptr);

  741. 

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

  743.         info.hints    = 0x0;

  744. 

  745.         if (desc->isInstrument)

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

  747.         if (true)

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

  749. 

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

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

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

  753.         info.midiOuts  = 0;

  754.         info.parameterIns  = 0;

  755.         info.parameterOuts = 0;

  756. 

  757.         static CarlaString sname, slabel, smaker;

  758. 

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

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

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

  762. 

  763.         info.name      = sname;

  764.         info.label     = slabel;

  765.         info.maker     = smaker;

  766.         info.copyright = gNullCharPtr;

  767. 

  768.         return &info;

  769. #else

  770.         break;

  771. #endif

  772.     }

  773. 

  774.     default:

  775.         break;

  776.     }

  777. 

  778.     info.category      = CB::PLUGIN_CATEGORY_NONE;

  779.     info.hints         = 0x0;

  780.     info.audioIns      = 0;

  781.     info.audioOuts     = 0;

  782.     info.midiIns       = 0;

  783.     info.midiOuts      = 0;

  784.     info.parameterIns  = 0;

  785.     info.parameterOuts = 0;

  786.     info.name          = gNullCharPtr;

  787.     info.label         = gNullCharPtr;

  788.     info.maker         = gNullCharPtr;

  789.     info.copyright     = gNullCharPtr;

  790.     return &info;

  791. }

  792. 

  793. // -------------------------------------------------------------------------------------------------------------------

  794. 

  795. void carla_set_process_name(const char* name)

  796. {

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

  798. 

  799.     CarlaThread::setCurrentThreadName(name);

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

  801. }

  802. 

  803. // -------------------------------------------------------------------------------------------------------------------

  804. 

  805. class CarlaPipeClientPlugin : public CarlaPipeClient

  806. {

  807. public:

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

  809.         : CarlaPipeClient(),

  810.           fCallbackFunc(callbackFunc),

  811.           fCallbackPtr(callbackPtr),

  812.           leakDetector_CarlaPipeClientPlugin()

  813.     {

  814.         CARLA_SAFE_ASSERT(fCallbackFunc != nullptr);

  815.     }

  816. 

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

  818.     {

  819.         return CarlaPipeClient::_readlineblock(timeout);

  820.     }

  821. 

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

  823.     {

  824.         if (fCallbackFunc != nullptr)

  825.         {

  826.             try {

  827.                 fCallbackFunc(fCallbackPtr, msg);

  828.             } CARLA_SAFE_EXCEPTION("msgReceived");

  829.         }

  830. 

  831.         return true;

  832.     }

  833. 

  834. private:

  835.     const CarlaPipeCallbackFunc fCallbackFunc;

  836.     void* const fCallbackPtr;

  837. 

  838.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaPipeClientPlugin)

  839. };

  840. 

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

  842. {

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

  844. 

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

  846. 

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

  848.     {

  849.         delete pipe;

  850.         return nullptr;

  851.     }

  852. 

  853.     return pipe;

  854. }

  855. 

  856. void carla_pipe_client_idle(CarlaPipeClientHandle handle)

  857. {

  858.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  859. 

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

  861. }

  862. 

  863. bool carla_pipe_client_is_running(CarlaPipeClientHandle handle)

  864. {

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

  866. 

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

  868. }

  869. 

  870. void carla_pipe_client_lock(CarlaPipeClientHandle handle)

  871. {

  872.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  873. 

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

  875. }

  876. 

  877. void carla_pipe_client_unlock(CarlaPipeClientHandle handle)

  878. {

  879.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  880. 

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

  882. }

  883. 

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

  885. {

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

  887. 

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

  889. }

  890. 

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

  892. {

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

  894. 

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

  896. }

  897. 

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

  899. {

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

  901. 

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

  903. }

  904. 

  905. bool carla_pipe_client_flush(CarlaPipeClientHandle handle)

  906. {

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

  908. 

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

  910. }

  911. 

  912. bool carla_pipe_client_flush_and_unlock(CarlaPipeClientHandle handle)

  913. {

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

  915. 

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

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

  918.     pipe->unlockPipe();

  919.     return ret;

  920. }

  921. 

  922. void carla_pipe_client_destroy(CarlaPipeClientHandle handle)

  923. {

  924.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

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

  926. 

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

  928.     pipe->closePipeClient();

  929.     delete pipe;

  930. }

  931. 

  932. // -------------------------------------------------------------------------------------------------------------------

  933. 

  934. const char* carla_get_library_filename()

  935. {

  936.     carla_debug("carla_get_library_filename()");

  937. 

  938.     static CarlaString ret;

  939. 

  940.     if (ret.isEmpty())

  941.     {

  942.         using juce::File;

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

  944.     }

  945. 

  946.     return ret;

  947. }

  948. 

  949. const char* carla_get_library_folder()

  950. {

  951.     carla_debug("carla_get_library_folder()");

  952. 

  953.     static CarlaString ret;

  954. 

  955.     if (ret.isEmpty())

  956.     {

  957.         using juce::File;

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

  959.     }

  960. 

  961.     return ret;

  962. }

  963. 

  964. // -------------------------------------------------------------------------------------------------------------------

  965. 

  966. #include "CarlaPipeUtils.cpp"

  967. 

  968. // -------------------------------------------------------------------------------------------------------------------