falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 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.
3879 Commits
17 Branches
480MB
Tree: badfa6d5ae
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'badfa6d5ae'
${ noResults }
Carla/source/discovery/carla-discovery.cpp

1737 lines
54KB
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 CARLA_OS_MAC

  41. # import <Foundation/Foundation.h>

  42. #endif

  43. 

  44. #ifdef HAVE_FLUIDSYNTH

  45. # include <fluidsynth.h>

  46. #endif

  47. 

  48. #ifdef HAVE_LINUXSAMPLER

  49. # include "linuxsampler/EngineFactory.h"

  50. #endif

  51. 

  52. #include <iostream>

  53. 

  54. #include "water/water.h"

  55. 

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

  57. 

  58. using water::CharPointer_UTF8;

  59. using water::File;

  60. using water::StringArray;

  61. 

  62. CARLA_BACKEND_USE_NAMESPACE

  63. 

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

  65. // Dummy values to test plugins with

  66. 

  67. static const uint32_t kBufferSize  = 512;

  68. static const double   kSampleRate  = 44100.0;

  69. static const int32_t  kSampleRatei = 44100;

  70. static const float    kSampleRatef = 44100.0f;

  71. 

  72. // --------------------------------------------------------------------------

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

  74. 

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

  76. {

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

  78. 

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

  80.         DISCOVERY_OUT("error", error);

  81. }

  82. 

  83. // --------------------------------------------------------------------------

  84. // VST stuff

  85. 

  86. // Check if plugin is currently processing

  87. static bool gVstIsProcessing = false;

  88. 

  89. // Check if plugin needs idle

  90. static bool gVstNeedsIdle = false;

  91. 

  92. // Check if plugin wants midi

  93. static bool gVstWantsMidi = false;

  94. 

  95. // Check if plugin wants time

  96. static bool gVstWantsTime = false;

  97. 

  98. // Current uniqueId for VST shell plugins

  99. static intptr_t gVstCurrentUniqueId = 0;

  100. 

  101. // Supported Carla features

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

  103. {

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

  105. 

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

  107.         return 1;

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

  109.         return 1;

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

  111.         return 1;

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

  113.         return 1;

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

  115.     {

  116.         gVstWantsTime = true;

  117.         return 1;

  118.     }

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

  120.         return 1;

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

  122.         return 1;

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

  124.         return -1;

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

  126.         return -1;

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

  128.         return 1;

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

  130.         return 1;

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

  132.         return -1;

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

  134.         return -1;

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

  136.         return -1;

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

  138.         return 1;

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

  140.         return 1;

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

  142.         return 1;

  143.     if (std::strcmp(feature, "NIMKPIVendorSpecificCallbacks") == 0)

  144.         return -1;

  145. 

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

  147.     // "asyncProcessing"

  148.     // "editFile"

  149. 

  150.     // unimplemented

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

  152.     return 0;

  153. }

  154. 

  155. // Host-side callback

  156. 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)

  157. {

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

  159. 

  160.     static VstTimeInfo timeInfo;

  161.     intptr_t ret = 0;

  162. 

  163.     switch (opcode)

  164.     {

  165.     case audioMasterAutomate:

  166.         ret = 1;

  167.         break;

  168. 

  169.     case audioMasterVersion:

  170.         ret = kVstVersion;

  171.         break;

  172. 

  173.     case audioMasterCurrentId:

  174.         ret = gVstCurrentUniqueId;

  175.         break;

  176. 

  177.     case DECLARE_VST_DEPRECATED(audioMasterWantMidi):

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

  179. 

  180.         gVstWantsMidi = true;

  181.         ret = 1;

  182.         break;

  183. 

  184.     case audioMasterGetTime:

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

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

  187. 

  188.         carla_zeroStruct(timeInfo);

  189.         timeInfo.sampleRate = kSampleRate;

  190. 

  191.         // Tempo

  192.         timeInfo.tempo  = 120.0;

  193.         timeInfo.flags |= kVstTempoValid;

  194. 

  195.         // Time Signature

  196.         timeInfo.timeSigNumerator   = 4;

  197.         timeInfo.timeSigDenominator = 4;

  198.         timeInfo.flags |= kVstTimeSigValid;

  199. 

  200.         ret = (intptr_t)&timeInfo;

  201.         break;

  202. 

  203.     case DECLARE_VST_DEPRECATED(audioMasterTempoAt):

  204.         ret = 120 * 10000;

  205.         break;

  206. 

  207.     case DECLARE_VST_DEPRECATED(audioMasterGetNumAutomatableParameters):

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

  209.         break;

  210. 

  211.     case DECLARE_VST_DEPRECATED(audioMasterGetParameterQuantization):

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

  213.         break;

  214. 

  215.     case DECLARE_VST_DEPRECATED(audioMasterNeedIdle):

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

  217. 

  218.         gVstNeedsIdle = true;

  219.         ret = 1;

  220.         break;

  221. 

  222.     case audioMasterGetSampleRate:

  223.         ret = kSampleRatei;

  224.         break;

  225. 

  226.     case audioMasterGetBlockSize:

  227.         ret = kBufferSize;

  228.         break;

  229. 

  230.     case DECLARE_VST_DEPRECATED(audioMasterWillReplaceOrAccumulate):

  231.         ret = 1; // replace

  232.         break;

  233. 

  234.     case audioMasterGetCurrentProcessLevel:

  235.         ret = gVstIsProcessing ? kVstProcessLevelRealtime : kVstProcessLevelUser;

  236.         break;

  237. 

  238.     case audioMasterGetAutomationState:

  239.         ret = kVstAutomationOff;

  240.         break;

  241. 

  242.     case audioMasterGetVendorString:

  243.         CARLA_SAFE_ASSERT_BREAK(ptr != nullptr);

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

  245.         ret = 1;

  246.         break;

  247. 

  248.     case audioMasterGetProductString:

  249.         CARLA_SAFE_ASSERT_BREAK(ptr != nullptr);

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

  251.         ret = 1;

  252.         break;

  253. 

  254.     case audioMasterGetVendorVersion:

  255.         ret = CARLA_VERSION_HEX;

  256.         break;

  257. 

  258.     case audioMasterCanDo:

  259.         CARLA_SAFE_ASSERT_BREAK(ptr != nullptr);

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

  261.         break;

  262. 

  263.     case audioMasterGetLanguage:

  264.         ret = kVstLangEnglish;

  265.         break;

  266. 

  267.     default:

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

  269.         break;

  270.     }

  271. 

  272.     return ret;

  273. }

  274. 

  275. #ifdef HAVE_LINUXSAMPLER

  276. // --------------------------------------------------------------------------

  277. // LinuxSampler stuff

  278. 

  279. class LinuxSamplerScopedEngine

  280. {

  281. public:

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

  283.         : fEngine(nullptr)

  284.     {

  285.         using namespace LinuxSampler;

  286. 

  287.         try {

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

  289.         }

  290.         catch (const Exception& e)

  291.         {

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

  293.             return;

  294.         }

  295. 

  296.         if (fEngine == nullptr)

  297.             return;

  298. 

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

  300. 

  301.         if (insMan == nullptr)

  302.         {

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

  304.             return;

  305.         }

  306. 

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

  308. 

  309.         try {

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

  311.         }

  312.         catch (const InstrumentManagerException& e)

  313.         {

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

  315.             return;

  316.         }

  317. 

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

  319.         {

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

  321.             return;

  322.         }

  323. 

  324.         InstrumentManager::instrument_info_t info;

  325. 

  326.         try {

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

  328.         }

  329.         catch (const InstrumentManagerException& e)

  330.         {

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

  332.             return;

  333.         }

  334. 

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

  336.     }

  337. 

  338.     ~LinuxSamplerScopedEngine()

  339.     {

  340.         if (fEngine != nullptr)

  341.         {

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

  343.             fEngine = nullptr;

  344.         }

  345.     }

  346. 

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

  348.     {

  349.         CarlaString name;

  350.         const char* label;

  351. 

  352.         if (info != nullptr)

  353.         {

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

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

  356.         }

  357.         else

  358.         {

  359.             name  = basename;

  360.             label = basename;

  361.         }

  362. 

  363.         // 2 channels

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

  365.         DISCOVERY_OUT("build", BINARY_NATIVE);

  366.         DISCOVERY_OUT("hints", PLUGIN_IS_SYNTH);

  367. 

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

  369.         DISCOVERY_OUT("label", label);

  370. 

  371.         if (info != nullptr)

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

  373. 

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

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

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

  377. 

  378.         // 16 channels

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

  380.             return;

  381. 

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

  383. 

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

  385.         DISCOVERY_OUT("build", BINARY_NATIVE);

  386.         DISCOVERY_OUT("hints", PLUGIN_IS_SYNTH);

  387. 

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

  389.         DISCOVERY_OUT("label", label);

  390. 

  391.         if (info != nullptr)

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

  393. 

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

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

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

  397.     }

  398. 

  399. private:

  400.     LinuxSampler::Engine* fEngine;

  401. 

  402.     CARLA_PREVENT_HEAP_ALLOCATION

  403.     CARLA_DECLARE_NON_COPY_CLASS(LinuxSamplerScopedEngine)

  404. };

  405. #endif // HAVE_LINUXSAMPLER

  406. 

  407. // ------------------------------ Plugin Checks -----------------------------

  408. 

  409. #ifndef BUILD_BRIDGE

  410. static void do_cached_check(const PluginType type)

  411. {

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

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

  414. 

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

  416.     {

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

  418.         CARLA_SAFE_ASSERT_CONTINUE(pinfo != nullptr);

  419. 

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

  421.         DISCOVERY_OUT("build", BINARY_NATIVE);

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

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

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

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

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

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

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

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

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

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

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

  433.     }

  434. }

  435. #endif

  436. 

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

  438. {

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

  440. 

  441.     if (descFn == nullptr)

  442.     {

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

  444.         return;

  445.     }

  446. 

  447.     const LADSPA_Descriptor* descriptor;

  448. 

  449.     {

  450.         descriptor = descFn(0);

  451. 

  452.         if (descriptor == nullptr)

  453.         {

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

  455.             return;

  456.         }

  457. 

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

  459.         {

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

  461. 

  462.             if (handle == nullptr)

  463.             {

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

  465.                 return;

  466.             }

  467. 

  468.             descriptor->cleanup(handle);

  469. 

  470.             lib_close(libHandle);

  471.             libHandle = lib_open(filename);

  472. 

  473.             if (libHandle == nullptr)

  474.             {

  475.                 print_lib_error(filename);

  476.                 return;

  477.             }

  478. 

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

  480. 

  481.             if (descFn == nullptr)

  482.             {

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

  484.                 return;

  485.             }

  486.         }

  487.     }

  488. 

  489.     unsigned long i = 0;

  490. 

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

  492.     {

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

  494.         {

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

  496.             continue;

  497.         }

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

  499.         {

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

  501.             continue;

  502.         }

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

  504.         {

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

  506.             continue;

  507.         }

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

  509.         {

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

  511.         }

  512. 

  513.         uint hints = 0x0;

  514.         int audioIns = 0;

  515.         int audioOuts = 0;

  516.         int audioTotal = 0;

  517.         int parametersIns = 0;

  518.         int parametersOuts = 0;

  519.         int parametersTotal = 0;

  520. 

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

  522.             hints |= PLUGIN_IS_RTSAFE;

  523. 

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

  525.         {

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

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

  528. 

  529.             if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  530.             {

  531.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  532.                     audioIns += 1;

  533.                 else if (LADSPA_IS_PORT_OUTPUT(portDescriptor))

  534.                     audioOuts += 1;

  535. 

  536.                 audioTotal += 1;

  537.             }

  538.             else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  539.             {

  540.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  541.                     parametersIns += 1;

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

  543.                     parametersOuts += 1;

  544. 

  545.                 parametersTotal += 1;

  546.             }

  547.         }

  548. 

  549.         if (doInit)

  550.         {

  551.             // -----------------------------------------------------------------------

  552.             // start crash-free plugin test

  553. 

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

  555. 

  556.             if (handle == nullptr)

  557.             {

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

  559.                 continue;

  560.             }

  561. 

  562.             // Test quick init and cleanup

  563.             descriptor->cleanup(handle);

  564. 

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

  566. 

  567.             if (handle == nullptr)

  568.             {

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

  570.                 continue;

  571.             }

  572. 

  573.             LADSPA_Data bufferAudio[kBufferSize][audioTotal];

  574.             LADSPA_Data bufferParams[parametersTotal];

  575.             LADSPA_Data min, max, def;

  576. 

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

  578.             {

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

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

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

  582. 

  583.                 if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  584.                 {

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

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

  587.                 }

  588.                 else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  589.                 {

  590.                     // min value

  591.                     if (LADSPA_IS_HINT_BOUNDED_BELOW(portRangeHints.HintDescriptor))

  592.                         min = portRangeHints.LowerBound;

  593.                     else

  594.                         min = 0.0f;

  595. 

  596.                     // max value

  597.                     if (LADSPA_IS_HINT_BOUNDED_ABOVE(portRangeHints.HintDescriptor))

  598.                         max = portRangeHints.UpperBound;

  599.                     else

  600.                         max = 1.0f;

  601. 

  602.                     if (min > max)

  603.                     {

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

  605.                         max = min + 0.1f;

  606.                     }

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

  608.                     {

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

  610.                         max = min + 0.1f;

  611.                     }

  612. 

  613.                     // default value

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

  615. 

  616.                     if (LADSPA_IS_HINT_SAMPLE_RATE(portRangeHints.HintDescriptor))

  617.                     {

  618.                         min *= kSampleRatef;

  619.                         max *= kSampleRatef;

  620.                         def *= kSampleRatef;

  621.                     }

  622. 

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

  624.                     {

  625.                         // latency parameter

  626.                         def = 0.0f;

  627.                     }

  628.                     else

  629.                     {

  630.                         if (def < min)

  631.                             def = min;

  632.                         else if (def > max)

  633.                             def = max;

  634.                     }

  635. 

  636.                     bufferParams[iC] = def;

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

  638.                 }

  639.             }

  640. 

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

  642.                 descriptor->activate(handle);

  643. 

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

  645. 

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

  647.                 descriptor->deactivate(handle);

  648. 

  649.             descriptor->cleanup(handle);

  650. 

  651.             // end crash-free plugin test

  652.             // -----------------------------------------------------------------------

  653.         }

  654. 

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

  656.         DISCOVERY_OUT("build", BINARY_NATIVE);

  657.         DISCOVERY_OUT("hints", hints);

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

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

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

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

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

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

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

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

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

  667.     }

  668. }

  669. 

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

  671. {

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

  673. 

  674.     if (descFn == nullptr)

  675.     {

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

  677.         return;

  678.     }

  679. 

  680.     const DSSI_Descriptor* descriptor;

  681. 

  682.     {

  683.         descriptor = descFn(0);

  684. 

  685.         if (descriptor == nullptr)

  686.         {

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

  688.             return;

  689.         }

  690. 

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

  692. 

  693.         if (ldescriptor == nullptr)

  694.         {

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

  696.             return;

  697.         }

  698. 

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

  700.         {

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

  702. 

  703.             if (handle == nullptr)

  704.             {

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

  706.                 return;

  707.             }

  708. 

  709.             ldescriptor->cleanup(handle);

  710. 

  711.             lib_close(libHandle);

  712.             libHandle = lib_open(filename);

  713. 

  714.             if (libHandle == nullptr)

  715.             {

  716.                 print_lib_error(filename);

  717.                 return;

  718.             }

  719. 

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

  721. 

  722.             if (descFn == nullptr)

  723.             {

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

  725.                 return;

  726.             }

  727.         }

  728.     }

  729. 

  730.     unsigned long i = 0;

  731. 

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

  733.     {

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

  735. 

  736.         if (ldescriptor == nullptr)

  737.         {

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

  739.             continue;

  740.         }

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

  742.         {

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

  744.             continue;

  745.         }

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

  747.         {

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

  749.             continue;

  750.         }

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

  752.         {

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

  754.             continue;

  755.         }

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

  757.         {

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

  759.             continue;

  760.         }

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

  762.         {

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

  764.             continue;

  765.         }

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

  767.         {

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

  769.         }

  770. 

  771.         uint hints = 0x0;

  772.         int audioIns = 0;

  773.         int audioOuts = 0;

  774.         int audioTotal = 0;

  775.         int midiIns = 0;

  776.         int parametersIns = 0;

  777.         int parametersOuts = 0;

  778.         int parametersTotal = 0;

  779. 

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

  781.             hints |= PLUGIN_IS_RTSAFE;

  782. 

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

  784.         {

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

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

  787. 

  788.             if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  789.             {

  790.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  791.                     audioIns += 1;

  792.                 else if (LADSPA_IS_PORT_OUTPUT(portDescriptor))

  793.                     audioOuts += 1;

  794. 

  795.                 audioTotal += 1;

  796.             }

  797.             else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  798.             {

  799.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  800.                     parametersIns += 1;

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

  802.                     parametersOuts += 1;

  803. 

  804.                 parametersTotal += 1;

  805.             }

  806.         }

  807. 

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

  809.             midiIns = 1;

  810. 

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

  812.             hints |= PLUGIN_IS_SYNTH;

  813. 

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

  815.         {

  816.             hints |= PLUGIN_HAS_CUSTOM_UI;

  817.             delete[] ui;

  818.         }

  819. 

  820.         if (doInit)

  821.         {

  822.             // -----------------------------------------------------------------------

  823.             // start crash-free plugin test

  824. 

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

  826. 

  827.             if (handle == nullptr)

  828.             {

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

  830.                 continue;

  831.             }

  832. 

  833.             // Test quick init and cleanup

  834.             ldescriptor->cleanup(handle);

  835. 

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

  837. 

  838.             if (handle == nullptr)

  839.             {

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

  841.                 continue;

  842.             }

  843. 

  844.             LADSPA_Data bufferAudio[kBufferSize][audioTotal];

  845.             LADSPA_Data bufferParams[parametersTotal];

  846.             LADSPA_Data min, max, def;

  847. 

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

  849.             {

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

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

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

  853. 

  854.                 if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  855.                 {

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

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

  858.                 }

  859.                 else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  860.                 {

  861.                     // min value

  862.                     if (LADSPA_IS_HINT_BOUNDED_BELOW(portRangeHints.HintDescriptor))

  863.                         min = portRangeHints.LowerBound;

  864.                     else

  865.                         min = 0.0f;

  866. 

  867.                     // max value

  868.                     if (LADSPA_IS_HINT_BOUNDED_ABOVE(portRangeHints.HintDescriptor))

  869.                         max = portRangeHints.UpperBound;

  870.                     else

  871.                         max = 1.0f;

  872. 

  873.                     if (min > max)

  874.                     {

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

  876.                         max = min + 0.1f;

  877.                     }

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

  879.                     {

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

  881.                         max = min + 0.1f;

  882.                     }

  883. 

  884.                     // default value

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

  886. 

  887.                     if (LADSPA_IS_HINT_SAMPLE_RATE(portRangeHints.HintDescriptor))

  888.                     {

  889.                         min *= kSampleRatef;

  890.                         max *= kSampleRatef;

  891.                         def *= kSampleRatef;

  892.                     }

  893. 

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

  895.                     {

  896.                         // latency parameter

  897.                         def = 0.0f;

  898.                     }

  899.                     else

  900.                     {

  901.                         if (def < min)

  902.                             def = min;

  903.                         else if (def > max)

  904.                             def = max;

  905.                     }

  906. 

  907.                     bufferParams[iC] = def;

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

  909.                 }

  910.             }

  911. 

  912.             // select first midi-program if available

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

  914.             {

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

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

  917.             }

  918. 

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

  920.                 ldescriptor->activate(handle);

  921. 

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

  923.             {

  924.                 snd_seq_event_t midiEvents[2];

  925.                 carla_zeroStructs(midiEvents, 2);

  926. 

  927.                 const unsigned long midiEventCount = 2;

  928. 

  929.                 midiEvents[0].type = SND_SEQ_EVENT_NOTEON;

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

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

  932. 

  933.                 midiEvents[1].type = SND_SEQ_EVENT_NOTEOFF;

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

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

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

  937. 

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

  939.             }

  940.             else

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

  942. 

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

  944.                 ldescriptor->deactivate(handle);

  945. 

  946.             ldescriptor->cleanup(handle);

  947. 

  948.             // end crash-free plugin test

  949.             // -----------------------------------------------------------------------

  950.         }

  951. 

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

  953.         DISCOVERY_OUT("build", BINARY_NATIVE);

  954.         DISCOVERY_OUT("hints", hints);

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

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

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

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

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

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

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

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

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

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

  965.     }

  966. }

  967. 

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

  969. {

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

  971. 

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

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

  974. 

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

  976. 

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

  978.         sBundle += "/";

  979. 

  980.     // Load bundle

  981.     lv2World.load_bundle(sBundle);

  982. 

  983.     // Load plugins in this bundle

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

  985. 

  986.     // Get all plugin URIs in this bundle

  987.     StringArray URIs;

  988. 

  989.     LILV_FOREACH(plugins, it, lilvPlugins)

  990.     {

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

  992. 

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

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

  995.     }

  996. 

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

  998.     {

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

  1000.         return;

  1001.     }

  1002. 

  1003.     // Get & check every plugin-instance

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

  1005.     {

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

  1007. 

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

  1009.         {

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

  1011.             continue;

  1012.         }

  1013. 

  1014.         if (doInit)

  1015.         {

  1016.             // test if DLL is loadable, twice

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

  1018. 

  1019.             if (libHandle1 == nullptr)

  1020.             {

  1021.                 print_lib_error(rdfDescriptor->Binary);

  1022.                 delete rdfDescriptor;

  1023.                 continue;

  1024.             }

  1025. 

  1026.             lib_close(libHandle1);

  1027. 

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

  1029. 

  1030.             if (libHandle2 == nullptr)

  1031.             {

  1032.                 print_lib_error(rdfDescriptor->Binary);

  1033.                 delete rdfDescriptor;

  1034.                 continue;

  1035.             }

  1036. 

  1037.             lib_close(libHandle2);

  1038.         }

  1039. 

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

  1041.         {

  1042.             bool supported = true;

  1043. 

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

  1045.             {

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

  1047. 

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

  1049.                 {

  1050.                     pass();

  1051.                 }

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

  1053.                 {

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

  1055.                     supported = false;

  1056.                     break;

  1057.                 }

  1058.             }

  1059. 

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

  1061.             {

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

  1063. 

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

  1065.                 {

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

  1067.                 }

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

  1069.                 {

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

  1071.                     supported = false;

  1072.                     break;

  1073.                 }

  1074.             }

  1075. 

  1076.             if (! supported)

  1077.             {

  1078.                 delete rdfDescriptor;

  1079.                 continue;

  1080.             }

  1081.         }

  1082. 

  1083.         uint hints = 0x0;

  1084.         int audioIns = 0;

  1085.         int audioOuts = 0;

  1086.         int midiIns = 0;

  1087.         int midiOuts = 0;

  1088.         int parametersIns = 0;

  1089.         int parametersOuts = 0;

  1090. 

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

  1092.         {

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

  1094. 

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

  1096.                 hints |= PLUGIN_IS_RTSAFE;

  1097.         }

  1098. 

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

  1100.         {

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

  1102. 

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

  1104.             {

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

  1106.                     audioIns += 1;

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

  1108.                     audioOuts += 1;

  1109.             }

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

  1111.             {

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

  1113.                 {

  1114.                     pass();

  1115.                 }

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

  1117.                 {

  1118.                     pass();

  1119.                 }

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

  1121.                 {

  1122.                     pass();

  1123.                 }

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

  1125.                 {

  1126.                     pass();

  1127.                 }

  1128.                 else

  1129.                 {

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

  1131.                         parametersIns += 1;

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

  1133.                         parametersOuts += 1;

  1134.                 }

  1135.             }

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

  1137.             {

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

  1139.                     midiIns += 1;

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

  1141.                     midiOuts += 1;

  1142.             }

  1143.         }

  1144. 

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

  1146.             hints |= PLUGIN_IS_SYNTH;

  1147. 

  1148.         if (rdfDescriptor->UICount > 0)

  1149.             hints |= PLUGIN_HAS_CUSTOM_UI;

  1150. 

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

  1152.         DISCOVERY_OUT("build", BINARY_NATIVE);

  1153.         DISCOVERY_OUT("hints", hints);

  1154. 

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

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

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

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

  1159. 

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

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

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

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

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

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

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

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

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

  1169. 

  1170.         delete rdfDescriptor;

  1171.     }

  1172. }

  1173. 

  1174. static void do_vst_check(lib_t& libHandle, const char* const filename, const bool doInit)

  1175. {

  1176.     VST_Function vstFn = nullptr;

  1177. 

  1178. #ifdef CARLA_OS_MAC

  1179.     CFBundleRef bundleRef = nullptr;

  1180.     CFBundleRefNum resFileId;

  1181. 

  1182.     if (libHandle == nullptr)

  1183.     {

  1184.         const CFURLRef urlRef = CFURLCreateFromFileSystemRepresentation(0, (const UInt8*)filename, (CFIndex)strlen(filename), true);

  1185.         CARLA_SAFE_ASSERT_RETURN(urlRef != nullptr,);

  1186. 

  1187.         bundleRef = CFBundleCreate(kCFAllocatorDefault, urlRef);

  1188.         CFRelease(urlRef);

  1189.         CARLA_SAFE_ASSERT_RETURN(bundleRef != nullptr,);

  1190. 

  1191.         if (! CFBundleLoadExecutable(bundleRef))

  1192.         {

  1193.             CFRelease(bundleRef);

  1194.             DISCOVERY_OUT("error", "Failed to load VST bundle executable");

  1195.             return;

  1196.         }

  1197. 

  1198.         vstFn = (VST_Function)CFBundleGetFunctionPointerForName(bundleRef, CFSTR("main_macho"));

  1199. 

  1200.         if (vstFn == nullptr)

  1201.             vstFn = (VST_Function)CFBundleGetFunctionPointerForName(bundleRef, CFSTR("VSTPluginMain"));

  1202. 

  1203.         if (vstFn == nullptr)

  1204.         {

  1205.             CFBundleUnloadExecutable(bundleRef);

  1206.             CFRelease(bundleRef);

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

  1208.             return;

  1209.         }

  1210. 

  1211.         resFileId = CFBundleOpenBundleResourceMap(bundleRef);

  1212.     }

  1213.     else

  1214. #endif

  1215.     {

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

  1217. 

  1218.         if (vstFn == nullptr)

  1219.         {

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

  1221. 

  1222.             if (vstFn == nullptr)

  1223.             {

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

  1225.                 return;

  1226.             }

  1227.         }

  1228.     }

  1229. 

  1230.     AEffect* effect = vstFn(vstHostCallback);

  1231. 

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

  1233.     {

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

  1235.         return;

  1236.     }

  1237. 

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

  1239.     {

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

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

  1242.         return;

  1243.     }

  1244. 

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

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

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

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

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

  1250. 

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

  1252. 

  1253.     if (effect->numPrograms > 0)

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

  1255. 

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

  1257.     gVstCurrentUniqueId =  effect->uniqueID;

  1258. 

  1259.     char strBuf[STR_MAX+1];

  1260.     CarlaString cName;

  1261.     CarlaString cProduct;

  1262.     CarlaString cVendor;

  1263.     LinkedList<intptr_t> uniqueIds;

  1264. 

  1265.     if (isShell)

  1266.     {

  1267.         for (;;)

  1268.         {

  1269.             carla_zeroChars(strBuf, STR_MAX+1);

  1270. 

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

  1272. 

  1273.             if (gVstCurrentUniqueId == 0)

  1274.                 break;

  1275. 

  1276.             uniqueIds.append(gVstCurrentUniqueId);

  1277.         }

  1278. 

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

  1280.         effect = nullptr;

  1281.     }

  1282.     else

  1283.     {

  1284.         uniqueIds.append(gVstCurrentUniqueId);

  1285.     }

  1286. 

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

  1288.     {

  1289.         gVstCurrentUniqueId = it.getValue(0);

  1290. 

  1291.         if (effect == nullptr)

  1292.         {

  1293.             effect = vstFn(vstHostCallback);

  1294. 

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

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

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

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

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

  1300. 

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

  1302. 

  1303.             if (effect->numPrograms > 0)

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

  1305.         }

  1306. 

  1307.         // get name

  1308.         carla_zeroChars(strBuf, STR_MAX+1);

  1309. 

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

  1311.             cName = strBuf;

  1312.         else

  1313.             cName.clear();

  1314. 

  1315.         // get product

  1316.         carla_zeroChars(strBuf, STR_MAX+1);

  1317. 

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

  1319.             cProduct = strBuf;

  1320.         else

  1321.             cProduct.clear();

  1322. 

  1323.         // get vendor

  1324.         carla_zeroChars(strBuf, STR_MAX+1);

  1325. 

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

  1327.             cVendor = strBuf;

  1328.         else

  1329.             cVendor.clear();

  1330. 

  1331.         // get everything else

  1332.         uint hints = 0x0;

  1333.         int audioIns = effect->numInputs;

  1334.         int audioOuts = effect->numOutputs;

  1335.         int midiIns = 0;

  1336.         int midiOuts = 0;

  1337.         int parameters = effect->numParams;

  1338. 

  1339.         if (effect->flags & effFlagsHasEditor)

  1340.             hints |= PLUGIN_HAS_CUSTOM_UI;

  1341. 

  1342.         if (effect->flags & effFlagsIsSynth)

  1343.             hints |= PLUGIN_IS_SYNTH;

  1344. 

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

  1346.             midiIns = 1;

  1347. 

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

  1349.             midiOuts = 1;

  1350. 

  1351.         // -----------------------------------------------------------------------

  1352.         // start crash-free plugin test

  1353. 

  1354.         if (doInit)

  1355.         {

  1356.             if (gVstNeedsIdle)

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

  1358. 

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

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

  1361. 

  1362.             if (gVstNeedsIdle)

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

  1364. 

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

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

  1367.             {

  1368.                 midiIns = 1;

  1369.             }

  1370. 

  1371.             float* bufferAudioIn[audioIns];

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

  1373.             {

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

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

  1376.             }

  1377. 

  1378.             float* bufferAudioOut[audioOuts];

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

  1380.             {

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

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

  1383.             }

  1384. 

  1385.             struct VstEventsFixed {

  1386.                 int32_t numEvents;

  1387.                 intptr_t reserved;

  1388.                 VstEvent* data[2];

  1389. 

  1390.                 VstEventsFixed()

  1391.                     : numEvents(0),

  1392.                       reserved(0)

  1393.                 {

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

  1395.                 }

  1396.             } events;

  1397. 

  1398.             VstMidiEvent midiEvents[2];

  1399.             carla_zeroStructs(midiEvents, 2);

  1400. 

  1401.             midiEvents[0].type = kVstMidiType;

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

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

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

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

  1406. 

  1407.             midiEvents[1].type = kVstMidiType;

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

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

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

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

  1412. 

  1413.             events.numEvents = 2;

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

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

  1416. 

  1417.             // processing

  1418.             gVstIsProcessing = true;

  1419. 

  1420.             if (midiIns > 0)

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

  1422. 

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

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

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

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

  1427.             else

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

  1429. 

  1430.             gVstIsProcessing = false;

  1431. 

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

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

  1434. 

  1435.             if (gVstNeedsIdle)

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

  1437. 

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

  1439.                 delete[] bufferAudioIn[j];

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

  1441.                 delete[] bufferAudioOut[j];

  1442.         }

  1443. 

  1444.         // end crash-free plugin test

  1445.         // -----------------------------------------------------------------------

  1446. 

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

  1448.         DISCOVERY_OUT("build", BINARY_NATIVE);

  1449.         DISCOVERY_OUT("hints", hints);

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

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

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

  1453.         DISCOVERY_OUT("uniqueId", gVstCurrentUniqueId);

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

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

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

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

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

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

  1460. 

  1461.         gVstWantsMidi = false;

  1462.         gVstWantsTime = false;

  1463. 

  1464.         if (! isShell)

  1465.             break;

  1466. 

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

  1468.         effect = nullptr;

  1469.     }

  1470. 

  1471.     uniqueIds.clear();

  1472. 

  1473.     if (effect != nullptr)

  1474.     {

  1475.         if (gVstNeedsIdle)

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

  1477. 

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

  1479.     }

  1480. 

  1481. #ifdef CARLA_OS_MAC

  1482.     if (bundleRef != nullptr)

  1483.     {

  1484.         CFBundleCloseBundleResourceMap(bundleRef, resFileId);

  1485.         CFBundleUnloadExecutable(bundleRef);

  1486.         CFRelease(bundleRef);

  1487.     }

  1488. #else

  1489.     return;

  1490. 

  1491.     // unused

  1492.     (void)filename;

  1493. #endif

  1494. }

  1495. 

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

  1497. {

  1498. #ifdef HAVE_FLUIDSYNTH

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

  1500.     const File file(jfilename);

  1501. 

  1502.     if (! file.existsAsFile())

  1503.     {

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

  1505.         return;

  1506.     }

  1507. 

  1508.     if (! fluid_is_soundfont(filename))

  1509.     {

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

  1511.         return;

  1512.     }

  1513. 

  1514.     int programs = 0;

  1515. 

  1516.     if (doInit)

  1517.     {

  1518.         fluid_settings_t* const f_settings = new_fluid_settings();

  1519.         CARLA_SAFE_ASSERT_RETURN(f_settings != nullptr,);

  1520. 

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

  1522.         CARLA_SAFE_ASSERT_RETURN(f_synth != nullptr,);

  1523. 

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

  1525. 

  1526.         if (f_id < 0)

  1527.         {

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

  1529.             return;

  1530.         }

  1531. 

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

  1533.         {

  1534.             fluid_preset_t f_preset;

  1535. 

  1536.             f_sfont->iteration_start(f_sfont);

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

  1538.                 ++programs;

  1539.         }

  1540. 

  1541.         delete_fluid_synth(f_synth);

  1542.         delete_fluid_settings(f_settings);

  1543.     }

  1544. 

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

  1546.     CarlaString label(name);

  1547. 

  1548.     // 2 channels

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

  1550.     DISCOVERY_OUT("build", BINARY_NATIVE);

  1551.     DISCOVERY_OUT("hints", PLUGIN_IS_SYNTH);

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

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

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

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

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

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

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

  1559. 

  1560.     // 16 channels

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

  1562.         return;

  1563. 

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

  1565. 

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

  1567.     DISCOVERY_OUT("build", BINARY_NATIVE);

  1568.     DISCOVERY_OUT("hints", PLUGIN_IS_SYNTH);

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

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

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

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

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

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

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

  1576. #else // HAVE_FLUIDSYNTH

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

  1578.     return;

  1579. 

  1580.     // unused

  1581.     (void)filename;

  1582.     (void)doInit;

  1583. #endif

  1584. }

  1585. 

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

  1587. {

  1588. #ifdef HAVE_LINUXSAMPLER

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

  1590.     const File file(jfilename);

  1591. 

  1592.     if (! file.existsAsFile())

  1593.     {

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

  1595.         return;

  1596.     }

  1597. 

  1598.     if (doInit)

  1599.         const LinuxSamplerScopedEngine engine(filename, stype);

  1600.     else

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

  1602. #else // HAVE_LINUXSAMPLER

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

  1604.     return;

  1605. 

  1606.     // unused

  1607.     (void)filename;

  1608.     (void)doInit;

  1609. #endif

  1610. }

  1611. 

  1612. // ------------------------------ main entry point ------------------------------

  1613. 

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

  1615. {

  1616.     if (argc != 3)

  1617.     {

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

  1619.         return 1;

  1620.     }

  1621. 

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

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

  1624.     const PluginType  type     = getPluginTypeFromString(stype);

  1625. 

  1626.     CarlaString filenameCheck(filename);

  1627.     filenameCheck.toLower();

  1628. 

  1629.     bool openLib = false;

  1630.     lib_t handle = nullptr;

  1631. 

  1632.     switch (type)

  1633.     {

  1634.     case PLUGIN_LADSPA:

  1635.     case PLUGIN_DSSI:

  1636.     case PLUGIN_VST2:

  1637.         openLib = true;

  1638.     default:

  1639.         break;

  1640.     }

  1641. 

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

  1643.     {

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

  1645.         {

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

  1647.             return 0;

  1648.         }

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

  1650.         {

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

  1652.             return 0;

  1653.         }

  1654. #ifdef CARLA_OS_MAC

  1655.         if (type == PLUGIN_VST2 && (filenameCheck.endsWith(".vst") || filenameCheck.endsWith(".vst/")))

  1656.             openLib = false;

  1657. #endif

  1658.     }

  1659. 

  1660.     if (openLib)

  1661.     {

  1662.         handle = lib_open(filename);

  1663. 

  1664.         if (handle == nullptr)

  1665.         {

  1666.             print_lib_error(filename);

  1667.             return 1;

  1668.         }

  1669.     }

  1670. 

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

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

  1673. 

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

  1675.         doInit = false;

  1676. 

  1677.     if (doInit && openLib && handle != nullptr)

  1678.     {

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

  1680.         if (! lib_close(handle))

  1681.         {

  1682.             print_lib_error(filename);

  1683.             return 1;

  1684.         }

  1685. 

  1686.         handle = lib_open(filename);

  1687. 

  1688.         if (handle == nullptr)

  1689.         {

  1690.             print_lib_error(filename);

  1691.             return 1;

  1692.         }

  1693.     }

  1694. 

  1695. #ifndef BUILD_BRIDGE

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

  1697.     {

  1698.         do_cached_check(type);

  1699.         return 0;

  1700.     }

  1701. #endif

  1702. 

  1703.     switch (type)

  1704.     {

  1705.     case PLUGIN_LADSPA:

  1706.         do_ladspa_check(handle, filename, doInit);

  1707.         break;

  1708.     case PLUGIN_DSSI:

  1709.         do_dssi_check(handle, filename, doInit);

  1710.         break;

  1711.     case PLUGIN_LV2:

  1712.         do_lv2_check(filename, doInit);

  1713.         break;

  1714.     case PLUGIN_VST2:

  1715.         do_vst_check(handle, filename, doInit);

  1716.         break;

  1717.     case PLUGIN_GIG:

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

  1719.         break;

  1720.     case PLUGIN_SF2:

  1721.         do_fluidsynth_check(filename, doInit);

  1722.         break;

  1723.     case PLUGIN_SFZ:

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

  1725.         break;

  1726.     default:

  1727.         break;

  1728.     }

  1729. 

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

  1731.         lib_close(handle);

  1732. 

  1733.     return 0;

  1734. }

  1735. 

  1736. // --------------------------------------------------------------------------