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

1559 lines
48KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin discovery

  3.  * Copyright (C) 2011-2013 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 GPL.txt file

  16.  */

  17. 

  18. #include "CarlaBackend.hpp"

  19. #include "CarlaJuceUtils.hpp"

  20. #include "CarlaLibUtils.hpp"

  21. #include "CarlaString.hpp"

  22. #include "CarlaMIDI.h"

  23. 

  24. #ifdef WANT_LADSPA

  25. # include "CarlaLadspaUtils.hpp"

  26. #endif

  27. #ifdef WANT_DSSI

  28. # include "CarlaLadspaUtils.hpp"

  29. # include "dssi/dssi.h"

  30. #endif

  31. #ifdef WANT_LV2

  32. # include <QtCore/QDir>

  33. # include <QtCore/QUrl>

  34. # include "CarlaLv2Utils.hpp"

  35. #endif

  36. #ifdef WANT_VST

  37. # include "CarlaVstUtils.hpp"

  38. #endif

  39. #ifdef WANT_FLUIDSYNTH

  40. # include <fluidsynth.h>

  41. #endif

  42. #ifdef WANT_LINUXSAMPLER

  43. # include <QtCore/QFileInfo>

  44. # include "linuxsampler/EngineFactory.h"

  45. #endif

  46. 

  47. #include <iostream>

  48. 

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

  50. 

  51. CARLA_BACKEND_USE_NAMESPACE

  52. 

  53. #ifdef WANT_LV2

  54. // --------------------------------------------------------------------------

  55. // Our LV2 World class object

  56. 

  57. Lv2WorldClass lv2World;

  58. #endif

  59. 

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

  61. // Dummy values to test plugins with

  62. 

  63. const uint32_t bufferSize = 512;

  64. const double   sampleRate = 44100.0;

  65. 

  66. // --------------------------------------------------------------------------

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

  68. 

  69. void print_lib_error(const char* const filename)

  70. {

  71.     const char* const error = lib_error(filename);

  72.     if (error && strstr(error, "wrong ELF class") == nullptr && strstr(error, "Bad EXE format") == nullptr)

  73.         DISCOVERY_OUT("error", error);

  74. }

  75. 

  76. // --------------------------------------------------------------------------

  77. // VST stuff

  78. 

  79. #ifdef WANT_VST

  80. // Check if plugin wants midi

  81. bool vstWantsMidi = false;

  82. 

  83. // Check if plugin is processing

  84. bool vstIsProcessing = false;

  85. 

  86. // Current uniqueId for vst shell plugins

  87. intptr_t vstCurrentUniqueId = 0;

  88. 

  89. // Supported Carla features

  90. intptr_t vstHostCanDo(const char* const feature)

  91. {

  92. #if DEBUG

  93.     qDebug("vstHostCanDo(\"%s\")", feature);

  94. #endif

  95. 

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

  97.         return 1;

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

  99.         return 1;

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

  101.         return 1;

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

  103.         return 1;

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

  105.         return 1;

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

  107.         return 1;

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

  109.         return 1;

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

  111.         return -1;

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

  113.         return -1;

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

  115.         return 1;

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

  117.         return 1;

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

  119.         return -1;

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

  121.         return -1;

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

  123.         return -1;

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

  125.         return 1;

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

  127.         return 1;

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

  129.         return 1;

  130. 

  131.     // unimplemented

  132.     qWarning("vstHostCanDo(\"%s\") - unknown feature", feature);

  133.     return 0;

  134. }

  135. 

  136. // Host-side callback

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

  138. {

  139. #if DEBUG

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

  141. #endif

  142. 

  143.     intptr_t ret = 0;

  144. 

  145.     switch (opcode)

  146.     {

  147.     case audioMasterAutomate:

  148.         if (effect)

  149.         {

  150.             effect->setParameter(effect, index, opt);

  151.             ret = 1;

  152.         }

  153.         break;

  154. 

  155.     case audioMasterVersion:

  156.         ret = kVstVersion;

  157.         break;

  158. 

  159.     case audioMasterCurrentId:

  160.         ret = vstCurrentUniqueId;

  161.         break;

  162. 

  163. #if ! VST_FORCE_DEPRECATED

  164.     case audioMasterWantMidi:

  165.         vstWantsMidi = true;

  166.         ret = 1;

  167.         break;

  168. #endif

  169. 

  170.     case audioMasterGetTime:

  171.         static VstTimeInfo_R timeInfo;

  172.         memset(&timeInfo, 0, sizeof(VstTimeInfo_R)); //FIXME

  173.         timeInfo.sampleRate = sampleRate;

  174. 

  175.         // Tempo

  176.         timeInfo.tempo  = 120.0;

  177.         timeInfo.flags |= kVstTempoValid;

  178. 

  179.         // Time Signature

  180.         timeInfo.timeSigNumerator   = 4;

  181.         timeInfo.timeSigDenominator = 4;

  182.         timeInfo.flags |= kVstTimeSigValid;

  183. 

  184.         ret = (intptr_t)&timeInfo;

  185.         break;

  186. 

  187. #if ! VST_FORCE_DEPRECATED

  188.     case audioMasterTempoAt:

  189.         ret = 120 * 10000;

  190.         break;

  191. 

  192.     case audioMasterGetNumAutomatableParameters:

  193.         ret = carla_min<int32_t>(effect->numParams, MAX_DEFAULT_PARAMETERS, 0);

  194.         break;

  195. 

  196.     case audioMasterGetParameterQuantization:

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

  198.         break;

  199. #endif

  200. 

  201.     case audioMasterGetSampleRate:

  202.         ret = sampleRate;

  203.         break;

  204. 

  205.     case audioMasterGetBlockSize:

  206.         ret = bufferSize;

  207.         break;

  208. 

  209. #if ! VST_FORCE_DEPRECATED

  210.     case audioMasterWillReplaceOrAccumulate:

  211.         ret = 1; // replace

  212.         break;

  213. #endif

  214. 

  215.     case audioMasterGetCurrentProcessLevel:

  216.         ret = vstIsProcessing ? kVstProcessLevelRealtime : kVstProcessLevelUser;

  217.         break;

  218. 

  219.     case audioMasterGetAutomationState:

  220.         ret = kVstAutomationOff;

  221.         break;

  222. 

  223.     case audioMasterGetVendorString:

  224.         if (ptr)

  225.         {

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

  227.             ret = 1;

  228.         }

  229.         break;

  230. 

  231.     case audioMasterGetProductString:

  232.         if (ptr)

  233.         {

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

  235.             ret = 1;

  236.         }

  237.         break;

  238. 

  239.     case audioMasterGetVendorVersion:

  240.         ret = 0x050; // 0.5.0

  241.         break;

  242. 

  243.     case audioMasterCanDo:

  244.         if (ptr)

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

  246.         break;

  247. 

  248.     case audioMasterGetLanguage:

  249.         ret = kVstLangEnglish;

  250.         break;

  251. 

  252.     default:

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

  254.         break;

  255.     }

  256. 

  257.     return ret;

  258. }

  259. #endif

  260. 

  261. // --------------------------------------------------------------------------

  262. // LinuxSampler stuff

  263. 

  264. #ifdef WANT_LINUXSAMPLER

  265. class LinuxSamplerScopedEngine

  266. {

  267. public:

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

  269.         : engine(nullptr),

  270.           ins(nullptr)

  271.     {

  272.         using namespace LinuxSampler;

  273. 

  274.         try {

  275.             engine = EngineFactory::Create(stype);

  276.         }

  277.         catch (const Exception& e)

  278.         {

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

  280.             return;

  281.         }

  282. 

  283.         if (engine == nullptr)

  284.             return;

  285. 

  286.         ins = engine->GetInstrumentManager();

  287. 

  288.         if (ins == nullptr)

  289.         {

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

  291.             return;

  292.         }

  293. 

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

  295. 

  296.         try {

  297.             ids = ins->GetInstrumentFileContent(filename);

  298.         }

  299.         catch (const Exception& e)

  300.         {

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

  302.             return;

  303.         }

  304. 

  305.         if (ids.size() > 0)

  306.         {

  307.             InstrumentManager::instrument_info_t info = ins->GetInstrumentInfo(ids[0]);

  308.             outputInfo(&info, ids.size());

  309.         }

  310.     }

  311. 

  312.     ~LinuxSamplerScopedEngine()

  313.     {

  314.         if (engine != nullptr)

  315.             LinuxSampler::EngineFactory::Destroy(engine);

  316.     }

  317. 

  318.     static void outputInfo(LinuxSampler::InstrumentManager::instrument_info_t* const info, const int programs, const char* const basename = nullptr)

  319.     {

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

  321. 

  322.         if (info != nullptr)

  323.         {

  324.             DISCOVERY_OUT("name", info->InstrumentName);

  325.             DISCOVERY_OUT("label", info->Product);

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

  327.             DISCOVERY_OUT("copyright", info->Artists);

  328.         }

  329.         else

  330.         {

  331.             DISCOVERY_OUT("name", basename);

  332.             DISCOVERY_OUT("label", basename);

  333.         }

  334. 

  335.         DISCOVERY_OUT("hints", PLUGIN_IS_SYNTH);

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

  337.         DISCOVERY_OUT("audio.total", 2);

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

  339.         DISCOVERY_OUT("midi.total", 1);

  340.         DISCOVERY_OUT("programs.total", programs);

  341.         //DISCOVERY_OUT("parameters.ins", 13); // defined in Carla - TODO

  342.         //DISCOVERY_OUT("parameters.outs", 1);

  343.         //DISCOVERY_OUT("parameters.total", 14);

  344.         DISCOVERY_OUT("build", BINARY_NATIVE);

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

  346.     }

  347. 

  348. private:

  349.     LinuxSampler::Engine* engine;

  350.     LinuxSampler::InstrumentManager* ins;

  351. 

  352.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(LinuxSamplerScopedEngine)

  353. };

  354. #endif

  355. 

  356. // ------------------------------ Plugin Checks -----------------------------

  357. 

  358. void do_ladspa_check(void* const libHandle, const bool init)

  359. {

  360. #ifdef WANT_LADSPA

  361.     const LADSPA_Descriptor_Function descFn = (LADSPA_Descriptor_Function)lib_symbol(libHandle, "ladspa_descriptor");

  362. 

  363.     if (! descFn)

  364.     {

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

  366.         return;

  367.     }

  368. 

  369.     unsigned long i = 0;

  370.     const LADSPA_Descriptor* descriptor;

  371. 

  372.     while ((descriptor = descFn(i++)))

  373.     {

  374.         if (! descriptor->instantiate)

  375.         {

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

  377.             continue;

  378.         }

  379.         if (! descriptor->cleanup)

  380.         {

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

  382.             continue;

  383.         }

  384.         if (! descriptor->run)

  385.         {

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

  387.             continue;

  388.         }

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

  390.         {

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

  392.         }

  393. 

  394.         int hints = 0;

  395.         int audioIns = 0;

  396.         int audioOuts = 0;

  397.         int audioTotal = 0;

  398.         int parametersIns = 0;

  399.         int parametersOuts = 0;

  400.         int parametersTotal = 0;

  401. 

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

  403.             hints |= PLUGIN_IS_RTSAFE;

  404. 

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

  406.         {

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

  408. 

  409.             if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  410.             {

  411.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  412.                     audioIns += 1;

  413.                 else if (LADSPA_IS_PORT_OUTPUT(portDescriptor))

  414.                     audioOuts += 1;

  415. 

  416.                 audioTotal += 1;

  417.             }

  418.             else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  419.             {

  420.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  421.                     parametersIns += 1;

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

  423.                     parametersOuts += 1;

  424. 

  425.                 parametersTotal += 1;

  426.             }

  427.         }

  428. 

  429.         if (init)

  430.         {

  431.             // -----------------------------------------------------------------------

  432.             // start crash-free plugin test

  433. 

  434.             const LADSPA_Handle handle = descriptor->instantiate(descriptor, sampleRate);

  435. 

  436.             if (! handle)

  437.             {

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

  439.                 continue;

  440.             }

  441. 

  442.             LADSPA_Data bufferAudio[bufferSize][audioTotal];

  443.             LADSPA_Data bufferParams[parametersTotal];

  444.             LADSPA_Data min, max, def;

  445. 

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

  447.             {

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

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

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

  451. 

  452.                 if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  453.                 {

  454.                     carla_zeroFloat(bufferAudio[iA], bufferSize);

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

  456.                 }

  457.                 else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  458.                 {

  459.                     // min value

  460.                     if (LADSPA_IS_HINT_BOUNDED_BELOW(portRangeHints.HintDescriptor))

  461.                         min = portRangeHints.LowerBound;

  462.                     else

  463.                         min = 0.0f;

  464. 

  465.                     // max value

  466.                     if (LADSPA_IS_HINT_BOUNDED_ABOVE(portRangeHints.HintDescriptor))

  467.                         max = portRangeHints.UpperBound;

  468.                     else

  469.                         max = 1.0f;

  470. 

  471.                     if (min > max)

  472.                     {

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

  474.                         max = min + 0.1f;

  475.                     }

  476.                     else if (max - min == 0.0f)

  477.                     {

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

  479.                         max = min + 0.1f;

  480.                     }

  481. 

  482.                     // default value

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

  484. 

  485.                     if (LADSPA_IS_HINT_SAMPLE_RATE(portRangeHints.HintDescriptor))

  486.                     {

  487.                         min *= sampleRate;

  488.                         max *= sampleRate;

  489.                         def *= sampleRate;

  490.                     }

  491. 

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

  493.                     {

  494.                         // latency parameter

  495.                         def = 0.0f;

  496.                     }

  497.                     else

  498.                     {

  499.                         if (def < min)

  500.                             def = min;

  501.                         else if (def > max)

  502.                             def = max;

  503.                     }

  504. 

  505.                     bufferParams[iC] = def;

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

  507.                 }

  508.             }

  509. 

  510.             if (descriptor->activate)

  511.                 descriptor->activate(handle);

  512. 

  513.             descriptor->run(handle, bufferSize);

  514. 

  515.             if (descriptor->deactivate)

  516.                 descriptor->deactivate(handle);

  517. 

  518.             descriptor->cleanup(handle);

  519. 

  520.             // end crash-free plugin test

  521.             // -----------------------------------------------------------------------

  522.         }

  523. 

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

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

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

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

  528.         DISCOVERY_OUT("copyright", descriptor->Copyright);

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

  530.         DISCOVERY_OUT("hints", hints);

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

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

  533.         DISCOVERY_OUT("audio.total", audioTotal);

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

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

  536.         DISCOVERY_OUT("parameters.total", parametersTotal);

  537.         DISCOVERY_OUT("build", BINARY_NATIVE);

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

  539.     }

  540. #else

  541.     DISCOVERY_OUT("error", "LADSPA support not available");

  542.     Q_UNUSED(libHandle);

  543.     Q_UNUSED(init);

  544. #endif

  545. }

  546. 

  547. void do_dssi_check(void* const libHandle, const bool init)

  548. {

  549. #ifdef WANT_DSSI

  550.     const DSSI_Descriptor_Function descFn = (DSSI_Descriptor_Function)lib_symbol(libHandle, "dssi_descriptor");

  551. 

  552.     if (! descFn)

  553.     {

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

  555.         return;

  556.     }

  557. 

  558.     unsigned long i = 0;

  559.     const DSSI_Descriptor* descriptor;

  560. 

  561.     while ((descriptor = descFn(i++)))

  562.     {

  563.         const LADSPA_Descriptor* const ldescriptor = descriptor->LADSPA_Plugin;

  564. 

  565.         if (! ldescriptor)

  566.         {

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

  568.             continue;

  569.         }

  570.         if (! ldescriptor->instantiate)

  571.         {

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

  573.             continue;

  574.         }

  575.         if (! ldescriptor->cleanup)

  576.         {

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

  578.             continue;

  579.         }

  580.         if (! (ldescriptor->run || descriptor->run_synth || descriptor->run_multiple_synths))

  581.         {

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

  583.             continue;

  584.         }

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

  586.         {

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

  588.         }

  589. 

  590.         int hints = 0;

  591.         int audioIns = 0;

  592.         int audioOuts = 0;

  593.         int audioTotal = 0;

  594.         int midiIns = 0;

  595.         int midiTotal = 0;

  596.         int parametersIns = 0;

  597.         int parametersOuts = 0;

  598.         int parametersTotal = 0;

  599.         int programsTotal = 0;

  600. 

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

  602.             hints |= PLUGIN_IS_RTSAFE;

  603. 

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

  605.         {

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

  607. 

  608.             if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  609.             {

  610.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  611.                     audioIns += 1;

  612.                 else if (LADSPA_IS_PORT_OUTPUT(portDescriptor))

  613.                     audioOuts += 1;

  614. 

  615.                 audioTotal += 1;

  616.             }

  617.             else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  618.             {

  619.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  620.                     parametersIns += 1;

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

  622.                     parametersOuts += 1;

  623. 

  624.                 parametersTotal += 1;

  625.             }

  626.         }

  627. 

  628.         if (descriptor->run_synth || descriptor->run_multiple_synths)

  629.             midiIns = midiTotal = 1;

  630. 

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

  632.             hints |= PLUGIN_IS_SYNTH;

  633. 

  634.         if (init)

  635.         {

  636.             // -----------------------------------------------------------------------

  637.             // start crash-free plugin test

  638. 

  639.             const LADSPA_Handle handle = ldescriptor->instantiate(ldescriptor, sampleRate);

  640. 

  641.             if (! handle)

  642.             {

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

  644.                 continue;

  645.             }

  646. 

  647.             if (descriptor->get_program && descriptor->select_program)

  648.             {

  649.                 while (descriptor->get_program(handle, programsTotal++))

  650.                     continue;

  651.             }

  652. 

  653.             LADSPA_Data bufferAudio[bufferSize][audioTotal];

  654.             LADSPA_Data bufferParams[parametersTotal];

  655.             LADSPA_Data min, max, def;

  656. 

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

  658.             {

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

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

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

  662. 

  663.                 if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  664.                 {

  665.                     carla_zeroFloat(bufferAudio[iA], bufferSize);

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

  667.                 }

  668.                 else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  669.                 {

  670.                     // min value

  671.                     if (LADSPA_IS_HINT_BOUNDED_BELOW(portRangeHints.HintDescriptor))

  672.                         min = portRangeHints.LowerBound;

  673.                     else

  674.                         min = 0.0f;

  675. 

  676.                     // max value

  677.                     if (LADSPA_IS_HINT_BOUNDED_ABOVE(portRangeHints.HintDescriptor))

  678.                         max = portRangeHints.UpperBound;

  679.                     else

  680.                         max = 1.0f;

  681. 

  682.                     if (min > max)

  683.                     {

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

  685.                         max = min + 0.1f;

  686.                     }

  687.                     else if (max - min == 0.0f)

  688.                     {

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

  690.                         max = min + 0.1f;

  691.                     }

  692. 

  693.                     // default value

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

  695. 

  696.                     if (LADSPA_IS_HINT_SAMPLE_RATE(portRangeHints.HintDescriptor))

  697.                     {

  698.                         min *= sampleRate;

  699.                         max *= sampleRate;

  700.                         def *= sampleRate;

  701.                     }

  702. 

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

  704.                     {

  705.                         // latency parameter

  706.                         def = 0.0f;

  707.                     }

  708.                     else

  709.                     {

  710.                         if (def < min)

  711.                             def = min;

  712.                         else if (def > max)

  713.                             def = max;

  714.                     }

  715. 

  716.                     bufferParams[iC] = def;

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

  718.                 }

  719.             }

  720. 

  721.             // select first midi-program if available

  722.             if (programsTotal > 0)

  723.             {

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

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

  726.             }

  727. 

  728.             if (ldescriptor->activate)

  729.                 ldescriptor->activate(handle);

  730. 

  731.             if (descriptor->run_synth || descriptor->run_multiple_synths)

  732.             {

  733.                 snd_seq_event_t midiEvents[2];

  734.                 memset(midiEvents, 0, sizeof(snd_seq_event_t)*2); //FIXME

  735. 

  736.                 const unsigned long midiEventCount = 2;

  737. 

  738.                 midiEvents[0].type = SND_SEQ_EVENT_NOTEON;

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

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

  741. 

  742.                 midiEvents[1].type = SND_SEQ_EVENT_NOTEOFF;

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

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

  745.                 midiEvents[1].time.tick = bufferSize/2;

  746. 

  747.                 if (descriptor->run_multiple_synths && ! descriptor->run_synth)

  748.                 {

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

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

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

  752.                     descriptor->run_multiple_synths(1, handlePtr, bufferSize, midiEventsPtr, midiEventCountPtr);

  753.                 }

  754.                 else

  755.                     descriptor->run_synth(handle, bufferSize, midiEvents, midiEventCount);

  756.             }

  757.             else

  758.                 ldescriptor->run(handle, bufferSize);

  759. 

  760.             if (ldescriptor->deactivate)

  761.                 ldescriptor->deactivate(handle);

  762. 

  763.             ldescriptor->cleanup(handle);

  764. 

  765.             // end crash-free plugin test

  766.             // -----------------------------------------------------------------------

  767.         }

  768. 

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

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

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

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

  773.         DISCOVERY_OUT("copyright", ldescriptor->Copyright);

  774.         DISCOVERY_OUT("unique_id", ldescriptor->UniqueID);

  775.         DISCOVERY_OUT("hints", hints);

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

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

  778.         DISCOVERY_OUT("audio.total", audioTotal);

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

  780.         DISCOVERY_OUT("midi.total", midiTotal);

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

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

  783.         DISCOVERY_OUT("parameters.total", parametersTotal);

  784.         DISCOVERY_OUT("programs.total", programsTotal);

  785.         DISCOVERY_OUT("build", BINARY_NATIVE);

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

  787.     }

  788. #else

  789.     DISCOVERY_OUT("error", "DSSI support not available");

  790.     Q_UNUSED(libHandle);

  791.     Q_UNUSED(init);

  792. #endif

  793. }

  794. 

  795. void do_lv2_check(const char* const bundle, const bool init)

  796. {

  797. #ifdef WANT_LV2

  798.     // Convert bundle filename to URI

  799.     QString qBundle(QUrl::fromLocalFile(bundle).toString());

  800.     if (! qBundle.endsWith(QDir::separator()))

  801.         qBundle += QDir::separator();

  802. 

  803.     // Load bundle

  804.     Lilv::Node lilvBundle(lv2World.new_uri(qBundle.toUtf8().constData()));

  805.     lv2World.load_bundle(lilvBundle);

  806. 

  807.     // Load plugins in this bundle

  808.     const Lilv::Plugins lilvPlugins = lv2World.get_all_plugins();

  809. 

  810.     // Get all plugin URIs in this bundle

  811.     QStringList URIs;

  812. 

  813.     LILV_FOREACH(plugins, i, lilvPlugins)

  814.     {

  815.         Lilv::Plugin lilvPlugin(lilv_plugins_get(lilvPlugins, i));

  816. 

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

  818.             URIs.append(QString(uri));

  819.     }

  820. 

  821.     if (URIs.count() == 0)

  822.     {

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

  824.         return;

  825.     }

  826. 

  827.     // Get & check every plugin-instance

  828.     for (int i=0; i < URIs.count(); i++)

  829.     {

  830.         const LV2_RDF_Descriptor* const rdfDescriptor = lv2_rdf_new(URIs.at(i).toUtf8().constData());

  831.         CARLA_ASSERT(rdfDescriptor && rdfDescriptor->URI);

  832. 

  833.         if (! (rdfDescriptor && rdfDescriptor->URI))

  834.         {

  835.             DISCOVERY_OUT("error", "Failed to find LV2 plugin '" << URIs.at(i).toUtf8().constData() << "'");

  836.             continue;

  837.         }

  838. 

  839.         if (init)

  840.         {

  841.             // test if DLL is loadable, twice

  842.             bool isLoadable = true;

  843. 

  844.             for (int j=0; j < 2; j++)

  845.             {

  846.                 void* const libHandle = lib_open(rdfDescriptor->Binary);

  847. 

  848.                 if (! libHandle)

  849.                 {

  850.                     isLoadable = false;

  851.                     print_lib_error(rdfDescriptor->Binary);

  852.                     delete rdfDescriptor;

  853.                     break;

  854.                 }

  855. 

  856.                 lib_close(libHandle);

  857.             }

  858. 

  859.             if (! isLoadable)

  860.                 continue;

  861.         }

  862. 

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

  864.         {

  865.             bool supported = true;

  866. 

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

  868.             {

  869.                 const LV2_RDF_Port* const rdfPort = &rdfDescriptor->Ports[j];

  870. 

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

  872.                 {

  873.                     pass();

  874.                 }

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

  876.                 {

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

  878.                     supported = false;

  879.                     break;

  880.                 }

  881.             }

  882. 

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

  884.             {

  885.                 const LV2_RDF_Feature* const rdfFeature = &rdfDescriptor->Features[j];

  886. 

  887.                 if (is_lv2_feature_supported(rdfFeature->URI))

  888.                 {

  889.                     pass();

  890.                 }

  891.                 else if (LV2_IS_FEATURE_REQUIRED(rdfFeature->Type))

  892.                 {

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

  894.                     supported = false;

  895.                     break;

  896.                 }

  897.             }

  898. 

  899.             if (! supported)

  900.             {

  901.                 delete rdfDescriptor;

  902.                 continue;

  903.             }

  904.         }

  905. 

  906.         int hints = 0;

  907.         int audioIns = 0;

  908.         int audioOuts = 0;

  909.         int audioTotal = 0;

  910.         int midiIns = 0;

  911.         int midiOuts = 0;

  912.         int midiTotal = 0;

  913.         int parametersIns = 0;

  914.         int parametersOuts = 0;

  915.         int parametersTotal = 0;

  916.         int programsTotal = rdfDescriptor->PresetCount;

  917. 

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

  919.         {

  920.             const LV2_RDF_Feature* const rdfFeature = &rdfDescriptor->Features[j];

  921. 

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

  923.                 hints |= PLUGIN_IS_RTSAFE;

  924.         }

  925. 

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

  927.         {

  928.             const LV2_RDF_Port* const rdfPort = &rdfDescriptor->Ports[j];

  929. 

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

  931.             {

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

  933.                     audioIns += 1;

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

  935.                     audioOuts += 1;

  936. 

  937.                 audioTotal += 1;

  938.             }

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

  940.             {

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

  942.                 {

  943.                     pass();

  944.                 }

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

  946.                 {

  947.                     pass();

  948.                 }

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

  950.                 {

  951.                     pass();

  952.                 }

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

  954.                 {

  955.                     pass();

  956.                 }

  957.                 else

  958.                 {

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

  960.                         parametersIns += 1;

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

  962.                         parametersOuts += 1;

  963. 

  964.                     parametersTotal += 1;

  965.                 }

  966.             }

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

  968.             {

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

  970.                     midiIns += 1;

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

  972.                     midiOuts += 1;

  973. 

  974.                 midiTotal += 1;

  975.             }

  976.         }

  977. 

  978.         if (rdfDescriptor->Type[1] & LV2_PLUGIN_INSTRUMENT)

  979.             hints |= PLUGIN_IS_SYNTH;

  980. 

  981.         if (rdfDescriptor->UICount > 0)

  982.             hints |= PLUGIN_HAS_GUI;

  983. 

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

  985.         DISCOVERY_OUT("label", rdfDescriptor->URI);

  986.         if (rdfDescriptor->Name)

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

  988.         if (rdfDescriptor->Author)

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

  990.         if (rdfDescriptor->License)

  991.             DISCOVERY_OUT("copyright", rdfDescriptor->License);

  992.         DISCOVERY_OUT("unique_id", rdfDescriptor->UniqueID);

  993.         DISCOVERY_OUT("hints", hints);

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

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

  996.         DISCOVERY_OUT("audio.total", audioTotal);

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

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

  999.         DISCOVERY_OUT("midi.total", midiTotal);

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

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

  1002.         DISCOVERY_OUT("parameters.total", parametersTotal);

  1003.         DISCOVERY_OUT("programs.total", programsTotal);

  1004.         DISCOVERY_OUT("build", BINARY_NATIVE);

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

  1006. 

  1007.         delete rdfDescriptor;

  1008.     }

  1009. #else

  1010.     DISCOVERY_OUT("error", "LV2 support not available");

  1011.     Q_UNUSED(bundle);

  1012.     Q_UNUSED(init);

  1013. #endif

  1014. }

  1015. 

  1016. void do_vst_check(void* const libHandle, const bool init)

  1017. {

  1018. #ifdef WANT_VST

  1019.     VST_Function vstFn = (VST_Function)lib_symbol(libHandle, "VSTPluginMain");

  1020. 

  1021.     if (! vstFn)

  1022.     {

  1023.         vstFn = (VST_Function)lib_symbol(libHandle, "main");

  1024. 

  1025.         if (! vstFn)

  1026.         {

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

  1028.             return;

  1029.         }

  1030.     }

  1031. 

  1032.     AEffect* const effect = vstFn(vstHostCallback);

  1033. 

  1034.     if (! (effect && effect->magic == kEffectMagic))

  1035.     {

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

  1037.         return;

  1038.     }

  1039. 

  1040.     char strBuf[STR_MAX] = { 0 };

  1041.     CarlaString cName;

  1042.     CarlaString cProduct;

  1043.     CarlaString cVendor;

  1044. 

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

  1046. 

  1047.     intptr_t vstCategory = effect->dispatcher(effect, effGetPlugCategory, 0, 0, nullptr, 0.0f);

  1048. 

  1049.     if (vstCategory == kPlugCategShell && effect->uniqueID == 0)

  1050.     {

  1051.         if ((vstCurrentUniqueId = effect->dispatcher(effect, effShellGetNextPlugin, 0, 0, strBuf, 0.0f)) != 0)

  1052.             cName = strBuf;

  1053.     }

  1054.     else

  1055.     {

  1056.         vstCurrentUniqueId = effect->uniqueID;

  1057. 

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

  1059.             cName = strBuf;

  1060.     }

  1061. 

  1062.     memset(strBuf, 0, sizeof(char)*STR_MAX); //FIXME

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

  1064.         cVendor = strBuf;

  1065. 

  1066.     // FIXME: Waves crash during processing

  1067.     if (cVendor == "Waves")

  1068.         memset((void*)&init, 0, sizeof(bool)); //FIXME

  1069. 

  1070.     if (vstCurrentUniqueId == 0)

  1071.     {

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

  1073.         return;

  1074.     }

  1075. 

  1076.     while (vstCurrentUniqueId != 0)

  1077.     {

  1078.         memset(strBuf, 0, sizeof(char)*STR_MAX); //FIXME

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

  1080.             cProduct = strBuf;

  1081.         else

  1082.             cProduct.clear();

  1083. 

  1084.         vstWantsMidi = false;

  1085. 

  1086.         int hints = 0;

  1087.         int audioIns = effect->numInputs;

  1088.         int audioOuts = effect->numOutputs;

  1089.         int audioTotal = audioIns + audioOuts;

  1090.         int midiIns = 0;

  1091.         int midiOuts = 0;

  1092.         int midiTotal = 0;

  1093.         int parametersIns = effect->numParams;

  1094.         int parametersTotal = parametersIns;

  1095.         int programsTotal = effect->numPrograms;

  1096. 

  1097.         if (effect->flags & effFlagsHasEditor)

  1098.             hints |= PLUGIN_HAS_GUI;

  1099. 

  1100.         if (effect->flags & effFlagsIsSynth)

  1101.             hints |= PLUGIN_IS_SYNTH;

  1102. 

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

  1104.             midiIns = 1;

  1105. 

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

  1107.             midiOuts = 1;

  1108. 

  1109.         midiTotal = midiIns + midiOuts;

  1110. 

  1111.         // -----------------------------------------------------------------------

  1112.         // start crash-free plugin test

  1113. 

  1114.         if (init)

  1115.         {

  1116. #if ! VST_FORCE_DEPRECATED

  1117.             effect->dispatcher(effect, effSetBlockSizeAndSampleRate, 0, bufferSize, nullptr, sampleRate);

  1118. #endif

  1119.             effect->dispatcher(effect, effSetBlockSize, 0, bufferSize, nullptr, 0.0f);

  1120.             effect->dispatcher(effect, effSetSampleRate, 0, 0, nullptr, sampleRate);

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

  1122. 

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

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

  1125. 

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

  1127.             if (midiIns == 0 && vstWantsMidi)

  1128.             {

  1129.                 midiIns = 1;

  1130.                 midiTotal = midiIns + midiOuts;

  1131.             }

  1132. 

  1133.             float* bufferAudioIn[audioIns];

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

  1135.             {

  1136.                 bufferAudioIn[j] = new float [bufferSize];

  1137.                 carla_zeroFloat(bufferAudioIn[j], bufferSize);

  1138.             }

  1139. 

  1140.             float* bufferAudioOut[audioOuts];

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

  1142.             {

  1143.                 bufferAudioOut[j] = new float [bufferSize];

  1144.                 carla_zeroFloat(bufferAudioOut[j], bufferSize);

  1145.             }

  1146. 

  1147.             struct VstEventsFixed {

  1148.                 int32_t numEvents;

  1149.                 intptr_t reserved;

  1150.                 VstEvent* data[2];

  1151.             };

  1152.             VstEventsFixed events;

  1153.             VstMidiEvent   midiEvents[2];

  1154. 

  1155.             memset(&events, 0, sizeof(VstEventsFixed)); //FIXME

  1156.             memset(midiEvents, 0, sizeof(VstMidiEvent)*2); //FIXME

  1157. 

  1158.             midiEvents[0].type = kVstMidiType;

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

  1160.             midiEvents[0].midiData[0] = MIDI_STATUS_NOTE_ON;

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

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

  1163. 

  1164.             midiEvents[1].type = kVstMidiType;

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

  1166.             midiEvents[1].midiData[0] = MIDI_STATUS_NOTE_OFF;

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

  1168.             midiEvents[1].deltaFrames = bufferSize/2;

  1169. 

  1170.             events.numEvents = 2;

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

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

  1173. 

  1174.             // processing

  1175.             {

  1176.                 vstIsProcessing = true;

  1177. 

  1178.                 if (midiIns > 0)

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

  1180. 

  1181. #if ! VST_FORCE_DEPRECATED

  1182.                 if ((effect->flags & effFlagsCanReplacing) > 0 && effect->processReplacing && effect->processReplacing != effect->process)

  1183.                     effect->processReplacing(effect, bufferAudioIn, bufferAudioOut, bufferSize);

  1184.                 else if (effect->process)

  1185.                     effect->process(effect, bufferAudioIn, bufferAudioOut, bufferSize);

  1186.                 else

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

  1188. #else

  1189.                 CARLA_ASSERT(effect->flags & effFlagsCanReplacing);

  1190.                 if (effect->flags & effFlagsCanReplacing)

  1191.                 {

  1192.                     if (effect->processReplacing)

  1193.                         effect->processReplacing(effect, bufferAudioIn, bufferAudioOut, bufferSize);

  1194.                     else

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

  1196.                 }

  1197.                 else

  1198.                     DISCOVERY_OUT("error", "Plugin doesn't have can't do process replacing");

  1199. #endif

  1200. 

  1201.                 vstIsProcessing = false;

  1202.             }

  1203. 

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

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

  1206. 

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

  1208.                 delete[] bufferAudioIn[j];

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

  1210.                 delete[] bufferAudioOut[j];

  1211.         }

  1212. 

  1213.         // end crash-free plugin test

  1214.         // -----------------------------------------------------------------------

  1215. 

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

  1217.         DISCOVERY_OUT("name", (const char*)cName);

  1218.         DISCOVERY_OUT("label", (const char*)cProduct);

  1219.         DISCOVERY_OUT("maker", (const char*)cVendor);

  1220.         DISCOVERY_OUT("copyright", (const char*)cVendor);

  1221.         DISCOVERY_OUT("unique_id", vstCurrentUniqueId);

  1222.         DISCOVERY_OUT("hints", hints);

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

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

  1225.         DISCOVERY_OUT("audio.total", audioTotal);

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

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

  1228.         DISCOVERY_OUT("midi.total", midiTotal);

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

  1230.         DISCOVERY_OUT("parameters.total", parametersTotal);

  1231.         DISCOVERY_OUT("programs.total", programsTotal);

  1232.         DISCOVERY_OUT("build", BINARY_NATIVE);

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

  1234. 

  1235.         if (vstCategory != kPlugCategShell)

  1236.             break;

  1237. 

  1238.         // request next Unique ID

  1239.         intptr_t nextUniqueId = vstCurrentUniqueId;

  1240. 

  1241.         // FIXME: Waves sometimes return the same ID

  1242.         while (nextUniqueId == vstCurrentUniqueId)

  1243.         {

  1244.             memset(strBuf, 0, sizeof(char)*STR_MAX); //FIXME

  1245.             if ((vstCurrentUniqueId = effect->dispatcher(effect, effShellGetNextPlugin, 0, 0, strBuf, 0.0f)) != 0)

  1246.                 cName = strBuf;

  1247.         }

  1248.     }

  1249. 

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

  1251. #else

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

  1253.     Q_UNUSED(libHandle);

  1254.     Q_UNUSED(init);

  1255. #endif

  1256. }

  1257. 

  1258. void do_fluidsynth_check(const char* const filename, const bool init)

  1259. {

  1260. #ifdef WANT_FLUIDSYNTH

  1261.     if (! fluid_is_soundfont(filename))

  1262.     {

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

  1264.         return;

  1265.     }

  1266. 

  1267.     int programs = 0;

  1268. 

  1269.     if (init)

  1270.     {

  1271.         fluid_settings_t* const f_settings = new_fluid_settings();

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

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

  1274. 

  1275.         if (f_id < 0)

  1276.         {

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

  1278.             return;

  1279.         }

  1280. 

  1281.         fluid_sfont_t* f_sfont;

  1282.         fluid_preset_t f_preset;

  1283. 

  1284.         f_sfont = fluid_synth_get_sfont_by_id(f_synth, f_id);

  1285. 

  1286.         f_sfont->iteration_start(f_sfont);

  1287.         while (f_sfont->iteration_next(f_sfont, &f_preset))

  1288.             programs += 1;

  1289. 

  1290.         delete_fluid_synth(f_synth);

  1291.         delete_fluid_settings(f_settings);

  1292.     }

  1293. 

  1294. #if CARLA_OS_WIN

  1295.     int sep = '\\';

  1296. #else

  1297.     int sep = '/';

  1298. #endif

  1299. 

  1300.     CarlaString name(std::strrchr(filename, sep)+1);

  1301.     name.truncate(name.rfind('.'));

  1302. 

  1303.     CarlaString label(name);

  1304. 

  1305.     // 2 channels

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

  1307.     DISCOVERY_OUT("name", (const char*)name);

  1308.     DISCOVERY_OUT("label", (const char*)label);

  1309.     DISCOVERY_OUT("maker", "");

  1310.     DISCOVERY_OUT("copyright", "");

  1311.     DISCOVERY_OUT("hints", PLUGIN_IS_SYNTH);

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

  1313.     DISCOVERY_OUT("audio.total", 2);

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

  1315.     DISCOVERY_OUT("midi.total", 1);

  1316.     DISCOVERY_OUT("programs.total", programs);

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

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

  1319.     DISCOVERY_OUT("parameters.total", 14);

  1320.     DISCOVERY_OUT("build", BINARY_NATIVE);

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

  1322. 

  1323.     // 16 channels

  1324.     if (name.isNotEmpty())

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

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

  1327.     DISCOVERY_OUT("name", "");

  1328.     DISCOVERY_OUT("name", (const char*)name);

  1329.     DISCOVERY_OUT("label", (const char*)label);

  1330.     DISCOVERY_OUT("copyright", "");

  1331.     DISCOVERY_OUT("hints", PLUGIN_IS_SYNTH);

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

  1333.     DISCOVERY_OUT("audio.total", 32);

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

  1335.     DISCOVERY_OUT("midi.total", 1);

  1336.     DISCOVERY_OUT("programs.total", programs);

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

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

  1339.     DISCOVERY_OUT("parameters.total", 14);

  1340.     DISCOVERY_OUT("build", BINARY_NATIVE);

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

  1342. #else

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

  1344.     Q_UNUSED(filename);

  1345.     Q_UNUSED(init);

  1346. #endif

  1347. }

  1348. 

  1349. void do_linuxsampler_check(const char* const filename, const char* const stype, const bool init)

  1350. {

  1351. #ifdef WANT_LINUXSAMPLER

  1352.     const QFileInfo file(filename);

  1353. 

  1354.     if (! file.exists())

  1355.     {

  1356.         DISCOVERY_OUT("error", "Requested file does not exist");

  1357.         return;

  1358.     }

  1359. 

  1360.     if (! file.isFile())

  1361.     {

  1362.         DISCOVERY_OUT("error", "Requested file is not valid");

  1363.         return;

  1364.     }

  1365. 

  1366.     if (! file.isReadable())

  1367.     {

  1368.         DISCOVERY_OUT("error", "Requested file is not readable");

  1369.         return;

  1370.     }

  1371. 

  1372.     if (init)

  1373.         const LinuxSamplerScopedEngine engine(filename, stype);

  1374.     else

  1375.         LinuxSamplerScopedEngine::outputInfo(nullptr, 0, file.baseName().toUtf8().constData());

  1376. #else

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

  1378.     Q_UNUSED(filename);

  1379.     Q_UNUSED(init);

  1380. #endif

  1381. }

  1382. 

  1383. // ------------------------------ main entry point ------------------------------

  1384. 

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

  1386. {

  1387.     if (argc == 2 && std::strcmp(argv[1], "-formats") == 0)

  1388.     {

  1389.         printf("Available plugin formats:\n");

  1390.         printf("LADSPA: ");

  1391. #ifdef WANT_LADSPA

  1392.         printf("yes\n");

  1393. #else

  1394.         printf("no\n");

  1395. #endif

  1396.         printf("DSSI:   ");

  1397. #ifdef WANT_DSSI

  1398.         printf("yes\n");

  1399. #else

  1400.         printf("no\n");

  1401. #endif

  1402.         printf("LV2:    ");

  1403. #ifdef WANT_LV2

  1404.         printf("yes\n");

  1405. #else

  1406.         printf("no\n");

  1407. #endif

  1408.         printf("VST:    ");

  1409. #ifdef WANT_VST

  1410.         printf("yes\n");

  1411. #else

  1412.         printf("no\n");

  1413. #endif

  1414.         printf("\n");

  1415. 

  1416.         printf("Available sampler formats:\n");

  1417.         printf("GIG (LinuxSampler): ");

  1418. #ifdef WANT_LINUXSAMPLER

  1419.         printf("yes\n");

  1420. #else

  1421.         printf("no\n");

  1422. #endif

  1423.         printf("SF2 (FluidSynth):   ");

  1424. #ifdef WANT_FLUIDSYNTH

  1425.         printf("yes\n");

  1426. #else

  1427.         printf("no\n");

  1428. #endif

  1429.         printf("SFZ (LinuxSampler): ");

  1430. #ifdef WANT_LINUXSAMPLER

  1431.         printf("yes\n");

  1432. #else

  1433.         printf("no\n");

  1434. #endif

  1435.         return 0;

  1436.     }

  1437. 

  1438.     if (argc != 3)

  1439.     {

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

  1441.         return 1;

  1442.     }

  1443. 

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

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

  1446. 

  1447.     bool openLib;

  1448.     PluginType type;

  1449.     void* handle = nullptr;

  1450. 

  1451.     if (std::strcmp(stype, "LADSPA") == 0)

  1452.     {

  1453.         openLib = true;

  1454.         type = PLUGIN_LADSPA;

  1455.     }

  1456.     else if (std::strcmp(stype, "DSSI") == 0)

  1457.     {

  1458.         openLib = true;

  1459.         type = PLUGIN_DSSI;

  1460.     }

  1461.     else if (std::strcmp(stype, "LV2") == 0)

  1462.     {

  1463.         openLib = false;

  1464.         type = PLUGIN_LV2;

  1465.     }

  1466.     else if (std::strcmp(stype, "VST") == 0)

  1467.     {

  1468.         openLib = true;

  1469.         type = PLUGIN_VST;

  1470.     }

  1471.     else if (std::strcmp(stype, "GIG") == 0)

  1472.     {

  1473.         openLib = false;

  1474.         type = PLUGIN_GIG;

  1475.     }

  1476.     else if (std::strcmp(stype, "SF2") == 0)

  1477.     {

  1478.         openLib = false;

  1479.         type = PLUGIN_SF2;

  1480.     }

  1481.     else if (std::strcmp(stype, "SFZ") == 0)

  1482.     {

  1483.         openLib = false;

  1484.         type = PLUGIN_SFZ;

  1485.     }

  1486.     else

  1487.     {

  1488.         DISCOVERY_OUT("error", "Invalid plugin type");

  1489.         return 1;

  1490.     }

  1491. 

  1492.     if (openLib)

  1493.     {

  1494.         handle = lib_open(filename);

  1495. 

  1496.         if (! handle)

  1497.         {

  1498.             print_lib_error(filename);

  1499.             return 1;

  1500.         }

  1501.     }

  1502. 

  1503.     bool doInit = ! QString(filename).endsWith("dssi-vst.so", Qt::CaseInsensitive);

  1504. 

  1505.     if (doInit && getenv("CARLA_DISCOVERY_NO_PROCESSING_CHECKS"))

  1506.         doInit = false;

  1507. 

  1508.     if (doInit && handle)

  1509.     {

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

  1511. 

  1512.         if (! lib_close(handle))

  1513.         {

  1514.             print_lib_error(filename);

  1515.             return 1;

  1516.         }

  1517. 

  1518.         handle = lib_open(filename);

  1519. 

  1520.         if (! handle)

  1521.         {

  1522.             print_lib_error(filename);

  1523.             return 1;

  1524.         }

  1525.     }

  1526. 

  1527.     switch (type)

  1528.     {

  1529.     case PLUGIN_LADSPA:

  1530.         do_ladspa_check(handle, doInit);

  1531.         break;

  1532.     case PLUGIN_DSSI:

  1533.         do_dssi_check(handle, doInit);

  1534.         break;

  1535.     case PLUGIN_LV2:

  1536.         do_lv2_check(filename, doInit);

  1537.         break;

  1538.     case PLUGIN_VST:

  1539.         do_vst_check(handle, doInit);

  1540.         break;

  1541.     case PLUGIN_GIG:

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

  1543.         break;

  1544.     case PLUGIN_SF2:

  1545.         do_fluidsynth_check(filename, doInit);

  1546.         break;

  1547.     case PLUGIN_SFZ:

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

  1549.         break;

  1550.     default:

  1551.         break;

  1552.     }

  1553. 

  1554.     if (openLib && handle)

  1555.         lib_close(handle);

  1556. 

  1557.     return 0;

  1558. }