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

976 lines
34KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

  3.  * Copyright (C) 2011-2014 Filipe Coelho <falktx@falktx.com>

  4.  *

  5.  * This program is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU General Public License as

  7.  * published by the Free Software Foundation; either version 2 of

  8.  * the License, or any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the doc/GPL.txt file.

  16.  */

  17. 

  18. #include "CarlaUtils.h"

  19. 

  20. #include "CarlaNative.h"

  21. 

  22. #include "CarlaBackendUtils.hpp"

  23. #include "CarlaLv2Utils.hpp"

  24. #include "CarlaPipeUtils.hpp"

  25. #include "CarlaThread.hpp"

  26. #include "LinkedList.hpp"

  27. 

  28. #include "juce_audio_formats.h"

  29. 

  30. #ifdef CARLA_OS_MAC

  31. # include "juce_audio_processors.h"

  32. #endif

  33. 

  34. namespace CB = CarlaBackend;

  35. 

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

  37. 

  38. #ifdef CARLA_OS_MAC

  39. static juce::StringArray gCachedAuPluginResults;

  40. #endif

  41. 

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

  43. 

  44. _CarlaCachedPluginInfo::_CarlaCachedPluginInfo() noexcept

  45.     : category(CB::PLUGIN_CATEGORY_NONE),

  46.       hints(0x0),

  47.       audioIns(0),

  48.       audioOuts(0),

  49.       midiIns(0),

  50.       midiOuts(0),

  51.       parameterIns(0),

  52.       parameterOuts(0),

  53.       name(gNullCharPtr),

  54.       label(gNullCharPtr),

  55.       maker(gNullCharPtr),

  56.       copyright(gNullCharPtr) {}

  57. 

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

  59. 

  60. static const NativePluginDescriptor carlaRackDesc = {

  61.     /* category  */ NATIVE_PLUGIN_CATEGORY_OTHER,

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

  63.                                                   |NATIVE_PLUGIN_HAS_UI

  64.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS

  65.                                                   |NATIVE_PLUGIN_NEEDS_SINGLE_THREAD

  66.                                                   |NATIVE_PLUGIN_NEEDS_DSP_IDLE

  67.                                                   |NATIVE_PLUGIN_USES_STATE

  68.                                                   |NATIVE_PLUGIN_USES_TIME),

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

  70.     /* audioIns  */ 2,

  71.     /* audioOuts */ 2,

  72.     /* midiIns   */ 1,

  73.     /* midiOuts  */ 1,

  74.     /* paramIns  */ 0,

  75.     /* paramOuts */ 0,

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

  77.     /* label     */ "carlarack",

  78.     /* maker     */ "falkTX",

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

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

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

  82.     nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  83.     nullptr, nullptr, nullptr, nullptr, nullptr

  84. };

  85. 

  86. static const NativePluginDescriptor carlaPatchbayDesc = {

  87.     /* category  */ NATIVE_PLUGIN_CATEGORY_OTHER,

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

  89.                                                   |NATIVE_PLUGIN_HAS_UI

  90.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS

  91.                                                   |NATIVE_PLUGIN_NEEDS_SINGLE_THREAD

  92.                                                   |NATIVE_PLUGIN_NEEDS_DSP_IDLE

  93.                                                   |NATIVE_PLUGIN_USES_STATE

  94.                                                   |NATIVE_PLUGIN_USES_TIME),

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

  96.     /* audioIns  */ 2,

  97.     /* audioOuts */ 2,

  98.     /* midiIns   */ 1,

  99.     /* midiOuts  */ 1,

  100.     /* paramIns  */ 0,

  101.     /* paramOuts */ 0,

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

  103.     /* label     */ "carlapatchbay",

  104.     /* maker     */ "falkTX",

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

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

  107.     nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  108.     nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  109.     nullptr, nullptr, nullptr, nullptr, nullptr

  110. };

  111. 

  112. static const NativePluginDescriptor carlaPatchbay3sDesc = {

  113.     /* category  */ NATIVE_PLUGIN_CATEGORY_OTHER,

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

  115.                                                   |NATIVE_PLUGIN_HAS_UI

  116.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS

  117.                                                   |NATIVE_PLUGIN_NEEDS_SINGLE_THREAD

  118.                                                   |NATIVE_PLUGIN_NEEDS_DSP_IDLE

  119.                                                   |NATIVE_PLUGIN_USES_STATE

  120.                                                   |NATIVE_PLUGIN_USES_TIME),

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

  122.     /* audioIns  */ 3,

  123.     /* audioOuts */ 2,

  124.     /* midiIns   */ 1,

  125.     /* midiOuts  */ 1,

  126.     /* paramIns  */ 0,

  127.     /* paramOuts */ 0,

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

  129.     /* label     */ "carlapatchbay3s",

  130.     /* maker     */ "falkTX",

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

  132.     nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  133.     nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  134.     nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  135.     nullptr, nullptr, nullptr, nullptr, nullptr

  136. };

  137. 

  138. static const NativePluginDescriptor carlaPatchbay16Desc = {

  139.     /* category  */ NATIVE_PLUGIN_CATEGORY_OTHER,

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

  141.                                                   |NATIVE_PLUGIN_HAS_UI

  142.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS

  143.                                                   |NATIVE_PLUGIN_NEEDS_SINGLE_THREAD

  144.                                                   |NATIVE_PLUGIN_NEEDS_DSP_IDLE

  145.                                                   |NATIVE_PLUGIN_USES_STATE

  146.                                                   |NATIVE_PLUGIN_USES_TIME),

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

  148.     /* audioIns  */ 16,

  149.     /* audioOuts */ 16,

  150.     /* midiIns   */ 1,

  151.     /* midiOuts  */ 1,

  152.     /* paramIns  */ 0,

  153.     /* paramOuts */ 0,

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

  155.     /* label     */ "carlapatchbay16",

  156.     /* maker     */ "falkTX",

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

  158.     nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  159.     nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  160.     nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  161.     nullptr, nullptr, nullptr, nullptr, nullptr

  162. };

  163. 

  164. static const NativePluginDescriptor carlaPatchbay32Desc = {

  165.     /* category  */ NATIVE_PLUGIN_CATEGORY_OTHER,

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

  167.                                                   |NATIVE_PLUGIN_HAS_UI

  168.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS

  169.                                                   |NATIVE_PLUGIN_NEEDS_SINGLE_THREAD

  170.                                                   |NATIVE_PLUGIN_NEEDS_DSP_IDLE

  171.                                                   |NATIVE_PLUGIN_USES_STATE

  172.                                                   |NATIVE_PLUGIN_USES_TIME),

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

  174.     /* audioIns  */ 32,

  175.     /* audioOuts */ 32,

  176.     /* midiIns   */ 1,

  177.     /* midiOuts  */ 1,

  178.     /* paramIns  */ 0,

  179.     /* paramOuts */ 0,

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

  181.     /* label     */ "carlapatchbay32",

  182.     /* maker     */ "falkTX",

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

  184.     nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  185.     nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  186.     nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  187.     nullptr, nullptr, nullptr, nullptr, nullptr

  188. };

  189. 

  190. static LinkedList<const NativePluginDescriptor*> gPluginDescriptors;

  191. 

  192. static const

  193. struct ScopedInitializer {

  194.     ScopedInitializer()

  195.     {

  196.         carla_register_all_plugins();

  197.     }

  198. 

  199.     ~ScopedInitializer()

  200.     {

  201.         gPluginDescriptors.clear();

  202.     }

  203. } _si;

  204. 

  205. // -------------------------------------------------------------------------------------------------------------------

  206. 

  207. CARLA_EXTERN_C

  208. void carla_register_native_plugin_carla();

  209. 

  210. void carla_register_native_plugin_carla()

  211. {

  212.     gPluginDescriptors.append(&carlaRackDesc);

  213.     gPluginDescriptors.append(&carlaPatchbayDesc);

  214.     gPluginDescriptors.append(&carlaPatchbay3sDesc);

  215.     gPluginDescriptors.append(&carlaPatchbay16Desc);

  216.     gPluginDescriptors.append(&carlaPatchbay32Desc);

  217. }

  218. 

  219. void carla_register_native_plugin(const NativePluginDescriptor* desc)

  220. {

  221.     gPluginDescriptors.append(desc);

  222. }

  223. 

  224. // -------------------------------------------------------------------------------------------------------------------

  225. 

  226. const char* carla_get_complete_license_text()

  227. {

  228.     carla_debug("carla_get_complete_license_text()");

  229. 

  230.     static CarlaString retText;

  231. 

  232.     if (retText.isEmpty())

  233.     {

  234.         retText =

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

  236.         "<ul>"

  237. 

  238.         // Plugin formats

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

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

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

  242. #ifdef VESTIGE_HEADER

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

  244. #else

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

  246. #endif

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

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

  249. #endif

  250. #ifdef CARLA_OS_MAC

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

  252. #endif

  253. 

  254.         // Sample kit libraries

  255. #ifdef HAVE_FLUIDSYNTH

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

  257. #endif

  258. #ifdef HAVE_LINUXSAMPLER

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

  260. #endif

  261. 

  262.         // Internal plugins

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

  264. #ifdef WANT_ZYNADDSUBFX

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

  266. #endif

  267. 

  268.         // misc libs

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

  270. #ifdef CARLA_OS_MAC

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

  272. #endif

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

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

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

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

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

  278. #endif

  279. 

  280.         // end

  281.         "</ul>"

  282. 

  283.         "<p>"

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

  285.         // Required by VST SDK

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

  287. #endif

  288. #ifdef HAVE_LINUXSAMPLER

  289.         // LinuxSampler GPL exception

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

  291. #endif

  292.         "</p>"

  293.         ;

  294.     }

  295. 

  296.     return retText;

  297. }

  298. 

  299. const char* carla_get_juce_version()

  300. {

  301.     carla_debug("carla_get_juce_version()");

  302. 

  303.     static CarlaString retVersion;

  304. 

  305.     if (retVersion.isEmpty())

  306.     {

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

  308.             retVersion = version+6;

  309.         else

  310.             retVersion = "3.0";

  311.     }

  312. 

  313.     return retVersion;

  314. }

  315. 

  316. const char* carla_get_supported_file_extensions()

  317. {

  318.     carla_debug("carla_get_supported_file_extensions()");

  319. 

  320.     static CarlaString retText;

  321. 

  322.     if (retText.isEmpty())

  323.     {

  324.         retText =

  325.         // Base types

  326.         "*.carxp;*.carxs"

  327.         // MIDI files

  328.         ";*.mid;*.midi"

  329. #ifdef HAVE_FLUIDSYNTH

  330.         // fluidsynth (sf2)

  331.         ";*.sf2"

  332. #endif

  333. #ifdef HAVE_LINUXSAMPLER

  334.         // linuxsampler (gig and sfz)

  335.         ";*.gig;*.sfz"

  336. #endif

  337. #ifdef WANT_ZYNADDSUBFX

  338.         // zynaddsubfx presets

  339.         ";*.xmz;*.xiz"

  340. #endif

  341.         ;

  342. 

  343.         // Audio files

  344.         {

  345.             using namespace juce;

  346. 

  347.             AudioFormatManager afm;

  348.             afm.registerBasicFormats();

  349. 

  350.             String juceFormats;

  351. 

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

  353.             {

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

  355. 

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

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

  358.             }

  359. 

  360.             retText += juceFormats.toRawUTF8();

  361.         }

  362.     }

  363. 

  364.     return retText;

  365. }

  366. 

  367. // -------------------------------------------------------------------------------------------------------------------

  368. 

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

  370. {

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

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

  373. 

  374.     switch (ptype)

  375.     {

  376.     case CB::PLUGIN_INTERNAL: {

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

  378.     }

  379. 

  380.     case CB::PLUGIN_LV2: {

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

  382.         lv2World.initIfNeeded(pluginPath);

  383.         return lv2World.getPluginCount();

  384.     }

  385. 

  386.     case CB::PLUGIN_AU: {

  387. #ifdef CARLA_OS_MAC

  388.         static bool initiated = false;

  389. 

  390.         if (initiated)

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

  392. 

  393.         using namespace juce;

  394. 

  395.         initiated = true;

  396.         AudioUnitPluginFormat auFormat;

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

  398. 

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

  400. #else

  401.         return 0;

  402. #endif

  403.     }

  404. 

  405.     default:

  406.         return 0;

  407.     }

  408. }

  409. 

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

  411. {

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

  413. 

  414.     static CarlaCachedPluginInfo info;

  415. 

  416.     switch (ptype)

  417.     {

  418.     case CB::PLUGIN_INTERNAL: {

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

  420.         CARLA_SAFE_ASSERT_BREAK(desc != nullptr);

  421. 

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

  423.         info.hints    = 0x0;

  424. 

  425.         if (desc->hints & NATIVE_PLUGIN_IS_RTSAFE)

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

  427.         if (desc->hints & NATIVE_PLUGIN_IS_SYNTH)

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

  429.         if (desc->hints & NATIVE_PLUGIN_HAS_UI)

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

  431.         if (desc->hints & NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS)

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

  433.         if (desc->hints & NATIVE_PLUGIN_NEEDS_SINGLE_THREAD)

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

  435. 

  436.         info.audioIns      = desc->audioIns;

  437.         info.audioOuts     = desc->audioOuts;

  438.         info.midiIns       = desc->midiIns;

  439.         info.midiOuts      = desc->midiOuts;

  440.         info.parameterIns  = desc->paramIns;

  441.         info.parameterOuts = desc->paramOuts;

  442.         info.name          = desc->name;

  443.         info.label         = desc->label;

  444.         info.maker         = desc->maker;

  445.         info.copyright     = desc->copyright;

  446.         return &info;

  447.     }

  448. 

  449.     case CB::PLUGIN_LV2: {

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

  451. 

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

  453.         CARLA_SAFE_ASSERT_BREAK(cPlugin != nullptr);

  454. 

  455.         Lilv::Plugin lilvPlugin(cPlugin);

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

  457. 

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

  459. 

  460.         // features

  461.         info.hints = 0x0;

  462. 

  463. #if 0

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

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

  466. #endif

  467. 

  468.         {

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

  470. 

  471.             LILV_FOREACH(nodes, it, lilvFeatureNodes)

  472.             {

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

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

  475.                 CARLA_SAFE_ASSERT_CONTINUE(featureURI != nullptr);

  476. 

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

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

  479.             }

  480. 

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

  482.         }

  483. 

  484.         // category

  485.         info.category = CB::PLUGIN_CATEGORY_NONE;

  486. 

  487.         {

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

  489. 

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

  491.             {

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

  493.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  495.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  497.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  499.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  501.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  503.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  505.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  507.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  509.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  511.                     info.category = CB::PLUGIN_CATEGORY_DELAY;

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

  513.                     info.category = CB::PLUGIN_CATEGORY_DISTORTION;

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

  515.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  517.                     info.category = CB::PLUGIN_CATEGORY_EQ;

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

  519.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  521.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  523.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  525.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  527.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  529.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  531.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  533.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  535.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  537.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  539.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  541.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  543.                     info.category = CB::PLUGIN_CATEGORY_EQ;

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

  545.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  547.                     info.category = CB::PLUGIN_CATEGORY_EQ;

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

  549.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  551.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  553.                     info.category = CB::PLUGIN_CATEGORY_DELAY;

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

  555.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  557.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  559.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  561.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  563.                     info.category = CB::PLUGIN_CATEGORY_DISTORTION;

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

  565.                 {

  566.                     info.category = CB::PLUGIN_CATEGORY_SYNTH;

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

  568.                 }

  569.             }

  570. 

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

  572.         }

  573. 

  574.         // number data

  575.         info.audioIns      = 0;

  576.         info.audioOuts     = 0;

  577.         info.midiIns       = 0;

  578.         info.midiOuts      = 0;

  579.         info.parameterIns  = 0;

  580.         info.parameterOuts = 0;

  581. 

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

  583.         {

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

  585. 

  586.             bool isInput;

  587. 

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

  589.                 isInput = true;

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

  591.                 isInput = false;

  592.             else

  593.                 continue;

  594. 

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

  596.             {

  597.                 // skip some control ports

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

  599.                     continue;

  600. 

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

  602.                 {

  603.                     bool skip = false;

  604. 

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

  606.                     {

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

  608.                             skip = true;

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

  610.                             skip = true;

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

  612.                             skip = true;

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

  614.                             skip = true;

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

  616.                             skip = true;

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

  618.                             skip = true;

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

  620.                             skip = true;

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

  622.                             skip = true;

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

  624.                             skip = true;

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

  626.                             skip = true;

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

  628.                             skip = true;

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

  630.                             skip = true;

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

  632.                             skip = true;

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

  634.                             skip = true;

  635.                     }

  636. 

  637.                     lilv_node_free(designationNode);

  638. 

  639.                     if (skip)

  640.                         continue;

  641.                 }

  642. 

  643.                 if (isInput)

  644.                     ++(info.parameterIns);

  645.                 else

  646.                     ++(info.parameterOuts);

  647.             }

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

  649.             {

  650.                 if (isInput)

  651.                     ++(info.audioIns);

  652.                 else

  653.                     ++(info.audioOuts);

  654.             }

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

  656.             {

  657.             }

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

  659.             {

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

  661. 

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

  663.                 {

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

  665.                     CARLA_SAFE_ASSERT_CONTINUE(node.is_uri());

  666. 

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

  668.                     {

  669.                         if (isInput)

  670.                             ++(info.midiIns);

  671.                         else

  672.                             ++(info.midiOuts);

  673.                     }

  674.                 }

  675. 

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

  677.             }

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

  679.             {

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

  681.                 {

  682.                     if (isInput)

  683.                         ++(info.midiIns);

  684.                     else

  685.                         ++(info.midiOuts);

  686.                 }

  687.             }

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

  689.             {

  690.                 if (isInput)

  691.                     ++(info.midiIns);

  692.                 else

  693.                     ++(info.midiOuts);

  694.             }

  695.         }

  696. 

  697.         // text data

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

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

  700. 

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

  702. 

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

  704.             sname = name;

  705.         else

  706.             sname.clear();

  707. 

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

  709.             smaker = author;

  710.         else

  711.             smaker.clear();

  712. 

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

  714. 

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

  716.         {

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

  718.                 slicense = license;

  719.         }

  720. 

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

  722. 

  723.         info.name      = sname;

  724.         info.label     = suri;

  725.         info.maker     = smaker;

  726.         info.copyright = slicense;

  727. 

  728.         return &info;

  729.     }

  730. 

  731.     case CB::PLUGIN_AU: {

  732. #ifdef CARLA_OS_MAC

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

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

  735. 

  736.         using namespace juce;

  737. 

  738.         String pluginId(gCachedAuPluginResults[indexi]);

  739.         OwnedArray<PluginDescription> results;

  740. 

  741.         AudioUnitPluginFormat auFormat;

  742.         auFormat.findAllTypesForFile(results, pluginId);

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

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

  745. 

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

  747.         CARLA_SAFE_ASSERT_BREAK(desc != nullptr);

  748. 

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

  750.         info.hints    = 0x0;

  751. 

  752.         if (desc->isInstrument)

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

  754.         if (true)

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

  756. 

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

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

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

  760.         info.midiOuts  = 0;

  761.         info.parameterIns  = 0;

  762.         info.parameterOuts = 0;

  763. 

  764.         static CarlaString sname, slabel, smaker;

  765. 

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

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

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

  769. 

  770.         info.name      = sname;

  771.         info.label     = slabel;

  772.         info.maker     = smaker;

  773.         info.copyright = gNullCharPtr;

  774. 

  775.         return &info;

  776. #else

  777.         break;

  778. #endif

  779.     }

  780. 

  781.     default:

  782.         break;

  783.     }

  784. 

  785.     info.category      = CB::PLUGIN_CATEGORY_NONE;

  786.     info.hints         = 0x0;

  787.     info.audioIns      = 0;

  788.     info.audioOuts     = 0;

  789.     info.midiIns       = 0;

  790.     info.midiOuts      = 0;

  791.     info.parameterIns  = 0;

  792.     info.parameterOuts = 0;

  793.     info.name          = gNullCharPtr;

  794.     info.label         = gNullCharPtr;

  795.     info.maker         = gNullCharPtr;

  796.     info.copyright     = gNullCharPtr;

  797.     return &info;

  798. }

  799. 

  800. // -------------------------------------------------------------------------------------------------------------------

  801. 

  802. void carla_set_process_name(const char* name)

  803. {

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

  805. 

  806.     CarlaThread::setCurrentThreadName(name);

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

  808. }

  809. 

  810. // -------------------------------------------------------------------------------------------------------------------

  811. 

  812. class CarlaPipeClientPlugin : public CarlaPipeClient

  813. {

  814. public:

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

  816.         : CarlaPipeClient(),

  817.           fCallbackFunc(callbackFunc),

  818.           fCallbackPtr(callbackPtr),

  819.           leakDetector_CarlaPipeClientPlugin()

  820.     {

  821.         CARLA_SAFE_ASSERT(fCallbackFunc != nullptr);

  822.     }

  823. 

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

  825.     {

  826.         return CarlaPipeClient::_readlineblock(timeout);

  827.     }

  828. 

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

  830.     {

  831.         if (fCallbackFunc != nullptr)

  832.         {

  833.             try {

  834.                 fCallbackFunc(fCallbackPtr, msg);

  835.             } CARLA_SAFE_EXCEPTION("msgReceived");

  836.         }

  837. 

  838.         return true;

  839.     }

  840. 

  841. private:

  842.     const CarlaPipeCallbackFunc fCallbackFunc;

  843.     void* const fCallbackPtr;

  844. 

  845.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaPipeClientPlugin)

  846. };

  847. 

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

  849. {

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

  851. 

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

  853. 

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

  855.     {

  856.         delete pipe;

  857.         return nullptr;

  858.     }

  859. 

  860.     return pipe;

  861. }

  862. 

  863. void carla_pipe_client_idle(CarlaPipeClientHandle handle)

  864. {

  865.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  866. 

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

  868. }

  869. 

  870. bool carla_pipe_client_is_running(CarlaPipeClientHandle handle)

  871. {

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

  873. 

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

  875. }

  876. 

  877. void carla_pipe_client_lock(CarlaPipeClientHandle handle)

  878. {

  879.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  880. 

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

  882. }

  883. 

  884. void carla_pipe_client_unlock(CarlaPipeClientHandle handle)

  885. {

  886.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  887. 

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

  889. }

  890. 

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

  892. {

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

  894. 

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

  896. }

  897. 

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

  899. {

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

  901. 

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

  903. }

  904. 

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

  906. {

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

  908. 

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

  910. }

  911. 

  912. bool carla_pipe_client_flush(CarlaPipeClientHandle handle)

  913. {

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

  915. 

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

  917. }

  918. 

  919. bool carla_pipe_client_flush_and_unlock(CarlaPipeClientHandle handle)

  920. {

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

  922. 

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

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

  925.     pipe->unlockPipe();

  926.     return ret;

  927. }

  928. 

  929. void carla_pipe_client_destroy(CarlaPipeClientHandle handle)

  930. {

  931.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

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

  933. 

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

  935.     pipe->closePipeClient();

  936.     delete pipe;

  937. }

  938. 

  939. // -------------------------------------------------------------------------------------------------------------------

  940. 

  941. const char* carla_get_library_filename()

  942. {

  943.     carla_debug("carla_get_library_filename()");

  944. 

  945.     static CarlaString ret;

  946. 

  947.     if (ret.isEmpty())

  948.     {

  949.         using juce::File;

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

  951.     }

  952. 

  953.     return ret;

  954. }

  955. 

  956. const char* carla_get_library_folder()

  957. {

  958.     carla_debug("carla_get_library_folder()");

  959. 

  960.     static CarlaString ret;

  961. 

  962.     if (ret.isEmpty())

  963.     {

  964.         using juce::File;

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

  966.     }

  967. 

  968.     return ret;

  969. }

  970. 

  971. // -------------------------------------------------------------------------------------------------------------------

  972. 

  973. #include "CarlaPipeUtils.cpp"

  974. 

  975. // -------------------------------------------------------------------------------------------------------------------