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.
2917 Commits
16 Branches
14GB
Tree: 53bcf1d9a8
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '53bcf1d9a8'
${ noResults }
Carla/source/discovery/carla-discovery.cpp

1780 lines
56KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin discovery

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. #include "CarlaBackendUtils.hpp"

  19. #include "CarlaLibUtils.hpp"

  20. #include "CarlaMathUtils.hpp"

  21. #include "CarlaMIDI.h"

  22. #include "LinkedList.hpp"

  23. 

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

  25. # define USE_JUCE_PROCESSORS

  26. # include "juce_audio_processors.h"

  27. #endif

  28. 

  29. #ifdef BUILD_BRIDGE

  30. # undef HAVE_FLUIDSYNTH

  31. # undef HAVE_LINUXSAMPLER

  32. #endif

  33. 

  34. #include "CarlaLadspaUtils.hpp"

  35. #include "CarlaDssiUtils.cpp"

  36. #include "CarlaLv2Utils.hpp"

  37. #include "CarlaVstUtils.hpp"

  38. 

  39. #ifdef HAVE_FLUIDSYNTH

  40. # include <fluidsynth.h>

  41. #endif

  42. 

  43. #ifdef HAVE_LINUXSAMPLER

  44. # include "linuxsampler/EngineFactory.h"

  45. #endif

  46. 

  47. #include <iostream>

  48. 

  49. #include "juce_core.h"

  50. using juce::CharPointer_UTF8;

  51. using juce::File;

  52. using juce::String;

  53. using juce::StringArray;

  54. 

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

  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<VstTimeInfo>(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_ladspa_check(lib_t& libHandle, const char* const filename, const bool doInit)

  405. {

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

  407. 

  408.     if (descFn == nullptr)

  409.     {

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

  411.         return;

  412.     }

  413. 

  414.     const LADSPA_Descriptor* descriptor;

  415. 

  416.     {

  417.         descriptor = descFn(0);

  418. 

  419.         if (descriptor == nullptr)

  420.         {

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

  422.             return;

  423.         }

  424. 

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

  426.         {

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

  428. 

  429.             if (handle == nullptr)

  430.             {

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

  432.                 return;

  433.             }

  434. 

  435.             descriptor->cleanup(handle);

  436. 

  437.             lib_close(libHandle);

  438.             libHandle = lib_open(filename);

  439. 

  440.             if (libHandle == nullptr)

  441.             {

  442.                 print_lib_error(filename);

  443.                 return;

  444.             }

  445. 

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

  447. 

  448.             if (descFn == nullptr)

  449.             {

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

  451.                 return;

  452.             }

  453.         }

  454.     }

  455. 

  456.     unsigned long i = 0;

  457. 

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

  459.     {

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

  461.         {

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

  463.             continue;

  464.         }

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

  466.         {

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

  468.             continue;

  469.         }

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

  471.         {

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

  473.             continue;

  474.         }

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

  476.         {

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

  478.         }

  479. 

  480.         uint hints = 0x0;

  481.         int audioIns = 0;

  482.         int audioOuts = 0;

  483.         int audioTotal = 0;

  484.         int parametersIns = 0;

  485.         int parametersOuts = 0;

  486.         int parametersTotal = 0;

  487. 

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

  489.             hints |= PLUGIN_IS_RTSAFE;

  490. 

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

  492.         {

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

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

  495. 

  496.             if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  497.             {

  498.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  499.                     audioIns += 1;

  500.                 else if (LADSPA_IS_PORT_OUTPUT(portDescriptor))

  501.                     audioOuts += 1;

  502. 

  503.                 audioTotal += 1;

  504.             }

  505.             else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  506.             {

  507.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  508.                     parametersIns += 1;

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

  510.                     parametersOuts += 1;

  511. 

  512.                 parametersTotal += 1;

  513.             }

  514.         }

  515. 

  516.         if (doInit)

  517.         {

  518.             // -----------------------------------------------------------------------

  519.             // start crash-free plugin test

  520. 

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

  522. 

  523.             if (handle == nullptr)

  524.             {

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

  526.                 continue;

  527.             }

  528. 

  529.             // Test quick init and cleanup

  530.             descriptor->cleanup(handle);

  531. 

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

  533. 

  534.             if (handle == nullptr)

  535.             {

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

  537.                 continue;

  538.             }

  539. 

  540.             LADSPA_Data bufferAudio[kBufferSize][audioTotal];

  541.             LADSPA_Data bufferParams[parametersTotal];

  542.             LADSPA_Data min, max, def;

  543. 

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

  545.             {

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

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

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

  549. 

  550.                 if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  551.                 {

  552.                     carla_zeroFloat(bufferAudio[iA], kBufferSize);

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

  554.                 }

  555.                 else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  556.                 {

  557.                     // min value

  558.                     if (LADSPA_IS_HINT_BOUNDED_BELOW(portRangeHints.HintDescriptor))

  559.                         min = portRangeHints.LowerBound;

  560.                     else

  561.                         min = 0.0f;

  562. 

  563.                     // max value

  564.                     if (LADSPA_IS_HINT_BOUNDED_ABOVE(portRangeHints.HintDescriptor))

  565.                         max = portRangeHints.UpperBound;

  566.                     else

  567.                         max = 1.0f;

  568. 

  569.                     if (min > max)

  570.                     {

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

  572.                         max = min + 0.1f;

  573.                     }

  574.                     else if (carla_compareFloats(min, max))

  575.                     {

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

  577.                         max = min + 0.1f;

  578.                     }

  579. 

  580.                     // default value

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

  582. 

  583.                     if (LADSPA_IS_HINT_SAMPLE_RATE(portRangeHints.HintDescriptor))

  584.                     {

  585.                         min *= kSampleRatef;

  586.                         max *= kSampleRatef;

  587.                         def *= kSampleRatef;

  588.                     }

  589. 

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

  591.                     {

  592.                         // latency parameter

  593.                         def = 0.0f;

  594.                     }

  595.                     else

  596.                     {

  597.                         if (def < min)

  598.                             def = min;

  599.                         else if (def > max)

  600.                             def = max;

  601.                     }

  602. 

  603.                     bufferParams[iC] = def;

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

  605.                 }

  606.             }

  607. 

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

  609.                 descriptor->activate(handle);

  610. 

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

  612. 

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

  614.                 descriptor->deactivate(handle);

  615. 

  616.             descriptor->cleanup(handle);

  617. 

  618.             // end crash-free plugin test

  619.             // -----------------------------------------------------------------------

  620.         }

  621. 

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

  623.         DISCOVERY_OUT("build", BINARY_NATIVE);

  624.         DISCOVERY_OUT("hints", hints);

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

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

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

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

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

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

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

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

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

  634.     }

  635. }

  636. 

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

  638. {

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

  640. 

  641.     if (descFn == nullptr)

  642.     {

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

  644.         return;

  645.     }

  646. 

  647.     const DSSI_Descriptor* descriptor;

  648. 

  649.     {

  650.         descriptor = descFn(0);

  651. 

  652.         if (descriptor == nullptr)

  653.         {

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

  655.             return;

  656.         }

  657. 

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

  659. 

  660.         if (ldescriptor == nullptr)

  661.         {

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

  663.             return;

  664.         }

  665. 

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

  667.         {

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

  669. 

  670.             if (handle == nullptr)

  671.             {

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

  673.                 return;

  674.             }

  675. 

  676.             ldescriptor->cleanup(handle);

  677. 

  678.             lib_close(libHandle);

  679.             libHandle = lib_open(filename);

  680. 

  681.             if (libHandle == nullptr)

  682.             {

  683.                 print_lib_error(filename);

  684.                 return;

  685.             }

  686. 

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

  688. 

  689.             if (descFn == nullptr)

  690.             {

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

  692.                 return;

  693.             }

  694.         }

  695.     }

  696. 

  697.     unsigned long i = 0;

  698. 

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

  700.     {

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

  702. 

  703.         if (ldescriptor == nullptr)

  704.         {

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

  706.             continue;

  707.         }

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

  709.         {

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

  711.             continue;

  712.         }

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

  714.         {

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

  716.             continue;

  717.         }

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

  719.         {

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

  721.             continue;

  722.         }

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

  724.         {

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

  726.             continue;

  727.         }

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

  729.         {

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

  731.         }

  732. 

  733.         uint hints = 0x0;

  734.         int audioIns = 0;

  735.         int audioOuts = 0;

  736.         int audioTotal = 0;

  737.         int midiIns = 0;

  738.         int parametersIns = 0;

  739.         int parametersOuts = 0;

  740.         int parametersTotal = 0;

  741. 

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

  743.             hints |= PLUGIN_IS_RTSAFE;

  744. 

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

  746.         {

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

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

  749. 

  750.             if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  751.             {

  752.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  753.                     audioIns += 1;

  754.                 else if (LADSPA_IS_PORT_OUTPUT(portDescriptor))

  755.                     audioOuts += 1;

  756. 

  757.                 audioTotal += 1;

  758.             }

  759.             else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  760.             {

  761.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  762.                     parametersIns += 1;

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

  764.                     parametersOuts += 1;

  765. 

  766.                 parametersTotal += 1;

  767.             }

  768.         }

  769. 

  770.         if (descriptor->run_synth != nullptr || descriptor->run_multiple_synths != nullptr)

  771.             midiIns = 1;

  772. 

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

  774.             hints |= PLUGIN_IS_SYNTH;

  775. 

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

  777.         {

  778.             hints |= PLUGIN_HAS_CUSTOM_UI;

  779.             delete[] ui;

  780.         }

  781. 

  782.         if (doInit)

  783.         {

  784.             // -----------------------------------------------------------------------

  785.             // start crash-free plugin test

  786. 

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

  788. 

  789.             if (handle == nullptr)

  790.             {

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

  792.                 continue;

  793.             }

  794. 

  795.             // Test quick init and cleanup

  796.             ldescriptor->cleanup(handle);

  797. 

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

  799. 

  800.             if (handle == nullptr)

  801.             {

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

  803.                 continue;

  804.             }

  805. 

  806.             LADSPA_Data bufferAudio[kBufferSize][audioTotal];

  807.             LADSPA_Data bufferParams[parametersTotal];

  808.             LADSPA_Data min, max, def;

  809. 

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

  811.             {

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

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

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

  815. 

  816.                 if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  817.                 {

  818.                     carla_zeroFloat(bufferAudio[iA], kBufferSize);

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

  820.                 }

  821.                 else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  822.                 {

  823.                     // min value

  824.                     if (LADSPA_IS_HINT_BOUNDED_BELOW(portRangeHints.HintDescriptor))

  825.                         min = portRangeHints.LowerBound;

  826.                     else

  827.                         min = 0.0f;

  828. 

  829.                     // max value

  830.                     if (LADSPA_IS_HINT_BOUNDED_ABOVE(portRangeHints.HintDescriptor))

  831.                         max = portRangeHints.UpperBound;

  832.                     else

  833.                         max = 1.0f;

  834. 

  835.                     if (min > max)

  836.                     {

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

  838.                         max = min + 0.1f;

  839.                     }

  840.                     else if (carla_compareFloats(min, max))

  841.                     {

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

  843.                         max = min + 0.1f;

  844.                     }

  845. 

  846.                     // default value

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

  848. 

  849.                     if (LADSPA_IS_HINT_SAMPLE_RATE(portRangeHints.HintDescriptor))

  850.                     {

  851.                         min *= kSampleRatef;

  852.                         max *= kSampleRatef;

  853.                         def *= kSampleRatef;

  854.                     }

  855. 

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

  857.                     {

  858.                         // latency parameter

  859.                         def = 0.0f;

  860.                     }

  861.                     else

  862.                     {

  863.                         if (def < min)

  864.                             def = min;

  865.                         else if (def > max)

  866.                             def = max;

  867.                     }

  868. 

  869.                     bufferParams[iC] = def;

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

  871.                 }

  872.             }

  873. 

  874.             // select first midi-program if available

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

  876.             {

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

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

  879.             }

  880. 

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

  882.                 ldescriptor->activate(handle);

  883. 

  884.             if (descriptor->run_synth != nullptr || descriptor->run_multiple_synths != nullptr)

  885.             {

  886.                 snd_seq_event_t midiEvents[2];

  887.                 carla_zeroStruct<snd_seq_event_t>(midiEvents, 2);

  888. 

  889.                 const unsigned long midiEventCount = 2;

  890. 

  891.                 midiEvents[0].type = SND_SEQ_EVENT_NOTEON;

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

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

  894. 

  895.                 midiEvents[1].type = SND_SEQ_EVENT_NOTEOFF;

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

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

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

  899. 

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

  901.                 {

  902.                     LADSPA_Handle handlePtr[1] = { handle };

  903.                     snd_seq_event_t* midiEventsPtr[1] = { midiEvents };

  904.                     unsigned long midiEventCountPtr[1] = { midiEventCount };

  905.                     descriptor->run_multiple_synths(1, handlePtr, kBufferSize, midiEventsPtr, midiEventCountPtr);

  906.                 }

  907.                 else

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

  909.             }

  910.             else

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

  912. 

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

  914.                 ldescriptor->deactivate(handle);

  915. 

  916.             ldescriptor->cleanup(handle);

  917. 

  918.             // end crash-free plugin test

  919.             // -----------------------------------------------------------------------

  920.         }

  921. 

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

  923.         DISCOVERY_OUT("build", BINARY_NATIVE);

  924.         DISCOVERY_OUT("hints", hints);

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

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

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

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

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

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

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

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

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

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

  935.     }

  936. }

  937. 

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

  939. {

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

  941. 

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

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

  944. 

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

  946. 

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

  948.         sBundle += "/";

  949. 

  950.     // Load bundle

  951.     lv2World.load_bundle(sBundle);

  952. 

  953.     // Load plugins in this bundle

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

  955. 

  956.     // Get all plugin URIs in this bundle

  957.     StringArray URIs;

  958. 

  959.     LILV_FOREACH(plugins, it, lilvPlugins)

  960.     {

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

  962. 

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

  964.             URIs.addIfNotAlreadyThere(String(uri));

  965.     }

  966. 

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

  968.     {

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

  970.         return;

  971.     }

  972. 

  973.     // Get & check every plugin-instance

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

  975.     {

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

  977. 

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

  979.         {

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

  981.             continue;

  982.         }

  983. 

  984.         if (doInit)

  985.         {

  986.             // test if DLL is loadable, twice

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

  988. 

  989.             if (libHandle1 == nullptr)

  990.             {

  991.                 print_lib_error(rdfDescriptor->Binary);

  992.                 delete rdfDescriptor;

  993.                 continue;

  994.             }

  995. 

  996.             lib_close(libHandle1);

  997. 

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

  999. 

  1000.             if (libHandle2 == nullptr)

  1001.             {

  1002.                 print_lib_error(rdfDescriptor->Binary);

  1003.                 delete rdfDescriptor;

  1004.                 continue;

  1005.             }

  1006. 

  1007.             lib_close(libHandle2);

  1008.         }

  1009. 

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

  1011.         {

  1012.             bool supported = true;

  1013. 

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

  1015.             {

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

  1017. 

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

  1019.                 {

  1020.                     pass();

  1021.                 }

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

  1023.                 {

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

  1025.                     supported = false;

  1026.                     break;

  1027.                 }

  1028.             }

  1029. 

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

  1031.             {

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

  1033. 

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

  1035.                 {

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

  1037.                 }

  1038.                 else if (LV2_IS_FEATURE_REQUIRED(feature.Type) && ! is_lv2_feature_supported(feature.URI))

  1039.                 {

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

  1041.                     supported = false;

  1042.                     break;

  1043.                 }

  1044.             }

  1045. 

  1046.             if (! supported)

  1047.             {

  1048.                 delete rdfDescriptor;

  1049.                 continue;

  1050.             }

  1051.         }

  1052. 

  1053.         uint hints = 0x0;

  1054.         int audioIns = 0;

  1055.         int audioOuts = 0;

  1056.         int midiIns = 0;

  1057.         int midiOuts = 0;

  1058.         int parametersIns = 0;

  1059.         int parametersOuts = 0;

  1060. 

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

  1062.         {

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

  1064. 

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

  1066.                 hints |= PLUGIN_IS_RTSAFE;

  1067.         }

  1068. 

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

  1070.         {

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

  1072. 

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

  1074.             {

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

  1076.                     audioIns += 1;

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

  1078.                     audioOuts += 1;

  1079.             }

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

  1081.             {

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

  1083.                 {

  1084.                     pass();

  1085.                 }

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

  1087.                 {

  1088.                     pass();

  1089.                 }

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

  1091.                 {

  1092.                     pass();

  1093.                 }

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

  1095.                 {

  1096.                     pass();

  1097.                 }

  1098.                 else

  1099.                 {

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

  1101.                         parametersIns += 1;

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

  1103.                         parametersOuts += 1;

  1104.                 }

  1105.             }

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

  1107.             {

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

  1109.                     midiIns += 1;

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

  1111.                     midiOuts += 1;

  1112.             }

  1113.         }

  1114. 

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

  1116.             hints |= PLUGIN_IS_SYNTH;

  1117. 

  1118.         if (rdfDescriptor->UICount > 0)

  1119.             hints |= PLUGIN_HAS_CUSTOM_UI;

  1120. 

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

  1122.         DISCOVERY_OUT("build", BINARY_NATIVE);

  1123.         DISCOVERY_OUT("hints", hints);

  1124. 

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

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

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

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

  1129. 

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

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

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

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

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

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

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

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

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

  1139. 

  1140.         delete rdfDescriptor;

  1141.     }

  1142. }

  1143. 

  1144. #ifndef CARLA_OS_MAC

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

  1146. {

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

  1148. 

  1149.     if (vstFn == nullptr)

  1150.     {

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

  1152. 

  1153.         if (vstFn == nullptr)

  1154.         {

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

  1156.             return;

  1157.         }

  1158.     }

  1159. 

  1160.     AEffect* effect = vstFn(vstHostCallback);

  1161. 

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

  1163.     {

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

  1165.         return;

  1166.     }

  1167. 

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

  1169.     {

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

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

  1172.         return;

  1173.     }

  1174. 

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

  1176.     effect->dispatcher(effect, DECLARE_VST_DEPRECATED(effSetBlockSizeAndSampleRate), 0, kBufferSize, nullptr, kSampleRate);

  1177.     effect->dispatcher(effect, effSetSampleRate, 0, 0, nullptr, kSampleRate);

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

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

  1180. 

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

  1182. 

  1183.     if (effect->numPrograms > 0)

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

  1185. 

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

  1187.     gVstCurrentUniqueId =  effect->uniqueID;

  1188. 

  1189.     char strBuf[STR_MAX+1];

  1190.     CarlaString cName;

  1191.     CarlaString cProduct;

  1192.     CarlaString cVendor;

  1193.     LinkedList<intptr_t> uniqueIds;

  1194. 

  1195.     if (isShell)

  1196.     {

  1197.         for (;;)

  1198.         {

  1199.             carla_zeroChar(strBuf, STR_MAX+1);

  1200. 

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

  1202. 

  1203.             if (gVstCurrentUniqueId == 0)

  1204.                 break;

  1205. 

  1206.             uniqueIds.append(gVstCurrentUniqueId);

  1207.         }

  1208. 

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

  1210.         effect = nullptr;

  1211.     }

  1212.     else

  1213.     {

  1214.         uniqueIds.append(gVstCurrentUniqueId);

  1215.     }

  1216. 

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

  1218.     {

  1219.         gVstCurrentUniqueId = it.getValue(0);

  1220. 

  1221.         if (effect == nullptr)

  1222.         {

  1223.             effect = vstFn(vstHostCallback);

  1224. 

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

  1226.             effect->dispatcher(effect, DECLARE_VST_DEPRECATED(effSetBlockSizeAndSampleRate), 0, kBufferSize, nullptr, kSampleRate);

  1227.             effect->dispatcher(effect, effSetSampleRate, 0, 0, nullptr, kSampleRate);

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

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

  1230. 

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

  1232. 

  1233.             if (effect->numPrograms > 0)

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

  1235.         }

  1236. 

  1237.         // get name

  1238.         carla_zeroChar(strBuf, STR_MAX+1);

  1239. 

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

  1241.             cName = strBuf;

  1242.         else

  1243.             cName.clear();

  1244. 

  1245.         // get product

  1246.         carla_zeroChar(strBuf, STR_MAX+1);

  1247. 

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

  1249.             cProduct = strBuf;

  1250.         else

  1251.             cProduct.clear();

  1252. 

  1253.         // get vendor

  1254.         carla_zeroChar(strBuf, STR_MAX+1);

  1255. 

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

  1257.             cVendor = strBuf;

  1258.         else

  1259.             cVendor.clear();

  1260. 

  1261.         // get everything else

  1262.         uint hints = 0x0;

  1263.         int audioIns = effect->numInputs;

  1264.         int audioOuts = effect->numOutputs;

  1265.         int midiIns = 0;

  1266.         int midiOuts = 0;

  1267.         int parameters = effect->numParams;

  1268. 

  1269.         if (effect->flags & effFlagsHasEditor)

  1270.             hints |= PLUGIN_HAS_CUSTOM_UI;

  1271. 

  1272.         if (effect->flags & effFlagsIsSynth)

  1273.             hints |= PLUGIN_IS_SYNTH;

  1274. 

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

  1276.             midiIns = 1;

  1277. 

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

  1279.             midiOuts = 1;

  1280. 

  1281.         // -----------------------------------------------------------------------

  1282.         // start crash-free plugin test

  1283. 

  1284.         if (doInit)

  1285.         {

  1286.             if (gVstNeedsIdle)

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

  1288. 

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

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

  1291. 

  1292.             if (gVstNeedsIdle)

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

  1294. 

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

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

  1297.             {

  1298.                 midiIns = 1;

  1299.             }

  1300. 

  1301.             float* bufferAudioIn[audioIns];

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

  1303.             {

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

  1305.                 carla_zeroFloat(bufferAudioIn[j], kBufferSize);

  1306.             }

  1307. 

  1308.             float* bufferAudioOut[audioOuts];

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

  1310.             {

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

  1312.                 carla_zeroFloat(bufferAudioOut[j], kBufferSize);

  1313.             }

  1314. 

  1315.             struct VstEventsFixed {

  1316.                 int32_t numEvents;

  1317.                 intptr_t reserved;

  1318.                 VstEvent* data[2];

  1319. 

  1320.                 VstEventsFixed()

  1321.                     : numEvents(0),

  1322.                       reserved(0)

  1323.                 {

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

  1325.                 }

  1326.             } events;

  1327. 

  1328.             VstMidiEvent midiEvents[2];

  1329.             carla_zeroStruct<VstMidiEvent>(midiEvents, 2);

  1330. 

  1331.             midiEvents[0].type = kVstMidiType;

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

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

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

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

  1336. 

  1337.             midiEvents[1].type = kVstMidiType;

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

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

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

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

  1342. 

  1343.             events.numEvents = 2;

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

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

  1346. 

  1347.             // processing

  1348.             gVstIsProcessing = true;

  1349. 

  1350.             if (midiIns > 0)

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

  1352. 

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

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

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

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

  1357.             else

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

  1359. 

  1360.             gVstIsProcessing = false;

  1361. 

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

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

  1364. 

  1365.             if (gVstNeedsIdle)

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

  1367. 

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

  1369.                 delete[] bufferAudioIn[j];

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

  1371.                 delete[] bufferAudioOut[j];

  1372.         }

  1373. 

  1374.         // end crash-free plugin test

  1375.         // -----------------------------------------------------------------------

  1376. 

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

  1378.         DISCOVERY_OUT("build", BINARY_NATIVE);

  1379.         DISCOVERY_OUT("hints", hints);

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

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

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

  1383.         DISCOVERY_OUT("uniqueId", gVstCurrentUniqueId);

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

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

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

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

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

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

  1390. 

  1391.         gVstWantsMidi = false;

  1392.         gVstWantsTime = false;

  1393. 

  1394.         if (! isShell)

  1395.             break;

  1396. 

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

  1398.         effect = nullptr;

  1399.     }

  1400. 

  1401.     uniqueIds.clear();

  1402. 

  1403.     if (effect == nullptr)

  1404.         return;

  1405. 

  1406.     if (gVstNeedsIdle)

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

  1408. 

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

  1410. }

  1411. #endif // ! CARLA_OS_MAC

  1412. 

  1413. #ifdef USE_JUCE_PROCESSORS

  1414. static void do_juce_check(const char* const filename_, const char* const stype, const bool doInit)

  1415. {

  1416.     CARLA_SAFE_ASSERT_RETURN(stype != nullptr && stype[0] != 0,) // FIXME

  1417.     carla_debug("do_juce_check(%s, %s, %s)", filename_, stype, bool2str(doInit));

  1418. 

  1419.     using namespace juce;

  1420.     juce::String filename;

  1421. 

  1422. #ifdef CARLA_OS_WIN

  1423.     // Fix for wine usage

  1424.     if (juce_isRunningInWine() && filename_[0] == '/')

  1425.     {

  1426.         filename = filename_;

  1427.         filename.replace("/", "\\");

  1428.         filename = "Z:" + filename;

  1429.     }

  1430.     else

  1431. #endif

  1432.      filename = File(filename_).getFullPathName();

  1433. 

  1434.     juce::ScopedPointer<AudioPluginFormat> pluginFormat;

  1435. 

  1436.     /* */ if (std::strcmp(stype, "VST2") == 0)

  1437.     {

  1438. #if JUCE_PLUGINHOST_VST

  1439.         pluginFormat = new VSTPluginFormat();

  1440. #else

  1441.         DISCOVERY_OUT("error", "VST support not available");

  1442. #endif

  1443.     }

  1444.     else if (std::strcmp(stype, "VST3") == 0)

  1445.     {

  1446. #if JUCE_PLUGINHOST_VST3

  1447.         pluginFormat = new VST3PluginFormat();

  1448. #else

  1449.         DISCOVERY_OUT("error", "VST3 support not available");

  1450. #endif

  1451.     }

  1452.     else if (std::strcmp(stype, "AU") == 0)

  1453.     {

  1454. #if JUCE_PLUGINHOST_AU

  1455.         pluginFormat = new AudioUnitPluginFormat();

  1456. #else

  1457.         DISCOVERY_OUT("error", "AU support not available");

  1458. #endif

  1459.     }

  1460. 

  1461.     if (pluginFormat == nullptr)

  1462.     {

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

  1464.         return;

  1465.     }

  1466. 

  1467. #ifdef CARLA_OS_WIN

  1468.     CARLA_SAFE_ASSERT_RETURN(File(filename).existsAsFile(),);

  1469. #endif

  1470.     CARLA_SAFE_ASSERT_RETURN(pluginFormat->fileMightContainThisPluginType(filename),);

  1471. 

  1472.     OwnedArray<PluginDescription> results;

  1473.     pluginFormat->findAllTypesForFile(results, filename);

  1474. 

  1475.     if (results.size() == 0)

  1476.     {

  1477.         DISCOVERY_OUT("error", "No plugins found");

  1478.         return;

  1479.     }

  1480. 

  1481.     for (PluginDescription **it = results.begin(), **end = results.end(); it != end; ++it)

  1482.     {

  1483.         PluginDescription* const desc(*it);

  1484. 

  1485.         uint hints = 0x0;

  1486.         int audioIns = desc->numInputChannels;

  1487.         int audioOuts = desc->numOutputChannels;

  1488.         int midiIns = 0;

  1489.         int midiOuts = 0;

  1490.         int parameters = 0;

  1491. 

  1492.         if (desc->isInstrument)

  1493.             hints |= PLUGIN_IS_SYNTH;

  1494. 

  1495.         if (doInit)

  1496.         {

  1497.             if (AudioPluginInstance* const instance = pluginFormat->createInstanceFromDescription(*desc, kSampleRate, kBufferSize))

  1498.             {

  1499.                 instance->refreshParameterList();

  1500. 

  1501.                 parameters = instance->getNumParameters();

  1502. 

  1503.                 if (instance->hasEditor())

  1504.                     hints |= PLUGIN_HAS_CUSTOM_UI;

  1505.                 if (instance->acceptsMidi())

  1506.                     midiIns = 1;

  1507.                 if (instance->producesMidi())

  1508.                     midiOuts = 1;

  1509. 

  1510.                 delete instance;

  1511.             }

  1512.         }

  1513. 

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

  1515.         DISCOVERY_OUT("build", BINARY_NATIVE);

  1516.         DISCOVERY_OUT("hints", hints);

  1517.         DISCOVERY_OUT("name", desc->descriptiveName);

  1518.         DISCOVERY_OUT("label", desc->name);

  1519.         DISCOVERY_OUT("maker", desc->manufacturerName);

  1520.         DISCOVERY_OUT("uniqueId", desc->uid);

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

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

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

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

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

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

  1527.     }

  1528. }

  1529. #endif

  1530. 

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

  1532. {

  1533. #ifdef HAVE_FLUIDSYNTH

  1534.     const String jfilename = String(CharPointer_UTF8(filename));

  1535.     const File file(jfilename);

  1536. 

  1537.     if (! file.existsAsFile())

  1538.     {

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

  1540.         return;

  1541.     }

  1542. 

  1543.     if (! fluid_is_soundfont(filename))

  1544.     {

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

  1546.         return;

  1547.     }

  1548. 

  1549.     int programs = 0;

  1550. 

  1551.     if (doInit)

  1552.     {

  1553.         fluid_settings_t* const f_settings = new_fluid_settings();

  1554.         CARLA_SAFE_ASSERT_RETURN(f_settings != nullptr,);

  1555. 

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

  1557.         CARLA_SAFE_ASSERT_RETURN(f_synth != nullptr,);

  1558. 

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

  1560. 

  1561.         if (f_id < 0)

  1562.         {

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

  1564.             return;

  1565.         }

  1566. 

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

  1568.         {

  1569.             fluid_preset_t f_preset;

  1570. 

  1571.             f_sfont->iteration_start(f_sfont);

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

  1573.                 ++programs;

  1574.         }

  1575. 

  1576.         delete_fluid_synth(f_synth);

  1577.         delete_fluid_settings(f_settings);

  1578.     }

  1579. 

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

  1581.     CarlaString label(name);

  1582. 

  1583.     // 2 channels

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

  1585.     DISCOVERY_OUT("build", BINARY_NATIVE);

  1586.     DISCOVERY_OUT("hints", PLUGIN_IS_SYNTH);

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

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

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

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

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

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

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

  1594. 

  1595.     // 16 channels

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

  1597.         return;

  1598. 

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

  1600. 

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

  1602.     DISCOVERY_OUT("build", BINARY_NATIVE);

  1603.     DISCOVERY_OUT("hints", PLUGIN_IS_SYNTH);

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

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

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

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

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

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

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

  1611. #else // HAVE_FLUIDSYNTH

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

  1613.     return;

  1614. 

  1615.     // unused

  1616.     (void)filename;

  1617.     (void)doInit;

  1618. #endif

  1619. }

  1620. 

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

  1622. {

  1623. #ifdef HAVE_LINUXSAMPLER

  1624.     const String jfilename = String(CharPointer_UTF8(filename));

  1625.     const File file(jfilename);

  1626. 

  1627.     if (! file.existsAsFile())

  1628.     {

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

  1630.         return;

  1631.     }

  1632. 

  1633.     if (doInit)

  1634.         const LinuxSamplerScopedEngine engine(filename, stype);

  1635.     else

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

  1637. #else // HAVE_LINUXSAMPLER

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

  1639.     return;

  1640. 

  1641.     // unused

  1642.     (void)filename;

  1643.     (void)doInit;

  1644. #endif

  1645. }

  1646. 

  1647. // ------------------------------ main entry point ------------------------------

  1648. 

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

  1650. {

  1651.     if (argc != 3)

  1652.     {

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

  1654.         return 1;

  1655.     }

  1656. 

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

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

  1659.     const PluginType  type     = getPluginTypeFromString(stype);

  1660. 

  1661.     CarlaString filenameCheck(filename);

  1662.     filenameCheck.toLower();

  1663. 

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

  1665.     {

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

  1667.         {

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

  1669.             return 0;

  1670.         }

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

  1672.         {

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

  1674.             return 0;

  1675.         }

  1676.     }

  1677. 

  1678.     bool openLib = false;

  1679.     lib_t handle = nullptr;

  1680. 

  1681.     switch (type)

  1682.     {

  1683.     case PLUGIN_LADSPA:

  1684.     case PLUGIN_DSSI:

  1685. #ifndef CARLA_OS_MAC

  1686.     case PLUGIN_VST2:

  1687.         openLib = true;

  1688. #endif

  1689.     default:

  1690.         break;

  1691.     }

  1692. 

  1693.     if (openLib)

  1694.     {

  1695.         handle = lib_open(filename);

  1696. 

  1697.         if (handle == nullptr)

  1698.         {

  1699.             print_lib_error(filename);

  1700.             return 1;

  1701.         }

  1702.     }

  1703. 

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

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

  1706. 

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

  1708.         doInit = false;

  1709. 

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

  1711.     {

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

  1713.         if (! lib_close(handle))

  1714.         {

  1715.             print_lib_error(filename);

  1716.             return 1;

  1717.         }

  1718. 

  1719.         handle = lib_open(filename);

  1720. 

  1721.         if (handle == nullptr)

  1722.         {

  1723.             print_lib_error(filename);

  1724.             return 1;

  1725.         }

  1726.     }

  1727. 

  1728.     switch (type)

  1729.     {

  1730.     case PLUGIN_LADSPA:

  1731.         do_ladspa_check(handle, filename, doInit);

  1732.         break;

  1733.     case PLUGIN_DSSI:

  1734.         do_dssi_check(handle, filename, doInit);

  1735.         break;

  1736.     case PLUGIN_LV2:

  1737.         do_lv2_check(filename, doInit);

  1738.         break;

  1739.     case PLUGIN_VST2:

  1740. #ifdef CARLA_OS_MAC

  1741.         do_juce_check(filename, "VST2", doInit);

  1742. #else

  1743.         do_vst_check(handle, doInit);

  1744. #endif

  1745.         break;

  1746.     case PLUGIN_VST3:

  1747. #ifdef USE_JUCE_PROCESSORS

  1748.         do_juce_check(filename, "VST3", doInit);

  1749. #else

  1750.         DISCOVERY_OUT("error", "VST3 support not available");

  1751. #endif

  1752.         break;

  1753.     case PLUGIN_AU:

  1754. #ifdef USE_JUCE_PROCESSORS

  1755.         do_juce_check(filename, "AU", doInit);

  1756. #else

  1757.         DISCOVERY_OUT("error", "AU support not available");

  1758. #endif

  1759.         break;

  1760.     case PLUGIN_GIG:

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

  1762.         break;

  1763.     case PLUGIN_SF2:

  1764.         do_fluidsynth_check(filename, doInit);

  1765.         break;

  1766.     case PLUGIN_SFZ:

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

  1768.         break;

  1769.     default:

  1770.         break;

  1771.     }

  1772. 

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

  1774.         lib_close(handle);

  1775. 

  1776.     return 0;

  1777. }

  1778. 

  1779. // --------------------------------------------------------------------------