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

975 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. #if defined(CARLA_OS_MAC) || defined(CARLA_OS_WIN) || ! defined(VESTIGE_HEADER)

  234. # define LS_NOTE_NO "2"

  235. #else

  236. # define LS_NOTE_NO "1"

  237. #endif

  238. 

  239.         // Plugin formats

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

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

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

  243. #ifdef VESTIGE_HEADER

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

  245. #else

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

  247. #endif

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

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

  250. #endif

  251. #ifdef CARLA_OS_MAC

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

  253. #endif

  254. 

  255.         // Sample kit libraries

  256. #ifdef HAVE_FLUIDSYNTH

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

  258. #endif

  259. #ifdef HAVE_LINUXSAMPLER

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

  261. #endif

  262. 

  263.         // Internal plugins

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

  265. #ifdef HAVE_ZYN_DEPS

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

  267. #endif

  268. 

  269.         // misc libs

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

  271. #ifdef CARLA_OS_MAC

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

  273. #endif

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

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

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

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

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

  279. #endif

  280. 

  281.         // end

  282.         "</ul>"

  283. 

  284.         "<p>"

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

  286.         // Required by VST SDK

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

  288. #endif

  289. #ifdef HAVE_LINUXSAMPLER

  290.         // LinuxSampler GPL exception

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

  292. #endif

  293.         "</p>"

  294.         ;

  295.     }

  296. 

  297.     return retText;

  298. }

  299. 

  300. const char* carla_get_juce_version()

  301. {

  302.     carla_debug("carla_get_juce_version()");

  303. 

  304.     static CarlaString retVersion;

  305. 

  306.     if (retVersion.isEmpty())

  307.     {

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

  309.             retVersion = version+6;

  310.         else

  311.             retVersion = "3.0";

  312.     }

  313. 

  314.     return retVersion;

  315. }

  316. 

  317. const char* carla_get_supported_file_extensions()

  318. {

  319.     carla_debug("carla_get_supported_file_extensions()");

  320. 

  321.     static CarlaString retText;

  322. 

  323.     if (retText.isEmpty())

  324.     {

  325.         retText =

  326.         // Base types

  327.         "*.carxp;*.carxs"

  328.         // MIDI files

  329.         ";*.mid;*.midi"

  330. #ifdef HAVE_FLUIDSYNTH

  331.         // fluidsynth (sf2)

  332.         ";*.sf2"

  333. #endif

  334. #ifdef HAVE_LINUXSAMPLER

  335.         // linuxsampler (gig and sfz)

  336.         ";*.gig;*.sfz"

  337. #endif

  338. #ifdef HAVE_ZYN_DEPS

  339.         // zynaddsubfx presets

  340.         ";*.xmz;*.xiz"

  341. #endif

  342.         ;

  343. 

  344.         // Audio files

  345.         {

  346.             using namespace juce;

  347. 

  348.             AudioFormatManager afm;

  349.             afm.registerBasicFormats();

  350. 

  351.             String juceFormats;

  352. 

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

  354.             {

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

  356. 

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

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

  359.             }

  360. 

  361.             retText += juceFormats.toRawUTF8();

  362.         }

  363.     }

  364. 

  365.     return retText;

  366. }

  367. 

  368. // -------------------------------------------------------------------------------------------------------------------

  369. 

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

  371. {

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

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

  374. 

  375.     switch (ptype)

  376.     {

  377.     case CB::PLUGIN_INTERNAL: {

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

  379.     }

  380. 

  381.     case CB::PLUGIN_LV2: {

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

  383.         lv2World.initIfNeeded(pluginPath);

  384.         return lv2World.getPluginCount();

  385.     }

  386. 

  387.     case CB::PLUGIN_AU: {

  388. #ifdef CARLA_OS_MAC

  389.         static bool initiated = false;

  390. 

  391.         if (initiated)

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

  393. 

  394.         using namespace juce;

  395. 

  396.         initiated = true;

  397.         AudioUnitPluginFormat auFormat;

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

  399. 

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

  401. #else

  402.         return 0;

  403. #endif

  404.     }

  405. 

  406.     default:

  407.         return 0;

  408.     }

  409. }

  410. 

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

  412. {

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

  414. 

  415.     static CarlaCachedPluginInfo info;

  416. 

  417.     switch (ptype)

  418.     {

  419.     case CB::PLUGIN_INTERNAL: {

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

  421.         CARLA_SAFE_ASSERT_BREAK(desc != nullptr);

  422. 

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

  424.         info.hints    = 0x0;

  425. 

  426.         if (desc->hints & NATIVE_PLUGIN_IS_RTSAFE)

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

  428.         if (desc->hints & NATIVE_PLUGIN_IS_SYNTH)

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

  430.         if (desc->hints & NATIVE_PLUGIN_HAS_UI)

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

  432.         if (desc->hints & NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS)

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

  434.         if (desc->hints & NATIVE_PLUGIN_NEEDS_UI_MAIN_THREAD)

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

  436. 

  437.         info.audioIns      = desc->audioIns;

  438.         info.audioOuts     = desc->audioOuts;

  439.         info.midiIns       = desc->midiIns;

  440.         info.midiOuts      = desc->midiOuts;

  441.         info.parameterIns  = desc->paramIns;

  442.         info.parameterOuts = desc->paramOuts;

  443.         info.name          = desc->name;

  444.         info.label         = desc->label;

  445.         info.maker         = desc->maker;

  446.         info.copyright     = desc->copyright;

  447.         return &info;

  448.     }

  449. 

  450.     case CB::PLUGIN_LV2: {

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

  452. 

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

  454.         CARLA_SAFE_ASSERT_BREAK(cPlugin != nullptr);

  455. 

  456.         Lilv::Plugin lilvPlugin(cPlugin);

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

  458. 

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

  460. 

  461.         // features

  462.         info.hints = 0x0;

  463. 

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

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

  466. 

  467.         {

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

  469. 

  470.             LILV_FOREACH(nodes, it, lilvFeatureNodes)

  471.             {

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

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

  474.                 CARLA_SAFE_ASSERT_CONTINUE(featureURI != nullptr);

  475. 

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

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

  478.             }

  479. 

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

  481.         }

  482. 

  483.         // category

  484.         info.category = CB::PLUGIN_CATEGORY_NONE;

  485. 

  486.         {

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

  488. 

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

  490.             {

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

  492.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  494.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  496.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  498.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  500.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  502.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  504.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  506.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  508.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  510.                     info.category = CB::PLUGIN_CATEGORY_DELAY;

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

  512.                     info.category = CB::PLUGIN_CATEGORY_DISTORTION;

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

  514.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  516.                     info.category = CB::PLUGIN_CATEGORY_EQ;

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

  518.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  520.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  522.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  524.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  526.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  528.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  530.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  532.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  534.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  536.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  538.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  540.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  542.                     info.category = CB::PLUGIN_CATEGORY_EQ;

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

  544.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  546.                     info.category = CB::PLUGIN_CATEGORY_EQ;

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

  548.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  550.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  552.                     info.category = CB::PLUGIN_CATEGORY_DELAY;

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

  554.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  556.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  558.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  560.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  562.                     info.category = CB::PLUGIN_CATEGORY_DISTORTION;

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

  564.                 {

  565.                     info.category = CB::PLUGIN_CATEGORY_SYNTH;

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

  567.                 }

  568.             }

  569. 

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

  571.         }

  572. 

  573.         // number data

  574.         info.audioIns      = 0;

  575.         info.audioOuts     = 0;

  576.         info.midiIns       = 0;

  577.         info.midiOuts      = 0;

  578.         info.parameterIns  = 0;

  579.         info.parameterOuts = 0;

  580. 

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

  582.         {

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

  584. 

  585.             bool isInput;

  586. 

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

  588.                 isInput = true;

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

  590.                 isInput = false;

  591.             else

  592.                 continue;

  593. 

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

  595.             {

  596.                 // skip some control ports

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

  598.                     continue;

  599. 

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

  601.                 {

  602.                     bool skip = false;

  603. 

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

  605.                     {

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

  607.                             skip = true;

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

  609.                             skip = true;

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

  611.                             skip = true;

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

  613.                             skip = true;

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

  615.                             skip = true;

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

  617.                             skip = true;

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

  619.                             skip = true;

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

  621.                             skip = true;

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

  623.                             skip = true;

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

  625.                             skip = true;

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

  627.                             skip = true;

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

  629.                             skip = true;

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

  631.                             skip = true;

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

  633.                             skip = true;

  634.                     }

  635. 

  636.                     lilv_node_free(designationNode);

  637. 

  638.                     if (skip)

  639.                         continue;

  640.                 }

  641. 

  642.                 if (isInput)

  643.                     ++(info.parameterIns);

  644.                 else

  645.                     ++(info.parameterOuts);

  646.             }

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

  648.             {

  649.                 if (isInput)

  650.                     ++(info.audioIns);

  651.                 else

  652.                     ++(info.audioOuts);

  653.             }

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

  655.             {

  656.             }

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

  658.             {

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

  660. 

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

  662.                 {

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

  664.                     CARLA_SAFE_ASSERT_CONTINUE(node.is_uri());

  665. 

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

  667.                     {

  668.                         if (isInput)

  669.                             ++(info.midiIns);

  670.                         else

  671.                             ++(info.midiOuts);

  672.                     }

  673.                 }

  674. 

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

  676.             }

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

  678.             {

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

  680.                 {

  681.                     if (isInput)

  682.                         ++(info.midiIns);

  683.                     else

  684.                         ++(info.midiOuts);

  685.                 }

  686.             }

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

  688.             {

  689.                 if (isInput)

  690.                     ++(info.midiIns);

  691.                 else

  692.                     ++(info.midiOuts);

  693.             }

  694.         }

  695. 

  696.         // text data

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

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

  699. 

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

  701. 

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

  703.             sname = name;

  704.         else

  705.             sname.clear();

  706. 

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

  708.             smaker = author;

  709.         else

  710.             smaker.clear();

  711. 

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

  713. 

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

  715.         {

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

  717.                 slicense = license;

  718.         }

  719. 

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

  721. 

  722.         info.name      = sname;

  723.         info.label     = suri;

  724.         info.maker     = smaker;

  725.         info.copyright = slicense;

  726. 

  727.         return &info;

  728.     }

  729. 

  730.     case CB::PLUGIN_AU: {

  731. #ifdef CARLA_OS_MAC

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

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

  734. 

  735.         using namespace juce;

  736. 

  737.         String pluginId(gCachedAuPluginResults[indexi]);

  738.         OwnedArray<PluginDescription> results;

  739. 

  740.         AudioUnitPluginFormat auFormat;

  741.         auFormat.findAllTypesForFile(results, pluginId);

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

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

  744. 

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

  746.         CARLA_SAFE_ASSERT_BREAK(desc != nullptr);

  747. 

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

  749.         info.hints    = 0x0;

  750. 

  751.         if (desc->isInstrument)

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

  753.         if (true)

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

  755. 

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

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

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

  759.         info.midiOuts  = 0;

  760.         info.parameterIns  = 0;

  761.         info.parameterOuts = 0;

  762. 

  763.         static CarlaString sname, slabel, smaker;

  764. 

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

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

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

  768. 

  769.         info.name      = sname;

  770.         info.label     = slabel;

  771.         info.maker     = smaker;

  772.         info.copyright = gNullCharPtr;

  773. 

  774.         return &info;

  775. #else

  776.         break;

  777. #endif

  778.     }

  779. 

  780.     default:

  781.         break;

  782.     }

  783. 

  784.     info.category      = CB::PLUGIN_CATEGORY_NONE;

  785.     info.hints         = 0x0;

  786.     info.audioIns      = 0;

  787.     info.audioOuts     = 0;

  788.     info.midiIns       = 0;

  789.     info.midiOuts      = 0;

  790.     info.parameterIns  = 0;

  791.     info.parameterOuts = 0;

  792.     info.name          = gNullCharPtr;

  793.     info.label         = gNullCharPtr;

  794.     info.maker         = gNullCharPtr;

  795.     info.copyright     = gNullCharPtr;

  796.     return &info;

  797. }

  798. 

  799. // -------------------------------------------------------------------------------------------------------------------

  800. 

  801. void carla_set_process_name(const char* name)

  802. {

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

  804. 

  805.     CarlaThread::setCurrentThreadName(name);

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

  807. }

  808. 

  809. // -------------------------------------------------------------------------------------------------------------------

  810. 

  811. class CarlaPipeClientPlugin : public CarlaPipeClient

  812. {

  813. public:

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

  815.         : CarlaPipeClient(),

  816.           fCallbackFunc(callbackFunc),

  817.           fCallbackPtr(callbackPtr),

  818.           leakDetector_CarlaPipeClientPlugin()

  819.     {

  820.         CARLA_SAFE_ASSERT(fCallbackFunc != nullptr);

  821.     }

  822. 

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

  824.     {

  825.         return CarlaPipeClient::_readlineblock(timeout);

  826.     }

  827. 

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

  829.     {

  830.         if (fCallbackFunc != nullptr)

  831.         {

  832.             try {

  833.                 fCallbackFunc(fCallbackPtr, msg);

  834.             } CARLA_SAFE_EXCEPTION("msgReceived");

  835.         }

  836. 

  837.         return true;

  838.     }

  839. 

  840. private:

  841.     const CarlaPipeCallbackFunc fCallbackFunc;

  842.     void* const fCallbackPtr;

  843. 

  844.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaPipeClientPlugin)

  845. };

  846. 

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

  848. {

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

  850. 

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

  852. 

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

  854.     {

  855.         delete pipe;

  856.         return nullptr;

  857.     }

  858. 

  859.     return pipe;

  860. }

  861. 

  862. void carla_pipe_client_idle(CarlaPipeClientHandle handle)

  863. {

  864.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  865. 

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

  867. }

  868. 

  869. bool carla_pipe_client_is_running(CarlaPipeClientHandle handle)

  870. {

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

  872. 

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

  874. }

  875. 

  876. void carla_pipe_client_lock(CarlaPipeClientHandle handle)

  877. {

  878.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  879. 

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

  881. }

  882. 

  883. void carla_pipe_client_unlock(CarlaPipeClientHandle handle)

  884. {

  885.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  886. 

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

  888. }

  889. 

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

  891. {

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

  893. 

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

  895. }

  896. 

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

  898. {

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

  900. 

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

  902. }

  903. 

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

  905. {

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

  907. 

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

  909. }

  910. 

  911. bool carla_pipe_client_flush(CarlaPipeClientHandle handle)

  912. {

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

  914. 

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

  916. }

  917. 

  918. bool carla_pipe_client_flush_and_unlock(CarlaPipeClientHandle handle)

  919. {

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

  921. 

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

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

  924.     pipe->unlockPipe();

  925.     return ret;

  926. }

  927. 

  928. void carla_pipe_client_destroy(CarlaPipeClientHandle handle)

  929. {

  930.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

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

  932. 

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

  934.     pipe->closePipeClient();

  935.     delete pipe;

  936. }

  937. 

  938. // -------------------------------------------------------------------------------------------------------------------

  939. 

  940. const char* carla_get_library_filename()

  941. {

  942.     carla_debug("carla_get_library_filename()");

  943. 

  944.     static CarlaString ret;

  945. 

  946.     if (ret.isEmpty())

  947.     {

  948.         using juce::File;

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

  950.     }

  951. 

  952.     return ret;

  953. }

  954. 

  955. const char* carla_get_library_folder()

  956. {

  957.     carla_debug("carla_get_library_folder()");

  958. 

  959.     static CarlaString ret;

  960. 

  961.     if (ret.isEmpty())

  962.     {

  963.         using juce::File;

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

  965.     }

  966. 

  967.     return ret;

  968. }

  969. 

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

  971. 

  972. #include "CarlaPipeUtils.cpp"

  973. 

  974. // -------------------------------------------------------------------------------------------------------------------