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

831 lines
28KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

  3.  * Copyright (C) 2011-2016 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. #ifndef CARLA_UTILS_CACHED_PLUGINS_ONLY

  29. # include "juce_audio_formats/juce_audio_formats.h"

  30. #endif

  31. 

  32. #ifdef CARLA_OS_MAC

  33. # include "juce_audio_processors/juce_audio_processors.h"

  34. #endif

  35. 

  36. #include "../native-plugins/_data.cpp"

  37. 

  38. namespace CB = CarlaBackend;

  39. 

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

  41. 

  42. #ifdef CARLA_OS_MAC

  43. static juce::StringArray gCachedAuPluginResults;

  44. #endif

  45. 

  46. // -------------------------------------------------------------------------------------------------------------------

  47. 

  48. _CarlaCachedPluginInfo::_CarlaCachedPluginInfo() noexcept

  49.     : category(CB::PLUGIN_CATEGORY_NONE),

  50.       hints(0x0),

  51.       audioIns(0),

  52.       audioOuts(0),

  53.       midiIns(0),

  54.       midiOuts(0),

  55.       parameterIns(0),

  56.       parameterOuts(0),

  57.       name(gNullCharPtr),

  58.       label(gNullCharPtr),

  59.       maker(gNullCharPtr),

  60.       copyright(gNullCharPtr) {}

  61. 

  62. // -------------------------------------------------------------------------------------------------------------------

  63. 

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

  65. {

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

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

  68. 

  69.     switch (ptype)

  70.     {

  71.     case CB::PLUGIN_INTERNAL: {

  72.         uint32_t count = 0;

  73.         carla_get_native_plugins_data(&count);

  74.         return count;

  75.     }

  76. 

  77.     case CB::PLUGIN_LV2: {

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

  79.         lv2World.initIfNeeded(pluginPath);

  80.         return lv2World.getPluginCount();

  81.     }

  82. 

  83.     case CB::PLUGIN_AU: {

  84. #ifdef CARLA_OS_MAC

  85.         static bool initiated = false;

  86. 

  87.         if (! initiated)

  88.         {

  89.             using namespace juce;

  90.             initiated = true;

  91.             AudioUnitPluginFormat auFormat;

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

  93.         }

  94. 

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

  96. #else

  97.         return 0;

  98. #endif

  99.     }

  100. 

  101.     default:

  102.         return 0;

  103.     }

  104. }

  105. 

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

  107. {

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

  109. 

  110.     static CarlaCachedPluginInfo info;

  111. 

  112.     switch (ptype)

  113.     {

  114.     case CB::PLUGIN_INTERNAL: {

  115.         uint32_t count = 0;

  116.         const NativePluginDescriptor* const descs(carla_get_native_plugins_data(&count));

  117.         CARLA_SAFE_ASSERT_BREAK(index < count);

  118.         CARLA_SAFE_ASSERT_BREAK(descs != nullptr);

  119. 

  120.         const NativePluginDescriptor& desc(descs[index]);

  121. 

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

  123.         info.hints    = 0x0;

  124. 

  125.         if (desc.hints & NATIVE_PLUGIN_IS_RTSAFE)

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

  127.         if (desc.hints & NATIVE_PLUGIN_IS_SYNTH)

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

  129.         if (desc.hints & NATIVE_PLUGIN_HAS_UI)

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

  131.         if (desc.hints & NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS)

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

  133.         if (desc.hints & NATIVE_PLUGIN_NEEDS_UI_MAIN_THREAD)

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

  135.         if (desc.hints & NATIVE_PLUGIN_USES_MULTI_PROGS)

  136.             info.hints |= CB::PLUGIN_USES_MULTI_PROGS;

  137. 

  138.         info.audioIns      = desc.audioIns;

  139.         info.audioOuts     = desc.audioOuts;

  140.         info.midiIns       = desc.midiIns;

  141.         info.midiOuts      = desc.midiOuts;

  142.         info.parameterIns  = desc.paramIns;

  143.         info.parameterOuts = desc.paramOuts;

  144.         info.name          = desc.name;

  145.         info.label         = desc.label;

  146.         info.maker         = desc.maker;

  147.         info.copyright     = desc.copyright;

  148.         return &info;

  149.     }

  150. 

  151.     case CB::PLUGIN_LV2: {

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

  153. 

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

  155.         CARLA_SAFE_ASSERT_BREAK(cPlugin != nullptr);

  156. 

  157.         Lilv::Plugin lilvPlugin(cPlugin);

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

  159. 

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

  161. 

  162.         // features

  163.         info.hints = 0x0;

  164. 

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

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

  167. 

  168.         {

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

  170. 

  171.             LILV_FOREACH(nodes, it, lilvFeatureNodes)

  172.             {

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

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

  175.                 CARLA_SAFE_ASSERT_CONTINUE(featureURI != nullptr);

  176. 

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

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

  179.             }

  180. 

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

  182.         }

  183. 

  184.         // category

  185.         info.category = CB::PLUGIN_CATEGORY_NONE;

  186. 

  187.         {

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

  189. 

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

  191.             {

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

  193.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  195.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  197.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  199.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  201.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  203.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  205.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  207.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  209.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  211.                     info.category = CB::PLUGIN_CATEGORY_DELAY;

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

  213.                     info.category = CB::PLUGIN_CATEGORY_DISTORTION;

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

  215.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  217.                     info.category = CB::PLUGIN_CATEGORY_EQ;

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

  219.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  221.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  223.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  225.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  227.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  229.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  231.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  233.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  235.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  237.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  239.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  241.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  243.                     info.category = CB::PLUGIN_CATEGORY_EQ;

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

  245.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  247.                     info.category = CB::PLUGIN_CATEGORY_EQ;

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

  249.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  251.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  253.                     info.category = CB::PLUGIN_CATEGORY_DELAY;

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

  255.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  257.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  259.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  261.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  263.                     info.category = CB::PLUGIN_CATEGORY_DISTORTION;

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

  265.                 {

  266.                     info.category = CB::PLUGIN_CATEGORY_SYNTH;

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

  268.                 }

  269.             }

  270. 

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

  272.         }

  273. 

  274.         // number data

  275.         info.audioIns      = 0;

  276.         info.audioOuts     = 0;

  277.         info.midiIns       = 0;

  278.         info.midiOuts      = 0;

  279.         info.parameterIns  = 0;

  280.         info.parameterOuts = 0;

  281. 

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

  283.         {

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

  285. 

  286.             bool isInput;

  287. 

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

  289.                 isInput = true;

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

  291.                 isInput = false;

  292.             else

  293.                 continue;

  294. 

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

  296.             {

  297.                 // skip some control ports

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

  299.                     continue;

  300. 

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

  302.                 {

  303.                     bool skip = false;

  304. 

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

  306.                     {

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

  308.                             skip = true;

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

  310.                             skip = true;

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

  312.                             skip = true;

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

  314.                             skip = true;

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

  316.                             skip = true;

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

  318.                             skip = true;

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

  320.                             skip = true;

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

  322.                             skip = true;

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

  324.                             skip = true;

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

  326.                             skip = true;

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

  328.                             skip = true;

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

  330.                             skip = true;

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

  332.                             skip = true;

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

  334.                             skip = true;

  335.                     }

  336. 

  337.                     lilv_node_free(designationNode);

  338. 

  339.                     if (skip)

  340.                         continue;

  341.                 }

  342. 

  343.                 if (isInput)

  344.                     ++(info.parameterIns);

  345.                 else

  346.                     ++(info.parameterOuts);

  347.             }

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

  349.             {

  350.                 if (isInput)

  351.                     ++(info.audioIns);

  352.                 else

  353.                     ++(info.audioOuts);

  354.             }

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

  356.             {

  357.             }

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

  359.             {

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

  361. 

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

  363.                 {

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

  365.                     CARLA_SAFE_ASSERT_CONTINUE(node.is_uri());

  366. 

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

  368.                     {

  369.                         if (isInput)

  370.                             ++(info.midiIns);

  371.                         else

  372.                             ++(info.midiOuts);

  373.                     }

  374.                 }

  375. 

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

  377.             }

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

  379.             {

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

  381.                 {

  382.                     if (isInput)

  383.                         ++(info.midiIns);

  384.                     else

  385.                         ++(info.midiOuts);

  386.                 }

  387.             }

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

  389.             {

  390.                 if (isInput)

  391.                     ++(info.midiIns);

  392.                 else

  393.                     ++(info.midiOuts);

  394.             }

  395.         }

  396. 

  397.         // text data

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

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

  400. 

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

  402. 

  403.         if (LilvNode* const nameNode = lilv_plugin_get_name(lilvPlugin.me))

  404.         {

  405.             if (const char* const name = lilv_node_as_string(nameNode))

  406.                 sname = name;

  407.             lilv_node_free(nameNode);

  408.         }

  409. 

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

  411.             smaker = author;

  412. 

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

  414. 

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

  416.         {

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

  418.                 slicense = license;

  419.         }

  420. 

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

  422. 

  423.         info.name      = sname;

  424.         info.label     = suri;

  425.         info.maker     = smaker;

  426.         info.copyright = slicense;

  427. 

  428.         return &info;

  429.     }

  430. 

  431.     case CB::PLUGIN_AU: {

  432. #ifdef CARLA_OS_MAC

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

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

  435. 

  436.         using namespace juce;

  437. 

  438.         String pluginId(gCachedAuPluginResults[indexi]);

  439.         OwnedArray<PluginDescription> results;

  440. 

  441.         AudioUnitPluginFormat auFormat;

  442.         auFormat.findAllTypesForFile(results, pluginId);

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

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

  445. 

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

  447.         CARLA_SAFE_ASSERT_BREAK(desc != nullptr);

  448. 

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

  450.         info.hints    = 0x0;

  451. 

  452.         if (desc->isInstrument)

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

  454.         if (true)

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

  456. 

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

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

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

  460.         info.midiOuts  = 0;

  461.         info.parameterIns  = 0;

  462.         info.parameterOuts = 0;

  463. 

  464.         static CarlaString sname, slabel, smaker;

  465. 

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

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

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

  469. 

  470.         info.name      = sname;

  471.         info.label     = slabel;

  472.         info.maker     = smaker;

  473.         info.copyright = gNullCharPtr;

  474. 

  475.         return &info;

  476. #else

  477.         break;

  478. #endif

  479.     }

  480. 

  481.     default:

  482.         break;

  483.     }

  484. 

  485.     info.category      = CB::PLUGIN_CATEGORY_NONE;

  486.     info.hints         = 0x0;

  487.     info.audioIns      = 0;

  488.     info.audioOuts     = 0;

  489.     info.midiIns       = 0;

  490.     info.midiOuts      = 0;

  491.     info.parameterIns  = 0;

  492.     info.parameterOuts = 0;

  493.     info.name          = gNullCharPtr;

  494.     info.label         = gNullCharPtr;

  495.     info.maker         = gNullCharPtr;

  496.     info.copyright     = gNullCharPtr;

  497.     return &info;

  498. }

  499. 

  500. #ifndef CARLA_UTILS_CACHED_PLUGINS_ONLY

  501. // -------------------------------------------------------------------------------------------------------------------

  502. 

  503. const char* carla_get_complete_license_text()

  504. {

  505.     carla_debug("carla_get_complete_license_text()");

  506. 

  507.     static CarlaString retText;

  508. 

  509.     if (retText.isEmpty())

  510.     {

  511.         retText =

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

  513.         "<ul>"

  514. 

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

  516. # define LS_NOTE_NO "2"

  517. #else

  518. # define LS_NOTE_NO "1"

  519. #endif

  520. 

  521.         // Plugin formats

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

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

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

  525. #ifdef VESTIGE_HEADER

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

  527. #else

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

  529. #endif

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

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

  532. #endif

  533. #ifdef CARLA_OS_MAC

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

  535. #endif

  536. 

  537.         // Sample kit libraries

  538. #ifdef HAVE_FLUIDSYNTH

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

  540. #endif

  541. #ifdef HAVE_LINUXSAMPLER

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

  543. #endif

  544. 

  545.         // misc libs

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

  547. #ifdef CARLA_OS_MAC

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

  549. #endif

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

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

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

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

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

  555. #endif

  556. 

  557.         // Internal plugins

  558. #ifdef HAVE_EXPERIMENTAL_PLUGINS

  559.         "<li>AT1, BLS1 and REV1 plugin code by Fons Adriaensen</li>"

  560. #endif

  561.         "<li>MIDI Sequencer UI code by Perry Nguyen</li>"

  562.         "<li>Nekobi plugin code based on nekobee by Sean Bolton and others</li>"

  563.         "<li>VectorJuice and WobbleJuice plugin code by Andre Sklenar</li>"

  564. #ifdef HAVE_ZYN_DEPS

  565.         "<li>ZynAddSubFX plugin code by Mark McCurry and Nasca Octavian Paul</li>"

  566. #endif

  567. 

  568.         // end

  569.         "</ul>"

  570. 

  571.         "<p>"

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

  573.         // Required by VST SDK

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

  575. #endif

  576. #ifdef HAVE_LINUXSAMPLER

  577.         // LinuxSampler GPL exception

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

  579. #endif

  580.         "</p>"

  581.         ;

  582.     }

  583. 

  584.     return retText;

  585. }

  586. 

  587. const char* carla_get_juce_version()

  588. {

  589.     carla_debug("carla_get_juce_version()");

  590. 

  591.     static CarlaString retVersion;

  592. 

  593.     if (retVersion.isEmpty())

  594.     {

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

  596.             retVersion = version+6;

  597.         else

  598.             retVersion = "3.0";

  599.     }

  600. 

  601.     return retVersion;

  602. }

  603. 

  604. const char* carla_get_supported_file_extensions()

  605. {

  606.     carla_debug("carla_get_supported_file_extensions()");

  607. 

  608.     static CarlaString retText;

  609. 

  610.     if (retText.isEmpty())

  611.     {

  612.         retText =

  613.         // Base types

  614.         "*.carxp;*.carxs"

  615.         // MIDI files

  616.         ";*.mid;*.midi"

  617. #ifdef HAVE_FLUIDSYNTH

  618.         // fluidsynth (sf2)

  619.         ";*.sf2"

  620. #endif

  621. #ifdef HAVE_LINUXSAMPLER

  622.         // linuxsampler (gig and sfz)

  623.         ";*.gig;*.sfz"

  624. #endif

  625. #ifdef HAVE_ZYN_DEPS

  626.         // zynaddsubfx presets

  627.         ";*.xmz;*.xiz"

  628. #endif

  629.         ;

  630. 

  631.         // Audio files

  632.         {

  633.             using namespace juce;

  634. 

  635.             AudioFormatManager afm;

  636.             afm.registerBasicFormats();

  637. 

  638.             String juceFormats;

  639. 

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

  641.             {

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

  643. 

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

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

  646.             }

  647. 

  648.             retText += juceFormats.toRawUTF8();

  649.         }

  650.     }

  651. 

  652.     return retText;

  653. }

  654. 

  655. // -------------------------------------------------------------------------------------------------------------------

  656. 

  657. void carla_set_process_name(const char* name)

  658. {

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

  660. 

  661.     CarlaThread::setCurrentThreadName(name);

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

  663. }

  664. 

  665. // -------------------------------------------------------------------------------------------------------------------

  666. 

  667. class CarlaPipeClientPlugin : public CarlaPipeClient

  668. {

  669. public:

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

  671.         : CarlaPipeClient(),

  672.           fCallbackFunc(callbackFunc),

  673.           fCallbackPtr(callbackPtr)

  674.     {

  675.         CARLA_SAFE_ASSERT(fCallbackFunc != nullptr);

  676.     }

  677. 

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

  679.     {

  680.         return CarlaPipeClient::_readlineblock(timeout);

  681.     }

  682. 

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

  684.     {

  685.         if (fCallbackFunc != nullptr)

  686.         {

  687.             try {

  688.                 fCallbackFunc(fCallbackPtr, msg);

  689.             } CARLA_SAFE_EXCEPTION("msgReceived");

  690.         }

  691. 

  692.         return true;

  693.     }

  694. 

  695. private:

  696.     const CarlaPipeCallbackFunc fCallbackFunc;

  697.     void* const fCallbackPtr;

  698. 

  699.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaPipeClientPlugin)

  700. };

  701. 

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

  703. {

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

  705. 

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

  707. 

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

  709.     {

  710.         delete pipe;

  711.         return nullptr;

  712.     }

  713. 

  714.     return pipe;

  715. }

  716. 

  717. void carla_pipe_client_idle(CarlaPipeClientHandle handle)

  718. {

  719.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  720. 

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

  722. }

  723. 

  724. bool carla_pipe_client_is_running(CarlaPipeClientHandle handle)

  725. {

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

  727. 

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

  729. }

  730. 

  731. void carla_pipe_client_lock(CarlaPipeClientHandle handle)

  732. {

  733.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  734. 

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

  736. }

  737. 

  738. void carla_pipe_client_unlock(CarlaPipeClientHandle handle)

  739. {

  740.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  741. 

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

  743. }

  744. 

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

  746. {

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

  748. 

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

  750. }

  751. 

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

  753. {

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

  755. 

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

  757. }

  758. 

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

  760. {

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

  762. 

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

  764. }

  765. 

  766. bool carla_pipe_client_flush(CarlaPipeClientHandle handle)

  767. {

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

  769. 

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

  771. }

  772. 

  773. bool carla_pipe_client_flush_and_unlock(CarlaPipeClientHandle handle)

  774. {

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

  776. 

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

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

  779.     pipe->unlockPipe();

  780.     return ret;

  781. }

  782. 

  783. void carla_pipe_client_destroy(CarlaPipeClientHandle handle)

  784. {

  785.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

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

  787. 

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

  789.     pipe->closePipeClient();

  790.     delete pipe;

  791. }

  792. 

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

  794. 

  795. const char* carla_get_library_filename()

  796. {

  797.     carla_debug("carla_get_library_filename()");

  798. 

  799.     static CarlaString ret;

  800. 

  801.     if (ret.isEmpty())

  802.     {

  803.         using juce::File;

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

  805.     }

  806. 

  807.     return ret;

  808. }

  809. 

  810. const char* carla_get_library_folder()

  811. {

  812.     carla_debug("carla_get_library_folder()");

  813. 

  814.     static CarlaString ret;

  815. 

  816.     if (ret.isEmpty())

  817.     {

  818.         using juce::File;

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

  820.     }

  821. 

  822.     return ret;

  823. }

  824. 

  825. // -------------------------------------------------------------------------------------------------------------------

  826. 

  827. #include "CarlaPipeUtils.cpp"

  828. 

  829. // -------------------------------------------------------------------------------------------------------------------

  830. #endif //  CARLA_UTILS_CACHED_PLUGINS_ONLY