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

740 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.         // features

  370.         info.hints = 0x0;

  371. 

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

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

  374. 

  375.         {

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

  377. 

  378.             LILV_FOREACH(nodes, it, lilvFeatureNodes)

  379.             {

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

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

  382.                 CARLA_SAFE_ASSERT_CONTINUE(featureURI != nullptr);

  383. 

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

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

  386.             }

  387. 

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

  389.         }

  390. 

  391.         // category

  392.         info.category = CB::PLUGIN_CATEGORY_NONE;

  393. 

  394.         {

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

  396. 

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

  398.             {

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

  400.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  402.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  404.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  406.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  408.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  410.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  412.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  414.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  416.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  418.                     info.category = CB::PLUGIN_CATEGORY_DELAY;

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

  420.                     info.category = CB::PLUGIN_CATEGORY_DISTORTION;

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

  422.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  424.                     info.category = CB::PLUGIN_CATEGORY_EQ;

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

  426.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  428.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  430.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  432.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  434.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  436.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  438.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  440.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  442.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  444.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  446.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  448.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  450.                     info.category = CB::PLUGIN_CATEGORY_EQ;

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

  452.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  454.                     info.category = CB::PLUGIN_CATEGORY_EQ;

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

  456.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  458.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  460.                     info.category = CB::PLUGIN_CATEGORY_DELAY;

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

  462.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  464.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  466.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  468.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  470.                     info.category = CB::PLUGIN_CATEGORY_DISTORTION;

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

  472.                 {

  473.                     info.category = CB::PLUGIN_CATEGORY_SYNTH;

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

  475.                 }

  476.             }

  477. 

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

  479.         }

  480. 

  481.         // number data

  482.         info.audioIns      = 0;

  483.         info.audioOuts     = 0;

  484.         info.midiIns       = 0;

  485.         info.midiOuts      = 0;

  486.         info.parameterIns  = 0;

  487.         info.parameterOuts = 0;

  488. 

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

  490.         {

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

  492. 

  493.             bool isInput;

  494. 

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

  496.                 isInput = true;

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

  498.                 isInput = false;

  499.             else

  500.                 continue;

  501. 

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

  503.             {

  504.                 // skip some control ports

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

  506.                     continue;

  507. 

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

  509.                 {

  510.                     bool skip = false;

  511. 

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

  513.                     {

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

  515.                             skip = true;

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

  517.                             skip = true;

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

  519.                             skip = true;

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

  521.                             skip = true;

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

  523.                             skip = true;

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

  525.                             skip = true;

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

  527.                             skip = true;

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

  529.                             skip = true;

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

  531.                             skip = true;

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

  533.                             skip = true;

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

  535.                             skip = true;

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

  537.                             skip = true;

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

  539.                             skip = true;

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

  541.                             skip = true;

  542.                     }

  543. 

  544.                     lilv_node_free(designationNode);

  545. 

  546.                     if (skip)

  547.                         continue;

  548.                 }

  549. 

  550.                 if (isInput)

  551.                     ++(info.parameterIns);

  552.                 else

  553.                     ++(info.parameterOuts);

  554.             }

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

  556.             {

  557.                 if (isInput)

  558.                     ++(info.audioIns);

  559.                 else

  560.                     ++(info.audioOuts);

  561.             }

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

  563.             {

  564.             }

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

  566.             {

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

  568. 

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

  570.                 {

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

  572.                     CARLA_SAFE_ASSERT_CONTINUE(node.is_uri());

  573. 

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

  575.                     {

  576.                         if (isInput)

  577.                             ++(info.midiIns);

  578.                         else

  579.                             ++(info.midiOuts);

  580.                     }

  581.                 }

  582. 

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

  584.             }

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

  586.             {

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

  588.                 {

  589.                     if (isInput)

  590.                         ++(info.midiIns);

  591.                     else

  592.                         ++(info.midiOuts);

  593.                 }

  594.             }

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

  596.             {

  597.                 if (isInput)

  598.                     ++(info.midiIns);

  599.                 else

  600.                     ++(info.midiOuts);

  601.             }

  602.         }

  603. 

  604.         // text data

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

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

  607. 

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

  609. 

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

  611.             sname = name;

  612.         else

  613.             sname.clear();

  614. 

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

  616.             smaker = author;

  617.         else

  618.             smaker.clear();

  619. 

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

  621. 

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

  623.         {

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

  625.                 slicense = license;

  626.         }

  627. 

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

  629. 

  630.         info.name      = sname;

  631.         info.label     = suri;

  632.         info.maker     = smaker;

  633.         info.copyright = slicense;

  634. 

  635.         return &info;

  636.     }

  637. 

  638.     case CB::PLUGIN_AU: {

  639. #ifdef CARLA_OS_MAC

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

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

  642. 

  643.         using namespace juce;

  644. 

  645.         String pluginId(gCachedAuPluginResults[indexi]);

  646.         OwnedArray<PluginDescription> results;

  647. 

  648.         AudioUnitPluginFormat auFormat;

  649.         auFormat.findAllTypesForFile(results, pluginId);

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

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

  652. 

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

  654.         CARLA_SAFE_ASSERT_BREAK(desc != nullptr);

  655. 

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

  657.         info.hints    = 0x0;

  658. 

  659.         if (desc->isInstrument)

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

  661.         if (true)

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

  663. 

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

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

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

  667.         info.midiOuts  = 0;

  668.         info.parameterIns  = 0;

  669.         info.parameterOuts = 0;

  670. 

  671.         static CarlaString sname, slabel, smaker;

  672. 

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

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

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

  676. 

  677.         info.name      = sname;

  678.         info.label     = slabel;

  679.         info.maker     = smaker;

  680.         info.copyright = gNullCharPtr;

  681. 

  682.         return &info;

  683. #else

  684.         break;

  685. #endif

  686.     }

  687. 

  688.     default:

  689.         break;

  690.     }

  691. 

  692.     info.category      = CB::PLUGIN_CATEGORY_NONE;

  693.     info.hints         = 0x0;

  694.     info.audioIns      = 0;

  695.     info.audioOuts     = 0;

  696.     info.midiIns       = 0;

  697.     info.midiOuts      = 0;

  698.     info.parameterIns  = 0;

  699.     info.parameterOuts = 0;

  700.     info.name          = gNullCharPtr;

  701.     info.label         = gNullCharPtr;

  702.     info.maker         = gNullCharPtr;

  703.     info.copyright     = gNullCharPtr;

  704.     return &info;

  705. }

  706. 

  707. // -------------------------------------------------------------------------------------------------------------------

  708. 

  709. const char* carla_get_library_filename()

  710. {

  711.     carla_debug("carla_get_library_filename()");

  712. 

  713.     static CarlaString ret;

  714. 

  715.     if (ret.isEmpty())

  716.     {

  717.         using juce::File;

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

  719.     }

  720. 

  721.     return ret;

  722. }

  723. 

  724. const char* carla_get_library_folder()

  725. {

  726.     carla_debug("carla_get_library_folder()");

  727. 

  728.     static CarlaString ret;

  729. 

  730.     if (ret.isEmpty())

  731.     {

  732.         using juce::File;

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

  734.     }

  735. 

  736.     return ret;

  737. }

  738. 

  739. // -------------------------------------------------------------------------------------------------------------------