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

849 lines
27KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

  3.  * Copyright (C) 2011-2018 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 "water/files/File.h"

  29. 

  30. #ifdef CARLA_OS_MAC

  31. # import <Cocoa/Cocoa.h>

  32. #endif

  33. 

  34. #ifndef CARLA_UTILS_CACHED_PLUGINS_ONLY

  35. # include "rtaudio/RtAudio.h"

  36. # include "rtmidi/RtMidi.h"

  37. # ifdef HAVE_X11

  38. #  include <X11/Xlib.h>

  39. # endif

  40. #endif

  41. 

  42. #include "../native-plugins/_data.all.cpp"

  43. 

  44. namespace CB = CarlaBackend;

  45. 

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

  47. 

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

  49. 

  50. _CarlaCachedPluginInfo::_CarlaCachedPluginInfo() noexcept

  51.     : category(CB::PLUGIN_CATEGORY_NONE),

  52.       hints(0x0),

  53.       audioIns(0),

  54.       audioOuts(0),

  55.       midiIns(0),

  56.       midiOuts(0),

  57.       parameterIns(0),

  58.       parameterOuts(0),

  59.       name(gNullCharPtr),

  60.       label(gNullCharPtr),

  61.       maker(gNullCharPtr),

  62.       copyright(gNullCharPtr) {}

  63. 

  64. // -------------------------------------------------------------------------------------------------------------------

  65. 

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

  67. {

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

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

  70. 

  71.     switch (ptype)

  72.     {

  73.     case CB::PLUGIN_INTERNAL: {

  74.         uint32_t count = 0;

  75.         carla_get_native_plugins_data(&count);

  76.         return count;

  77.     }

  78. 

  79.     case CB::PLUGIN_LV2: {

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

  81.         lv2World.initIfNeeded(pluginPath);

  82.         return lv2World.getPluginCount();

  83.     }

  84. 

  85.     default:

  86.         return 0;

  87.     }

  88. }

  89. 

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

  91. {

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

  93. 

  94.     static CarlaCachedPluginInfo info;

  95. 

  96.     switch (ptype)

  97.     {

  98.     case CB::PLUGIN_INTERNAL: {

  99.         uint32_t count = 0;

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

  101.         CARLA_SAFE_ASSERT_BREAK(index < count);

  102.         CARLA_SAFE_ASSERT_BREAK(descs != nullptr);

  103. 

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

  105. 

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

  107.         info.hints    = 0x0;

  108. 

  109.         if (desc.hints & NATIVE_PLUGIN_IS_RTSAFE)

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

  111.         if (desc.hints & NATIVE_PLUGIN_IS_SYNTH)

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

  113.         if (desc.hints & NATIVE_PLUGIN_HAS_UI)

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

  115.         if (desc.hints & NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS)

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

  117.         if (desc.hints & NATIVE_PLUGIN_NEEDS_UI_MAIN_THREAD)

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

  119.         if (desc.hints & NATIVE_PLUGIN_USES_MULTI_PROGS)

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

  121. 

  122.         info.audioIns      = desc.audioIns;

  123.         info.audioOuts     = desc.audioOuts;

  124.         info.midiIns       = desc.midiIns;

  125.         info.midiOuts      = desc.midiOuts;

  126.         info.parameterIns  = desc.paramIns;

  127.         info.parameterOuts = desc.paramOuts;

  128.         info.name          = desc.name;

  129.         info.label         = desc.label;

  130.         info.maker         = desc.maker;

  131.         info.copyright     = desc.copyright;

  132.         return &info;

  133.     }

  134. 

  135.     case CB::PLUGIN_LV2: {

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

  137. 

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

  139.         CARLA_SAFE_ASSERT_BREAK(cPlugin != nullptr);

  140. 

  141.         Lilv::Plugin lilvPlugin(cPlugin);

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

  143. 

  144.         // features

  145.         info.hints = 0x0;

  146. 

  147.         if (lilvPlugin.get_uis().size() > 0)

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

  149. 

  150.         {

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

  152. 

  153.             LILV_FOREACH(nodes, it, lilvFeatureNodes)

  154.             {

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

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

  157.                 CARLA_SAFE_ASSERT_CONTINUE(featureURI != nullptr);

  158. 

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

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

  161.             }

  162. 

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

  164.         }

  165. 

  166.         // category

  167.         info.category = CB::PLUGIN_CATEGORY_NONE;

  168. 

  169.         {

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

  171. 

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

  173.             {

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

  175.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  177.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  179.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  181.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  183.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  185.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  187.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  189.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  191.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  193.                     info.category = CB::PLUGIN_CATEGORY_DELAY;

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

  195.                     info.category = CB::PLUGIN_CATEGORY_DISTORTION;

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

  197.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  199.                     info.category = CB::PLUGIN_CATEGORY_EQ;

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

  201.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  203.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  205.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  207.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  209.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  211.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  213.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  215.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  217.                     info.category = CB::PLUGIN_CATEGORY_DYNAMICS;

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

  219.                     info.category = CB::PLUGIN_CATEGORY_FILTER;

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

  221.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  223.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  225.                     info.category = CB::PLUGIN_CATEGORY_EQ;

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

  227.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  229.                     info.category = CB::PLUGIN_CATEGORY_EQ;

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

  231.                     info.category = CB::PLUGIN_CATEGORY_MODULATOR;

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

  233.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  235.                     info.category = CB::PLUGIN_CATEGORY_DELAY;

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

  237.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  239.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  241.                     info.category = CB::PLUGIN_CATEGORY_OTHER;

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

  243.                     info.category = CB::PLUGIN_CATEGORY_UTILITY;

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

  245.                     info.category = CB::PLUGIN_CATEGORY_DISTORTION;

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

  247.                 {

  248.                     info.category = CB::PLUGIN_CATEGORY_SYNTH;

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

  250.                 }

  251.             }

  252. 

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

  254.         }

  255. 

  256.         // number data

  257.         info.audioIns      = 0;

  258.         info.audioOuts     = 0;

  259.         info.midiIns       = 0;

  260.         info.midiOuts      = 0;

  261.         info.parameterIns  = 0;

  262.         info.parameterOuts = 0;

  263. 

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

  265.         {

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

  267. 

  268.             bool isInput;

  269. 

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

  271.                 isInput = true;

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

  273.                 isInput = false;

  274.             else

  275.                 continue;

  276. 

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

  278.             {

  279.                 // skip some control ports

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

  281.                     continue;

  282. 

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

  284.                 {

  285.                     bool skip = false;

  286. 

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

  288.                     {

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

  290.                             skip = true;

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

  292.                             skip = true;

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

  294.                             skip = true;

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

  296.                             skip = true;

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

  298.                             skip = true;

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

  300.                             skip = true;

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

  302.                             skip = true;

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

  304.                             skip = true;

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

  306.                             skip = true;

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

  308.                             skip = true;

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

  310.                             skip = true;

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

  312.                             skip = true;

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

  314.                             skip = true;

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

  316.                             skip = true;

  317.                     }

  318. 

  319.                     lilv_node_free(designationNode);

  320. 

  321.                     if (skip)

  322.                         continue;

  323.                 }

  324. 

  325.                 if (isInput)

  326.                     ++(info.parameterIns);

  327.                 else

  328.                     ++(info.parameterOuts);

  329.             }

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

  331.             {

  332.                 if (isInput)

  333.                     ++(info.audioIns);

  334.                 else

  335.                     ++(info.audioOuts);

  336.             }

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

  338.             {

  339.             }

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

  341.             {

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

  343. 

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

  345.                 {

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

  347.                     CARLA_SAFE_ASSERT_CONTINUE(node.is_uri());

  348. 

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

  350.                     {

  351.                         if (isInput)

  352.                             ++(info.midiIns);

  353.                         else

  354.                             ++(info.midiOuts);

  355.                     }

  356.                 }

  357. 

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

  359.             }

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

  361.             {

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

  363.                 {

  364.                     if (isInput)

  365.                         ++(info.midiIns);

  366.                     else

  367.                         ++(info.midiOuts);

  368.                 }

  369.             }

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

  371.             {

  372.                 if (isInput)

  373.                     ++(info.midiIns);

  374.                 else

  375.                     ++(info.midiOuts);

  376.             }

  377.         }

  378. 

  379.         // text data

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

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

  382. 

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

  384. 

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

  386.         {

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

  388.                 sname = name;

  389.             lilv_node_free(nameNode);

  390.         }

  391. 

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

  393.             smaker = author;

  394. 

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

  396. 

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

  398.         {

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

  400.                 slicense = license;

  401.         }

  402. 

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

  404. 

  405.         info.name      = sname;

  406.         info.label     = suri;

  407.         info.maker     = smaker;

  408.         info.copyright = slicense;

  409. 

  410.         return &info;

  411.     }

  412. 

  413.     default:

  414.         break;

  415.     }

  416. 

  417.     info.category      = CB::PLUGIN_CATEGORY_NONE;

  418.     info.hints         = 0x0;

  419.     info.audioIns      = 0;

  420.     info.audioOuts     = 0;

  421.     info.midiIns       = 0;

  422.     info.midiOuts      = 0;

  423.     info.parameterIns  = 0;

  424.     info.parameterOuts = 0;

  425.     info.name          = gNullCharPtr;

  426.     info.label         = gNullCharPtr;

  427.     info.maker         = gNullCharPtr;

  428.     info.copyright     = gNullCharPtr;

  429.     return &info;

  430. }

  431. 

  432. #ifndef CARLA_UTILS_CACHED_PLUGINS_ONLY

  433. // -------------------------------------------------------------------------------------------------------------------

  434. 

  435. const char* carla_get_complete_license_text()

  436. {

  437.     carla_debug("carla_get_complete_license_text()");

  438. 

  439.     static CarlaString retText;

  440. 

  441.     if (retText.isEmpty())

  442.     {

  443.         retText =

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

  445.         "<ul>"

  446. 

  447.         // Plugin formats

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

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

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

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

  452. 

  453.         // Sample kit libraries

  454. #ifdef HAVE_FLUIDSYNTH

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

  456. #endif

  457. #ifdef HAVE_LINUXSAMPLER

  458.         "<li>LinuxSampler library for GIG and SFZ support [1]</li>"

  459. #endif

  460. 

  461.         // misc libs

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

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

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

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

  466.         "<li>RtAudio v" RTAUDIO_VERSION " and RtMidi v" RTMIDI_VERSION " for native Audio and MIDI support</li>"

  467. 

  468.         // Internal plugins

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

  470. 

  471.         // External plugins

  472. #ifdef HAVE_EXTERNAL_PLUGINS

  473. # ifdef HAVE_EXPERIMENTAL_PLUGINS

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

  475. # endif

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

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

  478. # ifdef HAVE_ZYN_DEPS

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

  480. # endif

  481. #endif // HAVE_EXTERNAL_PLUGINS

  482. 

  483.         // end

  484.         "</ul>"

  485. 

  486.         "<p>"

  487. #ifdef HAVE_LINUXSAMPLER

  488.         // LinuxSampler GPL exception

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

  490. #endif

  491.         "</p>"

  492.         ;

  493.     }

  494. 

  495.     return retText;

  496. }

  497. 

  498. const char* const* carla_get_supported_file_extensions()

  499. {

  500.     carla_debug("carla_get_supported_file_extensions()");

  501. 

  502.     // NOTE: please keep in sync with CarlaEngine::loadFile!!

  503.     static const char* const extensions[] = {

  504.         // Base types

  505.         "carxp", "carxs",

  506. 

  507.         // plugin files and resources

  508. #ifdef HAVE_FLUIDSYNTH

  509.         "sf2",

  510. #endif

  511. #ifdef HAVE_LINUXSAMPLER

  512.         "gig", "sfz",

  513. #endif

  514. #ifdef HAVE_ZYN_DEPS

  515.         "xmz", "xiz",

  516. #endif

  517. #if defined(CARLA_OS_MAC)

  518.         "vst",

  519. #else

  520.         "dll",

  521.         "so",

  522. #endif

  523. 

  524.         // Audio files

  525. #ifdef HAVE_SNDFILE

  526.         "aif", "aiff", "bwf", "flac", "oga", "ogg", "w64", "wav",

  527. #endif

  528. #ifdef HAVE_FFMPEG

  529.         "3g2", "3gp", "aac", "ac3", "amr", "ape", "mp2", "mp3", "mpc", "wma",

  530. #endif

  531. 

  532.         // MIDI files

  533.         "mid", "midi",

  534. 

  535.         // terminator

  536.         nullptr

  537.     };

  538. 

  539.     return extensions;

  540. }

  541. 

  542. const char* const* carla_get_supported_features()

  543. {

  544.     carla_debug("carla_get_supported_features()");

  545. 

  546.     static const char* const features[] = {

  547. #ifdef HAVE_FLUIDSYNTH

  548.         "sf2",

  549. #endif

  550. #ifdef HAVE_HYLIA

  551.         "link",

  552. #endif

  553. #ifdef HAVE_LIBLO

  554.         "osc",

  555. #endif

  556. #if defined(HAVE_LIBMAGIC) || defined(CARLA_OS_WIN)

  557.         "bridges",

  558. #endif

  559. #ifdef HAVE_LINUXSAMPLER

  560.         "gig", "sfz",

  561. #endif

  562. #ifdef HAVE_PYQT

  563.         "gui",

  564. #endif

  565.         nullptr

  566.     };

  567. 

  568.     return features;

  569. }

  570. 

  571. // -------------------------------------------------------------------------------------------------------------------

  572. 

  573. void carla_fflush(bool err)

  574. {

  575.     std::fflush(err ? stderr : stdout);

  576. }

  577. 

  578. void carla_fputs(bool err, const char* string)

  579. {

  580.     std::fputs(string, err ? stderr : stdout);

  581. }

  582. 

  583. void carla_set_process_name(const char* name)

  584. {

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

  586. 

  587.     CarlaThread::setCurrentThreadName(name);

  588. }

  589. 

  590. // -------------------------------------------------------------------------------------------------------------------

  591. 

  592. class CarlaPipeClientPlugin : public CarlaPipeClient

  593. {

  594. public:

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

  596.         : CarlaPipeClient(),

  597.           fCallbackFunc(callbackFunc),

  598.           fCallbackPtr(callbackPtr),

  599.           fLastReadLine(nullptr)

  600.     {

  601.         CARLA_SAFE_ASSERT(fCallbackFunc != nullptr);

  602.     }

  603. 

  604.     ~CarlaPipeClientPlugin() override

  605.     {

  606.         if (fLastReadLine != nullptr)

  607.         {

  608.             delete[] fLastReadLine;

  609.             fLastReadLine = nullptr;

  610.         }

  611.     }

  612. 

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

  614.     {

  615.         delete[] fLastReadLine;

  616.         fLastReadLine = CarlaPipeClient::_readlineblock(timeout);

  617.         return fLastReadLine;

  618.     }

  619. 

  620.     bool msgReceived(const char* const msg) noexcept override

  621.     {

  622.         if (fCallbackFunc != nullptr)

  623.         {

  624.             try {

  625.                 fCallbackFunc(fCallbackPtr, msg);

  626.             } CARLA_SAFE_EXCEPTION("msgReceived");

  627.         }

  628. 

  629.         return true;

  630.     }

  631. 

  632. private:

  633.     const CarlaPipeCallbackFunc fCallbackFunc;

  634.     void* const fCallbackPtr;

  635.     const char* fLastReadLine;

  636. 

  637.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaPipeClientPlugin)

  638. };

  639. 

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

  641. {

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

  643. 

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

  645. 

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

  647.     {

  648.         delete pipe;

  649.         return nullptr;

  650.     }

  651. 

  652.     return pipe;

  653. }

  654. 

  655. void carla_pipe_client_idle(CarlaPipeClientHandle handle)

  656. {

  657.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  658. 

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

  660. }

  661. 

  662. bool carla_pipe_client_is_running(CarlaPipeClientHandle handle)

  663. {

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

  665. 

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

  667. }

  668. 

  669. void carla_pipe_client_lock(CarlaPipeClientHandle handle)

  670. {

  671.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  672. 

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

  674. }

  675. 

  676. void carla_pipe_client_unlock(CarlaPipeClientHandle handle)

  677. {

  678.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  679. 

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

  681. }

  682. 

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

  684. {

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

  686. 

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

  688. }

  689. 

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

  691. {

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

  693. 

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

  695. }

  696. 

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

  698. {

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

  700. 

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

  702. }

  703. 

  704. bool carla_pipe_client_flush(CarlaPipeClientHandle handle)

  705. {

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

  707. 

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

  709. }

  710. 

  711. bool carla_pipe_client_flush_and_unlock(CarlaPipeClientHandle handle)

  712. {

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

  714. 

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

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

  717.     pipe->unlockPipe();

  718.     return ret;

  719. }

  720. 

  721. void carla_pipe_client_destroy(CarlaPipeClientHandle handle)

  722. {

  723.     CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

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

  725. 

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

  727.     pipe->closePipeClient();

  728.     delete pipe;

  729. }

  730. 

  731. // -------------------------------------------------------------------------------------------------------------------

  732. 

  733. const char* carla_get_library_filename()

  734. {

  735.     carla_debug("carla_get_library_filename()");

  736. 

  737.     static CarlaString ret;

  738. 

  739.     if (ret.isEmpty())

  740.     {

  741.         using water::File;

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

  743.     }

  744. 

  745.     return ret;

  746. }

  747. 

  748. const char* carla_get_library_folder()

  749. {

  750.     carla_debug("carla_get_library_folder()");

  751. 

  752.     static CarlaString ret;

  753. 

  754.     if (ret.isEmpty())

  755.     {

  756.         using water::File;

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

  758.     }

  759. 

  760.     return ret;

  761. }

  762. 

  763. // -------------------------------------------------------------------------------------------------------------------

  764. 

  765. void carla_x11_reparent_window(uintptr_t winId1, uintptr_t winId2)

  766. {

  767.     CARLA_SAFE_ASSERT_RETURN(winId1 != 0,);

  768.     CARLA_SAFE_ASSERT_RETURN(winId2 != 0,);

  769. 

  770. #ifdef HAVE_X11

  771.     if (::Display* const disp = XOpenDisplay(nullptr))

  772.     {

  773.         XReparentWindow(disp, winId1, winId2, 0, 0);

  774.         XMapWindow(disp, winId1);

  775.         XCloseDisplay(disp);

  776.     }

  777. #endif

  778. }

  779. 

  780. void carla_x11_move_window(uintptr_t winId, int x, int y)

  781. {

  782.     CARLA_SAFE_ASSERT_RETURN(winId != 0,);

  783. 

  784. #ifdef HAVE_X11

  785.     if (::Display* const disp = XOpenDisplay(nullptr))

  786.     {

  787.         XMoveWindow(disp, winId, x, y);

  788.         XCloseDisplay(disp);

  789.     }

  790. #else

  791.     // unused

  792.     return; (void)x; (void)y;

  793. #endif

  794. }

  795. 

  796. int* carla_x11_get_window_pos(uintptr_t winId)

  797. {

  798.     static int pos[2];

  799. 

  800.     if (winId == 0)

  801.     {

  802.         pos[0] = 0;

  803.         pos[1] = 0;

  804.     }

  805. #ifdef HAVE_X11

  806.     else if (::Display* const disp = XOpenDisplay(nullptr))

  807.     {

  808.         int x, y;

  809.         Window child;

  810.         XWindowAttributes xwa;

  811.         XTranslateCoordinates(disp, winId, XRootWindow(disp, 0), 0, 0, &x, &y, &child);

  812.         XGetWindowAttributes(disp, winId, &xwa);

  813.         XCloseDisplay(disp);

  814.         pos[0] = x - xwa.x;

  815.         pos[1] = y - xwa.y;

  816.     }

  817. #endif

  818.     else

  819.     {

  820.         pos[0] = 0;

  821.         pos[1] = 0;

  822.     }

  823. 

  824.     return pos;

  825. }

  826. 

  827. int carla_cocoa_get_window(void* nsViewPtr)

  828. {

  829.     CARLA_SAFE_ASSERT_RETURN(nsViewPtr != nullptr, 0);

  830. 

  831. #ifdef CARLA_OS_MAC

  832.     NSView* nsView = (NSView*)nsViewPtr;

  833.     return [[nsView window] windowNumber];

  834. #else

  835.     return 0;

  836. #endif

  837. }

  838. 

  839. // -------------------------------------------------------------------------------------------------------------------

  840. 

  841. #include "CarlaPipeUtils.cpp"

  842. 

  843. #if !(defined(DEBUG) || defined(BUILDING_CARLA_FOR_WINDOWS))

  844. # include "water/misc/Time.cpp"

  845. #endif

  846. 

  847. // -------------------------------------------------------------------------------------------------------------------

  848. #endif //  CARLA_UTILS_CACHED_PLUGINS_ONLY