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

1672 lines
52KB
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. #ifndef BUILD_BRIDGE

  35. // need to include this before linuxsampler

  36. # define CARLA_UTILS_CACHED_PLUGINS_ONLY

  37. # include "CarlaUtils.cpp"

  38. #endif

  39. 

  40. #ifdef HAVE_FLUIDSYNTH

  41. # include <fluidsynth.h>

  42. #endif

  43. 

  44. #ifdef HAVE_LINUXSAMPLER

  45. # include "linuxsampler/EngineFactory.h"

  46. #endif

  47. 

  48. #include <iostream>

  49. 

  50. #include "water/water.h"

  51. 

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

  53. 

  54. using water::CharPointer_UTF8;

  55. using water::File;

  56. using water::StringArray;

  57. 

  58. CARLA_BACKEND_USE_NAMESPACE

  59. 

  60. // --------------------------------------------------------------------------

  61. // Dummy values to test plugins with

  62. 

  63. static const uint32_t kBufferSize  = 512;

  64. static const double   kSampleRate  = 44100.0;

  65. static const int32_t  kSampleRatei = 44100;

  66. static const float    kSampleRatef = 44100.0f;

  67. 

  68. // --------------------------------------------------------------------------

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

  70. 

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

  72. {

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

  74. 

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

  76.         DISCOVERY_OUT("error", error);

  77. }

  78. 

  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. 

  269. #ifdef HAVE_LINUXSAMPLER

  270. // --------------------------------------------------------------------------

  271. // LinuxSampler stuff

  272. 

  273. class LinuxSamplerScopedEngine

  274. {

  275. public:

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

  277.         : fEngine(nullptr)

  278.     {

  279.         using namespace LinuxSampler;

  280. 

  281.         try {

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

  283.         }

  284.         catch (const Exception& e)

  285.         {

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

  287.             return;

  288.         }

  289. 

  290.         if (fEngine == nullptr)

  291.             return;

  292. 

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

  294. 

  295.         if (insMan == nullptr)

  296.         {

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

  298.             return;

  299.         }

  300. 

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

  302. 

  303.         try {

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

  305.         }

  306.         catch (const InstrumentManagerException& e)

  307.         {

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

  309.             return;

  310.         }

  311. 

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

  313.         {

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

  315.             return;

  316.         }

  317. 

  318.         InstrumentManager::instrument_info_t info;

  319. 

  320.         try {

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

  322.         }

  323.         catch (const InstrumentManagerException& e)

  324.         {

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

  326.             return;

  327.         }

  328. 

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

  330.     }

  331. 

  332.     ~LinuxSamplerScopedEngine()

  333.     {

  334.         if (fEngine != nullptr)

  335.         {

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

  337.             fEngine = nullptr;

  338.         }

  339.     }

  340. 

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

  342.     {

  343.         CarlaString name;

  344.         const char* label;

  345. 

  346.         if (info != nullptr)

  347.         {

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

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

  350.         }

  351.         else

  352.         {

  353.             name  = basename;

  354.             label = basename;

  355.         }

  356. 

  357.         // 2 channels

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

  359.         DISCOVERY_OUT("build", BINARY_NATIVE);

  360.         DISCOVERY_OUT("hints", PLUGIN_IS_SYNTH);

  361. 

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

  363.         DISCOVERY_OUT("label", label);

  364. 

  365.         if (info != nullptr)

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

  367. 

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

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

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

  371. 

  372.         // 16 channels

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

  374.             return;

  375. 

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

  377. 

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

  379.         DISCOVERY_OUT("build", BINARY_NATIVE);

  380.         DISCOVERY_OUT("hints", PLUGIN_IS_SYNTH);

  381. 

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

  383.         DISCOVERY_OUT("label", label);

  384. 

  385.         if (info != nullptr)

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

  387. 

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

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

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

  391.     }

  392. 

  393. private:

  394.     LinuxSampler::Engine* fEngine;

  395. 

  396.     CARLA_PREVENT_HEAP_ALLOCATION

  397.     CARLA_DECLARE_NON_COPY_CLASS(LinuxSamplerScopedEngine)

  398. };

  399. #endif // HAVE_LINUXSAMPLER

  400. 

  401. // ------------------------------ Plugin Checks -----------------------------

  402. 

  403. #ifndef BUILD_BRIDGE

  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. #endif

  430. 

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

  432. {

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

  434. 

  435.     if (descFn == nullptr)

  436.     {

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

  438.         return;

  439.     }

  440. 

  441.     const LADSPA_Descriptor* descriptor;

  442. 

  443.     {

  444.         descriptor = descFn(0);

  445. 

  446.         if (descriptor == nullptr)

  447.         {

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

  449.             return;

  450.         }

  451. 

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

  453.         {

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

  455. 

  456.             if (handle == nullptr)

  457.             {

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

  459.                 return;

  460.             }

  461. 

  462.             descriptor->cleanup(handle);

  463. 

  464.             lib_close(libHandle);

  465.             libHandle = lib_open(filename);

  466. 

  467.             if (libHandle == nullptr)

  468.             {

  469.                 print_lib_error(filename);

  470.                 return;

  471.             }

  472. 

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

  474. 

  475.             if (descFn == nullptr)

  476.             {

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

  478.                 return;

  479.             }

  480.         }

  481.     }

  482. 

  483.     unsigned long i = 0;

  484. 

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

  486.     {

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

  488.         {

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

  490.             continue;

  491.         }

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

  493.         {

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

  495.             continue;

  496.         }

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

  498.         {

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

  500.             continue;

  501.         }

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

  503.         {

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

  505.         }

  506. 

  507.         uint hints = 0x0;

  508.         int audioIns = 0;

  509.         int audioOuts = 0;

  510.         int audioTotal = 0;

  511.         int parametersIns = 0;

  512.         int parametersOuts = 0;

  513.         int parametersTotal = 0;

  514. 

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

  516.             hints |= PLUGIN_IS_RTSAFE;

  517. 

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

  519.         {

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

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

  522. 

  523.             if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  524.             {

  525.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  526.                     audioIns += 1;

  527.                 else if (LADSPA_IS_PORT_OUTPUT(portDescriptor))

  528.                     audioOuts += 1;

  529. 

  530.                 audioTotal += 1;

  531.             }

  532.             else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  533.             {

  534.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  535.                     parametersIns += 1;

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

  537.                     parametersOuts += 1;

  538. 

  539.                 parametersTotal += 1;

  540.             }

  541.         }

  542. 

  543.         if (doInit)

  544.         {

  545.             // -----------------------------------------------------------------------

  546.             // start crash-free plugin test

  547. 

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

  549. 

  550.             if (handle == nullptr)

  551.             {

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

  553.                 continue;

  554.             }

  555. 

  556.             // Test quick init and cleanup

  557.             descriptor->cleanup(handle);

  558. 

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

  560. 

  561.             if (handle == nullptr)

  562.             {

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

  564.                 continue;

  565.             }

  566. 

  567.             LADSPA_Data bufferAudio[kBufferSize][audioTotal];

  568.             LADSPA_Data bufferParams[parametersTotal];

  569.             LADSPA_Data min, max, def;

  570. 

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

  572.             {

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

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

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

  576. 

  577.                 if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  578.                 {

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

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

  581.                 }

  582.                 else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  583.                 {

  584.                     // min value

  585.                     if (LADSPA_IS_HINT_BOUNDED_BELOW(portRangeHints.HintDescriptor))

  586.                         min = portRangeHints.LowerBound;

  587.                     else

  588.                         min = 0.0f;

  589. 

  590.                     // max value

  591.                     if (LADSPA_IS_HINT_BOUNDED_ABOVE(portRangeHints.HintDescriptor))

  592.                         max = portRangeHints.UpperBound;

  593.                     else

  594.                         max = 1.0f;

  595. 

  596.                     if (min > max)

  597.                     {

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

  599.                         max = min + 0.1f;

  600.                     }

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

  602.                     {

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

  604.                         max = min + 0.1f;

  605.                     }

  606. 

  607.                     // default value

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

  609. 

  610.                     if (LADSPA_IS_HINT_SAMPLE_RATE(portRangeHints.HintDescriptor))

  611.                     {

  612.                         min *= kSampleRatef;

  613.                         max *= kSampleRatef;

  614.                         def *= kSampleRatef;

  615.                     }

  616. 

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

  618.                     {

  619.                         // latency parameter

  620.                         def = 0.0f;

  621.                     }

  622.                     else

  623.                     {

  624.                         if (def < min)

  625.                             def = min;

  626.                         else if (def > max)

  627.                             def = max;

  628.                     }

  629. 

  630.                     bufferParams[iC] = def;

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

  632.                 }

  633.             }

  634. 

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

  636.                 descriptor->activate(handle);

  637. 

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

  639. 

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

  641.                 descriptor->deactivate(handle);

  642. 

  643.             descriptor->cleanup(handle);

  644. 

  645.             // end crash-free plugin test

  646.             // -----------------------------------------------------------------------

  647.         }

  648. 

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

  650.         DISCOVERY_OUT("build", BINARY_NATIVE);

  651.         DISCOVERY_OUT("hints", hints);

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

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

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

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

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

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

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

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

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

  661.     }

  662. }

  663. 

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

  665. {

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

  667. 

  668.     if (descFn == nullptr)

  669.     {

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

  671.         return;

  672.     }

  673. 

  674.     const DSSI_Descriptor* descriptor;

  675. 

  676.     {

  677.         descriptor = descFn(0);

  678. 

  679.         if (descriptor == nullptr)

  680.         {

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

  682.             return;

  683.         }

  684. 

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

  686. 

  687.         if (ldescriptor == nullptr)

  688.         {

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

  690.             return;

  691.         }

  692. 

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

  694.         {

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

  696. 

  697.             if (handle == nullptr)

  698.             {

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

  700.                 return;

  701.             }

  702. 

  703.             ldescriptor->cleanup(handle);

  704. 

  705.             lib_close(libHandle);

  706.             libHandle = lib_open(filename);

  707. 

  708.             if (libHandle == nullptr)

  709.             {

  710.                 print_lib_error(filename);

  711.                 return;

  712.             }

  713. 

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

  715. 

  716.             if (descFn == nullptr)

  717.             {

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

  719.                 return;

  720.             }

  721.         }

  722.     }

  723. 

  724.     unsigned long i = 0;

  725. 

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

  727.     {

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

  729. 

  730.         if (ldescriptor == nullptr)

  731.         {

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

  733.             continue;

  734.         }

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

  736.         {

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

  738.             continue;

  739.         }

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

  741.         {

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

  743.             continue;

  744.         }

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

  746.         {

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

  748.             continue;

  749.         }

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

  751.         {

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

  753.             continue;

  754.         }

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

  756.         {

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

  758.             continue;

  759.         }

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

  761.         {

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

  763.         }

  764. 

  765.         uint hints = 0x0;

  766.         int audioIns = 0;

  767.         int audioOuts = 0;

  768.         int audioTotal = 0;

  769.         int midiIns = 0;

  770.         int parametersIns = 0;

  771.         int parametersOuts = 0;

  772.         int parametersTotal = 0;

  773. 

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

  775.             hints |= PLUGIN_IS_RTSAFE;

  776. 

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

  778.         {

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

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

  781. 

  782.             if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  783.             {

  784.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  785.                     audioIns += 1;

  786.                 else if (LADSPA_IS_PORT_OUTPUT(portDescriptor))

  787.                     audioOuts += 1;

  788. 

  789.                 audioTotal += 1;

  790.             }

  791.             else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  792.             {

  793.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  794.                     parametersIns += 1;

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

  796.                     parametersOuts += 1;

  797. 

  798.                 parametersTotal += 1;

  799.             }

  800.         }

  801. 

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

  803.             midiIns = 1;

  804. 

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

  806.             hints |= PLUGIN_IS_SYNTH;

  807. 

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

  809.         {

  810.             hints |= PLUGIN_HAS_CUSTOM_UI;

  811.             delete[] ui;

  812.         }

  813. 

  814.         if (doInit)

  815.         {

  816.             // -----------------------------------------------------------------------

  817.             // start crash-free plugin test

  818. 

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

  820. 

  821.             if (handle == nullptr)

  822.             {

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

  824.                 continue;

  825.             }

  826. 

  827.             // Test quick init and cleanup

  828.             ldescriptor->cleanup(handle);

  829. 

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

  831. 

  832.             if (handle == nullptr)

  833.             {

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

  835.                 continue;

  836.             }

  837. 

  838.             LADSPA_Data bufferAudio[kBufferSize][audioTotal];

  839.             LADSPA_Data bufferParams[parametersTotal];

  840.             LADSPA_Data min, max, def;

  841. 

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

  843.             {

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

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

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

  847. 

  848.                 if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  849.                 {

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

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

  852.                 }

  853.                 else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  854.                 {

  855.                     // min value

  856.                     if (LADSPA_IS_HINT_BOUNDED_BELOW(portRangeHints.HintDescriptor))

  857.                         min = portRangeHints.LowerBound;

  858.                     else

  859.                         min = 0.0f;

  860. 

  861.                     // max value

  862.                     if (LADSPA_IS_HINT_BOUNDED_ABOVE(portRangeHints.HintDescriptor))

  863.                         max = portRangeHints.UpperBound;

  864.                     else

  865.                         max = 1.0f;

  866. 

  867.                     if (min > max)

  868.                     {

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

  870.                         max = min + 0.1f;

  871.                     }

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

  873.                     {

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

  875.                         max = min + 0.1f;

  876.                     }

  877. 

  878.                     // default value

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

  880. 

  881.                     if (LADSPA_IS_HINT_SAMPLE_RATE(portRangeHints.HintDescriptor))

  882.                     {

  883.                         min *= kSampleRatef;

  884.                         max *= kSampleRatef;

  885.                         def *= kSampleRatef;

  886.                     }

  887. 

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

  889.                     {

  890.                         // latency parameter

  891.                         def = 0.0f;

  892.                     }

  893.                     else

  894.                     {

  895.                         if (def < min)

  896.                             def = min;

  897.                         else if (def > max)

  898.                             def = max;

  899.                     }

  900. 

  901.                     bufferParams[iC] = def;

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

  903.                 }

  904.             }

  905. 

  906.             // select first midi-program if available

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

  908.             {

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

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

  911.             }

  912. 

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

  914.                 ldescriptor->activate(handle);

  915. 

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

  917.             {

  918.                 snd_seq_event_t midiEvents[2];

  919.                 carla_zeroStructs(midiEvents, 2);

  920. 

  921.                 const unsigned long midiEventCount = 2;

  922. 

  923.                 midiEvents[0].type = SND_SEQ_EVENT_NOTEON;

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

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

  926. 

  927.                 midiEvents[1].type = SND_SEQ_EVENT_NOTEOFF;

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

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

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

  931. 

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

  933.             }

  934.             else

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

  936. 

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

  938.                 ldescriptor->deactivate(handle);

  939. 

  940.             ldescriptor->cleanup(handle);

  941. 

  942.             // end crash-free plugin test

  943.             // -----------------------------------------------------------------------

  944.         }

  945. 

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

  947.         DISCOVERY_OUT("build", BINARY_NATIVE);

  948.         DISCOVERY_OUT("hints", hints);

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

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

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

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

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

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

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

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

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

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

  959.     }

  960. }

  961. 

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

  963. {

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

  965. 

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

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

  968. 

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

  970. 

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

  972.         sBundle += "/";

  973. 

  974.     // Load bundle

  975.     lv2World.load_bundle(sBundle);

  976. 

  977.     // Load plugins in this bundle

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

  979. 

  980.     // Get all plugin URIs in this bundle

  981.     StringArray URIs;

  982. 

  983.     LILV_FOREACH(plugins, it, lilvPlugins)

  984.     {

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

  986. 

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

  988.             URIs.addIfNotAlreadyThere(water::String(uri));

  989.     }

  990. 

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

  992.     {

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

  994.         return;

  995.     }

  996. 

  997.     // Get & check every plugin-instance

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

  999.     {

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

  1001. 

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

  1003.         {

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

  1005.             continue;

  1006.         }

  1007. 

  1008.         if (doInit)

  1009.         {

  1010.             // test if DLL is loadable, twice

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

  1012. 

  1013.             if (libHandle1 == nullptr)

  1014.             {

  1015.                 print_lib_error(rdfDescriptor->Binary);

  1016.                 delete rdfDescriptor;

  1017.                 continue;

  1018.             }

  1019. 

  1020.             lib_close(libHandle1);

  1021. 

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

  1023. 

  1024.             if (libHandle2 == nullptr)

  1025.             {

  1026.                 print_lib_error(rdfDescriptor->Binary);

  1027.                 delete rdfDescriptor;

  1028.                 continue;

  1029.             }

  1030. 

  1031.             lib_close(libHandle2);

  1032.         }

  1033. 

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

  1035.         {

  1036.             bool supported = true;

  1037. 

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

  1039.             {

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

  1041. 

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

  1043.                 {

  1044.                     pass();

  1045.                 }

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

  1047.                 {

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

  1049.                     supported = false;

  1050.                     break;

  1051.                 }

  1052.             }

  1053. 

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

  1055.             {

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

  1057. 

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

  1059.                 {

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

  1061.                 }

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

  1063.                 {

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

  1065.                     supported = false;

  1066.                     break;

  1067.                 }

  1068.             }

  1069. 

  1070.             if (! supported)

  1071.             {

  1072.                 delete rdfDescriptor;

  1073.                 continue;

  1074.             }

  1075.         }

  1076. 

  1077.         uint hints = 0x0;

  1078.         int audioIns = 0;

  1079.         int audioOuts = 0;

  1080.         int midiIns = 0;

  1081.         int midiOuts = 0;

  1082.         int parametersIns = 0;

  1083.         int parametersOuts = 0;

  1084. 

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

  1086.         {

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

  1088. 

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

  1090.                 hints |= PLUGIN_IS_RTSAFE;

  1091.         }

  1092. 

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

  1094.         {

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

  1096. 

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

  1098.             {

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

  1100.                     audioIns += 1;

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

  1102.                     audioOuts += 1;

  1103.             }

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

  1105.             {

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

  1107.                 {

  1108.                     pass();

  1109.                 }

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

  1111.                 {

  1112.                     pass();

  1113.                 }

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

  1115.                 {

  1116.                     pass();

  1117.                 }

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

  1119.                 {

  1120.                     pass();

  1121.                 }

  1122.                 else

  1123.                 {

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

  1125.                         parametersIns += 1;

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

  1127.                         parametersOuts += 1;

  1128.                 }

  1129.             }

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

  1131.             {

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

  1133.                     midiIns += 1;

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

  1135.                     midiOuts += 1;

  1136.             }

  1137.         }

  1138. 

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

  1140.             hints |= PLUGIN_IS_SYNTH;

  1141. 

  1142.         if (rdfDescriptor->UICount > 0)

  1143.             hints |= PLUGIN_HAS_CUSTOM_UI;

  1144. 

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

  1146.         DISCOVERY_OUT("build", BINARY_NATIVE);

  1147.         DISCOVERY_OUT("hints", hints);

  1148. 

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

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

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

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

  1153. 

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

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

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

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

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

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

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

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

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

  1163. 

  1164.         delete rdfDescriptor;

  1165.     }

  1166. }

  1167. 

  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. 

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

  1436. {

  1437. #ifdef HAVE_FLUIDSYNTH

  1438.     const water::String jfilename = water::String(CharPointer_UTF8(filename));

  1439.     const File file(jfilename);

  1440. 

  1441.     if (! file.existsAsFile())

  1442.     {

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

  1444.         return;

  1445.     }

  1446. 

  1447.     if (! fluid_is_soundfont(filename))

  1448.     {

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

  1450.         return;

  1451.     }

  1452. 

  1453.     int programs = 0;

  1454. 

  1455.     if (doInit)

  1456.     {

  1457.         fluid_settings_t* const f_settings = new_fluid_settings();

  1458.         CARLA_SAFE_ASSERT_RETURN(f_settings != nullptr,);

  1459. 

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

  1461.         CARLA_SAFE_ASSERT_RETURN(f_synth != nullptr,);

  1462. 

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

  1464. 

  1465.         if (f_id < 0)

  1466.         {

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

  1468.             return;

  1469.         }

  1470. 

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

  1472.         {

  1473.             fluid_preset_t f_preset;

  1474. 

  1475.             f_sfont->iteration_start(f_sfont);

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

  1477.                 ++programs;

  1478.         }

  1479. 

  1480.         delete_fluid_synth(f_synth);

  1481.         delete_fluid_settings(f_settings);

  1482.     }

  1483. 

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

  1485.     CarlaString label(name);

  1486. 

  1487.     // 2 channels

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

  1489.     DISCOVERY_OUT("build", BINARY_NATIVE);

  1490.     DISCOVERY_OUT("hints", PLUGIN_IS_SYNTH);

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

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

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

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

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

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

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

  1498. 

  1499.     // 16 channels

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

  1501.         return;

  1502. 

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

  1504. 

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

  1506.     DISCOVERY_OUT("build", BINARY_NATIVE);

  1507.     DISCOVERY_OUT("hints", PLUGIN_IS_SYNTH);

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

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

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

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

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

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

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

  1515. #else // HAVE_FLUIDSYNTH

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

  1517.     return;

  1518. 

  1519.     // unused

  1520.     (void)filename;

  1521.     (void)doInit;

  1522. #endif

  1523. }

  1524. 

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

  1526. {

  1527. #ifdef HAVE_LINUXSAMPLER

  1528.     const water::String jfilename = water::String(CharPointer_UTF8(filename));

  1529.     const File file(jfilename);

  1530. 

  1531.     if (! file.existsAsFile())

  1532.     {

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

  1534.         return;

  1535.     }

  1536. 

  1537.     if (doInit)

  1538.         const LinuxSamplerScopedEngine engine(filename, stype);

  1539.     else

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

  1541. #else // HAVE_LINUXSAMPLER

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

  1543.     return;

  1544. 

  1545.     // unused

  1546.     (void)filename;

  1547.     (void)doInit;

  1548. #endif

  1549. }

  1550. 

  1551. // ------------------------------ main entry point ------------------------------

  1552. 

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

  1554. {

  1555.     if (argc != 3)

  1556.     {

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

  1558.         return 1;

  1559.     }

  1560. 

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

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

  1563.     const PluginType  type     = getPluginTypeFromString(stype);

  1564. 

  1565.     CarlaString filenameCheck(filename);

  1566.     filenameCheck.toLower();

  1567. 

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

  1569.     {

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

  1571.         {

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

  1573.             return 0;

  1574.         }

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

  1576.         {

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

  1578.             return 0;

  1579.         }

  1580.     }

  1581. 

  1582.     bool openLib = false;

  1583.     lib_t handle = nullptr;

  1584. 

  1585.     switch (type)

  1586.     {

  1587.     case PLUGIN_LADSPA:

  1588.     case PLUGIN_DSSI:

  1589.     case PLUGIN_VST2:

  1590.         openLib = true;

  1591.     default:

  1592.         break;

  1593.     }

  1594. 

  1595.     if (openLib)

  1596.     {

  1597.         handle = lib_open(filename);

  1598. 

  1599.         if (handle == nullptr)

  1600.         {

  1601.             print_lib_error(filename);

  1602.             return 1;

  1603.         }

  1604.     }

  1605. 

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

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

  1608. 

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

  1610.         doInit = false;

  1611. 

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

  1613.     {

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

  1615.         if (! lib_close(handle))

  1616.         {

  1617.             print_lib_error(filename);

  1618.             return 1;

  1619.         }

  1620. 

  1621.         handle = lib_open(filename);

  1622. 

  1623.         if (handle == nullptr)

  1624.         {

  1625.             print_lib_error(filename);

  1626.             return 1;

  1627.         }

  1628.     }

  1629. 

  1630. #ifndef BUILD_BRIDGE

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

  1632.     {

  1633.         do_cached_check(type);

  1634.         return 0;

  1635.     }

  1636. #endif

  1637. 

  1638.     switch (type)

  1639.     {

  1640.     case PLUGIN_LADSPA:

  1641.         do_ladspa_check(handle, filename, doInit);

  1642.         break;

  1643.     case PLUGIN_DSSI:

  1644.         do_dssi_check(handle, filename, doInit);

  1645.         break;

  1646.     case PLUGIN_LV2:

  1647.         do_lv2_check(filename, doInit);

  1648.         break;

  1649.     case PLUGIN_VST2:

  1650.         do_vst_check(handle, doInit);

  1651.         break;

  1652.     case PLUGIN_GIG:

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

  1654.         break;

  1655.     case PLUGIN_SF2:

  1656.         do_fluidsynth_check(filename, doInit);

  1657.         break;

  1658.     case PLUGIN_SFZ:

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

  1660.         break;

  1661.     default:

  1662.         break;

  1663.     }

  1664. 

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

  1666.         lib_close(handle);

  1667. 

  1668.     return 0;

  1669. }

  1670. 

  1671. // --------------------------------------------------------------------------