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

1521 lines
47KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin discovery code

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

  4.  *

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

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

  7.  * the Free Software Foundation; either version 2 of the License, or

  8.  * 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 COPYING file

  16.  */

  17. 

  18. #include "carla_backend.hpp"

  19. #include "carla_juce_utils.hpp"

  20. #include "carla_lib_utils.hpp"

  21. #include "carla_midi.h"

  22. 

  23. #ifdef WANT_LADSPA

  24. # include "carla_ladspa_utils.hpp"

  25. #endif

  26. #ifdef WANT_DSSI

  27. # include "carla_ladspa_utils.hpp"

  28. # include "dssi/dssi.h"

  29. #endif

  30. #ifdef WANT_LV2

  31. # include <QtCore/QDir>

  32. # include <QtCore/QUrl>

  33. # include "carla_lv2_utils.hpp"

  34. #endif

  35. #ifdef WANT_VST

  36. # include "carla_vst_utils.hpp"

  37. #endif

  38. #ifdef WANT_FLUIDSYNTH

  39. # include <fluidsynth.h>

  40. #endif

  41. #ifdef WANT_LINUXSAMPLER

  42. # include <QtCore/QFileInfo>

  43. # include "linuxsampler/EngineFactory.h"

  44. #endif

  45. 

  46. #include <iostream>

  47. 

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

  49. 

  50. CARLA_BACKEND_USE_NAMESPACE

  51. 

  52. #ifdef WANT_LV2

  53. // --------------------------------------------------------------------------

  54. // Our LV2 World class object

  55. 

  56. Lv2WorldClass lv2World;

  57. #endif

  58. 

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

  60. // Dummy values to test plugins with

  61. 

  62. const uint32_t bufferSize = 512;

  63. const double   sampleRate = 44100.0;

  64. 

  65. // --------------------------------------------------------------------------

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

  67. 

  68. void print_lib_error(const char* const filename)

  69. {

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

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

  72.         DISCOVERY_OUT("error", error);

  73. }

  74. 

  75. // --------------------------------------------------------------------------

  76. // VST stuff

  77. 

  78. #ifdef WANT_VST

  79. // Check if plugin wants midi

  80. bool vstWantsMidi = false;

  81. 

  82. // Check if plugin is processing

  83. bool vstIsProcessing = false;

  84. 

  85. // Current uniqueId for vst shell plugins

  86. intptr_t vstCurrentUniqueId = 0;

  87. 

  88. // Supported Carla features

  89. intptr_t vstHostCanDo(const char* const feature)

  90. {

  91. #if DEBUG

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

  93. #endif

  94. 

  95.     if (strcmp(feature, "supplyIdle") == 0)

  96.         return 1;

  97.     if (strcmp(feature, "sendVstEvents") == 0)

  98.         return 1;

  99.     if (strcmp(feature, "sendVstMidiEvent") == 0)

  100.         return 1;

  101.     if (strcmp(feature, "sendVstMidiEventFlagIsRealtime") == 0)

  102.         return 1;

  103.     if (strcmp(feature, "sendVstTimeInfo") == 0)

  104.         return 1;

  105.     if (strcmp(feature, "receiveVstEvents") == 0)

  106.         return 1;

  107.     if (strcmp(feature, "receiveVstMidiEvent") == 0)

  108.         return 1;

  109.     if (strcmp(feature, "receiveVstTimeInfo") == 0)

  110.         return -1;

  111.     if (strcmp(feature, "reportConnectionChanges") == 0)

  112.         return -1;

  113.     if (strcmp(feature, "acceptIOChanges") == 0)

  114.         return 1;

  115.     if (strcmp(feature, "sizeWindow") == 0)

  116.         return 1;

  117.     if (strcmp(feature, "offline") == 0)

  118.         return -1;

  119.     if (strcmp(feature, "openFileSelector") == 0)

  120.         return -1;

  121.     if (strcmp(feature, "closeFileSelector") == 0)

  122.         return -1;

  123.     if (strcmp(feature, "startStopProcess") == 0)

  124.         return 1;

  125.     if (strcmp(feature, "supportShell") == 0)

  126.         return 1;

  127.     if (strcmp(feature, "shellCategory") == 0)

  128.         return 1;

  129. 

  130.     // unimplemented

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

  132.     return 0;

  133. }

  134. 

  135. // Host-side callback

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

  137. {

  138. #if DEBUG

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

  140. #endif

  141. 

  142.     intptr_t ret = 0;

  143. 

  144.     switch (opcode)

  145.     {

  146.     case audioMasterAutomate:

  147.         if (effect)

  148.         {

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

  150.             ret = 1;

  151.         }

  152.         break;

  153. 

  154.     case audioMasterVersion:

  155.         ret = kVstVersion;

  156.         break;

  157. 

  158.     case audioMasterCurrentId:

  159.         ret = vstCurrentUniqueId;

  160.         break;

  161. 

  162. #if ! VST_FORCE_DEPRECATED

  163.     case audioMasterWantMidi:

  164.         vstWantsMidi = true;

  165.         ret = 1;

  166.         break;

  167. #endif

  168. 

  169.     case audioMasterGetTime:

  170.         static VstTimeInfo_R timeInfo;

  171.         memset(&timeInfo, 0, sizeof(VstTimeInfo_R));

  172.         timeInfo.sampleRate = sampleRate;

  173. 

  174.         // Tempo

  175.         timeInfo.tempo  = 120.0;

  176.         timeInfo.flags |= kVstTempoValid;

  177. 

  178.         // Time Signature

  179.         timeInfo.timeSigNumerator   = 4;

  180.         timeInfo.timeSigDenominator = 4;

  181.         timeInfo.flags |= kVstTimeSigValid;

  182. 

  183.         ret = (intptr_t)&timeInfo;

  184.         break;

  185. 

  186. #if ! VST_FORCE_DEPRECATED

  187.     case audioMasterTempoAt:

  188.         ret = 120 * 10000;

  189.         break;

  190. 

  191.     case audioMasterGetNumAutomatableParameters:

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

  193.         break;

  194. 

  195.     case audioMasterGetParameterQuantization:

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

  197.         break;

  198. #endif

  199. 

  200.     case audioMasterGetSampleRate:

  201.         ret = sampleRate;

  202.         break;

  203. 

  204.     case audioMasterGetBlockSize:

  205.         ret = bufferSize;

  206.         break;

  207. 

  208. #if ! VST_FORCE_DEPRECATED

  209.     case audioMasterWillReplaceOrAccumulate:

  210.         ret = 1; // replace

  211.         break;

  212. #endif

  213. 

  214.     case audioMasterGetCurrentProcessLevel:

  215.         ret = vstIsProcessing ? kVstProcessLevelRealtime : kVstProcessLevelUser;

  216.         break;

  217. 

  218.     case audioMasterGetAutomationState:

  219.         ret = kVstAutomationOff;

  220.         break;

  221. 

  222.     case audioMasterGetVendorString:

  223.         if (ptr)

  224.         {

  225.             strcpy((char*)ptr, "falkTX");

  226.             ret = 1;

  227.         }

  228.         break;

  229. 

  230.     case audioMasterGetProductString:

  231.         if (ptr)

  232.         {

  233.             strcpy((char*)ptr, "Carla-Discovery");

  234.             ret = 1;

  235.         }

  236.         break;

  237. 

  238.     case audioMasterGetVendorVersion:

  239.         ret = 0x050; // 0.5.0

  240.         break;

  241. 

  242.     case audioMasterCanDo:

  243.         if (ptr)

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

  245.         break;

  246. 

  247.     case audioMasterGetLanguage:

  248.         ret = kVstLangEnglish;

  249.         break;

  250. 

  251.     default:

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

  253.         break;

  254.     }

  255. 

  256.     return ret;

  257. }

  258. #endif

  259. 

  260. // ------------------------------ Plugin Checks -----------------------------

  261. 

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

  263. {

  264. #ifdef WANT_LADSPA

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

  266. 

  267.     if (! descFn)

  268.     {

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

  270.         return;

  271.     }

  272. 

  273.     unsigned long i = 0;

  274.     const LADSPA_Descriptor* descriptor;

  275. 

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

  277.     {

  278.         if (! descriptor->instantiate)

  279.         {

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

  281.             continue;

  282.         }

  283.         if (! descriptor->cleanup)

  284.         {

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

  286.             continue;

  287.         }

  288.         if (! descriptor->run)

  289.         {

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

  291.             continue;

  292.         }

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

  294.         {

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

  296.         }

  297. 

  298.         int hints = 0;

  299.         int audioIns = 0;

  300.         int audioOuts = 0;

  301.         int audioTotal = 0;

  302.         int parametersIns = 0;

  303.         int parametersOuts = 0;

  304.         int parametersTotal = 0;

  305. 

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

  307.             hints |= PLUGIN_IS_RTSAFE;

  308. 

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

  310.         {

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

  312. 

  313.             if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  314.             {

  315.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  316.                     audioIns += 1;

  317.                 else if (LADSPA_IS_PORT_OUTPUT(portDescriptor))

  318.                     audioOuts += 1;

  319. 

  320.                 audioTotal += 1;

  321.             }

  322.             else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  323.             {

  324.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  325.                     parametersIns += 1;

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

  327.                     parametersOuts += 1;

  328. 

  329.                 parametersTotal += 1;

  330.             }

  331.         }

  332. 

  333.         if (init)

  334.         {

  335.             // -----------------------------------------------------------------------

  336.             // start crash-free plugin test

  337. 

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

  339. 

  340.             if (! handle)

  341.             {

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

  343.                 continue;

  344.             }

  345. 

  346.             LADSPA_Data bufferAudio[bufferSize][audioTotal];

  347.             LADSPA_Data bufferParams[parametersTotal];

  348.             LADSPA_Data min, max, def;

  349. 

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

  351.             {

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

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

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

  355. 

  356.                 if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  357.                 {

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

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

  360.                 }

  361.                 else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  362.                 {

  363.                     // min value

  364.                     if (LADSPA_IS_HINT_BOUNDED_BELOW(portRangeHints.HintDescriptor))

  365.                         min = portRangeHints.LowerBound;

  366.                     else

  367.                         min = 0.0f;

  368. 

  369.                     // max value

  370.                     if (LADSPA_IS_HINT_BOUNDED_ABOVE(portRangeHints.HintDescriptor))

  371.                         max = portRangeHints.UpperBound;

  372.                     else

  373.                         max = 1.0f;

  374. 

  375.                     if (min > max)

  376.                     {

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

  378.                         max = min + 0.1f;

  379.                     }

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

  381.                     {

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

  383.                         max = min + 0.1f;

  384.                     }

  385. 

  386.                     // default value

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

  388. 

  389.                     if (LADSPA_IS_HINT_SAMPLE_RATE(portRangeHints.HintDescriptor))

  390.                     {

  391.                         min *= sampleRate;

  392.                         max *= sampleRate;

  393.                         def *= sampleRate;

  394.                     }

  395. 

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

  397.                     {

  398.                         // latency parameter

  399.                         def = 0.0f;

  400.                     }

  401.                     else

  402.                     {

  403.                         if (def < min)

  404.                             def = min;

  405.                         else if (def > max)

  406.                             def = max;

  407.                     }

  408. 

  409.                     bufferParams[iC] = def;

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

  411.                 }

  412.             }

  413. 

  414.             if (descriptor->activate)

  415.                 descriptor->activate(handle);

  416. 

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

  418. 

  419.             if (descriptor->deactivate)

  420.                 descriptor->deactivate(handle);

  421. 

  422.             descriptor->cleanup(handle);

  423. 

  424.             // end crash-free plugin test

  425.             // -----------------------------------------------------------------------

  426.         }

  427. 

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

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

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

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

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

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

  434.         DISCOVERY_OUT("hints", hints);

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

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

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

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

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

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

  441.         DISCOVERY_OUT("build", BINARY_NATIVE);

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

  443.     }

  444. #else

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

  446.     Q_UNUSED(libHandle);

  447.     Q_UNUSED(init);

  448. #endif

  449. }

  450. 

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

  452. {

  453. #ifdef WANT_DSSI

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

  455. 

  456.     if (! descFn)

  457.     {

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

  459.         return;

  460.     }

  461. 

  462.     unsigned long i = 0;

  463.     const DSSI_Descriptor* descriptor;

  464. 

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

  466.     {

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

  468. 

  469.         if (! ldescriptor)

  470.         {

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

  472.             continue;

  473.         }

  474.         if (! ldescriptor->instantiate)

  475.         {

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

  477.             continue;

  478.         }

  479.         if (! ldescriptor->cleanup)

  480.         {

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

  482.             continue;

  483.         }

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

  485.         {

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

  487.             continue;

  488.         }

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

  490.         {

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

  492.         }

  493. 

  494.         int hints = 0;

  495.         int audioIns = 0;

  496.         int audioOuts = 0;

  497.         int audioTotal = 0;

  498.         int midiIns = 0;

  499.         int midiTotal = 0;

  500.         int parametersIns = 0;

  501.         int parametersOuts = 0;

  502.         int parametersTotal = 0;

  503.         int programsTotal = 0;

  504. 

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

  506.             hints |= PLUGIN_IS_RTSAFE;

  507. 

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

  509.         {

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

  511. 

  512.             if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  513.             {

  514.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  515.                     audioIns += 1;

  516.                 else if (LADSPA_IS_PORT_OUTPUT(portDescriptor))

  517.                     audioOuts += 1;

  518. 

  519.                 audioTotal += 1;

  520.             }

  521.             else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  522.             {

  523.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  524.                     parametersIns += 1;

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

  526.                     parametersOuts += 1;

  527. 

  528.                 parametersTotal += 1;

  529.             }

  530.         }

  531. 

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

  533.             midiIns = midiTotal = 1;

  534. 

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

  536.             hints |= PLUGIN_IS_SYNTH;

  537. 

  538.         if (init)

  539.         {

  540.             // -----------------------------------------------------------------------

  541.             // start crash-free plugin test

  542. 

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

  544. 

  545.             if (! handle)

  546.             {

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

  548.                 continue;

  549.             }

  550. 

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

  552.             {

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

  554.                     continue;

  555.             }

  556. 

  557.             LADSPA_Data bufferAudio[bufferSize][audioTotal];

  558.             LADSPA_Data bufferParams[parametersTotal];

  559.             LADSPA_Data min, max, def;

  560. 

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

  562.             {

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

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

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

  566. 

  567.                 if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  568.                 {

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

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

  571.                 }

  572.                 else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  573.                 {

  574.                     // min value

  575.                     if (LADSPA_IS_HINT_BOUNDED_BELOW(portRangeHints.HintDescriptor))

  576.                         min = portRangeHints.LowerBound;

  577.                     else

  578.                         min = 0.0f;

  579. 

  580.                     // max value

  581.                     if (LADSPA_IS_HINT_BOUNDED_ABOVE(portRangeHints.HintDescriptor))

  582.                         max = portRangeHints.UpperBound;

  583.                     else

  584.                         max = 1.0f;

  585. 

  586.                     if (min > max)

  587.                     {

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

  589.                         max = min + 0.1f;

  590.                     }

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

  592.                     {

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

  594.                         max = min + 0.1f;

  595.                     }

  596. 

  597.                     // default value

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

  599. 

  600.                     if (LADSPA_IS_HINT_SAMPLE_RATE(portRangeHints.HintDescriptor))

  601.                     {

  602.                         min *= sampleRate;

  603.                         max *= sampleRate;

  604.                         def *= sampleRate;

  605.                     }

  606. 

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

  608.                     {

  609.                         // latency parameter

  610.                         def = 0.0f;

  611.                     }

  612.                     else

  613.                     {

  614.                         if (def < min)

  615.                             def = min;

  616.                         else if (def > max)

  617.                             def = max;

  618.                     }

  619. 

  620.                     bufferParams[iC] = def;

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

  622.                 }

  623.             }

  624. 

  625.             // select first midi-program if available

  626.             if (programsTotal > 0)

  627.             {

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

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

  630.             }

  631. 

  632.             if (ldescriptor->activate)

  633.                 ldescriptor->activate(handle);

  634. 

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

  636.             {

  637.                 snd_seq_event_t midiEvents[2];

  638.                 memset(midiEvents, 0, sizeof(snd_seq_event_t)*2);

  639. 

  640.                 const unsigned long midiEventCount = 2;

  641. 

  642.                 midiEvents[0].type = SND_SEQ_EVENT_NOTEON;

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

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

  645. 

  646.                 midiEvents[1].type = SND_SEQ_EVENT_NOTEOFF;

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

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

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

  650. 

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

  652.                 {

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

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

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

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

  657.                 }

  658.                 else

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

  660.             }

  661.             else

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

  663. 

  664.             if (ldescriptor->deactivate)

  665.                 ldescriptor->deactivate(handle);

  666. 

  667.             ldescriptor->cleanup(handle);

  668. 

  669.             // end crash-free plugin test

  670.             // -----------------------------------------------------------------------

  671.         }

  672. 

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

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

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

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

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

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

  679.         DISCOVERY_OUT("hints", hints);

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

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

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

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

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

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

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

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

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

  689.         DISCOVERY_OUT("build", BINARY_NATIVE);

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

  691.     }

  692. #else

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

  694.     Q_UNUSED(libHandle);

  695.     Q_UNUSED(init);

  696. #endif

  697. }

  698. 

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

  700. {

  701. #ifdef WANT_LV2

  702.     // Convert bundle filename to URI

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

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

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

  706. 

  707.     // Load bundle

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

  709.     lv2World.load_bundle(lilvBundle);

  710. 

  711.     // Load plugins in this bundle

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

  713. 

  714.     // Get all plugin URIs in this bundle

  715.     QStringList URIs;

  716. 

  717.     LILV_FOREACH(plugins, i, lilvPlugins)

  718.     {

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

  720. 

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

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

  723.     }

  724. 

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

  726.     {

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

  728.         return;

  729.     }

  730. 

  731.     // Get & check every plugin-instance

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

  733.     {

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

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

  736. 

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

  738.         {

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

  740.             continue;

  741.         }

  742. 

  743.         if (init)

  744.         {

  745.             // test if DLL is loadable, twice

  746.             bool isLoadable = true;

  747. 

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

  749.             {

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

  751. 

  752.                 if (! libHandle)

  753.                 {

  754.                     isLoadable = false;

  755.                     print_lib_error(rdfDescriptor->Binary);

  756.                     delete rdfDescriptor;

  757.                     break;

  758.                 }

  759. 

  760.                 lib_close(libHandle);

  761.             }

  762. 

  763.             if (! isLoadable)

  764.                 continue;

  765.         }

  766. 

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

  768.         {

  769.             bool supported = true;

  770. 

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

  772.             {

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

  774. 

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

  776.                 {

  777.                     pass();

  778.                 }

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

  780.                 {

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

  782.                     supported = false;

  783.                     break;

  784.                 }

  785.             }

  786. 

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

  788.             {

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

  790. 

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

  792.                 {

  793.                     pass();

  794.                 }

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

  796.                 {

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

  798.                     supported = false;

  799.                     break;

  800.                 }

  801.             }

  802. 

  803.             if (! supported)

  804.             {

  805.                 delete rdfDescriptor;

  806.                 continue;

  807.             }

  808.         }

  809. 

  810.         int hints = 0;

  811.         int audioIns = 0;

  812.         int audioOuts = 0;

  813.         int audioTotal = 0;

  814.         int midiIns = 0;

  815.         int midiOuts = 0;

  816.         int midiTotal = 0;

  817.         int parametersIns = 0;

  818.         int parametersOuts = 0;

  819.         int parametersTotal = 0;

  820.         int programsTotal = rdfDescriptor->PresetCount;

  821. 

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

  823.         {

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

  825. 

  826.             if (strcmp(rdfFeature->URI, LV2_CORE__hardRTCapable) == 0)

  827.                 hints |= PLUGIN_IS_RTSAFE;

  828.         }

  829. 

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

  831.         {

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

  833. 

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

  835.             {

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

  837.                     audioIns += 1;

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

  839.                     audioOuts += 1;

  840. 

  841.                 audioTotal += 1;

  842.             }

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

  844.             {

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

  846.                 {

  847.                     pass();

  848.                 }

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

  850.                 {

  851.                     pass();

  852.                 }

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

  854.                 {

  855.                     pass();

  856.                 }

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

  858.                 {

  859.                     pass();

  860.                 }

  861.                 else

  862.                 {

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

  864.                         parametersIns += 1;

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

  866.                         parametersOuts += 1;

  867. 

  868.                     parametersTotal += 1;

  869.                 }

  870.             }

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

  872.             {

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

  874.                     midiIns += 1;

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

  876.                     midiOuts += 1;

  877. 

  878.                 midiTotal += 1;

  879.             }

  880.         }

  881. 

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

  883.             hints |= PLUGIN_IS_SYNTH;

  884. 

  885.         if (rdfDescriptor->UICount > 0)

  886.             hints |= PLUGIN_HAS_GUI;

  887. 

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

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

  890.         if (rdfDescriptor->Name)

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

  892.         if (rdfDescriptor->Author)

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

  894.         if (rdfDescriptor->License)

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

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

  897.         DISCOVERY_OUT("hints", hints);

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

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

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

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

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

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

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

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

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

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

  908.         DISCOVERY_OUT("build", BINARY_NATIVE);

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

  910. 

  911.         delete rdfDescriptor;

  912.     }

  913. #else

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

  915.     Q_UNUSED(bundle);

  916.     Q_UNUSED(init);

  917. #endif

  918. }

  919. 

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

  921. {

  922. #ifdef WANT_VST

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

  924. 

  925.     if (! vstFn)

  926.     {

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

  928. 

  929.         if (! vstFn)

  930.         {

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

  932.             return;

  933.         }

  934.     }

  935. 

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

  937. 

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

  939.     {

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

  941.         return;

  942.     }

  943. 

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

  945.     CarlaString cName;

  946.     CarlaString cProduct;

  947.     CarlaString cVendor;

  948. 

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

  950. 

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

  952. 

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

  954.     {

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

  956.             cName = strBuf;

  957.     }

  958.     else

  959.     {

  960.         vstCurrentUniqueId = effect->uniqueID;

  961. 

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

  963.             cName = strBuf;

  964.     }

  965. 

  966.     memset(strBuf, 0, sizeof(char)*STR_MAX);

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

  968.         cVendor = strBuf;

  969. 

  970.     // FIXME: Waves crash during processing

  971.     if (cVendor == "Waves")

  972.         memset((void*)&init, 0, sizeof(bool));

  973. 

  974.     if (vstCurrentUniqueId == 0)

  975.     {

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

  977.         return;

  978.     }

  979. 

  980.     while (vstCurrentUniqueId != 0)

  981.     {

  982.         memset(strBuf, 0, sizeof(char)*STR_MAX);

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

  984.             cProduct = strBuf;

  985.         else

  986.             cProduct.clear();

  987. 

  988.         vstWantsMidi = false;

  989. 

  990.         int hints = 0;

  991.         int audioIns = effect->numInputs;

  992.         int audioOuts = effect->numOutputs;

  993.         int audioTotal = audioIns + audioOuts;

  994.         int midiIns = 0;

  995.         int midiOuts = 0;

  996.         int midiTotal = 0;

  997.         int parametersIns = effect->numParams;

  998.         int parametersTotal = parametersIns;

  999.         int programsTotal = effect->numPrograms;

  1000. 

  1001.         if (effect->flags & effFlagsHasEditor)

  1002.             hints |= PLUGIN_HAS_GUI;

  1003. 

  1004.         if (effect->flags & effFlagsIsSynth)

  1005.             hints |= PLUGIN_IS_SYNTH;

  1006. 

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

  1008.             midiIns = 1;

  1009. 

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

  1011.             midiOuts = 1;

  1012. 

  1013.         midiTotal = midiIns + midiOuts;

  1014. 

  1015.         // -----------------------------------------------------------------------

  1016.         // start crash-free plugin test

  1017. 

  1018.         if (init)

  1019.         {

  1020. #if ! VST_FORCE_DEPRECATED

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

  1022. #endif

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

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

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

  1026. 

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

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

  1029. 

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

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

  1032.             {

  1033.                 midiIns = 1;

  1034.                 midiTotal = midiIns + midiOuts;

  1035.             }

  1036. 

  1037.             float* bufferAudioIn[audioIns];

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

  1039.             {

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

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

  1042.             }

  1043. 

  1044.             float* bufferAudioOut[audioOuts];

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

  1046.             {

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

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

  1049.             }

  1050. 

  1051.             struct VstEventsFixed {

  1052.                 int32_t numEvents;

  1053.                 intptr_t reserved;

  1054.                 VstEvent* data[2];

  1055.             };

  1056.             VstEventsFixed events;

  1057.             VstMidiEvent   midiEvents[2];

  1058. 

  1059.             memset(&events, 0, sizeof(VstEventsFixed));

  1060.             memset(midiEvents, 0, sizeof(VstMidiEvent)*2);

  1061. 

  1062.             midiEvents[0].type = kVstMidiType;

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

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

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

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

  1067. 

  1068.             midiEvents[1].type = kVstMidiType;

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

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

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

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

  1073. 

  1074.             events.numEvents = 2;

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

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

  1077. 

  1078.             // processing

  1079.             {

  1080.                 vstIsProcessing = true;

  1081. 

  1082.                 if (midiIns > 0)

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

  1084. 

  1085. #if ! VST_FORCE_DEPRECATED

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

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

  1088.                 else if (effect->process)

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

  1090.                 else

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

  1092. #else

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

  1094.                 if (effect->flags & effFlagsCanReplacing)

  1095.                 {

  1096.                     if (effect->processReplacing)

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

  1098.                     else

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

  1100.                 }

  1101.                 else

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

  1103. #endif

  1104. 

  1105.                 vstIsProcessing = false;

  1106.             }

  1107. 

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

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

  1110. 

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

  1112.                 delete[] bufferAudioIn[j];

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

  1114.                 delete[] bufferAudioOut[j];

  1115.         }

  1116. 

  1117.         // end crash-free plugin test

  1118.         // -----------------------------------------------------------------------

  1119. 

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

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

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

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

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

  1125.         DISCOVERY_OUT("unique_id", vstCurrentUniqueId);

  1126.         DISCOVERY_OUT("hints", hints);

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

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

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

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

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

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

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

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

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

  1136.         DISCOVERY_OUT("build", BINARY_NATIVE);

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

  1138. 

  1139.         if (vstCategory != kPlugCategShell)

  1140.             break;

  1141. 

  1142.         // request next Unique ID

  1143.         intptr_t nextUniqueId = vstCurrentUniqueId;

  1144. 

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

  1146.         while (nextUniqueId == vstCurrentUniqueId)

  1147.         {

  1148.             memset(strBuf, 0, sizeof(char)*STR_MAX);

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

  1150.                 cName = strBuf;

  1151.         }

  1152.     }

  1153. 

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

  1155. #else

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

  1157.     Q_UNUSED(libHandle);

  1158.     Q_UNUSED(init);

  1159. #endif

  1160. }

  1161. 

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

  1163. {

  1164. #ifdef WANT_FLUIDSYNTH

  1165.     if (! fluid_is_soundfont(filename))

  1166.     {

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

  1168.         return;

  1169.     }

  1170. 

  1171.     int programs = 0;

  1172. 

  1173.     if (init)

  1174.     {

  1175.         fluid_settings_t* const f_settings = new_fluid_settings();

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

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

  1178. 

  1179.         if (f_id < 0)

  1180.         {

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

  1182.             return;

  1183.         }

  1184. 

  1185.         fluid_sfont_t* f_sfont;

  1186.         fluid_preset_t f_preset;

  1187. 

  1188.         f_sfont = fluid_synth_get_sfont_by_id(f_synth, f_id);

  1189. 

  1190.         f_sfont->iteration_start(f_sfont);

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

  1192.             programs += 1;

  1193. 

  1194.         delete_fluid_synth(f_synth);

  1195.         delete_fluid_settings(f_settings);

  1196.     }

  1197. 

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

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

  1200.     DISCOVERY_OUT("label", "");

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

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

  1203.     DISCOVERY_OUT("hints", PLUGIN_IS_SYNTH);

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

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

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

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

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

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

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

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

  1212.     DISCOVERY_OUT("build", BINARY_NATIVE);

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

  1214. #else

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

  1216.     Q_UNUSED(filename);

  1217.     Q_UNUSED(init);

  1218. #endif

  1219. }

  1220. 

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

  1222. {

  1223. #ifdef WANT_LINUXSAMPLER

  1224.     const QFileInfo file(filename);

  1225. 

  1226.     if (! file.exists())

  1227.     {

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

  1229.         return;

  1230.     }

  1231. 

  1232.     if (! file.isFile())

  1233.     {

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

  1235.         return;

  1236.     }

  1237. 

  1238.     if (! file.isReadable())

  1239.     {

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

  1241.         return;

  1242.     }

  1243. 

  1244.     using namespace LinuxSampler;

  1245. 

  1246.     class LinuxSamplerScopedEngine

  1247.     {

  1248.     public:

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

  1250.         {

  1251.             engine = nullptr;

  1252. 

  1253.             try {

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

  1255.             }

  1256.             catch (const Exception& e)

  1257.             {

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

  1259.                 return;

  1260.             }

  1261. 

  1262.             if (! engine)

  1263.                 return;

  1264. 

  1265.             ins = engine->GetInstrumentManager();

  1266. 

  1267.             if (! ins)

  1268.             {

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

  1270.                 return;

  1271.             }

  1272. 

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

  1274. 

  1275.             try {

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

  1277.             }

  1278.             catch (const Exception& e)

  1279.             {

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

  1281.                 return;

  1282.             }

  1283. 

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

  1285.             {

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

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

  1288.             }

  1289.         }

  1290. 

  1291.         ~LinuxSamplerScopedEngine()

  1292.         {

  1293.             if (engine)

  1294.                 EngineFactory::Destroy(engine);

  1295.         }

  1296. 

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

  1298.         {

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

  1300. 

  1301.             if (info)

  1302.             {

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

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

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

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

  1307.             }

  1308.             else

  1309.             {

  1310.                 DISCOVERY_OUT("name", basename);

  1311.                 DISCOVERY_OUT("label", basename);

  1312.             }

  1313. 

  1314.             DISCOVERY_OUT("hints", PLUGIN_IS_SYNTH);

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

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

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

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

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

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

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

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

  1323.             DISCOVERY_OUT("build", BINARY_NATIVE);

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

  1325.         }

  1326. 

  1327.     private:

  1328.         Engine* engine;

  1329.         InstrumentManager* ins;

  1330. 

  1331.         CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(LinuxSamplerScopedEngine)

  1332.     };

  1333. 

  1334.     if (init)

  1335.         const LinuxSamplerScopedEngine engine(filename, stype);

  1336.     else

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

  1338. #else

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

  1340.     Q_UNUSED(filename);

  1341.     Q_UNUSED(init);

  1342. #endif

  1343. }

  1344. 

  1345. // ------------------------------ main entry point ------------------------------

  1346. 

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

  1348. {

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

  1350.     {

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

  1352.         printf("LADSPA: ");

  1353. #ifdef WANT_LADSPA

  1354.         printf("yes\n");

  1355. #else

  1356.         printf("no\n");

  1357. #endif

  1358.         printf("DSSI:   ");

  1359. #ifdef WANT_DSSI

  1360.         printf("yes\n");

  1361. #else

  1362.         printf("no\n");

  1363. #endif

  1364.         printf("LV2:    ");

  1365. #ifdef WANT_LV2

  1366.         printf("yes\n");

  1367. #else

  1368.         printf("no\n");

  1369. #endif

  1370.         printf("VST:    ");

  1371. #ifdef WANT_VST

  1372.         printf("yes\n");

  1373. #else

  1374.         printf("no\n");

  1375. #endif

  1376.         printf("\n");

  1377. 

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

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

  1380. #ifdef WANT_LINUXSAMPLER

  1381.         printf("yes\n");

  1382. #else

  1383.         printf("no\n");

  1384. #endif

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

  1386. #ifdef WANT_FLUIDSYNTH

  1387.         printf("yes\n");

  1388. #else

  1389.         printf("no\n");

  1390. #endif

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

  1392. #ifdef WANT_LINUXSAMPLER

  1393.         printf("yes\n");

  1394. #else

  1395.         printf("no\n");

  1396. #endif

  1397.         return 0;

  1398.     }

  1399. 

  1400.     if (argc != 3)

  1401.     {

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

  1403.         return 1;

  1404.     }

  1405. 

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

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

  1408. 

  1409.     bool openLib;

  1410.     PluginType type;

  1411.     void* handle = nullptr;

  1412. 

  1413.     if (strcmp(stype, "LADSPA") == 0)

  1414.     {

  1415.         openLib = true;

  1416.         type = PLUGIN_LADSPA;

  1417.     }

  1418.     else if (strcmp(stype, "DSSI") == 0)

  1419.     {

  1420.         openLib = true;

  1421.         type = PLUGIN_DSSI;

  1422.     }

  1423.     else if (strcmp(stype, "LV2") == 0)

  1424.     {

  1425.         openLib = false;

  1426.         type = PLUGIN_LV2;

  1427.     }

  1428.     else if (strcmp(stype, "VST") == 0)

  1429.     {

  1430.         openLib = true;

  1431.         type = PLUGIN_VST;

  1432.     }

  1433.     else if (strcmp(stype, "GIG") == 0)

  1434.     {

  1435.         openLib = false;

  1436.         type = PLUGIN_GIG;

  1437.     }

  1438.     else if (strcmp(stype, "SF2") == 0)

  1439.     {

  1440.         openLib = false;

  1441.         type = PLUGIN_SF2;

  1442.     }

  1443.     else if (strcmp(stype, "SFZ") == 0)

  1444.     {

  1445.         openLib = false;

  1446.         type = PLUGIN_SFZ;

  1447.     }

  1448.     else

  1449.     {

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

  1451.         return 1;

  1452.     }

  1453. 

  1454.     if (openLib)

  1455.     {

  1456.         handle = lib_open(filename);

  1457. 

  1458.         if (! handle)

  1459.         {

  1460.             print_lib_error(filename);

  1461.             return 1;

  1462.         }

  1463.     }

  1464. 

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

  1466. 

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

  1468.         doInit = false;

  1469. 

  1470.     if (doInit && handle)

  1471.     {

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

  1473. 

  1474.         if (! lib_close(handle))

  1475.         {

  1476.             print_lib_error(filename);

  1477.             return 1;

  1478.         }

  1479. 

  1480.         handle = lib_open(filename);

  1481. 

  1482.         if (! handle)

  1483.         {

  1484.             print_lib_error(filename);

  1485.             return 1;

  1486.         }

  1487.     }

  1488. 

  1489.     switch (type)

  1490.     {

  1491.     case PLUGIN_LADSPA:

  1492.         do_ladspa_check(handle, doInit);

  1493.         break;

  1494.     case PLUGIN_DSSI:

  1495.         do_dssi_check(handle, doInit);

  1496.         break;

  1497.     case PLUGIN_LV2:

  1498.         do_lv2_check(filename, doInit);

  1499.         break;

  1500.     case PLUGIN_VST:

  1501.         do_vst_check(handle, doInit);

  1502.         break;

  1503.     case PLUGIN_GIG:

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

  1505.         break;

  1506.     case PLUGIN_SF2:

  1507.         do_fluidsynth_check(filename, doInit);

  1508.         break;

  1509.     case PLUGIN_SFZ:

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

  1511.         break;

  1512.     default:

  1513.         break;

  1514.     }

  1515. 

  1516.     if (openLib && handle)

  1517.         lib_close(handle);

  1518. 

  1519.     return 0;

  1520. }