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

742 lines
25KB
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 "CarlaHost.h"

  19. #include "CarlaNative.h"

  20. 

  21. #include "CarlaLv2Utils.hpp"

  22. #include "CarlaPlugin.hpp"

  23. #include "CarlaString.hpp"

  24. 

  25. #include "juce_audio_formats.h"

  26. 

  27. #ifdef CARLA_OS_MAC

  28. # include "juce_audio_processors.h"

  29. using juce::AudioUnitPluginFormat;

  30. using juce::StringArray;

  31. #endif

  32. 

  33. namespace CB = CarlaBackend;

  34. 

  35. // -------------------------------------------------------------------------------------------------------------------

  36. // Always return a valid string ptr

  37. 

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

  39. 

  40. #ifdef CARLA_COMMON_NEED_CHECKSTRINGPTR

  41. static void checkStringPtr(const char*& charPtr) noexcept

  42. {

  43.     if (charPtr == nullptr)

  44.         charPtr = gNullCharPtr;

  45. }

  46. #endif

  47. 

  48. // -------------------------------------------------------------------------------------------------------------------

  49. // Constructors

  50. 

  51. _CarlaPluginInfo::_CarlaPluginInfo() noexcept

  52.     : type(CB::PLUGIN_NONE),

  53.       category(CB::PLUGIN_CATEGORY_NONE),

  54.       hints(0x0),

  55.       optionsAvailable(0x0),

  56.       optionsEnabled(0x0),

  57.       filename(gNullCharPtr),

  58.       name(gNullCharPtr),

  59.       label(gNullCharPtr),

  60.       maker(gNullCharPtr),

  61.       copyright(gNullCharPtr),

  62.       iconName(gNullCharPtr),

  63.       uniqueId(0) {}

  64. 

  65. _CarlaPluginInfo::~_CarlaPluginInfo() noexcept

  66. {

  67.     if (label != gNullCharPtr)

  68.         delete[] label;

  69.     if (maker != gNullCharPtr)

  70.         delete[] maker;

  71.     if (copyright != gNullCharPtr)

  72.         delete[] copyright;

  73. }

  74. 

  75. _CarlaCachedPluginInfo::_CarlaCachedPluginInfo() noexcept

  76.     : category(CB::PLUGIN_CATEGORY_NONE),

  77.       hints(0x0),

  78.       audioIns(0),

  79.       audioOuts(0),

  80.       midiIns(0),

  81.       midiOuts(0),

  82.       parameterIns(0),

  83.       parameterOuts(0),

  84.       name(gNullCharPtr),

  85.       label(gNullCharPtr),

  86.       maker(gNullCharPtr),

  87.       copyright(gNullCharPtr) {}

  88. 

  89. _CarlaParameterInfo::_CarlaParameterInfo() noexcept

  90.     : name(gNullCharPtr),

  91.       symbol(gNullCharPtr),

  92.       unit(gNullCharPtr),

  93.       scalePointCount(0) {}

  94. 

  95. _CarlaParameterInfo::~_CarlaParameterInfo() noexcept

  96. {

  97.     if (name != gNullCharPtr)

  98.         delete[] name;

  99.     if (symbol != gNullCharPtr)

  100.         delete[] symbol;

  101.     if (unit != gNullCharPtr)

  102.         delete[] unit;

  103. }

  104. 

  105. _CarlaScalePointInfo::_CarlaScalePointInfo() noexcept

  106.     : value(0.0f),

  107.       label(gNullCharPtr) {}

  108. 

  109. _CarlaScalePointInfo::~_CarlaScalePointInfo() noexcept

  110. {

  111.     if (label != gNullCharPtr)

  112.         delete[] label;

  113. }

  114. 

  115. _CarlaTransportInfo::_CarlaTransportInfo() noexcept

  116.     : playing(false),

  117.       frame(0),

  118.       bar(0),

  119.       beat(0),

  120.       tick(0),

  121.       bpm(0.0) {}

  122. 

  123. // -------------------------------------------------------------------------------------------------------------------

  124. 

  125. const char* carla_get_complete_license_text()

  126. {

  127.     carla_debug("carla_get_complete_license_text()");

  128. 

  129.     static CarlaString retText;

  130. 

  131.     if (retText.isEmpty())

  132.     {

  133.         retText =

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

  135.         "<ul>"

  136. 

  137.         // Plugin formats

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

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

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

  141. #ifdef VESTIGE_HEADER

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

  143. #else

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

  145. #endif

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

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

  148. #endif

  149. #ifdef CARLA_OS_MAC

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

  151. #endif

  152. 

  153.         // Sample kit libraries

  154. #ifdef HAVE_FLUIDSYNTH

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

  156. #endif

  157. #ifdef HAVE_LINUXSAMPLER

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

  159. #endif

  160. 

  161.         // Internal plugins

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

  163. #ifdef WANT_ZYNADDSUBFX

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

  165. #endif

  166. 

  167.         // misc libs

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

  169. #ifdef CARLA_OS_MAC

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

  171. #endif

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

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

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

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

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

  177. #endif

  178. 

  179.         // end

  180.         "</ul>"

  181. 

  182.         "<p>"

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

  184.         // Required by VST SDK

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

  186. #endif

  187. #ifdef HAVE_LINUXSAMPLER

  188.         // LinuxSampler GPL exception

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

  190. #endif

  191.         "</p>"

  192.         ;

  193.     }

  194. 

  195.     return retText;

  196. }

  197. 

  198. const char* carla_get_juce_version()

  199. {

  200.     carla_debug("carla_get_juce_version()");

  201. 

  202.     static CarlaString retVersion;

  203. 

  204.     if (retVersion.isEmpty())

  205.     {

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

  207.             retVersion = version+6;

  208.         else

  209.             retVersion = "3.0";

  210.     }

  211. 

  212.     return retVersion;

  213. }

  214. 

  215. const char* carla_get_supported_file_extensions()

  216. {

  217.     carla_debug("carla_get_supported_file_extensions()");

  218. 

  219.     static CarlaString retText;

  220. 

  221.     if (retText.isEmpty())

  222.     {

  223.         retText =

  224.         // Base types

  225.         "*.carxp;*.carxs"

  226.         // MIDI files

  227.         ";*.mid;*.midi"

  228. #ifdef HAVE_FLUIDSYNTH

  229.         // fluidsynth (sf2)

  230.         ";*.sf2"

  231. #endif

  232. #ifdef HAVE_LINUXSAMPLER

  233.         // linuxsampler (gig and sfz)

  234.         ";*.gig;*.sfz"

  235. #endif

  236. #ifdef WANT_ZYNADDSUBFX

  237.         // zynaddsubfx presets

  238.         ";*.xmz;*.xiz"

  239. #endif

  240.         ;

  241. 

  242. #ifndef BUILD_BRIDGE

  243.         // Audio files

  244.         {

  245.             using namespace juce;

  246. 

  247.             AudioFormatManager afm;

  248.             afm.registerBasicFormats();

  249. 

  250.             String juceFormats;

  251. 

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

  253.             {

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

  255. 

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

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

  258.             }

  259. 

  260.             retText += juceFormats.toRawUTF8();

  261.         }

  262. #endif

  263.     }

  264. 

  265.     return retText;

  266. }

  267. 

  268. // -------------------------------------------------------------------------------------------------------------------

  269. 

  270. #ifdef CARLA_OS_MAC

  271. static StringArray gCachedAuPluginResults;

  272. #endif

  273. 

  274. uint carla_get_cached_plugin_count(PluginType ptype, const char* pluginPath)

  275. {

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

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

  278. 

  279.     switch (ptype)

  280.     {

  281.     case CB::PLUGIN_INTERNAL: {

  282. #ifndef BUILD_BRIDGE

  283.         return static_cast<uint>(CarlaPlugin::getNativePluginCount());

  284. #else

  285.         return 0;

  286. #endif

  287.     }

  288. 

  289.     case CB::PLUGIN_LV2: {

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

  291.         lv2World.initIfNeeded(pluginPath);

  292.         return lv2World.getPluginCount();

  293.     }

  294. 

  295.     case CB::PLUGIN_AU: {

  296. #ifdef CARLA_OS_MAC

  297.         static bool initiated = false;

  298. 

  299.         if (initiated)

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

  301. 

  302.         initiated = true;

  303.         AudioUnitPluginFormat auFormat;

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

  305. 

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

  307. #else

  308.         return 0;

  309. #endif

  310.     }

  311. 

  312.     default:

  313.         return 0;

  314.     }

  315. }

  316. 

  317. const CarlaCachedPluginInfo* carla_get_cached_plugin_info(PluginType ptype, uint index)

  318. {

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

  320. 

  321.     static CarlaCachedPluginInfo info;

  322. 

  323.     switch (ptype)

  324.     {

  325.     case CB::PLUGIN_INTERNAL: {

  326. #ifndef BUILD_BRIDGE

  327.         const NativePluginDescriptor* const desc(CarlaPlugin::getNativePluginDescriptor(index));

  328.         CARLA_SAFE_ASSERT_BREAK(desc != nullptr);

  329. 

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

  331.         info.hints    = 0x0;

  332. 

  333.         if (desc->hints & NATIVE_PLUGIN_IS_RTSAFE)

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

  335.         if (desc->hints & NATIVE_PLUGIN_IS_SYNTH)

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

  337.         if (desc->hints & NATIVE_PLUGIN_HAS_UI)

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

  339.         if (desc->hints & NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS)

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

  341.         if (desc->hints & NATIVE_PLUGIN_NEEDS_SINGLE_THREAD)

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

  343. 

  344.         info.audioIns      = desc->audioIns;

  345.         info.audioOuts     = desc->audioOuts;

  346.         info.midiIns       = desc->midiIns;

  347.         info.midiOuts      = desc->midiOuts;

  348.         info.parameterIns  = desc->paramIns;

  349.         info.parameterOuts = desc->paramOuts;

  350.         info.name          = desc->name;

  351.         info.label         = desc->label;

  352.         info.maker         = desc->maker;

  353.         info.copyright     = desc->copyright;

  354.         return &info;

  355. #else

  356.         break;

  357. #endif

  358.     }

  359. 

  360.     case CB::PLUGIN_LV2: {

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

  362. 

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

  364.         CARLA_SAFE_ASSERT_BREAK(cPlugin != nullptr);

  365. 

  366.         Lilv::Plugin lilvPlugin(cPlugin);

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

  368. 

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

  370. 

  371.         // features

  372.         info.hints = 0x0;

  373. 

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

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

  376. 

  377.         {

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

  379. 

  380.             LILV_FOREACH(nodes, it, lilvFeatureNodes)

  381.             {

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

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

  384.                 CARLA_SAFE_ASSERT_CONTINUE(featureURI != nullptr);

  385. 

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

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

  388.             }

  389. 

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

  391.         }

  392. 

  393.         // category

  394.         info.category = CB::PLUGIN_CATEGORY_NONE;

  395. 

  396.         {

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

  398. 

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

  400.             {

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

  402.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  404.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  406.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  408.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  410.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  412.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  414.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  416.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  418.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  420.                     info.category = CB::PLUGIN_CATEGORY_DELAY;

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

  422.                     info.category = CB::PLUGIN_CATEGORY_DISTORTION;

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

  424.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  426.                     info.category = CB::PLUGIN_CATEGORY_EQ;

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

  428.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  430.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  432.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  434.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  436.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  438.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  440.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  442.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  444.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  446.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  448.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  450.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  452.                     info.category = CB::PLUGIN_CATEGORY_EQ;

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

  454.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  456.                     info.category = CB::PLUGIN_CATEGORY_EQ;

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

  458.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  460.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  462.                     info.category = CB::PLUGIN_CATEGORY_DELAY;

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

  464.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  466.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  468.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  470.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  472.                     info.category = CB::PLUGIN_CATEGORY_DISTORTION;

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

  474.                 {

  475.                     info.category = CB::PLUGIN_CATEGORY_SYNTH;

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

  477.                 }

  478.             }

  479. 

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

  481.         }

  482. 

  483.         // number data

  484.         info.audioIns      = 0;

  485.         info.audioOuts     = 0;

  486.         info.midiIns       = 0;

  487.         info.midiOuts      = 0;

  488.         info.parameterIns  = 0;

  489.         info.parameterOuts = 0;

  490. 

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

  492.         {

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

  494. 

  495.             bool isInput;

  496. 

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

  498.                 isInput = true;

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

  500.                 isInput = false;

  501.             else

  502.                 continue;

  503. 

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

  505.             {

  506.                 // skip some control ports

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

  508.                     continue;

  509. 

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

  511.                 {

  512.                     bool skip = false;

  513. 

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

  515.                     {

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

  517.                             skip = true;

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

  519.                             skip = true;

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

  521.                             skip = true;

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

  523.                             skip = true;

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

  525.                             skip = true;

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

  527.                             skip = true;

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

  529.                             skip = true;

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

  531.                             skip = true;

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

  533.                             skip = true;

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

  535.                             skip = true;

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

  537.                             skip = true;

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

  539.                             skip = true;

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

  541.                             skip = true;

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

  543.                             skip = true;

  544.                     }

  545. 

  546.                     lilv_node_free(designationNode);

  547. 

  548.                     if (skip)

  549.                         continue;

  550.                 }

  551. 

  552.                 if (isInput)

  553.                     ++(info.parameterIns);

  554.                 else

  555.                     ++(info.parameterOuts);

  556.             }

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

  558.             {

  559.                 if (isInput)

  560.                     ++(info.audioIns);

  561.                 else

  562.                     ++(info.audioOuts);

  563.             }

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

  565.             {

  566.             }

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

  568.             {

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

  570. 

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

  572.                 {

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

  574.                     CARLA_SAFE_ASSERT_CONTINUE(node.is_uri());

  575. 

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

  577.                     {

  578.                         if (isInput)

  579.                             ++(info.midiIns);

  580.                         else

  581.                             ++(info.midiOuts);

  582.                     }

  583.                 }

  584. 

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

  586.             }

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

  588.             {

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

  590.                 {

  591.                     if (isInput)

  592.                         ++(info.midiIns);

  593.                     else

  594.                         ++(info.midiOuts);

  595.                 }

  596.             }

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

  598.             {

  599.                 if (isInput)

  600.                     ++(info.midiIns);

  601.                 else

  602.                     ++(info.midiOuts);

  603.             }

  604.         }

  605. 

  606.         // text data

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

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

  609. 

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

  611. 

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

  613.             sname = name;

  614.         else

  615.             sname.clear();

  616. 

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

  618.             smaker = author;

  619.         else

  620.             smaker.clear();

  621. 

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

  623. 

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

  625.         {

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

  627.                 slicense = license;

  628.         }

  629. 

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

  631. 

  632.         info.name      = sname;

  633.         info.label     = suri;

  634.         info.maker     = smaker;

  635.         info.copyright = slicense;

  636. 

  637.         return &info;

  638.     }

  639. 

  640.     case CB::PLUGIN_AU: {

  641. #ifdef CARLA_OS_MAC

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

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

  644. 

  645.         using namespace juce;

  646. 

  647.         String pluginId(gCachedAuPluginResults[indexi]);

  648.         OwnedArray<PluginDescription> results;

  649. 

  650.         AudioUnitPluginFormat auFormat;

  651.         auFormat.findAllTypesForFile(results, pluginId);

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

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

  654. 

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

  656.         CARLA_SAFE_ASSERT_BREAK(desc != nullptr);

  657. 

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

  659.         info.hints    = 0x0;

  660. 

  661.         if (desc->isInstrument)

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

  663.         if (true)

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

  665. 

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

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

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

  669.         info.midiOuts  = 0;

  670.         info.parameterIns  = 0;

  671.         info.parameterOuts = 0;

  672. 

  673.         static CarlaString sname, slabel, smaker;

  674. 

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

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

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

  678. 

  679.         info.name      = sname;

  680.         info.label     = slabel;

  681.         info.maker     = smaker;

  682.         info.copyright = gNullCharPtr;

  683. 

  684.         return &info;

  685. #else

  686.         break;

  687. #endif

  688.     }

  689. 

  690.     default:

  691.         break;

  692.     }

  693. 

  694.     info.category      = CB::PLUGIN_CATEGORY_NONE;

  695.     info.hints         = 0x0;

  696.     info.audioIns      = 0;

  697.     info.audioOuts     = 0;

  698.     info.midiIns       = 0;

  699.     info.midiOuts      = 0;

  700.     info.parameterIns  = 0;

  701.     info.parameterOuts = 0;

  702.     info.name          = gNullCharPtr;

  703.     info.label         = gNullCharPtr;

  704.     info.maker         = gNullCharPtr;

  705.     info.copyright     = gNullCharPtr;

  706.     return &info;

  707. }

  708. 

  709. // -------------------------------------------------------------------------------------------------------------------

  710. 

  711. const char* carla_get_library_filename()

  712. {

  713.     carla_debug("carla_get_library_filename()");

  714. 

  715.     static CarlaString ret;

  716. 

  717.     if (ret.isEmpty())

  718.     {

  719.         using juce::File;

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

  721.     }

  722. 

  723.     return ret;

  724. }

  725. 

  726. const char* carla_get_library_folder()

  727. {

  728.     carla_debug("carla_get_library_folder()");

  729. 

  730.     static CarlaString ret;

  731. 

  732.     if (ret.isEmpty())

  733.     {

  734.         using juce::File;

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

  736.     }

  737. 

  738.     return ret;

  739. }

  740. 

  741. // -------------------------------------------------------------------------------------------------------------------