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.
3665 Commits
16 Branches
498MB
Tree: f70ab2d39e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f70ab2d39e'
${ noResults }
Carla/source/discovery/carla-discovery.cpp

1673 lines
53KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin discovery

  3.  * Copyright (C) 2011-2017 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 "CarlaBackendUtils.hpp"

  19. #include "CarlaLibUtils.hpp"

  20. #include "CarlaMathUtils.hpp"

  21. #include "CarlaMIDI.h"

  22. #include "LinkedList.hpp"

  23. 

  24. #ifdef BUILD_BRIDGE

  25. # undef HAVE_FLUIDSYNTH

  26. # undef HAVE_LINUXSAMPLER

  27. #endif

  28. 

  29. #include "CarlaLadspaUtils.hpp"

  30. #include "CarlaDssiUtils.cpp"

  31. #include "CarlaLv2Utils.hpp"

  32. #include "CarlaVstUtils.hpp"

  33. 

  34. // need to include this before linuxsampler

  35. #define CARLA_UTILS_CACHED_PLUGINS_ONLY

  36. #include "CarlaUtils.cpp"

  37. 

  38. #ifdef HAVE_FLUIDSYNTH

  39. # include <fluidsynth.h>

  40. #endif

  41. 

  42. #ifdef HAVE_LINUXSAMPLER

  43. # include "linuxsampler/EngineFactory.h"

  44. #endif

  45. 

  46. #include <iostream>

  47. 

  48. #include "AppConfig.h"

  49. #include "juce_core/juce_core.h"

  50. 

  51. #define DISCOVERY_OUT(x, y) std::cout << "\ncarla-discovery::" << x << "::" << y << std::endl;

  52. 

  53. using juce::CharPointer_UTF8;

  54. using juce::File;

  55. using juce::StringArray;

  56. 

  57. CARLA_BACKEND_USE_NAMESPACE

  58. 

  59. // --------------------------------------------------------------------------

  60. // Dummy values to test plugins with

  61. 

  62. static const uint32_t kBufferSize  = 512;

  63. static const double   kSampleRate  = 44100.0;

  64. static const int32_t  kSampleRatei = 44100;

  65. static const float    kSampleRatef = 44100.0f;

  66. 

  67. // --------------------------------------------------------------------------

  68. // Don't print ELF/EXE related errors since discovery can find multi-architecture binaries

  69. 

  70. static void print_lib_error(const char* const filename)

  71. {

  72.     const char* const error(lib_error(filename));

  73. 

  74.     if (error != nullptr && std::strstr(error, "wrong ELF class") == nullptr && std::strstr(error, "Bad EXE format") == nullptr)

  75.         DISCOVERY_OUT("error", error);

  76. }

  77. 

  78. #ifndef CARLA_OS_MAC

  79. // --------------------------------------------------------------------------

  80. // VST stuff

  81. 

  82. // Check if plugin is currently processing

  83. static bool gVstIsProcessing = false;

  84. 

  85. // Check if plugin needs idle

  86. static bool gVstNeedsIdle = false;

  87. 

  88. // Check if plugin wants midi

  89. static bool gVstWantsMidi = false;

  90. 

  91. // Check if plugin wants time

  92. static bool gVstWantsTime = false;

  93. 

  94. // Current uniqueId for VST shell plugins

  95. static intptr_t gVstCurrentUniqueId = 0;

  96. 

  97. // Supported Carla features

  98. static intptr_t vstHostCanDo(const char* const feature)

  99. {

  100.     carla_debug("vstHostCanDo(\"%s\")", feature);

  101. 

  102.     if (std::strcmp(feature, "supplyIdle") == 0)

  103.         return 1;

  104.     if (std::strcmp(feature, "sendVstEvents") == 0)

  105.         return 1;

  106.     if (std::strcmp(feature, "sendVstMidiEvent") == 0)

  107.         return 1;

  108.     if (std::strcmp(feature, "sendVstMidiEventFlagIsRealtime") == 0)

  109.         return 1;

  110.     if (std::strcmp(feature, "sendVstTimeInfo") == 0)

  111.     {

  112.         gVstWantsTime = true;

  113.         return 1;

  114.     }

  115.     if (std::strcmp(feature, "receiveVstEvents") == 0)

  116.         return 1;

  117.     if (std::strcmp(feature, "receiveVstMidiEvent") == 0)

  118.         return 1;

  119.     if (std::strcmp(feature, "receiveVstTimeInfo") == 0)

  120.         return -1;

  121.     if (std::strcmp(feature, "reportConnectionChanges") == 0)

  122.         return -1;

  123.     if (std::strcmp(feature, "acceptIOChanges") == 0)

  124.         return 1;

  125.     if (std::strcmp(feature, "sizeWindow") == 0)

  126.         return 1;

  127.     if (std::strcmp(feature, "offline") == 0)

  128.         return -1;

  129.     if (std::strcmp(feature, "openFileSelector") == 0)

  130.         return -1;

  131.     if (std::strcmp(feature, "closeFileSelector") == 0)

  132.         return -1;

  133.     if (std::strcmp(feature, "startStopProcess") == 0)

  134.         return 1;

  135.     if (std::strcmp(feature, "supportShell") == 0)

  136.         return 1;

  137.     if (std::strcmp(feature, "shellCategory") == 0)

  138.         return 1;

  139. 

  140.     // non-official features found in some plugins:

  141.     // "asyncProcessing"

  142.     // "editFile"

  143. 

  144.     // unimplemented

  145.     carla_stderr("vstHostCanDo(\"%s\") - unknown feature", feature);

  146.     return 0;

  147. }

  148. 

  149. // Host-side callback

  150. static intptr_t VSTCALLBACK vstHostCallback(AEffect* const effect, const int32_t opcode, const int32_t index, const intptr_t value, void* const ptr, const float opt)

  151. {

  152.     carla_debug("vstHostCallback(%p, %i:%s, %i, " P_INTPTR ", %p, %f)", effect, opcode, vstMasterOpcode2str(opcode), index, value, ptr, opt);

  153. 

  154.     static VstTimeInfo timeInfo;

  155.     intptr_t ret = 0;

  156. 

  157.     switch (opcode)

  158.     {

  159.     case audioMasterAutomate:

  160.         ret = 1;

  161.         break;

  162. 

  163.     case audioMasterVersion:

  164.         ret = kVstVersion;

  165.         break;

  166. 

  167.     case audioMasterCurrentId:

  168.         ret = gVstCurrentUniqueId;

  169.         break;

  170. 

  171.     case DECLARE_VST_DEPRECATED(audioMasterWantMidi):

  172.         if (gVstWantsMidi) { DISCOVERY_OUT("warning", "Plugin requested MIDI more than once"); }

  173. 

  174.         gVstWantsMidi = true;

  175.         ret = 1;

  176.         break;

  177. 

  178.     case audioMasterGetTime:

  179.         if (! gVstIsProcessing) { DISCOVERY_OUT("warning", "Plugin requested timeInfo out of process"); }

  180.         if (! gVstWantsTime)    { DISCOVERY_OUT("warning", "Plugin requested timeInfo but didn't ask if host could do \"sendVstTimeInfo\""); }

  181. 

  182.         carla_zeroStruct(timeInfo);

  183.         timeInfo.sampleRate = kSampleRate;

  184. 

  185.         // Tempo

  186.         timeInfo.tempo  = 120.0;

  187.         timeInfo.flags |= kVstTempoValid;

  188. 

  189.         // Time Signature

  190.         timeInfo.timeSigNumerator   = 4;

  191.         timeInfo.timeSigDenominator = 4;

  192.         timeInfo.flags |= kVstTimeSigValid;

  193. 

  194.         ret = (intptr_t)&timeInfo;

  195.         break;

  196. 

  197.     case DECLARE_VST_DEPRECATED(audioMasterTempoAt):

  198.         ret = 120 * 10000;

  199.         break;

  200. 

  201.     case DECLARE_VST_DEPRECATED(audioMasterGetNumAutomatableParameters):

  202.         ret = carla_minPositive(effect->numParams, static_cast<int>(MAX_DEFAULT_PARAMETERS));

  203.         break;

  204. 

  205.     case DECLARE_VST_DEPRECATED(audioMasterGetParameterQuantization):

  206.         ret = 1; // full single float precision

  207.         break;

  208. 

  209.     case DECLARE_VST_DEPRECATED(audioMasterNeedIdle):

  210.         if (gVstNeedsIdle) { DISCOVERY_OUT("warning", "Plugin requested idle more than once"); }

  211. 

  212.         gVstNeedsIdle = true;

  213.         ret = 1;

  214.         break;

  215. 

  216.     case audioMasterGetSampleRate:

  217.         ret = kSampleRatei;

  218.         break;

  219. 

  220.     case audioMasterGetBlockSize:

  221.         ret = kBufferSize;

  222.         break;

  223. 

  224.     case DECLARE_VST_DEPRECATED(audioMasterWillReplaceOrAccumulate):

  225.         ret = 1; // replace

  226.         break;

  227. 

  228.     case audioMasterGetCurrentProcessLevel:

  229.         ret = gVstIsProcessing ? kVstProcessLevelRealtime : kVstProcessLevelUser;

  230.         break;

  231. 

  232.     case audioMasterGetAutomationState:

  233.         ret = kVstAutomationOff;

  234.         break;

  235. 

  236.     case audioMasterGetVendorString:

  237.         CARLA_SAFE_ASSERT_BREAK(ptr != nullptr);

  238.         std::strcpy((char*)ptr, "falkTX");

  239.         ret = 1;

  240.         break;

  241. 

  242.     case audioMasterGetProductString:

  243.         CARLA_SAFE_ASSERT_BREAK(ptr != nullptr);

  244.         std::strcpy((char*)ptr, "Carla-Discovery");

  245.         ret = 1;

  246.         break;

  247. 

  248.     case audioMasterGetVendorVersion:

  249.         ret = CARLA_VERSION_HEX;

  250.         break;

  251. 

  252.     case audioMasterCanDo:

  253.         CARLA_SAFE_ASSERT_BREAK(ptr != nullptr);

  254.         ret = vstHostCanDo((const char*)ptr);

  255.         break;

  256. 

  257.     case audioMasterGetLanguage:

  258.         ret = kVstLangEnglish;

  259.         break;

  260. 

  261.     default:

  262.         carla_stdout("vstHostCallback(%p, %i:%s, %i, " P_INTPTR ", %p, %f)", effect, opcode, vstMasterOpcode2str(opcode), index, value, ptr, opt);

  263.         break;

  264.     }

  265. 

  266.     return ret;

  267. }

  268. #endif // ! CARLA_OS_MAC

  269. 

  270. #ifdef HAVE_LINUXSAMPLER

  271. // --------------------------------------------------------------------------

  272. // LinuxSampler stuff

  273. 

  274. class LinuxSamplerScopedEngine

  275. {

  276. public:

  277.     LinuxSamplerScopedEngine(const char* const filename, const char* const stype)

  278.         : fEngine(nullptr)

  279.     {

  280.         using namespace LinuxSampler;

  281. 

  282.         try {

  283.             fEngine = EngineFactory::Create(stype);

  284.         }

  285.         catch (const Exception& e)

  286.         {

  287.             DISCOVERY_OUT("error", e.what());

  288.             return;

  289.         }

  290. 

  291.         if (fEngine == nullptr)

  292.             return;

  293. 

  294.         InstrumentManager* const insMan(fEngine->GetInstrumentManager());

  295. 

  296.         if (insMan == nullptr)

  297.         {

  298.             DISCOVERY_OUT("error", "Failed to get LinuxSampler instrument manager");

  299.             return;

  300.         }

  301. 

  302.         std::vector<InstrumentManager::instrument_id_t> ids;

  303. 

  304.         try {

  305.             ids = insMan->GetInstrumentFileContent(filename);

  306.         }

  307.         catch (const InstrumentManagerException& e)

  308.         {

  309.             DISCOVERY_OUT("error", e.what());

  310.             return;

  311.         }

  312. 

  313.         if (ids.size() == 0)

  314.         {

  315.             DISCOVERY_OUT("error", "Failed to find any instruments");

  316.             return;

  317.         }

  318. 

  319.         InstrumentManager::instrument_info_t info;

  320. 

  321.         try {

  322.             info = insMan->GetInstrumentInfo(ids[0]);

  323.         }

  324.         catch (const InstrumentManagerException& e)

  325.         {

  326.             DISCOVERY_OUT("error", e.what());

  327.             return;

  328.         }

  329. 

  330.         outputInfo(&info, nullptr, ids.size() > 1);

  331.     }

  332. 

  333.     ~LinuxSamplerScopedEngine()

  334.     {

  335.         if (fEngine != nullptr)

  336.         {

  337.             LinuxSampler::EngineFactory::Destroy(fEngine);

  338.             fEngine = nullptr;

  339.         }

  340.     }

  341. 

  342.     static void outputInfo(const LinuxSampler::InstrumentManager::instrument_info_t* const info, const char* const basename, const bool has16Outs)

  343.     {

  344.         CarlaString name;

  345.         const char* label;

  346. 

  347.         if (info != nullptr)

  348.         {

  349.             name  = info->InstrumentName.c_str();

  350.             label = info->Product.c_str();

  351.         }

  352.         else

  353.         {

  354.             name  = basename;

  355.             label = basename;

  356.         }

  357. 

  358.         // 2 channels

  359.         DISCOVERY_OUT("init", "-----------");

  360.         DISCOVERY_OUT("build", BINARY_NATIVE);

  361.         DISCOVERY_OUT("hints", PLUGIN_IS_SYNTH);

  362. 

  363.         DISCOVERY_OUT("name", name.buffer());

  364.         DISCOVERY_OUT("label", label);

  365. 

  366.         if (info != nullptr)

  367.             DISCOVERY_OUT("maker", info->Artists);

  368. 

  369.         DISCOVERY_OUT("audio.outs", 2);

  370.         DISCOVERY_OUT("midi.ins", 1);

  371.         DISCOVERY_OUT("end", "------------");

  372. 

  373.         // 16 channels

  374.         if (name.isEmpty() || ! has16Outs)

  375.             return;

  376. 

  377.         name += " (16 outputs)";

  378. 

  379.         DISCOVERY_OUT("init", "-----------");

  380.         DISCOVERY_OUT("build", BINARY_NATIVE);

  381.         DISCOVERY_OUT("hints", PLUGIN_IS_SYNTH);

  382. 

  383.         DISCOVERY_OUT("name", name.buffer());

  384.         DISCOVERY_OUT("label", label);

  385. 

  386.         if (info != nullptr)

  387.             DISCOVERY_OUT("maker", info->Artists);

  388. 

  389.         DISCOVERY_OUT("audio.outs", 32);

  390.         DISCOVERY_OUT("midi.ins", 1);

  391.         DISCOVERY_OUT("end", "------------");

  392.     }

  393. 

  394. private:

  395.     LinuxSampler::Engine* fEngine;

  396. 

  397.     CARLA_PREVENT_HEAP_ALLOCATION

  398.     CARLA_DECLARE_NON_COPY_CLASS(LinuxSamplerScopedEngine)

  399. };

  400. #endif // HAVE_LINUXSAMPLER

  401. 

  402. // ------------------------------ Plugin Checks -----------------------------

  403. 

  404. static void do_cached_check(const PluginType type)

  405. {

  406.     const char* const plugPath = (type == PLUGIN_LV2) ? std::getenv("LV2_PATH") : nullptr;

  407.     const uint count = carla_get_cached_plugin_count(type, plugPath);

  408. 

  409.     for (uint i=0; i<count; ++i)

  410.     {

  411.         const CarlaCachedPluginInfo* pinfo(carla_get_cached_plugin_info(type, i));

  412.         CARLA_SAFE_ASSERT_CONTINUE(pinfo != nullptr);

  413. 

  414.         DISCOVERY_OUT("init", "-----------");

  415.         DISCOVERY_OUT("build", BINARY_NATIVE);

  416.         DISCOVERY_OUT("hints", pinfo->hints);

  417.         DISCOVERY_OUT("name", pinfo->name);

  418.         DISCOVERY_OUT("maker", pinfo->maker);

  419.         DISCOVERY_OUT("label", pinfo->label);

  420.         DISCOVERY_OUT("audio.ins", pinfo->audioIns);

  421.         DISCOVERY_OUT("audio.outs", pinfo->audioOuts);

  422.         DISCOVERY_OUT("midi.ins", pinfo->midiIns);

  423.         DISCOVERY_OUT("midi.outs", pinfo->midiOuts);

  424.         DISCOVERY_OUT("parameters.ins", pinfo->parameterIns);

  425.         DISCOVERY_OUT("parameters.outs", pinfo->parameterOuts);

  426.         DISCOVERY_OUT("end", "------------");

  427.     }

  428. }

  429. 

  430. static void do_ladspa_check(lib_t& libHandle, const char* const filename, const bool doInit)

  431. {

  432.     LADSPA_Descriptor_Function descFn = lib_symbol<LADSPA_Descriptor_Function>(libHandle, "ladspa_descriptor");

  433. 

  434.     if (descFn == nullptr)

  435.     {

  436.         DISCOVERY_OUT("error", "Not a LADSPA plugin");

  437.         return;

  438.     }

  439. 

  440.     const LADSPA_Descriptor* descriptor;

  441. 

  442.     {

  443.         descriptor = descFn(0);

  444. 

  445.         if (descriptor == nullptr)

  446.         {

  447.             DISCOVERY_OUT("error", "Binary doesn't contain any plugins");

  448.             return;

  449.         }

  450. 

  451.         if (doInit && descriptor->instantiate != nullptr && descriptor->cleanup != nullptr)

  452.         {

  453.             LADSPA_Handle handle = descriptor->instantiate(descriptor, kSampleRatei);

  454. 

  455.             if (handle == nullptr)

  456.             {

  457.                 DISCOVERY_OUT("error", "Failed to init first LADSPA plugin");

  458.                 return;

  459.             }

  460. 

  461.             descriptor->cleanup(handle);

  462. 

  463.             lib_close(libHandle);

  464.             libHandle = lib_open(filename);

  465. 

  466.             if (libHandle == nullptr)

  467.             {

  468.                 print_lib_error(filename);

  469.                 return;

  470.             }

  471. 

  472.             descFn = lib_symbol<LADSPA_Descriptor_Function>(libHandle, "ladspa_descriptor");

  473. 

  474.             if (descFn == nullptr)

  475.             {

  476.                 DISCOVERY_OUT("error", "Not a LADSPA plugin (#2)");

  477.                 return;

  478.             }

  479.         }

  480.     }

  481. 

  482.     unsigned long i = 0;

  483. 

  484.     while ((descriptor = descFn(i++)) != nullptr)

  485.     {

  486.         if (descriptor->instantiate == nullptr)

  487.         {

  488.             DISCOVERY_OUT("error", "Plugin '" << descriptor->Name << "' has no instantiate()");

  489.             continue;

  490.         }

  491.         if (descriptor->cleanup == nullptr)

  492.         {

  493.             DISCOVERY_OUT("error", "Plugin '" << descriptor->Name << "' has no cleanup()");

  494.             continue;

  495.         }

  496.         if (descriptor->run == nullptr)

  497.         {

  498.             DISCOVERY_OUT("error", "Plugin '" << descriptor->Name << "' has no run()");

  499.             continue;

  500.         }

  501.         if (! LADSPA_IS_HARD_RT_CAPABLE(descriptor->Properties))

  502.         {

  503.             DISCOVERY_OUT("warning", "Plugin '" << descriptor->Name << "' is not hard real-time capable");

  504.         }

  505. 

  506.         uint hints = 0x0;

  507.         int audioIns = 0;

  508.         int audioOuts = 0;

  509.         int audioTotal = 0;

  510.         int parametersIns = 0;

  511.         int parametersOuts = 0;

  512.         int parametersTotal = 0;

  513. 

  514.         if (LADSPA_IS_HARD_RT_CAPABLE(descriptor->Properties))

  515.             hints |= PLUGIN_IS_RTSAFE;

  516. 

  517.         for (unsigned long j=0; j < descriptor->PortCount; ++j)

  518.         {

  519.             CARLA_ASSERT(descriptor->PortNames[j] != nullptr);

  520.             const LADSPA_PortDescriptor portDescriptor = descriptor->PortDescriptors[j];

  521. 

  522.             if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  523.             {

  524.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  525.                     audioIns += 1;

  526.                 else if (LADSPA_IS_PORT_OUTPUT(portDescriptor))

  527.                     audioOuts += 1;

  528. 

  529.                 audioTotal += 1;

  530.             }

  531.             else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  532.             {

  533.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  534.                     parametersIns += 1;

  535.                 else if (LADSPA_IS_PORT_OUTPUT(portDescriptor) && std::strcmp(descriptor->PortNames[j], "latency") != 0 && std::strcmp(descriptor->PortNames[j], "_latency") != 0)

  536.                     parametersOuts += 1;

  537. 

  538.                 parametersTotal += 1;

  539.             }

  540.         }

  541. 

  542.         if (doInit)

  543.         {

  544.             // -----------------------------------------------------------------------

  545.             // start crash-free plugin test

  546. 

  547.             LADSPA_Handle handle = descriptor->instantiate(descriptor, kSampleRatei);

  548. 

  549.             if (handle == nullptr)

  550.             {

  551.                 DISCOVERY_OUT("error", "Failed to init LADSPA plugin");

  552.                 continue;

  553.             }

  554. 

  555.             // Test quick init and cleanup

  556.             descriptor->cleanup(handle);

  557. 

  558.             handle = descriptor->instantiate(descriptor, kSampleRatei);

  559. 

  560.             if (handle == nullptr)

  561.             {

  562.                 DISCOVERY_OUT("error", "Failed to init LADSPA plugin (#2)");

  563.                 continue;

  564.             }

  565. 

  566.             LADSPA_Data bufferAudio[kBufferSize][audioTotal];

  567.             LADSPA_Data bufferParams[parametersTotal];

  568.             LADSPA_Data min, max, def;

  569. 

  570.             for (unsigned long j=0, iA=0, iC=0; j < descriptor->PortCount; ++j)

  571.             {

  572.                 const LADSPA_PortDescriptor portDescriptor = descriptor->PortDescriptors[j];

  573.                 const LADSPA_PortRangeHint  portRangeHints = descriptor->PortRangeHints[j];

  574.                 const char* const portName = descriptor->PortNames[j];

  575. 

  576.                 if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  577.                 {

  578.                     carla_zeroFloats(bufferAudio[iA], kBufferSize);

  579.                     descriptor->connect_port(handle, j, bufferAudio[iA++]);

  580.                 }

  581.                 else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  582.                 {

  583.                     // min value

  584.                     if (LADSPA_IS_HINT_BOUNDED_BELOW(portRangeHints.HintDescriptor))

  585.                         min = portRangeHints.LowerBound;

  586.                     else

  587.                         min = 0.0f;

  588. 

  589.                     // max value

  590.                     if (LADSPA_IS_HINT_BOUNDED_ABOVE(portRangeHints.HintDescriptor))

  591.                         max = portRangeHints.UpperBound;

  592.                     else

  593.                         max = 1.0f;

  594. 

  595.                     if (min > max)

  596.                     {

  597.                         DISCOVERY_OUT("warning", "Parameter '" << portName << "' is broken: min > max");

  598.                         max = min + 0.1f;

  599.                     }

  600.                     else if (carla_isEqual(min, max))

  601.                     {

  602.                         DISCOVERY_OUT("warning", "Parameter '" << portName << "' is broken: max == min");

  603.                         max = min + 0.1f;

  604.                     }

  605. 

  606.                     // default value

  607.                     def = get_default_ladspa_port_value(portRangeHints.HintDescriptor, min, max);

  608. 

  609.                     if (LADSPA_IS_HINT_SAMPLE_RATE(portRangeHints.HintDescriptor))

  610.                     {

  611.                         min *= kSampleRatef;

  612.                         max *= kSampleRatef;

  613.                         def *= kSampleRatef;

  614.                     }

  615. 

  616.                     if (LADSPA_IS_PORT_OUTPUT(portDescriptor) && (std::strcmp(portName, "latency") == 0 || std::strcmp(portName, "_latency") == 0))

  617.                     {

  618.                         // latency parameter

  619.                         def = 0.0f;

  620.                     }

  621.                     else

  622.                     {

  623.                         if (def < min)

  624.                             def = min;

  625.                         else if (def > max)

  626.                             def = max;

  627.                     }

  628. 

  629.                     bufferParams[iC] = def;

  630.                     descriptor->connect_port(handle, j, &bufferParams[iC++]);

  631.                 }

  632.             }

  633. 

  634.             if (descriptor->activate != nullptr)

  635.                 descriptor->activate(handle);

  636. 

  637.             descriptor->run(handle, kBufferSize);

  638. 

  639.             if (descriptor->deactivate != nullptr)

  640.                 descriptor->deactivate(handle);

  641. 

  642.             descriptor->cleanup(handle);

  643. 

  644.             // end crash-free plugin test

  645.             // -----------------------------------------------------------------------

  646.         }

  647. 

  648.         DISCOVERY_OUT("init", "-----------");

  649.         DISCOVERY_OUT("build", BINARY_NATIVE);

  650.         DISCOVERY_OUT("hints", hints);

  651.         DISCOVERY_OUT("name", descriptor->Name);

  652.         DISCOVERY_OUT("label", descriptor->Label);

  653.         DISCOVERY_OUT("maker", descriptor->Maker);

  654.         DISCOVERY_OUT("uniqueId", descriptor->UniqueID);

  655.         DISCOVERY_OUT("audio.ins", audioIns);

  656.         DISCOVERY_OUT("audio.outs", audioOuts);

  657.         DISCOVERY_OUT("parameters.ins", parametersIns);

  658.         DISCOVERY_OUT("parameters.outs", parametersOuts);

  659.         DISCOVERY_OUT("end", "------------");

  660.     }

  661. }

  662. 

  663. static void do_dssi_check(lib_t& libHandle, const char* const filename, const bool doInit)

  664. {

  665.     DSSI_Descriptor_Function descFn = lib_symbol<DSSI_Descriptor_Function>(libHandle, "dssi_descriptor");

  666. 

  667.     if (descFn == nullptr)

  668.     {

  669.         DISCOVERY_OUT("error", "Not a DSSI plugin");

  670.         return;

  671.     }

  672. 

  673.     const DSSI_Descriptor* descriptor;

  674. 

  675.     {

  676.         descriptor = descFn(0);

  677. 

  678.         if (descriptor == nullptr)

  679.         {

  680.             DISCOVERY_OUT("error", "Binary doesn't contain any plugins");

  681.             return;

  682.         }

  683. 

  684.         const LADSPA_Descriptor* const ldescriptor(descriptor->LADSPA_Plugin);

  685. 

  686.         if (ldescriptor == nullptr)

  687.         {

  688.             DISCOVERY_OUT("error", "DSSI plugin doesn't provide the LADSPA interface");

  689.             return;

  690.         }

  691. 

  692.         if (doInit && ldescriptor->instantiate != nullptr && ldescriptor->cleanup != nullptr)

  693.         {

  694.             LADSPA_Handle handle = ldescriptor->instantiate(ldescriptor, kSampleRatei);

  695. 

  696.             if (handle == nullptr)

  697.             {

  698.                 DISCOVERY_OUT("error", "Failed to init first LADSPA plugin");

  699.                 return;

  700.             }

  701. 

  702.             ldescriptor->cleanup(handle);

  703. 

  704.             lib_close(libHandle);

  705.             libHandle = lib_open(filename);

  706. 

  707.             if (libHandle == nullptr)

  708.             {

  709.                 print_lib_error(filename);

  710.                 return;

  711.             }

  712. 

  713.             descFn = lib_symbol<DSSI_Descriptor_Function>(libHandle, "dssi_descriptor");

  714. 

  715.             if (descFn == nullptr)

  716.             {

  717.                 DISCOVERY_OUT("error", "Not a DSSI plugin (#2)");

  718.                 return;

  719.             }

  720.         }

  721.     }

  722. 

  723.     unsigned long i = 0;

  724. 

  725.     while ((descriptor = descFn(i++)) != nullptr)

  726.     {

  727.         const LADSPA_Descriptor* const ldescriptor(descriptor->LADSPA_Plugin);

  728. 

  729.         if (ldescriptor == nullptr)

  730.         {

  731.             DISCOVERY_OUT("error", "Plugin '" << ldescriptor->Name << "' has no LADSPA interface");

  732.             continue;

  733.         }

  734.         if (descriptor->DSSI_API_Version != DSSI_VERSION_MAJOR)

  735.         {

  736.             DISCOVERY_OUT("error", "Plugin '" << ldescriptor->Name << "' uses an unsupported DSSI spec version " << descriptor->DSSI_API_Version);

  737.             continue;

  738.         }

  739.         if (ldescriptor->instantiate == nullptr)

  740.         {

  741.             DISCOVERY_OUT("error", "Plugin '" << ldescriptor->Name << "' has no instantiate()");

  742.             continue;

  743.         }

  744.         if (ldescriptor->cleanup == nullptr)

  745.         {

  746.             DISCOVERY_OUT("error", "Plugin '" << ldescriptor->Name << "' has no cleanup()");

  747.             continue;

  748.         }

  749.         if (ldescriptor->run == nullptr && descriptor->run_synth == nullptr)

  750.         {

  751.             DISCOVERY_OUT("error", "Plugin '" << ldescriptor->Name << "' has no run() or run_synth()");

  752.             continue;

  753.         }

  754.         if (descriptor->run_synth == nullptr && descriptor->run_multiple_synths != nullptr)

  755.         {

  756.             DISCOVERY_OUT("error", "Plugin '" << ldescriptor->Name << "' requires run_multiple_synths which is not supported");

  757.             continue;

  758.         }

  759.         if (! LADSPA_IS_HARD_RT_CAPABLE(ldescriptor->Properties))

  760.         {

  761.             DISCOVERY_OUT("warning", "Plugin '" << ldescriptor->Name << "' is not hard real-time capable");

  762.         }

  763. 

  764.         uint hints = 0x0;

  765.         int audioIns = 0;

  766.         int audioOuts = 0;

  767.         int audioTotal = 0;

  768.         int midiIns = 0;

  769.         int parametersIns = 0;

  770.         int parametersOuts = 0;

  771.         int parametersTotal = 0;

  772. 

  773.         if (LADSPA_IS_HARD_RT_CAPABLE(ldescriptor->Properties))

  774.             hints |= PLUGIN_IS_RTSAFE;

  775. 

  776.         for (unsigned long j=0; j < ldescriptor->PortCount; ++j)

  777.         {

  778.             CARLA_ASSERT(ldescriptor->PortNames[j] != nullptr);

  779.             const LADSPA_PortDescriptor portDescriptor = ldescriptor->PortDescriptors[j];

  780. 

  781.             if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  782.             {

  783.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  784.                     audioIns += 1;

  785.                 else if (LADSPA_IS_PORT_OUTPUT(portDescriptor))

  786.                     audioOuts += 1;

  787. 

  788.                 audioTotal += 1;

  789.             }

  790.             else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  791.             {

  792.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  793.                     parametersIns += 1;

  794.                 else if (LADSPA_IS_PORT_OUTPUT(portDescriptor) && std::strcmp(ldescriptor->PortNames[j], "latency") != 0 && std::strcmp(ldescriptor->PortNames[j], "_latency") != 0)

  795.                     parametersOuts += 1;

  796. 

  797.                 parametersTotal += 1;

  798.             }

  799.         }

  800. 

  801.         if (descriptor->run_synth != nullptr)

  802.             midiIns = 1;

  803. 

  804.         if (midiIns > 0 && audioIns == 0 && audioOuts > 0)

  805.             hints |= PLUGIN_IS_SYNTH;

  806. 

  807.         if (const char* const ui = find_dssi_ui(filename, ldescriptor->Label))

  808.         {

  809.             hints |= PLUGIN_HAS_CUSTOM_UI;

  810.             delete[] ui;

  811.         }

  812. 

  813.         if (doInit)

  814.         {

  815.             // -----------------------------------------------------------------------

  816.             // start crash-free plugin test

  817. 

  818.             LADSPA_Handle handle = ldescriptor->instantiate(ldescriptor, kSampleRatei);

  819. 

  820.             if (handle == nullptr)

  821.             {

  822.                 DISCOVERY_OUT("error", "Failed to init DSSI plugin");

  823.                 continue;

  824.             }

  825. 

  826.             // Test quick init and cleanup

  827.             ldescriptor->cleanup(handle);

  828. 

  829.             handle = ldescriptor->instantiate(ldescriptor, kSampleRatei);

  830. 

  831.             if (handle == nullptr)

  832.             {

  833.                 DISCOVERY_OUT("error", "Failed to init DSSI plugin (#2)");

  834.                 continue;

  835.             }

  836. 

  837.             LADSPA_Data bufferAudio[kBufferSize][audioTotal];

  838.             LADSPA_Data bufferParams[parametersTotal];

  839.             LADSPA_Data min, max, def;

  840. 

  841.             for (unsigned long j=0, iA=0, iC=0; j < ldescriptor->PortCount; ++j)

  842.             {

  843.                 const LADSPA_PortDescriptor portDescriptor = ldescriptor->PortDescriptors[j];

  844.                 const LADSPA_PortRangeHint  portRangeHints = ldescriptor->PortRangeHints[j];

  845.                 const char* const portName = ldescriptor->PortNames[j];

  846. 

  847.                 if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  848.                 {

  849.                     carla_zeroFloats(bufferAudio[iA], kBufferSize);

  850.                     ldescriptor->connect_port(handle, j, bufferAudio[iA++]);

  851.                 }

  852.                 else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  853.                 {

  854.                     // min value

  855.                     if (LADSPA_IS_HINT_BOUNDED_BELOW(portRangeHints.HintDescriptor))

  856.                         min = portRangeHints.LowerBound;

  857.                     else

  858.                         min = 0.0f;

  859. 

  860.                     // max value

  861.                     if (LADSPA_IS_HINT_BOUNDED_ABOVE(portRangeHints.HintDescriptor))

  862.                         max = portRangeHints.UpperBound;

  863.                     else

  864.                         max = 1.0f;

  865. 

  866.                     if (min > max)

  867.                     {

  868.                         DISCOVERY_OUT("warning", "Parameter '" << portName << "' is broken: min > max");

  869.                         max = min + 0.1f;

  870.                     }

  871.                     else if (carla_isEqual(min, max))

  872.                     {

  873.                         DISCOVERY_OUT("warning", "Parameter '" << portName << "' is broken: max == min");

  874.                         max = min + 0.1f;

  875.                     }

  876. 

  877.                     // default value

  878.                     def = get_default_ladspa_port_value(portRangeHints.HintDescriptor, min, max);

  879. 

  880.                     if (LADSPA_IS_HINT_SAMPLE_RATE(portRangeHints.HintDescriptor))

  881.                     {

  882.                         min *= kSampleRatef;

  883.                         max *= kSampleRatef;

  884.                         def *= kSampleRatef;

  885.                     }

  886. 

  887.                     if (LADSPA_IS_PORT_OUTPUT(portDescriptor) && (std::strcmp(portName, "latency") == 0 || std::strcmp(portName, "_latency") == 0))

  888.                     {

  889.                         // latency parameter

  890.                         def = 0.0f;

  891.                     }

  892.                     else

  893.                     {

  894.                         if (def < min)

  895.                             def = min;

  896.                         else if (def > max)

  897.                             def = max;

  898.                     }

  899. 

  900.                     bufferParams[iC] = def;

  901.                     ldescriptor->connect_port(handle, j, &bufferParams[iC++]);

  902.                 }

  903.             }

  904. 

  905.             // select first midi-program if available

  906.             if (descriptor->get_program != nullptr && descriptor->select_program != nullptr)

  907.             {

  908.                 if (const DSSI_Program_Descriptor* const pDesc = descriptor->get_program(handle, 0))

  909.                     descriptor->select_program(handle, pDesc->Bank, pDesc->Program);

  910.             }

  911. 

  912.             if (ldescriptor->activate != nullptr)

  913.                 ldescriptor->activate(handle);

  914. 

  915.             if (descriptor->run_synth != nullptr)

  916.             {

  917.                 snd_seq_event_t midiEvents[2];

  918.                 carla_zeroStructs(midiEvents, 2);

  919. 

  920.                 const unsigned long midiEventCount = 2;

  921. 

  922.                 midiEvents[0].type = SND_SEQ_EVENT_NOTEON;

  923.                 midiEvents[0].data.note.note     = 64;

  924.                 midiEvents[0].data.note.velocity = 100;

  925. 

  926.                 midiEvents[1].type = SND_SEQ_EVENT_NOTEOFF;

  927.                 midiEvents[1].data.note.note     = 64;

  928.                 midiEvents[1].data.note.velocity = 0;

  929.                 midiEvents[1].time.tick = kBufferSize/2;

  930. 

  931.                 descriptor->run_synth(handle, kBufferSize, midiEvents, midiEventCount);

  932.             }

  933.             else

  934.                 ldescriptor->run(handle, kBufferSize);

  935. 

  936.             if (ldescriptor->deactivate != nullptr)

  937.                 ldescriptor->deactivate(handle);

  938. 

  939.             ldescriptor->cleanup(handle);

  940. 

  941.             // end crash-free plugin test

  942.             // -----------------------------------------------------------------------

  943.         }

  944. 

  945.         DISCOVERY_OUT("init", "-----------");

  946.         DISCOVERY_OUT("build", BINARY_NATIVE);

  947.         DISCOVERY_OUT("hints", hints);

  948.         DISCOVERY_OUT("name", ldescriptor->Name);

  949.         DISCOVERY_OUT("label", ldescriptor->Label);

  950.         DISCOVERY_OUT("maker", ldescriptor->Maker);

  951.         DISCOVERY_OUT("uniqueId", ldescriptor->UniqueID);

  952.         DISCOVERY_OUT("audio.ins", audioIns);

  953.         DISCOVERY_OUT("audio.outs", audioOuts);

  954.         DISCOVERY_OUT("midi.ins", midiIns);

  955.         DISCOVERY_OUT("parameters.ins", parametersIns);

  956.         DISCOVERY_OUT("parameters.outs", parametersOuts);

  957.         DISCOVERY_OUT("end", "------------");

  958.     }

  959. }

  960. 

  961. static void do_lv2_check(const char* const bundle, const bool doInit)

  962. {

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

  964. 

  965.     Lilv::Node bundleNode(lv2World.new_file_uri(nullptr, bundle));

  966.     CARLA_SAFE_ASSERT_RETURN(bundleNode.is_uri(),);

  967. 

  968.     CarlaString sBundle(bundleNode.as_uri());

  969. 

  970.     if (! sBundle.endsWith("/"))

  971.         sBundle += "/";

  972. 

  973.     // Load bundle

  974.     lv2World.load_bundle(sBundle);

  975. 

  976.     // Load plugins in this bundle

  977.     const Lilv::Plugins lilvPlugins(lv2World.get_all_plugins());

  978. 

  979.     // Get all plugin URIs in this bundle

  980.     StringArray URIs;

  981. 

  982.     LILV_FOREACH(plugins, it, lilvPlugins)

  983.     {

  984.         Lilv::Plugin lilvPlugin(lilv_plugins_get(lilvPlugins, it));

  985. 

  986.         if (const char* const uri = lilvPlugin.get_uri().as_string())

  987.             URIs.addIfNotAlreadyThere(juce::String(uri));

  988.     }

  989. 

  990.     if (URIs.size() == 0)

  991.     {

  992.         DISCOVERY_OUT("warning", "LV2 Bundle doesn't provide any plugins");

  993.         return;

  994.     }

  995. 

  996.     // Get & check every plugin-instance

  997.     for (int i=0, count=URIs.size(); i < count; ++i)

  998.     {

  999.         const LV2_RDF_Descriptor* const rdfDescriptor(lv2_rdf_new(URIs[i].toRawUTF8(), false));

  1000. 

  1001.         if (rdfDescriptor == nullptr || rdfDescriptor->URI == nullptr)

  1002.         {

  1003.             DISCOVERY_OUT("error", "Failed to find LV2 plugin '" << URIs[i].toRawUTF8() << "'");

  1004.             continue;

  1005.         }

  1006. 

  1007.         if (doInit)

  1008.         {

  1009.             // test if DLL is loadable, twice

  1010.             const lib_t libHandle1 = lib_open(rdfDescriptor->Binary);

  1011. 

  1012.             if (libHandle1 == nullptr)

  1013.             {

  1014.                 print_lib_error(rdfDescriptor->Binary);

  1015.                 delete rdfDescriptor;

  1016.                 continue;

  1017.             }

  1018. 

  1019.             lib_close(libHandle1);

  1020. 

  1021.             const lib_t libHandle2 = lib_open(rdfDescriptor->Binary);

  1022. 

  1023.             if (libHandle2 == nullptr)

  1024.             {

  1025.                 print_lib_error(rdfDescriptor->Binary);

  1026.                 delete rdfDescriptor;

  1027.                 continue;

  1028.             }

  1029. 

  1030.             lib_close(libHandle2);

  1031.         }

  1032. 

  1033.         // test if we support all required ports and features

  1034.         {

  1035.             bool supported = true;

  1036. 

  1037.             for (uint32_t j=0; j < rdfDescriptor->PortCount && supported; ++j)

  1038.             {

  1039.                 const LV2_RDF_Port* const rdfPort(&rdfDescriptor->Ports[j]);

  1040. 

  1041.                 if (is_lv2_port_supported(rdfPort->Types))

  1042.                 {

  1043.                     pass();

  1044.                 }

  1045.                 else if (! LV2_IS_PORT_OPTIONAL(rdfPort->Properties))

  1046.                 {

  1047.                     DISCOVERY_OUT("error", "Plugin '" << rdfDescriptor->URI << "' requires a non-supported port type (portName: '" << rdfPort->Name << "')");

  1048.                     supported = false;

  1049.                     break;

  1050.                 }

  1051.             }

  1052. 

  1053.             for (uint32_t j=0; j < rdfDescriptor->FeatureCount && supported; ++j)

  1054.             {

  1055.                 const LV2_RDF_Feature& feature(rdfDescriptor->Features[j]);

  1056. 

  1057.                 if (std::strcmp(feature.URI, LV2_DATA_ACCESS_URI) == 0 || std::strcmp(feature.URI, LV2_INSTANCE_ACCESS_URI) == 0)

  1058.                 {

  1059.                     DISCOVERY_OUT("warning", "Plugin '" << rdfDescriptor->URI << "' DSP wants UI feature '" << feature.URI << "', ignoring this");

  1060.                 }

  1061.                 else if (feature.Required && ! is_lv2_feature_supported(feature.URI))

  1062.                 {

  1063.                     DISCOVERY_OUT("error", "Plugin '" << rdfDescriptor->URI << "' requires a non-supported feature '" << feature.URI << "'");

  1064.                     supported = false;

  1065.                     break;

  1066.                 }

  1067.             }

  1068. 

  1069.             if (! supported)

  1070.             {

  1071.                 delete rdfDescriptor;

  1072.                 continue;

  1073.             }

  1074.         }

  1075. 

  1076.         uint hints = 0x0;

  1077.         int audioIns = 0;

  1078.         int audioOuts = 0;

  1079.         int midiIns = 0;

  1080.         int midiOuts = 0;

  1081.         int parametersIns = 0;

  1082.         int parametersOuts = 0;

  1083. 

  1084.         for (uint32_t j=0; j < rdfDescriptor->FeatureCount; ++j)

  1085.         {

  1086.             const LV2_RDF_Feature* const rdfFeature(&rdfDescriptor->Features[j]);

  1087. 

  1088.             if (std::strcmp(rdfFeature->URI, LV2_CORE__hardRTCapable) == 0)

  1089.                 hints |= PLUGIN_IS_RTSAFE;

  1090.         }

  1091. 

  1092.         for (uint32_t j=0; j < rdfDescriptor->PortCount; ++j)

  1093.         {

  1094.             const LV2_RDF_Port* const rdfPort(&rdfDescriptor->Ports[j]);

  1095. 

  1096.             if (LV2_IS_PORT_AUDIO(rdfPort->Types))

  1097.             {

  1098.                 if (LV2_IS_PORT_INPUT(rdfPort->Types))

  1099.                     audioIns += 1;

  1100.                 else if (LV2_IS_PORT_OUTPUT(rdfPort->Types))

  1101.                     audioOuts += 1;

  1102.             }

  1103.             else if (LV2_IS_PORT_CONTROL(rdfPort->Types))

  1104.             {

  1105.                 if (LV2_IS_PORT_DESIGNATION_LATENCY(rdfPort->Designation))

  1106.                 {

  1107.                     pass();

  1108.                 }

  1109.                 else if (LV2_IS_PORT_DESIGNATION_SAMPLE_RATE(rdfPort->Designation))

  1110.                 {

  1111.                     pass();

  1112.                 }

  1113.                 else if (LV2_IS_PORT_DESIGNATION_FREEWHEELING(rdfPort->Designation))

  1114.                 {

  1115.                     pass();

  1116.                 }

  1117.                 else if (LV2_IS_PORT_DESIGNATION_TIME(rdfPort->Designation))

  1118.                 {

  1119.                     pass();

  1120.                 }

  1121.                 else

  1122.                 {

  1123.                     if (LV2_IS_PORT_INPUT(rdfPort->Types))

  1124.                         parametersIns += 1;

  1125.                     else if (LV2_IS_PORT_OUTPUT(rdfPort->Types))

  1126.                         parametersOuts += 1;

  1127.                 }

  1128.             }

  1129.             else if (LV2_PORT_SUPPORTS_MIDI_EVENT(rdfPort->Types))

  1130.             {

  1131.                 if (LV2_IS_PORT_INPUT(rdfPort->Types))

  1132.                     midiIns += 1;

  1133.                 else if (LV2_IS_PORT_OUTPUT(rdfPort->Types))

  1134.                     midiOuts += 1;

  1135.             }

  1136.         }

  1137. 

  1138.         if (LV2_IS_INSTRUMENT(rdfDescriptor->Type[0], rdfDescriptor->Type[1]))

  1139.             hints |= PLUGIN_IS_SYNTH;

  1140. 

  1141.         if (rdfDescriptor->UICount > 0)

  1142.             hints |= PLUGIN_HAS_CUSTOM_UI;

  1143. 

  1144.         DISCOVERY_OUT("init", "-----------");

  1145.         DISCOVERY_OUT("build", BINARY_NATIVE);

  1146.         DISCOVERY_OUT("hints", hints);

  1147. 

  1148.         if (rdfDescriptor->Name != nullptr)

  1149.             DISCOVERY_OUT("name", rdfDescriptor->Name);

  1150.         if (rdfDescriptor->Author != nullptr)

  1151.             DISCOVERY_OUT("maker", rdfDescriptor->Author);

  1152. 

  1153.         DISCOVERY_OUT("uri", rdfDescriptor->URI);

  1154.         DISCOVERY_OUT("uniqueId", rdfDescriptor->UniqueID);

  1155.         DISCOVERY_OUT("audio.ins", audioIns);

  1156.         DISCOVERY_OUT("audio.outs", audioOuts);

  1157.         DISCOVERY_OUT("midi.ins", midiIns);

  1158.         DISCOVERY_OUT("midi.outs", midiOuts);

  1159.         DISCOVERY_OUT("parameters.ins", parametersIns);

  1160.         DISCOVERY_OUT("parameters.outs", parametersOuts);

  1161.         DISCOVERY_OUT("end", "------------");

  1162. 

  1163.         delete rdfDescriptor;

  1164.     }

  1165. }

  1166. 

  1167. #ifndef CARLA_OS_MAC

  1168. static void do_vst_check(lib_t& libHandle, const bool doInit)

  1169. {

  1170.     VST_Function vstFn = lib_symbol<VST_Function>(libHandle, "VSTPluginMain");

  1171. 

  1172.     if (vstFn == nullptr)

  1173.     {

  1174.         vstFn = lib_symbol<VST_Function>(libHandle, "main");

  1175. 

  1176.         if (vstFn == nullptr)

  1177.         {

  1178.             DISCOVERY_OUT("error", "Not a VST plugin");

  1179.             return;

  1180.         }

  1181.     }

  1182. 

  1183.     AEffect* effect = vstFn(vstHostCallback);

  1184. 

  1185.     if (effect == nullptr || effect->magic != kEffectMagic)

  1186.     {

  1187.         DISCOVERY_OUT("error", "Failed to init VST plugin, or VST magic failed");

  1188.         return;

  1189.     }

  1190. 

  1191.     if (effect->uniqueID == 0)

  1192.     {

  1193.         DISCOVERY_OUT("error", "Plugin doesn't have an Unique ID");

  1194.         effect->dispatcher(effect, effClose, 0, 0, nullptr, 0.0f);

  1195.         return;

  1196.     }

  1197. 

  1198.     effect->dispatcher(effect, DECLARE_VST_DEPRECATED(effIdentify), 0, 0, nullptr, 0.0f);

  1199.     effect->dispatcher(effect, DECLARE_VST_DEPRECATED(effSetBlockSizeAndSampleRate), 0, kBufferSize, nullptr, kSampleRatef);

  1200.     effect->dispatcher(effect, effSetSampleRate, 0, 0, nullptr, kSampleRatef);

  1201.     effect->dispatcher(effect, effSetBlockSize, 0, kBufferSize, nullptr, 0.0f);

  1202.     effect->dispatcher(effect, effSetProcessPrecision, 0, kVstProcessPrecision32, nullptr, 0.0f);

  1203. 

  1204.     effect->dispatcher(effect, effOpen, 0, 0, nullptr, 0.0f);

  1205. 

  1206.     if (effect->numPrograms > 0)

  1207.         effect->dispatcher(effect, effSetProgram, 0, 0, nullptr, 0.0f);

  1208. 

  1209.     const bool isShell  = (effect->dispatcher(effect, effGetPlugCategory, 0, 0, nullptr, 0.0f) == kPlugCategShell);

  1210.     gVstCurrentUniqueId =  effect->uniqueID;

  1211. 

  1212.     char strBuf[STR_MAX+1];

  1213.     CarlaString cName;

  1214.     CarlaString cProduct;

  1215.     CarlaString cVendor;

  1216.     LinkedList<intptr_t> uniqueIds;

  1217. 

  1218.     if (isShell)

  1219.     {

  1220.         for (;;)

  1221.         {

  1222.             carla_zeroChars(strBuf, STR_MAX+1);

  1223. 

  1224.             gVstCurrentUniqueId = effect->dispatcher(effect, effShellGetNextPlugin, 0, 0, strBuf, 0.0f);

  1225. 

  1226.             if (gVstCurrentUniqueId == 0)

  1227.                 break;

  1228. 

  1229.             uniqueIds.append(gVstCurrentUniqueId);

  1230.         }

  1231. 

  1232.         effect->dispatcher(effect, effClose, 0, 0, nullptr, 0.0f);

  1233.         effect = nullptr;

  1234.     }

  1235.     else

  1236.     {

  1237.         uniqueIds.append(gVstCurrentUniqueId);

  1238.     }

  1239. 

  1240.     for (LinkedList<intptr_t>::Itenerator it = uniqueIds.begin2(); it.valid(); it.next())

  1241.     {

  1242.         gVstCurrentUniqueId = it.getValue(0);

  1243. 

  1244.         if (effect == nullptr)

  1245.         {

  1246.             effect = vstFn(vstHostCallback);

  1247. 

  1248.             effect->dispatcher(effect, DECLARE_VST_DEPRECATED(effIdentify), 0, 0, nullptr, 0.0f);

  1249.             effect->dispatcher(effect, DECLARE_VST_DEPRECATED(effSetBlockSizeAndSampleRate), 0, kBufferSize, nullptr, kSampleRatef);

  1250.             effect->dispatcher(effect, effSetSampleRate, 0, 0, nullptr, kSampleRatef);

  1251.             effect->dispatcher(effect, effSetBlockSize, 0, kBufferSize, nullptr, 0.0f);

  1252.             effect->dispatcher(effect, effSetProcessPrecision, 0, kVstProcessPrecision32, nullptr, 0.0f);

  1253. 

  1254.             effect->dispatcher(effect, effOpen, 0, 0, nullptr, 0.0f);

  1255. 

  1256.             if (effect->numPrograms > 0)

  1257.                 effect->dispatcher(effect, effSetProgram, 0, 0, nullptr, 0.0f);

  1258.         }

  1259. 

  1260.         // get name

  1261.         carla_zeroChars(strBuf, STR_MAX+1);

  1262. 

  1263.         if (effect->dispatcher(effect, effGetEffectName, 0, 0, strBuf, 0.0f) == 1)

  1264.             cName = strBuf;

  1265.         else

  1266.             cName.clear();

  1267. 

  1268.         // get product

  1269.         carla_zeroChars(strBuf, STR_MAX+1);

  1270. 

  1271.         if (effect->dispatcher(effect, effGetProductString, 0, 0, strBuf, 0.0f) == 1)

  1272.             cProduct = strBuf;

  1273.         else

  1274.             cProduct.clear();

  1275. 

  1276.         // get vendor

  1277.         carla_zeroChars(strBuf, STR_MAX+1);

  1278. 

  1279.         if (effect->dispatcher(effect, effGetVendorString, 0, 0, strBuf, 0.0f) == 1)

  1280.             cVendor = strBuf;

  1281.         else

  1282.             cVendor.clear();

  1283. 

  1284.         // get everything else

  1285.         uint hints = 0x0;

  1286.         int audioIns = effect->numInputs;

  1287.         int audioOuts = effect->numOutputs;

  1288.         int midiIns = 0;

  1289.         int midiOuts = 0;

  1290.         int parameters = effect->numParams;

  1291. 

  1292.         if (effect->flags & effFlagsHasEditor)

  1293.             hints |= PLUGIN_HAS_CUSTOM_UI;

  1294. 

  1295.         if (effect->flags & effFlagsIsSynth)

  1296.             hints |= PLUGIN_IS_SYNTH;

  1297. 

  1298.         if (vstPluginCanDo(effect, "receiveVstEvents") || vstPluginCanDo(effect, "receiveVstMidiEvent") || (effect->flags & effFlagsIsSynth) != 0)

  1299.             midiIns = 1;

  1300. 

  1301.         if (vstPluginCanDo(effect, "sendVstEvents") || vstPluginCanDo(effect, "sendVstMidiEvent"))

  1302.             midiOuts = 1;

  1303. 

  1304.         // -----------------------------------------------------------------------

  1305.         // start crash-free plugin test

  1306. 

  1307.         if (doInit)

  1308.         {

  1309.             if (gVstNeedsIdle)

  1310.                 effect->dispatcher(effect, DECLARE_VST_DEPRECATED(effIdle), 0, 0, nullptr, 0.0f);

  1311. 

  1312.             effect->dispatcher(effect, effMainsChanged, 0, 1, nullptr, 0.0f);

  1313.             effect->dispatcher(effect, effStartProcess, 0, 0, nullptr, 0.0f);

  1314. 

  1315.             if (gVstNeedsIdle)

  1316.                 effect->dispatcher(effect, DECLARE_VST_DEPRECATED(effIdle), 0, 0, nullptr, 0.0f);

  1317. 

  1318.             // Plugin might call wantMidi() during resume

  1319.             if (midiIns == 0 && gVstWantsMidi)

  1320.             {

  1321.                 midiIns = 1;

  1322.             }

  1323. 

  1324.             float* bufferAudioIn[audioIns];

  1325.             for (int j=0; j < audioIns; ++j)

  1326.             {

  1327.                 bufferAudioIn[j] = new float[kBufferSize];

  1328.                 carla_zeroFloats(bufferAudioIn[j], kBufferSize);

  1329.             }

  1330. 

  1331.             float* bufferAudioOut[audioOuts];

  1332.             for (int j=0; j < audioOuts; ++j)

  1333.             {

  1334.                 bufferAudioOut[j] = new float[kBufferSize];

  1335.                 carla_zeroFloats(bufferAudioOut[j], kBufferSize);

  1336.             }

  1337. 

  1338.             struct VstEventsFixed {

  1339.                 int32_t numEvents;

  1340.                 intptr_t reserved;

  1341.                 VstEvent* data[2];

  1342. 

  1343.                 VstEventsFixed()

  1344.                     : numEvents(0),

  1345.                       reserved(0)

  1346.                 {

  1347.                     data[0] = data[1] = nullptr;

  1348.                 }

  1349.             } events;

  1350. 

  1351.             VstMidiEvent midiEvents[2];

  1352.             carla_zeroStructs(midiEvents, 2);

  1353. 

  1354.             midiEvents[0].type = kVstMidiType;

  1355.             midiEvents[0].byteSize = sizeof(VstMidiEvent);

  1356.             midiEvents[0].midiData[0] = char(MIDI_STATUS_NOTE_ON);

  1357.             midiEvents[0].midiData[1] = 64;

  1358.             midiEvents[0].midiData[2] = 100;

  1359. 

  1360.             midiEvents[1].type = kVstMidiType;

  1361.             midiEvents[1].byteSize = sizeof(VstMidiEvent);

  1362.             midiEvents[1].midiData[0] = char(MIDI_STATUS_NOTE_OFF);

  1363.             midiEvents[1].midiData[1] = 64;

  1364.             midiEvents[1].deltaFrames = kBufferSize/2;

  1365. 

  1366.             events.numEvents = 2;

  1367.             events.data[0] = (VstEvent*)&midiEvents[0];

  1368.             events.data[1] = (VstEvent*)&midiEvents[1];

  1369. 

  1370.             // processing

  1371.             gVstIsProcessing = true;

  1372. 

  1373.             if (midiIns > 0)

  1374.                 effect->dispatcher(effect, effProcessEvents, 0, 0, &events, 0.0f);

  1375. 

  1376.             if ((effect->flags & effFlagsCanReplacing) > 0 && effect->processReplacing != nullptr && effect->processReplacing != effect->DECLARE_VST_DEPRECATED(process))

  1377.                 effect->processReplacing(effect, bufferAudioIn, bufferAudioOut, kBufferSize);

  1378.             else if (effect->DECLARE_VST_DEPRECATED(process) != nullptr)

  1379.                 effect->DECLARE_VST_DEPRECATED(process)(effect, bufferAudioIn, bufferAudioOut, kBufferSize);

  1380.             else

  1381.                 DISCOVERY_OUT("error", "Plugin doesn't have a process function");

  1382. 

  1383.             gVstIsProcessing = false;

  1384. 

  1385.             effect->dispatcher(effect, effStopProcess, 0, 0, nullptr, 0.0f);

  1386.             effect->dispatcher(effect, effMainsChanged, 0, 0, nullptr, 0.0f);

  1387. 

  1388.             if (gVstNeedsIdle)

  1389.                 effect->dispatcher(effect, DECLARE_VST_DEPRECATED(effIdle), 0, 0, nullptr, 0.0f);

  1390. 

  1391.             for (int j=0; j < audioIns; ++j)

  1392.                 delete[] bufferAudioIn[j];

  1393.             for (int j=0; j < audioOuts; ++j)

  1394.                 delete[] bufferAudioOut[j];

  1395.         }

  1396. 

  1397.         // end crash-free plugin test

  1398.         // -----------------------------------------------------------------------

  1399. 

  1400.         DISCOVERY_OUT("init", "-----------");

  1401.         DISCOVERY_OUT("build", BINARY_NATIVE);

  1402.         DISCOVERY_OUT("hints", hints);

  1403.         DISCOVERY_OUT("name", cName.buffer());

  1404.         DISCOVERY_OUT("label", cProduct.buffer());

  1405.         DISCOVERY_OUT("maker", cVendor.buffer());

  1406.         DISCOVERY_OUT("uniqueId", gVstCurrentUniqueId);

  1407.         DISCOVERY_OUT("audio.ins", audioIns);

  1408.         DISCOVERY_OUT("audio.outs", audioOuts);

  1409.         DISCOVERY_OUT("midi.ins", midiIns);

  1410.         DISCOVERY_OUT("midi.outs", midiOuts);

  1411.         DISCOVERY_OUT("parameters.ins", parameters);

  1412.         DISCOVERY_OUT("end", "------------");

  1413. 

  1414.         gVstWantsMidi = false;

  1415.         gVstWantsTime = false;

  1416. 

  1417.         if (! isShell)

  1418.             break;

  1419. 

  1420.         effect->dispatcher(effect, effClose, 0, 0, nullptr, 0.0f);

  1421.         effect = nullptr;

  1422.     }

  1423. 

  1424.     uniqueIds.clear();

  1425. 

  1426.     if (effect == nullptr)

  1427.         return;

  1428. 

  1429.     if (gVstNeedsIdle)

  1430.         effect->dispatcher(effect, DECLARE_VST_DEPRECATED(effIdle), 0, 0, nullptr, 0.0f);

  1431. 

  1432.     effect->dispatcher(effect, effClose, 0, 0, nullptr, 0.0f);

  1433. }

  1434. #endif // ! CARLA_OS_MAC

  1435. 

  1436. static void do_fluidsynth_check(const char* const filename, const bool doInit)

  1437. {

  1438. #ifdef HAVE_FLUIDSYNTH

  1439.     const juce::String jfilename = juce::String(CharPointer_UTF8(filename));

  1440.     const File file(jfilename);

  1441. 

  1442.     if (! file.existsAsFile())

  1443.     {

  1444.         DISCOVERY_OUT("error", "Requested file is not valid or does not exist");

  1445.         return;

  1446.     }

  1447. 

  1448.     if (! fluid_is_soundfont(filename))

  1449.     {

  1450.         DISCOVERY_OUT("error", "Not a SF2 file");

  1451.         return;

  1452.     }

  1453. 

  1454.     int programs = 0;

  1455. 

  1456.     if (doInit)

  1457.     {

  1458.         fluid_settings_t* const f_settings = new_fluid_settings();

  1459.         CARLA_SAFE_ASSERT_RETURN(f_settings != nullptr,);

  1460. 

  1461.         fluid_synth_t* const f_synth = new_fluid_synth(f_settings);

  1462.         CARLA_SAFE_ASSERT_RETURN(f_synth != nullptr,);

  1463. 

  1464.         const int f_id = fluid_synth_sfload(f_synth, filename, 0);

  1465. 

  1466.         if (f_id < 0)

  1467.         {

  1468.             DISCOVERY_OUT("error", "Failed to load SF2 file");

  1469.             return;

  1470.         }

  1471. 

  1472.         if (fluid_sfont_t* const f_sfont = fluid_synth_get_sfont_by_id(f_synth, static_cast<uint>(f_id)))

  1473.         {

  1474.             fluid_preset_t f_preset;

  1475. 

  1476.             f_sfont->iteration_start(f_sfont);

  1477.             for (; f_sfont->iteration_next(f_sfont, &f_preset);)

  1478.                 ++programs;

  1479.         }

  1480. 

  1481.         delete_fluid_synth(f_synth);

  1482.         delete_fluid_settings(f_settings);

  1483.     }

  1484. 

  1485.     CarlaString name(file.getFileNameWithoutExtension().toRawUTF8());

  1486.     CarlaString label(name);

  1487. 

  1488.     // 2 channels

  1489.     DISCOVERY_OUT("init", "-----------");

  1490.     DISCOVERY_OUT("build", BINARY_NATIVE);

  1491.     DISCOVERY_OUT("hints", PLUGIN_IS_SYNTH);

  1492.     DISCOVERY_OUT("name", name.buffer());

  1493.     DISCOVERY_OUT("label", label.buffer());

  1494.     DISCOVERY_OUT("audio.outs", 2);

  1495.     DISCOVERY_OUT("midi.ins", 1);

  1496.     DISCOVERY_OUT("parameters.ins", 13); // defined in Carla

  1497.     DISCOVERY_OUT("parameters.outs", 1);

  1498.     DISCOVERY_OUT("end", "------------");

  1499. 

  1500.     // 16 channels

  1501.     if (doInit && (name.isEmpty() || programs <= 1))

  1502.         return;

  1503. 

  1504.     name += " (16 outputs)";

  1505. 

  1506.     DISCOVERY_OUT("init", "-----------");

  1507.     DISCOVERY_OUT("build", BINARY_NATIVE);

  1508.     DISCOVERY_OUT("hints", PLUGIN_IS_SYNTH);

  1509.     DISCOVERY_OUT("name", name.buffer());

  1510.     DISCOVERY_OUT("label", label.buffer());

  1511.     DISCOVERY_OUT("audio.outs", 32);

  1512.     DISCOVERY_OUT("midi.ins", 1);

  1513.     DISCOVERY_OUT("parameters.ins", 13); // defined in Carla

  1514.     DISCOVERY_OUT("parameters.outs", 1);

  1515.     DISCOVERY_OUT("end", "------------");

  1516. #else // HAVE_FLUIDSYNTH

  1517.     DISCOVERY_OUT("error", "SF2 support not available");

  1518.     return;

  1519. 

  1520.     // unused

  1521.     (void)filename;

  1522.     (void)doInit;

  1523. #endif

  1524. }

  1525. 

  1526. static void do_linuxsampler_check(const char* const filename, const char* const stype, const bool doInit)

  1527. {

  1528. #ifdef HAVE_LINUXSAMPLER

  1529.     const juce::String jfilename = juce::String(CharPointer_UTF8(filename));

  1530.     const File file(jfilename);

  1531. 

  1532.     if (! file.existsAsFile())

  1533.     {

  1534.         DISCOVERY_OUT("error", "Requested file is not valid or does not exist");

  1535.         return;

  1536.     }

  1537. 

  1538.     if (doInit)

  1539.         const LinuxSamplerScopedEngine engine(filename, stype);

  1540.     else

  1541.         LinuxSamplerScopedEngine::outputInfo(nullptr, file.getFileNameWithoutExtension().toRawUTF8(), std::strcmp(stype, "gig") == 0);

  1542. #else // HAVE_LINUXSAMPLER

  1543.     DISCOVERY_OUT("error", stype << " support not available");

  1544.     return;

  1545. 

  1546.     // unused

  1547.     (void)filename;

  1548.     (void)doInit;

  1549. #endif

  1550. }

  1551. 

  1552. // ------------------------------ main entry point ------------------------------

  1553. 

  1554. int main(int argc, char* argv[])

  1555. {

  1556.     if (argc != 3)

  1557.     {

  1558.         carla_stdout("usage: %s <type> </path/to/plugin>", argv[0]);

  1559.         return 1;

  1560.     }

  1561. 

  1562.     const char* const stype    = argv[1];

  1563.     const char* const filename = argv[2];

  1564.     const PluginType  type     = getPluginTypeFromString(stype);

  1565. 

  1566.     CarlaString filenameCheck(filename);

  1567.     filenameCheck.toLower();

  1568. 

  1569.     if (type != PLUGIN_GIG && type != PLUGIN_SF2 && type != PLUGIN_SFZ)

  1570.     {

  1571.         if (filenameCheck.contains("fluidsynth", true))

  1572.         {

  1573.             DISCOVERY_OUT("info", "skipping fluidsynth based plugin");

  1574.             return 0;

  1575.         }

  1576.         if (filenameCheck.contains("linuxsampler", true) || filenameCheck.endsWith("ls16.so"))

  1577.         {

  1578.             DISCOVERY_OUT("info", "skipping linuxsampler based plugin");

  1579.             return 0;

  1580.         }

  1581.     }

  1582. 

  1583.     bool openLib = false;

  1584.     lib_t handle = nullptr;

  1585. 

  1586.     switch (type)

  1587.     {

  1588.     case PLUGIN_LADSPA:

  1589.     case PLUGIN_DSSI:

  1590. #ifndef CARLA_OS_MAC

  1591.     case PLUGIN_VST2:

  1592.         openLib = true;

  1593. #endif

  1594.     default:

  1595.         break;

  1596.     }

  1597. 

  1598.     if (openLib)

  1599.     {

  1600.         handle = lib_open(filename);

  1601. 

  1602.         if (handle == nullptr)

  1603.         {

  1604.             print_lib_error(filename);

  1605.             return 1;

  1606.         }

  1607.     }

  1608. 

  1609.     // never do init for dssi-vst, takes too long and it's crashy

  1610.     bool doInit = ! filenameCheck.contains("dssi-vst", true);

  1611. 

  1612.     if (doInit && getenv("CARLA_DISCOVERY_NO_PROCESSING_CHECKS") != nullptr)

  1613.         doInit = false;

  1614. 

  1615.     if (doInit && handle != nullptr)

  1616.     {

  1617.         // test fast loading & unloading DLL without initializing the plugin(s)

  1618.         if (! lib_close(handle))

  1619.         {

  1620.             print_lib_error(filename);

  1621.             return 1;

  1622.         }

  1623. 

  1624.         handle = lib_open(filename);

  1625. 

  1626.         if (handle == nullptr)

  1627.         {

  1628.             print_lib_error(filename);

  1629.             return 1;

  1630.         }

  1631.     }

  1632. 

  1633.     if (std::strcmp(filename, ":all") == 0)

  1634.     {

  1635.         do_cached_check(type);

  1636.         return 0;

  1637.     }

  1638. 

  1639.     switch (type)

  1640.     {

  1641.     case PLUGIN_LADSPA:

  1642.         do_ladspa_check(handle, filename, doInit);

  1643.         break;

  1644.     case PLUGIN_DSSI:

  1645.         do_dssi_check(handle, filename, doInit);

  1646.         break;

  1647.     case PLUGIN_LV2:

  1648.         do_lv2_check(filename, doInit);

  1649.         break;

  1650.     case PLUGIN_VST2:

  1651.         do_vst_check(handle, doInit);

  1652.         break;

  1653.     case PLUGIN_GIG:

  1654.         do_linuxsampler_check(filename, "gig", doInit);

  1655.         break;

  1656.     case PLUGIN_SF2:

  1657.         do_fluidsynth_check(filename, doInit);

  1658.         break;

  1659.     case PLUGIN_SFZ:

  1660.         do_linuxsampler_check(filename, "sfz", doInit);

  1661.         break;

  1662.     default:

  1663.         break;

  1664.     }

  1665. 

  1666.     if (openLib && handle != nullptr)

  1667.         lib_close(handle);

  1668. 

  1669.     return 0;

  1670. }

  1671. 

  1672. // --------------------------------------------------------------------------