falkTX
/
Cadence
mirror of https://github.com/falkTX/Cadence
1
0
Fork 0
Code Releases 3 Activity
Collection of tools useful for audio production
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.
500 Commits
2 Branches
16MB
Tree: b43a97817f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b43a97817f'
${ noResults }
Cadence/c++/carla-discovery/carla-discovery.cpp

1212 lines
38KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin discovery code

  3.  * Copyright (C) 2011-2012 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_includes.h"

  19. #include "carla_lib_includes.h"

  20. 

  21. #include <cstdint>

  22. #include <cstdlib>

  23. #include <cstring>

  24. #include <iostream>

  25. 

  26. #include <QtCore/QDir>

  27. #include <QtCore/QFileInfo>

  28. #include <QtCore/QUrl>

  29. 

  30. #include "carla_backend.h"

  31. 

  32. #include "carla_ladspa.h"

  33. #include "carla_dssi.h"

  34. #include "carla_lv2.h"

  35. #include "carla_vst.h"

  36. 

  37. #ifdef BUILD_NATIVE

  38.  #ifdef WANT_FLUIDSYNTH

  39.   #include "carla_fluidsynth.h"

  40.  #endif

  41.  #ifdef WANT_LINUXSAMPLER

  42.   #include "carla_linuxsampler.h"

  43.  #endif

  44. #endif

  45. 

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

  47. 

  48. // fake values to test plugins with

  49. const uint32_t bufferSize = 512;

  50. const double   sampleRate = 44100.0;

  51. 

  52. // Since discovery can find multi-architecture binaries, don't print ELF/EXE related errors

  53. void print_lib_error(const char* const filename)

  54. {

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

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

  57.         DISCOVERY_OUT("error", error);

  58. }

  59. 

  60. using namespace CarlaBackend;

  61. 

  62. // ------------------------------ VST Stuff ------------------------------

  63. 

  64. intptr_t vstCurrentUniqueId = 0;

  65. 

  66. intptr_t vstHostCanDo(const char* const feature)

  67. {

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

  69. 

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

  71.         return 1;

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

  73.         return 1;

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

  75.         return 1;

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

  77.         return -1;

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

  79.         return 1;

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

  81.         return 1;

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

  83.         return 1;

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

  85.         return -1;

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

  87.         return -1;

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

  89.         return 1;

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

  91.         return 1;

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

  93.         return -1;

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

  95.         return -1;

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

  97.         return -1;

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

  99.         return 1;

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

  101.         return 1;

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

  103.         return 1;

  104. 

  105.     // unimplemented

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

  107.     return 0;

  108. }

  109. 

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

  111. {

  112. #if DEBUG

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

  114. #endif

  115. 

  116.     intptr_t ret = 0;

  117. 

  118.     switch (opcode)

  119.     {

  120.     case audioMasterAutomate:

  121.         if (effect)

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

  123.         break;

  124. 

  125.     case audioMasterVersion:

  126.         ret = kVstVersion;

  127.         break;

  128. 

  129.     case audioMasterCurrentId:

  130.         ret = vstCurrentUniqueId;

  131.         break;

  132. 

  133.     case audioMasterGetTime:

  134.         static VstTimeInfo_R timeInfo;

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

  136.         timeInfo.sampleRate = sampleRate;

  137. 

  138.         // Tempo

  139.         timeInfo.tempo  = 120.0;

  140.         timeInfo.flags |= kVstTempoValid;

  141. 

  142.         // Time Signature

  143.         timeInfo.timeSigNumerator   = 4;

  144.         timeInfo.timeSigDenominator = 4;

  145.         timeInfo.flags |= kVstTimeSigValid;

  146. 

  147.         ret = (intptr_t)&timeInfo;

  148.         break;

  149. 

  150.     case audioMasterTempoAt:

  151.         // Deprecated in VST SDK 2.4

  152.         ret = 120 * 10000;

  153.         break;

  154. 

  155.     case audioMasterGetNumAutomatableParameters:

  156.         ret = MAX_PARAMETERS;

  157.         break;

  158. 

  159.     case audioMasterGetSampleRate:

  160.         ret = sampleRate;

  161.         break;

  162. 

  163.     case audioMasterGetBlockSize:

  164.         ret = bufferSize;

  165.         break;

  166. 

  167.     case audioMasterGetCurrentProcessLevel:

  168.         ret = kVstProcessLevelUser;

  169.         break;

  170. 

  171.     case audioMasterGetAutomationState:

  172.         ret = kVstAutomationReadWrite;

  173.         break;

  174. 

  175.     case audioMasterGetVendorString:

  176.         if (ptr)

  177.             strcpy((char*)ptr, "Cadence");

  178.         break;

  179. 

  180.     case audioMasterGetProductString:

  181.         if (ptr)

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

  183.         break;

  184. 

  185.     case audioMasterGetVendorVersion:

  186.         ret = 0x050; // 0.5.0

  187.         break;

  188. 

  189.     case audioMasterCanDo:

  190.         if (ptr)

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

  192.         break;

  193. 

  194.     case audioMasterGetLanguage:

  195.         ret = kVstLangEnglish;

  196.         break;

  197. 

  198.     default:

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

  200.         break;

  201.     }

  202. 

  203.     return ret;

  204. }

  205. 

  206. // ------------------------------ Plugin Checks -----------------------------

  207. 

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

  209. {

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

  211. 

  212.     if (! descFn)

  213.     {

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

  215.         return;

  216.     }

  217. 

  218.     unsigned long i = 0;

  219.     const LADSPA_Descriptor* descriptor;

  220. 

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

  222.     {

  223.         Q_ASSERT(descriptor->run);

  224. 

  225.         int hints = 0;

  226.         int audioIns = 0;

  227.         int audioOuts = 0;

  228.         int audioTotal = 0;

  229.         int parametersIns = 0;

  230.         int parametersOuts = 0;

  231.         int parametersTotal = 0;

  232. 

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

  234.         {

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

  236. 

  237.             if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  238.             {

  239.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  240.                     audioIns += 1;

  241.                 else if (LADSPA_IS_PORT_OUTPUT(portDescriptor))

  242.                     audioOuts += 1;

  243.                 audioTotal += 1;

  244.             }

  245.             else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  246.             {

  247.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  248.                     parametersIns += 1;

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

  250.                     parametersOuts += 1;

  251.                 parametersTotal += 1;

  252.             }

  253.         }

  254. 

  255.         if (init)

  256.         {

  257.             // -----------------------------------------------------------------------

  258.             // start crash-free plugin test

  259. 

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

  261. 

  262.             if (! handle)

  263.             {

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

  265.                 continue;

  266.             }

  267. 

  268.             LADSPA_Data bufferAudio[bufferSize][audioTotal];

  269.             memset(bufferAudio, 0, sizeof(float)*bufferSize*audioTotal);

  270. 

  271.             LADSPA_Data bufferParams[parametersTotal];

  272.             memset(bufferParams, 0, sizeof(float)*parametersTotal);

  273. 

  274.             LADSPA_Data min, max, def;

  275. 

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

  277.             {

  278.                 const LADSPA_PortDescriptor portType  = descriptor->PortDescriptors[j];

  279.                 const LADSPA_PortRangeHint  portHints = descriptor->PortRangeHints[j];

  280. 

  281.                 if (LADSPA_IS_PORT_AUDIO(portType))

  282.                 {

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

  284.                 }

  285.                 else if (LADSPA_IS_PORT_CONTROL(portType))

  286.                 {

  287.                     // min value

  288.                     if (LADSPA_IS_HINT_BOUNDED_BELOW(portHints.HintDescriptor))

  289.                         min = portHints.LowerBound;

  290.                     else

  291.                         min = 0.0f;

  292. 

  293.                     // max value

  294.                     if (LADSPA_IS_HINT_BOUNDED_ABOVE(portHints.HintDescriptor))

  295.                         max = portHints.UpperBound;

  296.                     else

  297.                         max = 1.0f;

  298. 

  299.                     if (min > max)

  300.                         max = min;

  301.                     else if (max < min)

  302.                         min = max;

  303. 

  304.                     if (max - min == 0.0f)

  305.                     {

  306.                         DISCOVERY_OUT("error", "Broken parameter: max - min == 0");

  307.                         max = min + 0.1f;

  308.                     }

  309. 

  310.                     // default value

  311.                     def = get_default_ladspa_port_value(portHints.HintDescriptor, min, max);

  312. 

  313.                     if (def < min)

  314.                         def = min;

  315.                     else if (def > max)

  316.                         def = max;

  317. 

  318.                     if (LADSPA_IS_HINT_SAMPLE_RATE(portHints.HintDescriptor))

  319.                     {

  320.                         min *= sampleRate;

  321.                         max *= sampleRate;

  322.                         def *= sampleRate;

  323.                     }

  324. 

  325.                     if (LADSPA_IS_PORT_OUTPUT(portType) && (strcmp(descriptor->PortNames[j], "latency") == 0 || strcmp(descriptor->PortNames[j], "_latency") == 0))

  326.                     {

  327.                         // latency parameter

  328.                         min = 0.0f;

  329.                         max = sampleRate;

  330.                         def = 0.0f;

  331.                     }

  332. 

  333.                     bufferParams[iP] = def;

  334. 

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

  336.                 }

  337.             }

  338. 

  339.             if (descriptor->activate)

  340.                 descriptor->activate(handle);

  341. 

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

  343. 

  344.             if (descriptor->deactivate)

  345.                 descriptor->deactivate(handle);

  346. 

  347.             if (descriptor->cleanup)

  348.                 descriptor->cleanup(handle);

  349. 

  350.             // end crash-free plugin test

  351.             // -----------------------------------------------------------------------

  352.         }

  353. 

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

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

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

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

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

  359.         DISCOVERY_OUT("unique_id", descriptor->UniqueID);

  360.         DISCOVERY_OUT("hints", hints);

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

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

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

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

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

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

  367.         DISCOVERY_OUT("build", BINARY_NATIVE);

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

  369.     }

  370. }

  371. 

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

  373. {

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

  375. 

  376.     if (! descFn)

  377.     {

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

  379.         return;

  380.     }

  381. 

  382.     unsigned long i = 0;

  383.     const DSSI_Descriptor* descriptor;

  384. 

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

  386.     {

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

  388.         Q_ASSERT(ldescriptor);

  389.         Q_ASSERT(ldescriptor->run || descriptor->run_synth || descriptor->run_multiple_synths);

  390. 

  391.         int hints = 0;

  392.         int audioIns = 0;

  393.         int audioOuts = 0;

  394.         int audioTotal = 0;

  395.         int midiIns = 0;

  396.         int midiTotal = 0;

  397.         int parametersIns = 0;

  398.         int parametersOuts = 0;

  399.         int parametersTotal = 0;

  400.         int programsTotal = 0;

  401. 

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

  403.         {

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

  405. 

  406.             if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  407.             {

  408.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  409.                     audioIns += 1;

  410.                 else if (LADSPA_IS_PORT_OUTPUT(portDescriptor))

  411.                     audioOuts += 1;

  412.                 audioTotal += 1;

  413.             }

  414.             else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  415.             {

  416.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  417.                     parametersIns += 1;

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

  419.                     parametersOuts += 1;

  420.                 parametersTotal += 1;

  421.             }

  422.         }

  423. 

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

  425.             midiIns = midiTotal = 1;

  426. 

  427.         if (midiIns > 0 && audioOuts > 0)

  428.             hints |= PLUGIN_IS_SYNTH;

  429. 

  430.         if (init)

  431.         {

  432.             // -----------------------------------------------------------------------

  433.             // start crash-free plugin test

  434. 

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

  436. 

  437.             if (! handle)

  438.             {

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

  440.                 continue;

  441.             }

  442. 

  443.             // we can only get program info per-handle

  444.             if (descriptor->get_program)

  445.             {

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

  447.                     continue;

  448.             }

  449. 

  450.             LADSPA_Data bufferAudio[bufferSize][audioTotal];

  451.             memset(bufferAudio, 0, sizeof(float)*bufferSize*audioTotal);

  452. 

  453.             LADSPA_Data bufferParams[parametersTotal];

  454.             memset(bufferParams, 0, sizeof(float)*parametersTotal);

  455. 

  456.             LADSPA_Data min, max, def;

  457. 

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

  459.             {

  460.                 const LADSPA_PortDescriptor portType  = ldescriptor->PortDescriptors[j];

  461.                 const LADSPA_PortRangeHint  portHints = ldescriptor->PortRangeHints[j];

  462. 

  463.                 if (LADSPA_IS_PORT_AUDIO(portType))

  464.                 {

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

  466.                 }

  467.                 else if (LADSPA_IS_PORT_CONTROL(portType))

  468.                 {

  469.                     // min value

  470.                     if (LADSPA_IS_HINT_BOUNDED_BELOW(portHints.HintDescriptor))

  471.                         min = portHints.LowerBound;

  472.                     else

  473.                         min = 0.0f;

  474. 

  475.                     // max value

  476.                     if (LADSPA_IS_HINT_BOUNDED_ABOVE(portHints.HintDescriptor))

  477.                         max = portHints.UpperBound;

  478.                     else

  479.                         max = 1.0f;

  480. 

  481.                     if (min > max)

  482.                         max = min;

  483.                     else if (max < min)

  484.                         min = max;

  485. 

  486.                     if (max - min == 0.0f)

  487.                     {

  488.                         DISCOVERY_OUT("error", "Broken parameter: max - min == 0");

  489.                         max = min + 0.1f;

  490.                     }

  491. 

  492.                     // default value

  493.                     def = get_default_ladspa_port_value(portHints.HintDescriptor, min, max);

  494. 

  495.                     if (def < min)

  496.                         def = min;

  497.                     else if (def > max)

  498.                         def = max;

  499. 

  500.                     if (LADSPA_IS_HINT_SAMPLE_RATE(portHints.HintDescriptor))

  501.                     {

  502.                         min *= sampleRate;

  503.                         max *= sampleRate;

  504.                         def *= sampleRate;

  505.                     }

  506. 

  507.                     if (LADSPA_IS_PORT_OUTPUT(portType) && (strcmp(ldescriptor->PortNames[j], "latency") == 0 || strcmp(ldescriptor->PortNames[j], "_latency") == 0))

  508.                     {

  509.                         // latency parameter

  510.                         min = 0.0f;

  511.                         max = sampleRate;

  512.                         def = 0.0f;

  513.                     }

  514. 

  515.                     bufferParams[iP] = def;

  516. 

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

  518.                 }

  519.             }

  520. 

  521.             if (ldescriptor->activate)

  522.                 ldescriptor->activate(handle);

  523. 

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

  525.             {

  526.                 snd_seq_event_t midiEvents[2];

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

  528. 

  529.                 const unsigned long midiEventCount = 2;

  530. 

  531.                 midiEvents[0].type = SND_SEQ_EVENT_NOTEON;

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

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

  534. 

  535.                 midiEvents[1].type = SND_SEQ_EVENT_NOTEOFF;

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

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

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

  539. 

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

  541.                 {

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

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

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

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

  546.                 }

  547.                 else

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

  549.             }

  550.             else

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

  552. 

  553.             if (ldescriptor->deactivate)

  554.                 ldescriptor->deactivate(handle);

  555. 

  556.             if (ldescriptor->cleanup)

  557.                 ldescriptor->cleanup(handle);

  558. 

  559.             // end crash-free plugin test

  560.             // -----------------------------------------------------------------------

  561.         }

  562. 

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

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

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

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

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

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

  569.         DISCOVERY_OUT("hints", hints);

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

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

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

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

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

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

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

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

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

  579.         DISCOVERY_OUT("build", BINARY_NATIVE);

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

  581.     }

  582. }

  583. 

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

  585. {

  586.     // Convert bundle filename to URI

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

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

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

  590. 

  591.     // Load bundle

  592.     Lilv::Node lilvBundle(Lv2World.new_uri(qBundle.toUtf8().constData()));

  593.     Lv2World.load_bundle(lilvBundle);

  594. 

  595.     // Load plugins in this bundle

  596.     const Lilv::Plugins lilvPlugins = Lv2World.get_all_plugins();

  597. 

  598.     // Get all plugin URIs in this bundle

  599.     QStringList URIs;

  600. 

  601.     LILV_FOREACH(plugins, i, lilvPlugins)

  602.     {

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

  604.         URIs.append(QString(lilvPlugin.get_uri().as_string()));

  605.     }

  606. 

  607.     // Get & check every plugin-instance

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

  609.     {

  610.         const LV2_RDF_Descriptor* const rdf_descriptor = lv2_rdf_new(URIs.at(i).toUtf8().constData());

  611.         Q_ASSERT(rdf_descriptor && rdf_descriptor->URI);

  612. 

  613.         if (init)

  614.         {

  615.             // test if DLL is loadable

  616.             void* const libHandle = lib_open(rdf_descriptor->Binary);

  617. 

  618.             if (! libHandle)

  619.             {

  620.                 print_lib_error(rdf_descriptor->Binary);

  621.                 continue;

  622.             }

  623. 

  624.             lib_close(libHandle);

  625. 

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

  627.             bool supported = true;

  628. 

  629.             for (uint32_t j=0; j < rdf_descriptor->PortCount; j++)

  630.             {

  631.                 const LV2_RDF_Port* const port = &rdf_descriptor->Ports[j];

  632.                 bool validPort = (LV2_IS_PORT_CONTROL(port->Type) || LV2_IS_PORT_AUDIO(port->Type) || LV2_IS_PORT_ATOM_SEQUENCE(port->Type) /*|| LV2_IS_PORT_CV(port->Type)*/ || LV2_IS_PORT_EVENT(port->Type) || LV2_IS_PORT_MIDI_LL(port->Type));

  633. 

  634.                 if (! (validPort || LV2_IS_PORT_OPTIONAL(port->Properties)))

  635.                 {

  636.                     DISCOVERY_OUT("error", "plugin requires a non-supported port type, port-name: " << port->Name);

  637.                     supported = false;

  638.                     break;

  639.                 }

  640.             }

  641. 

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

  643.             {

  644.                 const LV2_RDF_Feature* const feature = &rdf_descriptor->Features[j];

  645. 

  646.                 if (LV2_IS_FEATURE_REQUIRED(feature->Type) && ! is_lv2_feature_supported(feature->URI))

  647.                 {

  648.                     DISCOVERY_OUT("error", "plugin requires a non-supported feature " << feature->URI);

  649.                     supported = false;

  650.                     break;

  651.                 }

  652.             }

  653. 

  654.             if (! supported)

  655.                 continue;

  656.         }

  657. 

  658.         int hints = 0;

  659.         int audioIns = 0;

  660.         int audioOuts = 0;

  661.         int audioTotal = 0;

  662.         int midiIns = 0;

  663.         int midiOuts = 0;

  664.         int midiTotal = 0;

  665.         int parametersIns = 0;

  666.         int parametersOuts = 0;

  667.         int parametersTotal = 0;

  668. 

  669.         for (uint32_t j=0; j < rdf_descriptor->PortCount; j++)

  670.         {

  671.             const LV2_RDF_Port* const port = &rdf_descriptor->Ports[j];

  672. 

  673.             if (LV2_IS_PORT_AUDIO(port->Type))

  674.             {

  675.                 if (LV2_IS_PORT_INPUT(port->Type))

  676.                     audioIns += 1;

  677.                 else if (LV2_IS_PORT_OUTPUT(port->Type))

  678.                     audioOuts += 1;

  679.                 audioTotal += 1;

  680.             }

  681.             else if (LV2_IS_PORT_CONTROL(port->Type))

  682.             {

  683.                 if (LV2_IS_PORT_DESIGNATION_LATENCY(port->Designation) || LV2_IS_PORT_DESIGNATION_SAMPLE_RATE(port->Designation) ||

  684.                     LV2_IS_PORT_DESIGNATION_FREEWHEELING(port->Designation) || LV2_IS_PORT_DESIGNATION_TIME(port->Designation))

  685.                 {

  686.                     pass();

  687.                 }

  688.                 else

  689.                 {

  690.                     if (LV2_IS_PORT_INPUT(port->Type))

  691.                         parametersIns += 1;

  692.                     else if (LV2_IS_PORT_OUTPUT(port->Type))

  693.                         parametersOuts += 1;

  694.                     parametersTotal += 1;

  695.                 }

  696.             }

  697.             else if (port->Type & LV2_PORT_SUPPORTS_MIDI_EVENT)

  698.             {

  699.                 if (LV2_IS_PORT_INPUT(port->Type))

  700.                     midiIns += 1;

  701.                 else if (LV2_IS_PORT_OUTPUT(port->Type))

  702.                     midiOuts += 1;

  703.                 midiTotal += 1;

  704.             }

  705.         }

  706. 

  707.         if (rdf_descriptor->Type & LV2_CLASS_INSTRUMENT)

  708.             hints |= PLUGIN_IS_SYNTH;

  709. 

  710.         if (rdf_descriptor->UICount > 0)

  711.             hints |= PLUGIN_HAS_GUI;

  712. 

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

  714.         DISCOVERY_OUT("label", rdf_descriptor->URI);

  715.         if (rdf_descriptor->Name)

  716.             DISCOVERY_OUT("name", rdf_descriptor->Name);

  717.         if (rdf_descriptor->Author)

  718.             DISCOVERY_OUT("maker", rdf_descriptor->Author);

  719.         if (rdf_descriptor->License)

  720.             DISCOVERY_OUT("copyright", rdf_descriptor->License);

  721.         DISCOVERY_OUT("unique_id", rdf_descriptor->UniqueID);

  722.         DISCOVERY_OUT("hints", hints);

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

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

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

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

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

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

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

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

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

  732.         DISCOVERY_OUT("build", BINARY_NATIVE);

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

  734.     }

  735. }

  736. 

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

  738. {

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

  740. 

  741.     if (! vstFn)

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

  743. 

  744.     if (! vstFn)

  745.     {

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

  747.         return;

  748.     }

  749. 

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

  751. 

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

  753.     {

  754.         DISCOVERY_OUT("error", "Failed to init VST plugin");

  755.         return;

  756.     }

  757. 

  758.     const char* cName;

  759.     const char* cProduct;

  760.     const char* cVendor;

  761.     char strBuf[255] = { 0 };

  762. 

  763.     effect->dispatcher(effect, effGetEffectName, 0, 0, strBuf, 0.0f);

  764.     cName = strdup((strBuf[0] != 0) ? strBuf : "");

  765. 

  766.     strBuf[0] = 0;

  767.     effect->dispatcher(effect, effGetProductString, 0, 0, strBuf, 0.0f);

  768.     cProduct = strdup((strBuf[0] != 0) ? strBuf : "");

  769. 

  770.     strBuf[0] = 0;

  771.     effect->dispatcher(effect, effGetVendorString, 0, 0, strBuf, 0.0f);

  772.     cVendor = strdup((strBuf[0] != 0) ? strBuf : "");

  773. 

  774.     vstCurrentUniqueId = effect->uniqueID;

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

  776. 

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

  778. 

  779.     while (true)

  780.     {

  781.         int hints = 0;

  782.         int audioIns = effect->numInputs;

  783.         int audioOuts = effect->numOutputs;

  784.         int audioTotal = audioIns + audioOuts;

  785.         int midiIns = 0;

  786.         int midiOuts = 0;

  787.         int midiTotal = 0;

  788.         int parametersIns = effect->numParams;

  789.         int parametersTotal = parametersIns;

  790.         int programsTotal = effect->numPrograms;

  791. 

  792.         if (effect->flags & effFlagsHasEditor)

  793.             hints |= PLUGIN_HAS_GUI;

  794. 

  795.         if (effect->flags & effFlagsIsSynth)

  796.             hints |= PLUGIN_IS_SYNTH;

  797. 

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

  799.             midiIns = 1;

  800. 

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

  802.             midiOuts = 1;

  803. 

  804.         midiTotal = midiIns + midiOuts;

  805. 

  806.         // -----------------------------------------------------------------------

  807.         // start crash-free plugin test

  808. 

  809.         if (init)

  810.         {

  811.             float** bufferAudioIn = new float* [audioIns];

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

  813.             {

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

  815.                 memset(bufferAudioIn[j], 0, sizeof(float)*bufferSize);

  816.             }

  817. 

  818.             float** bufferAudioOut = new float* [audioOuts];

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

  820.             {

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

  822.                 memset(bufferAudioOut[j], 0, sizeof(float)*bufferSize);

  823.             }

  824. 

  825.             struct {

  826.                 int32_t numEvents;

  827.                 intptr_t reserved;

  828.                 VstEvent* data[2];

  829.             } events;

  830.             VstMidiEvent midiEvents[2];

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

  832. 

  833.             midiEvents[0].type = kVstMidiType;

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

  835.             midiEvents[0].midiData[0] = 0x90;

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

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

  838. 

  839.             midiEvents[1].type = kVstMidiType;

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

  841.             midiEvents[1].midiData[0] = 0x80;

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

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

  844. 

  845.             events.numEvents = 2;

  846.             events.reserved  = 0;

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

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

  849. 

  850. #if ! VST_FORCE_DEPRECATED

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

  852. #endif

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

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

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

  856. 

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

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

  859. 

  860.             if (midiIns > 0)

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

  862. 

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

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

  865. #if ! VST_FORCE_DEPRECATED

  866.             else

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

  868. #endif

  869. 

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

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

  872. 

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

  874.                 delete[] bufferAudioIn[j];

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

  876.                 delete[] bufferAudioOut[j];

  877.             delete[] bufferAudioIn;

  878.             delete[] bufferAudioOut;

  879.         }

  880. 

  881.         // end crash-free plugin test

  882.         // -----------------------------------------------------------------------

  883. 

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

  885.         DISCOVERY_OUT("name", cName);

  886.         DISCOVERY_OUT("label", cProduct);

  887.         DISCOVERY_OUT("maker", cVendor);

  888.         DISCOVERY_OUT("copyright", cVendor);

  889.         DISCOVERY_OUT("unique_id", vstCurrentUniqueId);

  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.total", parametersTotal);

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

  900.         DISCOVERY_OUT("build", BINARY_NATIVE);

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

  902. 

  903.         if (vstCategory != kPlugCategShell)

  904.             break;

  905. 

  906.         strBuf[0] = 0;

  907.         vstCurrentUniqueId = effect->dispatcher(effect, effShellGetNextPlugin, 0, 0, strBuf, 0.0f);

  908. 

  909.         if (vstCurrentUniqueId != 0)

  910.         {

  911.             free((void*)cName);

  912.             cName = strdup((strBuf[0] != 0) ? strBuf : "");

  913.         }

  914.         else

  915.             break;

  916.     }

  917. 

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

  919. 

  920.     free((void*)cName);

  921.     free((void*)cProduct);

  922.     free((void*)cVendor);

  923. }

  924. 

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

  926. {

  927. #ifdef WANT_FLUIDSYNTH

  928.     if (! fluid_is_soundfont(filename))

  929.     {

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

  931.         return;

  932.     }

  933. 

  934.     int programs = 0;

  935. 

  936.     if (init)

  937.     {

  938.         fluid_settings_t* const f_settings = new_fluid_settings();

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

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

  941. 

  942.         if (f_id < 0)

  943.         {

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

  945.             return;

  946.         }

  947. 

  948.         fluid_sfont_t* f_sfont;

  949.         fluid_preset_t f_preset;

  950. 

  951.         f_sfont = fluid_synth_get_sfont_by_id(f_synth, f_id);

  952. 

  953.         f_sfont->iteration_start(f_sfont);

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

  955.             programs += 1;

  956. 

  957.         delete_fluid_synth(f_synth);

  958.         delete_fluid_settings(f_settings);

  959.     }

  960. 

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

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

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

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

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

  966.     DISCOVERY_OUT("hints", PLUGIN_IS_SYNTH);

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

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

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

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

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

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

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

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

  975.     DISCOVERY_OUT("build", BINARY_NATIVE);

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

  977. #else

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

  979.     Q_UNUSED(filename);

  980.     Q_UNUSED(init);

  981. #endif

  982. }

  983. 

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

  985. {

  986. #ifdef WANT_LINUXSAMPLER

  987.     const QFileInfo file(filename);

  988. 

  989.     if (! file.exists())

  990.     {

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

  992.         return;

  993.     }

  994. 

  995.     if (! file.isFile())

  996.     {

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

  998.         return;

  999.     }

  1000. 

  1001.     if (! file.isReadable())

  1002.     {

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

  1004.         return;

  1005.     }

  1006. 

  1007.     using namespace LinuxSampler;

  1008. 

  1009.     class LinuxSamplerScopedEngine {

  1010.     public:

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

  1012.         {

  1013.             engine = nullptr;

  1014. 

  1015.             try {

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

  1017.             }

  1018.             catch (const Exception& e)

  1019.             {

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

  1021.                 return;

  1022.             }

  1023. 

  1024.             if (! engine)

  1025.                 return;

  1026. 

  1027.             ins = engine->GetInstrumentManager();

  1028. 

  1029.             if (! ins)

  1030.             {

  1031.                 DISCOVERY_OUT("error", "Failed to get LinuxSampeler instrument manager");

  1032.                 return;

  1033.             }

  1034. 

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

  1036. 

  1037.             try {

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

  1039.             }

  1040.             catch (const Exception& e)

  1041.             {

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

  1043.                 return;

  1044.             }

  1045. 

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

  1047.             {

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

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

  1050.             }

  1051.         }

  1052. 

  1053.         ~LinuxSamplerScopedEngine()

  1054.         {

  1055.             if (engine)

  1056.                 EngineFactory::Destroy(engine);

  1057.         }

  1058. 

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

  1060.         {

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

  1062. 

  1063.             if (info)

  1064.             {

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

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

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

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

  1069.             }

  1070.             else

  1071.             {

  1072.                 DISCOVERY_OUT("name", basename);

  1073.                 DISCOVERY_OUT("label", basename);

  1074.             }

  1075. 

  1076.             DISCOVERY_OUT("hints", PLUGIN_IS_SYNTH);

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

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

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

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

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

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

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

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

  1085.             DISCOVERY_OUT("build", BINARY_NATIVE);

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

  1087.         }

  1088. 

  1089.     private:

  1090.         Engine* engine;

  1091.         InstrumentManager* ins;

  1092.     };

  1093. 

  1094.     if (init)

  1095.         const LinuxSamplerScopedEngine engine(filename, stype);

  1096.     else

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

  1098. 

  1099. #else

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

  1101.     Q_UNUSED(filename);

  1102.     Q_UNUSED(init);

  1103. #endif

  1104. }

  1105. 

  1106. // ------------------------------ main entry point ------------------------------

  1107. 

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

  1109. {

  1110.     if (argc != 3)

  1111.     {

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

  1113.         return 1;

  1114.     }

  1115. 

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

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

  1118. 

  1119.     bool openLib;

  1120.     PluginType type;

  1121.     void* handle = nullptr;

  1122. 

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

  1124.     {

  1125.         openLib = true;

  1126.         type = PLUGIN_LADSPA;

  1127.     }

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

  1129.     {

  1130.         openLib = true;

  1131.         type = PLUGIN_DSSI;

  1132.     }

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

  1134.     {

  1135.         openLib = false;

  1136.         type = PLUGIN_LV2;

  1137.     }

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

  1139.     {

  1140.         openLib = true;

  1141.         type = PLUGIN_VST;

  1142.     }

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

  1144.     {

  1145.         openLib = false;

  1146.         type = PLUGIN_GIG;

  1147.     }

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

  1149.     {

  1150.         openLib = false;

  1151.         type = PLUGIN_SF2;

  1152.     }

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

  1154.     {

  1155.         openLib = false;

  1156.         type = PLUGIN_SFZ;

  1157.     }

  1158.     else

  1159.     {

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

  1161.         return 1;

  1162.     }

  1163. 

  1164.     if (openLib)

  1165.     {

  1166.         handle = lib_open(filename);

  1167. 

  1168.         if (! handle)

  1169.         {

  1170.             print_lib_error(filename);

  1171.             return 1;

  1172.         }

  1173.     }

  1174. 

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

  1176. 

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

  1178.         doInit = false;

  1179. 

  1180.     switch (type)

  1181.     {

  1182.     case PLUGIN_LADSPA:

  1183.         do_ladspa_check(handle, doInit);

  1184.         break;

  1185.     case PLUGIN_DSSI:

  1186.         do_dssi_check(handle, doInit);

  1187.         break;

  1188.     case PLUGIN_LV2:

  1189.         do_lv2_check(filename, doInit);

  1190.         break;

  1191.     case PLUGIN_VST:

  1192.         do_vst_check(handle, doInit);

  1193.         break;

  1194.     case PLUGIN_GIG:

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

  1196.         break;

  1197.     case PLUGIN_SF2:

  1198.         do_fluidsynth_check(filename, doInit);

  1199.         break;

  1200.     case PLUGIN_SFZ:

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

  1202.         break;

  1203.     default:

  1204.         break;

  1205.     }

  1206. 

  1207.     if (openLib)

  1208.         lib_close(handle);

  1209. 

  1210.     return 0;

  1211. }