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

1511 lines
46KB
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_lib_utils.hpp"

  20. #include "carla_midi.h"

  21. 

  22. #ifdef WANT_LADSPA

  23. # include "carla_ladspa_utils.hpp"

  24. #endif

  25. #ifdef WANT_DSSI

  26. # include "carla_ladspa_utils.hpp"

  27. # include "dssi/dssi.h"

  28. #endif

  29. #ifdef WANT_LV2

  30. # include <QtCore/QDir>

  31. # include <QtCore/QUrl>

  32. # include "carla_lv2_utils.hpp"

  33. #endif

  34. #ifdef WANT_VST

  35. # include "carla_vst_utils.hpp"

  36. #endif

  37. #ifdef WANT_FLUIDSYNTH

  38. # include <fluidsynth.h>

  39. #endif

  40. #ifdef WANT_LINUXSAMPLER

  41. # include <QtCore/QFileInfo>

  42. # include "linuxsampler/EngineFactory.h"

  43. #endif

  44. 

  45. #include <iostream>

  46. 

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

  48. 

  49. CARLA_BACKEND_USE_NAMESPACE

  50. 

  51. #ifdef WANT_LV2

  52. // --------------------------------------------------------------------------

  53. // Our LV2 World class object

  54. 

  55. Lv2WorldClass lv2World;

  56. #endif

  57. 

  58. // --------------------------------------------------------------------------

  59. // Dummy values to test plugins with

  60. 

  61. const uint32_t bufferSize = 512;

  62. const double   sampleRate = 44100.0;

  63. 

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

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

  66. 

  67. void print_lib_error(const char* const filename)

  68. {

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

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

  71.         DISCOVERY_OUT("error", error);

  72. }

  73. 

  74. // --------------------------------------------------------------------------

  75. // VST stuff

  76. 

  77. #ifdef WANT_VST

  78. // Check if plugin wants midi

  79. bool vstWantsMidi = false;

  80. 

  81. // Check if plugin is processing

  82. bool vstIsProcessing = false;

  83. 

  84. // Current uniqueId for vst shell plugins

  85. intptr_t vstCurrentUniqueId = 0;

  86. 

  87. // Supported Carla features

  88. intptr_t vstHostCanDo(const char* const feature)

  89. {

  90. #if DEBUG

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

  92. #endif

  93. 

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

  95.         return 1;

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

  97.         return 1;

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

  99.         return 1;

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

  101.         return 1;

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

  103.         return 1;

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

  105.         return 1;

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

  107.         return 1;

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

  109.         return -1;

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

  111.         return -1;

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

  113.         return 1;

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

  115.         return 1;

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

  117.         return -1;

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

  119.         return -1;

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

  121.         return -1;

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

  123.         return 1;

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

  125.         return 1;

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

  127.         return 1;

  128. 

  129.     // unimplemented

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

  131.     return 0;

  132. }

  133. 

  134. // Host-side callback

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

  136. {

  137. #if DEBUG

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

  139. #endif

  140. 

  141.     intptr_t ret = 0;

  142. 

  143.     switch (opcode)

  144.     {

  145.     case audioMasterAutomate:

  146.         if (effect)

  147.         {

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

  149.             ret = 1;

  150.         }

  151.         break;

  152. 

  153.     case audioMasterVersion:

  154.         ret = kVstVersion;

  155.         break;

  156. 

  157.     case audioMasterCurrentId:

  158.         ret = vstCurrentUniqueId;

  159.         break;

  160. 

  161. #if ! VST_FORCE_DEPRECATED

  162.     case audioMasterWantMidi:

  163.         vstWantsMidi = true;

  164.         ret = 1;

  165.         break;

  166. #endif

  167. 

  168.     case audioMasterGetTime:

  169.         static VstTimeInfo_R timeInfo;

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

  171.         timeInfo.sampleRate = sampleRate;

  172. 

  173.         // Tempo

  174.         timeInfo.tempo  = 120.0;

  175.         timeInfo.flags |= kVstTempoValid;

  176. 

  177.         // Time Signature

  178.         timeInfo.timeSigNumerator   = 4;

  179.         timeInfo.timeSigDenominator = 4;

  180.         timeInfo.flags |= kVstTimeSigValid;

  181. 

  182.         ret = (intptr_t)&timeInfo;

  183.         break;

  184. 

  185. #if ! VST_FORCE_DEPRECATED

  186.     case audioMasterTempoAt:

  187.         ret = 120 * 10000;

  188.         break;

  189. 

  190.     case audioMasterGetNumAutomatableParameters:

  191.         ret = carla_min<int32_t>(effect->numParams, MAX_PARAMETERS, 0);

  192.         break;

  193. 

  194.     case audioMasterGetParameterQuantization:

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

  196.         break;

  197. #endif

  198. 

  199.     case audioMasterGetSampleRate:

  200.         ret = sampleRate;

  201.         break;

  202. 

  203.     case audioMasterGetBlockSize:

  204.         ret = bufferSize;

  205.         break;

  206. 

  207. #if ! VST_FORCE_DEPRECATED

  208.     case audioMasterWillReplaceOrAccumulate:

  209.         ret = 1; // replace

  210.         break;

  211. #endif

  212. 

  213.     case audioMasterGetCurrentProcessLevel:

  214.         ret = vstIsProcessing ? kVstProcessLevelRealtime : kVstProcessLevelUser;

  215.         break;

  216. 

  217.     case audioMasterGetAutomationState:

  218.         ret = kVstAutomationOff;

  219.         break;

  220. 

  221.     case audioMasterGetVendorString:

  222.         if (ptr)

  223.         {

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

  225.             ret = 1;

  226.         }

  227.         break;

  228. 

  229.     case audioMasterGetProductString:

  230.         if (ptr)

  231.         {

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

  233.             ret = 1;

  234.         }

  235.         break;

  236. 

  237.     case audioMasterGetVendorVersion:

  238.         ret = 0x050; // 0.5.0

  239.         break;

  240. 

  241.     case audioMasterCanDo:

  242.         if (ptr)

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

  244.         break;

  245. 

  246.     case audioMasterGetLanguage:

  247.         ret = kVstLangEnglish;

  248.         break;

  249. 

  250.     default:

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

  252.         break;

  253.     }

  254. 

  255.     return ret;

  256. }

  257. #endif

  258. 

  259. // ------------------------------ Plugin Checks -----------------------------

  260. 

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

  262. {

  263. #ifdef WANT_LADSPA

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

  265. 

  266.     if (! descFn)

  267.     {

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

  269.         return;

  270.     }

  271. 

  272.     unsigned long i = 0;

  273.     const LADSPA_Descriptor* descriptor;

  274. 

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

  276.     {

  277.         if (! descriptor->instantiate)

  278.         {

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

  280.             continue;

  281.         }

  282.         if (! descriptor->cleanup)

  283.         {

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

  285.             continue;

  286.         }

  287.         if (! descriptor->run)

  288.         {

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

  290.             continue;

  291.         }

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

  293.         {

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

  295.         }

  296. 

  297.         int hints = 0;

  298.         int audioIns = 0;

  299.         int audioOuts = 0;

  300.         int audioTotal = 0;

  301.         int parametersIns = 0;

  302.         int parametersOuts = 0;

  303.         int parametersTotal = 0;

  304. 

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

  306.             hints |= PLUGIN_IS_RTSAFE;

  307. 

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

  309.         {

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

  311. 

  312.             if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  313.             {

  314.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  315.                     audioIns += 1;

  316.                 else if (LADSPA_IS_PORT_OUTPUT(portDescriptor))

  317.                     audioOuts += 1;

  318. 

  319.                 audioTotal += 1;

  320.             }

  321.             else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  322.             {

  323.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  324.                     parametersIns += 1;

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

  326.                     parametersOuts += 1;

  327. 

  328.                 parametersTotal += 1;

  329.             }

  330.         }

  331. 

  332.         if (init)

  333.         {

  334.             // -----------------------------------------------------------------------

  335.             // start crash-free plugin test

  336. 

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

  338. 

  339.             if (! handle)

  340.             {

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

  342.                 continue;

  343.             }

  344. 

  345.             LADSPA_Data bufferAudio[bufferSize][audioTotal];

  346.             LADSPA_Data bufferParams[parametersTotal];

  347.             LADSPA_Data min, max, def;

  348. 

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

  350.             {

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

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

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

  354. 

  355.                 if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  356.                 {

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

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

  359.                 }

  360.                 else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  361.                 {

  362.                     // min value

  363.                     if (LADSPA_IS_HINT_BOUNDED_BELOW(portRangeHints.HintDescriptor))

  364.                         min = portRangeHints.LowerBound;

  365.                     else

  366.                         min = 0.0f;

  367. 

  368.                     // max value

  369.                     if (LADSPA_IS_HINT_BOUNDED_ABOVE(portRangeHints.HintDescriptor))

  370.                         max = portRangeHints.UpperBound;

  371.                     else

  372.                         max = 1.0f;

  373. 

  374.                     if (min > max)

  375.                     {

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

  377.                         max = min + 0.1f;

  378.                     }

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

  380.                     {

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

  382.                         max = min + 0.1f;

  383.                     }

  384. 

  385.                     // default value

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

  387. 

  388.                     if (LADSPA_IS_HINT_SAMPLE_RATE(portRangeHints.HintDescriptor))

  389.                     {

  390.                         min *= sampleRate;

  391.                         max *= sampleRate;

  392.                         def *= sampleRate;

  393.                     }

  394. 

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

  396.                     {

  397.                         // latency parameter

  398.                         def = 0.0f;

  399.                     }

  400.                     else

  401.                     {

  402.                         if (def < min)

  403.                             def = min;

  404.                         else if (def > max)

  405.                             def = max;

  406.                     }

  407. 

  408.                     bufferParams[iC] = def;

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

  410.                 }

  411.             }

  412. 

  413.             if (descriptor->activate)

  414.                 descriptor->activate(handle);

  415. 

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

  417. 

  418.             if (descriptor->deactivate)

  419.                 descriptor->deactivate(handle);

  420. 

  421.             descriptor->cleanup(handle);

  422. 

  423.             // end crash-free plugin test

  424.             // -----------------------------------------------------------------------

  425.         }

  426. 

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

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

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

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

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

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

  433.         DISCOVERY_OUT("hints", hints);

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

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

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

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

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

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

  440.         DISCOVERY_OUT("build", BINARY_NATIVE);

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

  442.     }

  443. #else

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

  445.     Q_UNUSED(libHandle);

  446.     Q_UNUSED(init);

  447. #endif

  448. }

  449. 

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

  451. {

  452. #ifdef WANT_DSSI

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

  454. 

  455.     if (! descFn)

  456.     {

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

  458.         return;

  459.     }

  460. 

  461.     unsigned long i = 0;

  462.     const DSSI_Descriptor* descriptor;

  463. 

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

  465.     {

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

  467. 

  468.         if (! ldescriptor)

  469.         {

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

  471.             continue;

  472.         }

  473.         if (! ldescriptor->instantiate)

  474.         {

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

  476.             continue;

  477.         }

  478.         if (! ldescriptor->cleanup)

  479.         {

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

  481.             continue;

  482.         }

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

  484.         {

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

  486.             continue;

  487.         }

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

  489.         {

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

  491.         }

  492. 

  493.         int hints = 0;

  494.         int audioIns = 0;

  495.         int audioOuts = 0;

  496.         int audioTotal = 0;

  497.         int midiIns = 0;

  498.         int midiTotal = 0;

  499.         int parametersIns = 0;

  500.         int parametersOuts = 0;

  501.         int parametersTotal = 0;

  502.         int programsTotal = 0;

  503. 

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

  505.             hints |= PLUGIN_IS_RTSAFE;

  506. 

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

  508.         {

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

  510. 

  511.             if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  512.             {

  513.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  514.                     audioIns += 1;

  515.                 else if (LADSPA_IS_PORT_OUTPUT(portDescriptor))

  516.                     audioOuts += 1;

  517. 

  518.                 audioTotal += 1;

  519.             }

  520.             else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  521.             {

  522.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  523.                     parametersIns += 1;

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

  525.                     parametersOuts += 1;

  526. 

  527.                 parametersTotal += 1;

  528.             }

  529.         }

  530. 

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

  532.             midiIns = midiTotal = 1;

  533. 

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

  535.             hints |= PLUGIN_IS_SYNTH;

  536. 

  537.         if (init)

  538.         {

  539.             // -----------------------------------------------------------------------

  540.             // start crash-free plugin test

  541. 

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

  543. 

  544.             if (! handle)

  545.             {

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

  547.                 continue;

  548.             }

  549. 

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

  551.             {

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

  553.                     continue;

  554.             }

  555. 

  556.             LADSPA_Data bufferAudio[bufferSize][audioTotal];

  557.             LADSPA_Data bufferParams[parametersTotal];

  558.             LADSPA_Data min, max, def;

  559. 

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

  561.             {

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

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

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

  565. 

  566.                 if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  567.                 {

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

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

  570.                 }

  571.                 else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  572.                 {

  573.                     // min value

  574.                     if (LADSPA_IS_HINT_BOUNDED_BELOW(portRangeHints.HintDescriptor))

  575.                         min = portRangeHints.LowerBound;

  576.                     else

  577.                         min = 0.0f;

  578. 

  579.                     // max value

  580.                     if (LADSPA_IS_HINT_BOUNDED_ABOVE(portRangeHints.HintDescriptor))

  581.                         max = portRangeHints.UpperBound;

  582.                     else

  583.                         max = 1.0f;

  584. 

  585.                     if (min > max)

  586.                     {

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

  588.                         max = min + 0.1f;

  589.                     }

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

  591.                     {

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

  593.                         max = min + 0.1f;

  594.                     }

  595. 

  596.                     // default value

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

  598. 

  599.                     if (LADSPA_IS_HINT_SAMPLE_RATE(portRangeHints.HintDescriptor))

  600.                     {

  601.                         min *= sampleRate;

  602.                         max *= sampleRate;

  603.                         def *= sampleRate;

  604.                     }

  605. 

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

  607.                     {

  608.                         // latency parameter

  609.                         def = 0.0f;

  610.                     }

  611.                     else

  612.                     {

  613.                         if (def < min)

  614.                             def = min;

  615.                         else if (def > max)

  616.                             def = max;

  617.                     }

  618. 

  619.                     bufferParams[iC] = def;

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

  621.                 }

  622.             }

  623. 

  624.             // select first midi-program if available

  625.             if (programsTotal > 0)

  626.             {

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

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

  629.             }

  630. 

  631.             if (ldescriptor->activate)

  632.                 ldescriptor->activate(handle);

  633. 

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

  635.             {

  636.                 snd_seq_event_t midiEvents[2];

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

  638. 

  639.                 const unsigned long midiEventCount = 2;

  640. 

  641.                 midiEvents[0].type = SND_SEQ_EVENT_NOTEON;

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

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

  644. 

  645.                 midiEvents[1].type = SND_SEQ_EVENT_NOTEOFF;

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

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

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

  649. 

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

  651.                 {

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

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

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

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

  656.                 }

  657.                 else

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

  659.             }

  660.             else

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

  662. 

  663.             if (ldescriptor->deactivate)

  664.                 ldescriptor->deactivate(handle);

  665. 

  666.             ldescriptor->cleanup(handle);

  667. 

  668.             // end crash-free plugin test

  669.             // -----------------------------------------------------------------------

  670.         }

  671. 

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

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

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

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

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

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

  678.         DISCOVERY_OUT("hints", hints);

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

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

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

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

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

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

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

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

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

  688.         DISCOVERY_OUT("build", BINARY_NATIVE);

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

  690.     }

  691. #else

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

  693.     Q_UNUSED(libHandle);

  694.     Q_UNUSED(init);

  695. #endif

  696. }

  697. 

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

  699. {

  700. #ifdef WANT_LV2

  701.     // Convert bundle filename to URI

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

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

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

  705. 

  706.     // Load bundle

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

  708.     lv2World.load_bundle(lilvBundle);

  709. 

  710.     // Load plugins in this bundle

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

  712. 

  713.     // Get all plugin URIs in this bundle

  714.     QStringList URIs;

  715. 

  716.     LILV_FOREACH(plugins, i, lilvPlugins)

  717.     {

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

  719. 

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

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

  722.     }

  723. 

  724.     // Get & check every plugin-instance

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

  726.     {

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

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

  729. 

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

  731.         {

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

  733.             continue;

  734.         }

  735. 

  736.         if (init)

  737.         {

  738.             // test if DLL is loadable, twice

  739.             bool isLoadable = true;

  740. 

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

  742.             {

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

  744. 

  745.                 if (! libHandle)

  746.                 {

  747.                     isLoadable = false;

  748.                     print_lib_error(rdfDescriptor->Binary);

  749.                     delete rdfDescriptor;

  750.                     break;

  751.                 }

  752. 

  753.                 lib_close(libHandle);

  754.             }

  755. 

  756.             if (! isLoadable)

  757.                 continue;

  758.         }

  759. 

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

  761.         {

  762.             bool supported = true;

  763. 

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

  765.             {

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

  767. 

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

  769.                 {

  770.                     pass();

  771.                 }

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

  773.                 {

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

  775.                     supported = false;

  776.                     break;

  777.                 }

  778.             }

  779. 

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

  781.             {

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

  783. 

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

  785.                 {

  786.                     pass();

  787.                 }

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

  789.                 {

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

  791.                     supported = false;

  792.                     break;

  793.                 }

  794.             }

  795. 

  796.             if (! supported)

  797.             {

  798.                 delete rdfDescriptor;

  799.                 continue;

  800.             }

  801.         }

  802. 

  803.         int hints = 0;

  804.         int audioIns = 0;

  805.         int audioOuts = 0;

  806.         int audioTotal = 0;

  807.         int midiIns = 0;

  808.         int midiOuts = 0;

  809.         int midiTotal = 0;

  810.         int parametersIns = 0;

  811.         int parametersOuts = 0;

  812.         int parametersTotal = 0;

  813.         int programsTotal = rdfDescriptor->PresetCount;

  814. 

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

  816.         {

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

  818. 

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

  820.                 hints |= PLUGIN_IS_RTSAFE;

  821.         }

  822. 

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

  824.         {

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

  826. 

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

  828.             {

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

  830.                     audioIns += 1;

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

  832.                     audioOuts += 1;

  833. 

  834.                 audioTotal += 1;

  835.             }

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

  837.             {

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

  839.                 {

  840.                     pass();

  841.                 }

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

  843.                 {

  844.                     pass();

  845.                 }

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

  847.                 {

  848.                     pass();

  849.                 }

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

  851.                 {

  852.                     pass();

  853.                 }

  854.                 else

  855.                 {

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

  857.                         parametersIns += 1;

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

  859.                         parametersOuts += 1;

  860. 

  861.                     parametersTotal += 1;

  862.                 }

  863.             }

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

  865.             {

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

  867.                     midiIns += 1;

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

  869.                     midiOuts += 1;

  870. 

  871.                 midiTotal += 1;

  872.             }

  873.         }

  874. 

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

  876.             hints |= PLUGIN_IS_SYNTH;

  877. 

  878.         if (rdfDescriptor->UICount > 0)

  879.             hints |= PLUGIN_HAS_GUI;

  880. 

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

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

  883.         if (rdfDescriptor->Name)

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

  885.         if (rdfDescriptor->Author)

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

  887.         if (rdfDescriptor->License)

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

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

  890.         DISCOVERY_OUT("hints", hints);

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

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

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

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

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

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

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

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

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

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

  901.         DISCOVERY_OUT("build", BINARY_NATIVE);

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

  903. 

  904.         delete rdfDescriptor;

  905.     }

  906. #else

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

  908.     Q_UNUSED(bundle);

  909.     Q_UNUSED(init);

  910. #endif

  911. }

  912. 

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

  914. {

  915. #ifdef WANT_VST

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

  917. 

  918.     if (! vstFn)

  919.     {

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

  921. 

  922.         if (! vstFn)

  923.         {

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

  925.             return;

  926.         }

  927.     }

  928. 

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

  930. 

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

  932.     {

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

  934.         return;

  935.     }

  936. 

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

  938.     CarlaString cName;

  939.     CarlaString cProduct;

  940.     CarlaString cVendor;

  941. 

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

  943. 

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

  945. 

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

  947.     {

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

  949.             cName = strBuf;

  950.     }

  951.     else

  952.     {

  953.         vstCurrentUniqueId = effect->uniqueID;

  954. 

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

  956.             cName = strBuf;

  957.     }

  958. 

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

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

  961.         cVendor = strBuf;

  962. 

  963.     // FIXME: Waves crash during processing

  964.     if (cVendor == "Waves")

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

  966. 

  967.     if (vstCurrentUniqueId == 0)

  968.     {

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

  970.         return;

  971.     }

  972. 

  973.     while (vstCurrentUniqueId != 0)

  974.     {

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

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

  977.             cProduct = strBuf;

  978.         else

  979.             cProduct.clear();

  980. 

  981.         vstWantsMidi = false;

  982. 

  983.         int hints = 0;

  984.         int audioIns = effect->numInputs;

  985.         int audioOuts = effect->numOutputs;

  986.         int audioTotal = audioIns + audioOuts;

  987.         int midiIns = 0;

  988.         int midiOuts = 0;

  989.         int midiTotal = 0;

  990.         int parametersIns = effect->numParams;

  991.         int parametersTotal = parametersIns;

  992.         int programsTotal = effect->numPrograms;

  993. 

  994.         if (effect->flags & effFlagsHasEditor)

  995.             hints |= PLUGIN_HAS_GUI;

  996. 

  997.         if (effect->flags & effFlagsIsSynth)

  998.             hints |= PLUGIN_IS_SYNTH;

  999. 

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

  1001.             midiIns = 1;

  1002. 

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

  1004.             midiOuts = 1;

  1005. 

  1006.         midiTotal = midiIns + midiOuts;

  1007. 

  1008.         // -----------------------------------------------------------------------

  1009.         // start crash-free plugin test

  1010. 

  1011.         if (init)

  1012.         {

  1013. #if ! VST_FORCE_DEPRECATED

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

  1015. #endif

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

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

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

  1019. 

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

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

  1022. 

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

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

  1025.             {

  1026.                 midiIns = 1;

  1027.                 midiTotal = midiIns + midiOuts;

  1028.             }

  1029. 

  1030.             float* bufferAudioIn[audioIns];

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

  1032.             {

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

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

  1035.             }

  1036. 

  1037.             float* bufferAudioOut[audioOuts];

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

  1039.             {

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

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

  1042.             }

  1043. 

  1044.             struct VstEventsFixed {

  1045.                 int32_t numEvents;

  1046.                 intptr_t reserved;

  1047.                 VstEvent* data[2];

  1048.             };

  1049.             VstEventsFixed events;

  1050.             VstMidiEvent   midiEvents[2];

  1051. 

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

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

  1054. 

  1055.             midiEvents[0].type = kVstMidiType;

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

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

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

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

  1060. 

  1061.             midiEvents[1].type = kVstMidiType;

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

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

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

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

  1066. 

  1067.             events.numEvents = 2;

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

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

  1070. 

  1071.             // processing

  1072.             {

  1073.                 vstIsProcessing = true;

  1074. 

  1075.                 if (midiIns > 0)

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

  1077. 

  1078. #if ! VST_FORCE_DEPRECATED

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

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

  1081.                 else if (effect->process)

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

  1083.                 else

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

  1085. #else

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

  1087.                 if (effect->flags & effFlagsCanReplacing)

  1088.                 {

  1089.                     if (effect->processReplacing)

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

  1091.                     else

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

  1093.                 }

  1094.                 else

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

  1096. #endif

  1097. 

  1098.                 vstIsProcessing = false;

  1099.             }

  1100. 

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

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

  1103. 

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

  1105.                 delete[] bufferAudioIn[j];

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

  1107.                 delete[] bufferAudioOut[j];

  1108.         }

  1109. 

  1110.         // end crash-free plugin test

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

  1112. 

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

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

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

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

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

  1118.         DISCOVERY_OUT("unique_id", vstCurrentUniqueId);

  1119.         DISCOVERY_OUT("hints", hints);

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

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

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

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

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

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

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

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

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

  1129.         DISCOVERY_OUT("build", BINARY_NATIVE);

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

  1131. 

  1132.         if (vstCategory != kPlugCategShell)

  1133.             break;

  1134. 

  1135.         // request next Unique ID

  1136.         intptr_t nextUniqueId = vstCurrentUniqueId;

  1137. 

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

  1139.         while (nextUniqueId == vstCurrentUniqueId)

  1140.         {

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

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

  1143.                 cName = strBuf;

  1144.         }

  1145.     }

  1146. 

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

  1148. #else

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

  1150.     Q_UNUSED(libHandle);

  1151.     Q_UNUSED(init);

  1152. #endif

  1153. }

  1154. 

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

  1156. {

  1157. #ifdef WANT_FLUIDSYNTH

  1158.     if (! fluid_is_soundfont(filename))

  1159.     {

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

  1161.         return;

  1162.     }

  1163. 

  1164.     int programs = 0;

  1165. 

  1166.     if (init)

  1167.     {

  1168.         fluid_settings_t* const f_settings = new_fluid_settings();

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

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

  1171. 

  1172.         if (f_id < 0)

  1173.         {

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

  1175.             return;

  1176.         }

  1177. 

  1178.         fluid_sfont_t* f_sfont;

  1179.         fluid_preset_t f_preset;

  1180. 

  1181.         f_sfont = fluid_synth_get_sfont_by_id(f_synth, f_id);

  1182. 

  1183.         f_sfont->iteration_start(f_sfont);

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

  1185.             programs += 1;

  1186. 

  1187.         delete_fluid_synth(f_synth);

  1188.         delete_fluid_settings(f_settings);

  1189.     }

  1190. 

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

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

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

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

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

  1196.     DISCOVERY_OUT("hints", PLUGIN_IS_SYNTH);

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

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

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

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

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

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

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

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

  1205.     DISCOVERY_OUT("build", BINARY_NATIVE);

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

  1207. #else

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

  1209.     Q_UNUSED(filename);

  1210.     Q_UNUSED(init);

  1211. #endif

  1212. }

  1213. 

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

  1215. {

  1216. #ifdef WANT_LINUXSAMPLER

  1217.     const QFileInfo file(filename);

  1218. 

  1219.     if (! file.exists())

  1220.     {

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

  1222.         return;

  1223.     }

  1224. 

  1225.     if (! file.isFile())

  1226.     {

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

  1228.         return;

  1229.     }

  1230. 

  1231.     if (! file.isReadable())

  1232.     {

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

  1234.         return;

  1235.     }

  1236. 

  1237.     using namespace LinuxSampler;

  1238. 

  1239.     class LinuxSamplerScopedEngine {

  1240.     public:

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

  1242.         {

  1243.             engine = nullptr;

  1244. 

  1245.             try {

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

  1247.             }

  1248.             catch (const Exception& e)

  1249.             {

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

  1251.                 return;

  1252.             }

  1253. 

  1254.             if (! engine)

  1255.                 return;

  1256. 

  1257.             ins = engine->GetInstrumentManager();

  1258. 

  1259.             if (! ins)

  1260.             {

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

  1262.                 return;

  1263.             }

  1264. 

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

  1266. 

  1267.             try {

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

  1269.             }

  1270.             catch (const Exception& e)

  1271.             {

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

  1273.                 return;

  1274.             }

  1275. 

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

  1277.             {

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

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

  1280.             }

  1281.         }

  1282. 

  1283.         ~LinuxSamplerScopedEngine()

  1284.         {

  1285.             if (engine)

  1286.                 EngineFactory::Destroy(engine);

  1287.         }

  1288. 

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

  1290.         {

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

  1292. 

  1293.             if (info)

  1294.             {

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

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

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

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

  1299.             }

  1300.             else

  1301.             {

  1302.                 DISCOVERY_OUT("name", basename);

  1303.                 DISCOVERY_OUT("label", basename);

  1304.             }

  1305. 

  1306.             DISCOVERY_OUT("hints", PLUGIN_IS_SYNTH);

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

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

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

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

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

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

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

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

  1315.             DISCOVERY_OUT("build", BINARY_NATIVE);

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

  1317.         }

  1318. 

  1319.     private:

  1320.         Engine* engine;

  1321.         InstrumentManager* ins;

  1322.     };

  1323. 

  1324.     if (init)

  1325.         const LinuxSamplerScopedEngine engine(filename, stype);

  1326.     else

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

  1328. #else

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

  1330.     Q_UNUSED(filename);

  1331.     Q_UNUSED(init);

  1332. #endif

  1333. }

  1334. 

  1335. // ------------------------------ main entry point ------------------------------

  1336. 

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

  1338. {

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

  1340.     {

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

  1342.         printf("LADSPA: ");

  1343. #ifdef WANT_LADSPA

  1344.         printf("yes\n");

  1345. #else

  1346.         printf("no\n");

  1347. #endif

  1348.         printf("DSSI:   ");

  1349. #ifdef WANT_DSSI

  1350.         printf("yes\n");

  1351. #else

  1352.         printf("no\n");

  1353. #endif

  1354.         printf("LV2:    ");

  1355. #ifdef WANT_LV2

  1356.         printf("yes\n");

  1357. #else

  1358.         printf("no\n");

  1359. #endif

  1360.         printf("VST:    ");

  1361. #ifdef WANT_VST

  1362.         printf("yes\n");

  1363. #else

  1364.         printf("no\n");

  1365. #endif

  1366.         printf("\n");

  1367. 

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

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

  1370. #ifdef WANT_LINUXSAMPLER

  1371.         printf("yes\n");

  1372. #else

  1373.         printf("no\n");

  1374. #endif

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

  1376. #ifdef WANT_FLUIDSYNTH

  1377.         printf("yes\n");

  1378. #else

  1379.         printf("no\n");

  1380. #endif

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

  1382. #ifdef WANT_LINUXSAMPLER

  1383.         printf("yes\n");

  1384. #else

  1385.         printf("no\n");

  1386. #endif

  1387.         return 0;

  1388.     }

  1389. 

  1390.     if (argc != 3)

  1391.     {

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

  1393.         return 1;

  1394.     }

  1395. 

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

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

  1398. 

  1399.     bool openLib;

  1400.     PluginType type;

  1401.     void* handle = nullptr;

  1402. 

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

  1404.     {

  1405.         openLib = true;

  1406.         type = PLUGIN_LADSPA;

  1407.     }

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

  1409.     {

  1410.         openLib = true;

  1411.         type = PLUGIN_DSSI;

  1412.     }

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

  1414.     {

  1415.         openLib = false;

  1416.         type = PLUGIN_LV2;

  1417.     }

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

  1419.     {

  1420.         openLib = true;

  1421.         type = PLUGIN_VST;

  1422.     }

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

  1424.     {

  1425.         openLib = false;

  1426.         type = PLUGIN_GIG;

  1427.     }

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

  1429.     {

  1430.         openLib = false;

  1431.         type = PLUGIN_SF2;

  1432.     }

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

  1434.     {

  1435.         openLib = false;

  1436.         type = PLUGIN_SFZ;

  1437.     }

  1438.     else

  1439.     {

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

  1441.         return 1;

  1442.     }

  1443. 

  1444.     if (openLib)

  1445.     {

  1446.         handle = lib_open(filename);

  1447. 

  1448.         if (! handle)

  1449.         {

  1450.             print_lib_error(filename);

  1451.             return 1;

  1452.         }

  1453.     }

  1454. 

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

  1456. 

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

  1458.         doInit = false;

  1459. 

  1460.     if (doInit && handle)

  1461.     {

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

  1463. 

  1464.         if (! lib_close(handle))

  1465.         {

  1466.             print_lib_error(filename);

  1467.             return 1;

  1468.         }

  1469. 

  1470.         handle = lib_open(filename);

  1471. 

  1472.         if (! handle)

  1473.         {

  1474.             print_lib_error(filename);

  1475.             return 1;

  1476.         }

  1477.     }

  1478. 

  1479.     switch (type)

  1480.     {

  1481.     case PLUGIN_LADSPA:

  1482.         do_ladspa_check(handle, doInit);

  1483.         break;

  1484.     case PLUGIN_DSSI:

  1485.         do_dssi_check(handle, doInit);

  1486.         break;

  1487.     case PLUGIN_LV2:

  1488.         do_lv2_check(filename, doInit);

  1489.         break;

  1490.     case PLUGIN_VST:

  1491.         do_vst_check(handle, doInit);

  1492.         break;

  1493.     case PLUGIN_GIG:

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

  1495.         break;

  1496.     case PLUGIN_SF2:

  1497.         do_fluidsynth_check(filename, doInit);

  1498.         break;

  1499.     case PLUGIN_SFZ:

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

  1501.         break;

  1502.     default:

  1503.         break;

  1504.     }

  1505. 

  1506.     if (openLib && handle)

  1507.         lib_close(handle);

  1508. 

  1509.     return 0;

  1510. }