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.
838 Commits
2 Branches
42MB
Tree: b0e2ea16dd
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b0e2ea16dd'
${ noResults }
Cadence/c++/carla-discovery/carla-discovery.cpp

1338 lines
41KB
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 <iostream>

  19. #include <QtCore/QDir>

  20. #include <QtCore/QFileInfo>

  21. #include <QtCore/QUrl>

  22. 

  23. #include "carla_backend.hpp"

  24. #include "carla_lib_utils.hpp"

  25. 

  26. #ifdef WANT_LADSPA

  27. # include "carla_ladspa_utils.hpp"

  28. #endif

  29. #ifdef WANT_DSSI

  30. # include "carla_ladspa_utils.hpp"

  31. # include "dssi/dssi.h"

  32. #endif

  33. #ifdef WANT_LV2

  34. # include "carla_lv2_utils.hpp"

  35. #endif

  36. #ifdef WANT_VST

  37. # include "carla_vst_utils.hpp"

  38. #endif

  39. #ifdef WANT_FLUIDSYNTH

  40. # include <fluidsynth.h>

  41. #endif

  42. #ifdef WANT_LINUXSAMPLER

  43. # include "linuxsampler/EngineFactory.h"

  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. #ifdef WANT_VST

  65. bool vstWantsMidi = false;

  66. intptr_t vstCurrentUniqueId = 0;

  67. 

  68. intptr_t vstHostCanDo(const char* const feature)

  69. {

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

  71. 

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

  73.         return 1;

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

  75.         return 1;

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

  77.         return 1;

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

  79.         return -1;

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

  81.         return 1;

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

  83.         return 1;

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

  85.         return 1;

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

  87.         return -1;

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

  89.         return -1;

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

  91.         return 1;

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

  93.         return 1;

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

  95.         return -1;

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

  97.         return -1;

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

  99.         return -1;

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

  101.         return 1;

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

  103.         return 1;

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

  105.         return 1;

  106. 

  107.     // unimplemented

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

  109.     return 0;

  110. }

  111. 

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

  113. {

  114. #if DEBUG

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

  116. #endif

  117. 

  118.     intptr_t ret = 0;

  119. 

  120.     switch (opcode)

  121.     {

  122.     case audioMasterAutomate:

  123.         if (effect)

  124.         {

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

  126.             ret = 1;

  127.         }

  128.         break;

  129. 

  130.     case audioMasterVersion:

  131.         ret = kVstVersion;

  132.         break;

  133. 

  134.     case audioMasterCurrentId:

  135.         ret = vstCurrentUniqueId;

  136.         break;

  137. 

  138. #if ! VST_FORCE_DEPRECATED

  139.     case audioMasterWantMidi:

  140.         vstWantsMidi = true;

  141.         ret = 1;

  142.         break;

  143. #endif

  144. 

  145.     case audioMasterGetTime:

  146.         static VstTimeInfo_R timeInfo;

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

  148.         timeInfo.sampleRate = sampleRate;

  149. 

  150.         // Tempo

  151.         timeInfo.tempo  = 120.0;

  152.         timeInfo.flags |= kVstTempoValid;

  153. 

  154.         // Time Signature

  155.         timeInfo.timeSigNumerator   = 4;

  156.         timeInfo.timeSigDenominator = 4;

  157.         timeInfo.flags |= kVstTimeSigValid;

  158. 

  159.         ret = (intptr_t)&timeInfo;

  160.         break;

  161. 

  162. #if ! VST_FORCE_DEPRECATED

  163.     case audioMasterTempoAt:

  164.         ret = 120 * 10000;

  165.         break;

  166. 

  167.     case audioMasterGetNumAutomatableParameters:

  168.         ret = carla_minPositiveI(effect->numParams, MAX_PARAMETERS);

  169.         break;

  170. 

  171.     case audioMasterGetParameterQuantization:

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

  173.         break;

  174. #endif

  175. 

  176.     case audioMasterGetSampleRate:

  177.         ret = sampleRate;

  178.         break;

  179. 

  180.     case audioMasterGetBlockSize:

  181.         ret = bufferSize;

  182.         break;

  183. 

  184. #if ! VST_FORCE_DEPRECATED

  185.     case audioMasterWillReplaceOrAccumulate:

  186.         ret = 1; // replace

  187.         break;

  188. #endif

  189. 

  190.     case audioMasterGetCurrentProcessLevel:

  191.         ret = kVstProcessLevelUser;

  192.         break;

  193. 

  194.     case audioMasterGetAutomationState:

  195.         ret = kVstAutomationOff;

  196.         break;

  197. 

  198.     case audioMasterGetVendorString:

  199.         if (ptr)

  200.         {

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

  202.             ret = 1;

  203.         }

  204.         break;

  205. 

  206.     case audioMasterGetProductString:

  207.         if (ptr)

  208.         {

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

  210.             ret = 1;

  211.         }

  212.         break;

  213. 

  214.     case audioMasterGetVendorVersion:

  215.         ret = 0x050; // 0.5.0

  216.         break;

  217. 

  218.     case audioMasterCanDo:

  219.         if (ptr)

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

  221.         break;

  222. 

  223.     case audioMasterGetLanguage:

  224.         ret = kVstLangEnglish;

  225.         break;

  226. 

  227.     default:

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

  229.         break;

  230.     }

  231. 

  232.     return ret;

  233. }

  234. #endif

  235. 

  236. // ------------------------------ Plugin Checks -----------------------------

  237. 

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

  239. {

  240. #ifdef WANT_LADSPA

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

  242. 

  243.     if (! descFn)

  244.     {

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

  246.         return;

  247.     }

  248. 

  249.     unsigned long i = 0;

  250.     const LADSPA_Descriptor* descriptor;

  251. 

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

  253.     {

  254.         CARLA_ASSERT(descriptor->run);

  255. 

  256.         int hints = 0;

  257.         int audioIns = 0;

  258.         int audioOuts = 0;

  259.         int audioTotal = 0;

  260.         int parametersIns = 0;

  261.         int parametersOuts = 0;

  262.         int parametersTotal = 0;

  263. 

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

  265.         {

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

  267. 

  268.             if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  269.             {

  270.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  271.                     audioIns += 1;

  272.                 else if (LADSPA_IS_PORT_OUTPUT(portDescriptor))

  273.                     audioOuts += 1;

  274.                 audioTotal += 1;

  275.             }

  276.             else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  277.             {

  278.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  279.                     parametersIns += 1;

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

  281.                     parametersOuts += 1;

  282.                 parametersTotal += 1;

  283.             }

  284.         }

  285. 

  286.         if (init)

  287.         {

  288.             // -----------------------------------------------------------------------

  289.             // start crash-free plugin test

  290. 

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

  292. 

  293.             if (! handle)

  294.             {

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

  296.                 continue;

  297.             }

  298. 

  299.             LADSPA_Data bufferAudio[bufferSize][audioTotal];

  300.             LADSPA_Data bufferParams[parametersTotal];

  301.             LADSPA_Data min, max, def;

  302. 

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

  304.             {

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

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

  307. 

  308.                 if (LADSPA_IS_PORT_AUDIO(portType))

  309.                 {

  310.                     carla_zeroF(bufferAudio[iA], bufferSize);

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

  312.                 }

  313.                 else if (LADSPA_IS_PORT_CONTROL(portType))

  314.                 {

  315.                     // min value

  316.                     if (LADSPA_IS_HINT_BOUNDED_BELOW(portHints.HintDescriptor))

  317.                         min = portHints.LowerBound;

  318.                     else

  319.                         min = 0.0f;

  320. 

  321.                     // max value

  322.                     if (LADSPA_IS_HINT_BOUNDED_ABOVE(portHints.HintDescriptor))

  323.                         max = portHints.UpperBound;

  324.                     else

  325.                         max = 1.0f;

  326. 

  327.                     if (min > max)

  328.                         max = min;

  329.                     else if (max < min)

  330.                         min = max;

  331. 

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

  333.                     {

  334.                         DISCOVERY_OUT("error", "Broken parameter '" << descriptor->PortNames[j] << "': max - min == 0");

  335.                         max = min + 0.1f;

  336.                     }

  337. 

  338.                     // default value

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

  340. 

  341.                     if (LADSPA_IS_HINT_SAMPLE_RATE(portHints.HintDescriptor))

  342.                     {

  343.                         min *= sampleRate;

  344.                         max *= sampleRate;

  345.                         def *= sampleRate;

  346.                     }

  347. 

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

  349.                     {

  350.                         // latency parameter

  351.                         min = 0.0f;

  352.                         max = sampleRate;

  353.                         def = 0.0f;

  354.                     }

  355. 

  356.                     if (def < min)

  357.                         def = min;

  358.                     else if (def > max)

  359.                         def = max;

  360. 

  361.                     bufferParams[iP] = def;

  362. 

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

  364.                 }

  365.             }

  366. 

  367.             if (descriptor->activate)

  368.                 descriptor->activate(handle);

  369. 

  370.             if (descriptor->run)

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

  372. 

  373.             if (descriptor->deactivate)

  374.                 descriptor->deactivate(handle);

  375. 

  376.             if (descriptor->cleanup)

  377.                 descriptor->cleanup(handle);

  378. 

  379.             // end crash-free plugin test

  380.             // -----------------------------------------------------------------------

  381.         }

  382. 

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

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

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

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

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

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

  389.         DISCOVERY_OUT("hints", hints);

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

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

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

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

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

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

  396.         DISCOVERY_OUT("build", BINARY_NATIVE);

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

  398.     }

  399. #else

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

  401.     Q_UNUSED(libHandle);

  402.     Q_UNUSED(init);

  403. #endif

  404. }

  405. 

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

  407. {

  408. #ifdef WANT_DSSI

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

  410. 

  411.     if (! descFn)

  412.     {

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

  414.         return;

  415.     }

  416. 

  417.     unsigned long i = 0;

  418.     const DSSI_Descriptor* descriptor;

  419. 

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

  421.     {

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

  423.         CARLA_ASSERT(ldescriptor);

  424.         CARLA_ASSERT(ldescriptor->run || descriptor->run_synth || descriptor->run_multiple_synths);

  425. 

  426.         int hints = 0;

  427.         int audioIns = 0;

  428.         int audioOuts = 0;

  429.         int audioTotal = 0;

  430.         int midiIns = 0;

  431.         int midiTotal = 0;

  432.         int parametersIns = 0;

  433.         int parametersOuts = 0;

  434.         int parametersTotal = 0;

  435.         int programsTotal = 0;

  436. 

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

  438.         {

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

  440. 

  441.             if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  442.             {

  443.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  444.                     audioIns += 1;

  445.                 else if (LADSPA_IS_PORT_OUTPUT(portDescriptor))

  446.                     audioOuts += 1;

  447.                 audioTotal += 1;

  448.             }

  449.             else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  450.             {

  451.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  452.                     parametersIns += 1;

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

  454.                     parametersOuts += 1;

  455.                 parametersTotal += 1;

  456.             }

  457.         }

  458. 

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

  460.             midiIns = midiTotal = 1;

  461. 

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

  463.             hints |= PLUGIN_IS_SYNTH;

  464. 

  465.         if (init)

  466.         {

  467.             // -----------------------------------------------------------------------

  468.             // start crash-free plugin test

  469. 

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

  471. 

  472.             if (! handle)

  473.             {

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

  475.                 continue;

  476.             }

  477. 

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

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

  480.             {

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

  482.                     continue;

  483.             }

  484. 

  485.             LADSPA_Data bufferAudio[bufferSize][audioTotal];

  486.             LADSPA_Data bufferParams[parametersTotal];

  487.             LADSPA_Data min, max, def;

  488. 

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

  490.             {

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

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

  493. 

  494.                 if (LADSPA_IS_PORT_AUDIO(portType))

  495.                 {

  496.                     carla_zeroF(bufferAudio[iA], bufferSize);

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

  498.                 }

  499.                 else if (LADSPA_IS_PORT_CONTROL(portType))

  500.                 {

  501.                     // min value

  502.                     if (LADSPA_IS_HINT_BOUNDED_BELOW(portHints.HintDescriptor))

  503.                         min = portHints.LowerBound;

  504.                     else

  505.                         min = 0.0f;

  506. 

  507.                     // max value

  508.                     if (LADSPA_IS_HINT_BOUNDED_ABOVE(portHints.HintDescriptor))

  509.                         max = portHints.UpperBound;

  510.                     else

  511.                         max = 1.0f;

  512. 

  513.                     if (min > max)

  514.                         max = min;

  515.                     else if (max < min)

  516.                         min = max;

  517. 

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

  519.                     {

  520.                         DISCOVERY_OUT("error", "Broken parameter '" << ldescriptor->PortNames[j] << "': max - min == 0");

  521.                         max = min + 0.1f;

  522.                     }

  523. 

  524.                     // default value

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

  526. 

  527.                     if (LADSPA_IS_HINT_SAMPLE_RATE(portHints.HintDescriptor))

  528.                     {

  529.                         min *= sampleRate;

  530.                         max *= sampleRate;

  531.                         def *= sampleRate;

  532.                     }

  533. 

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

  535.                     {

  536.                         // latency parameter

  537.                         min = 0.0f;

  538.                         max = sampleRate;

  539.                         def = 0.0f;

  540.                     }

  541. 

  542.                     if (def < min)

  543.                         def = min;

  544.                     else if (def > max)

  545.                         def = max;

  546. 

  547.                     bufferParams[iP] = def;

  548. 

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

  550.                 }

  551.             }

  552. 

  553.             // select first midi-program if available

  554.             if (programsTotal > 0)

  555.             {

  556.                 const DSSI_Program_Descriptor* pDesc = descriptor->get_program(handle, 0);

  557.                 CARLA_ASSERT(pDesc);

  558. 

  559.                 if (pDesc)

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

  561.             }

  562. 

  563.             if (ldescriptor->activate)

  564.                 ldescriptor->activate(handle);

  565. 

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

  567.             {

  568.                 snd_seq_event_t midiEvents[2];

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

  570. 

  571.                 const unsigned long midiEventCount = 2;

  572. 

  573.                 midiEvents[0].type = SND_SEQ_EVENT_NOTEON;

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

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

  576. 

  577.                 midiEvents[1].type = SND_SEQ_EVENT_NOTEOFF;

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

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

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

  581. 

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

  583.                 {

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

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

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

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

  588.                 }

  589.                 else

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

  591.             }

  592.             else if (ldescriptor->run)

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

  594. 

  595.             if (ldescriptor->deactivate)

  596.                 ldescriptor->deactivate(handle);

  597. 

  598.             if (ldescriptor->cleanup)

  599.                 ldescriptor->cleanup(handle);

  600. 

  601.             // end crash-free plugin test

  602.             // -----------------------------------------------------------------------

  603.         }

  604. 

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

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

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

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

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

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

  611.         DISCOVERY_OUT("hints", hints);

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

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

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

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

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

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

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

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

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

  621.         DISCOVERY_OUT("build", BINARY_NATIVE);

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

  623.     }

  624. #else

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

  626.     Q_UNUSED(libHandle);

  627.     Q_UNUSED(init);

  628. #endif

  629. }

  630. 

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

  632. {

  633. #ifdef WANT_LV2

  634.     // Convert bundle filename to URI

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

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

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

  638. 

  639.     // Load bundle

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

  641.     lv2World.load_bundle(lilvBundle);

  642. 

  643.     // Load plugins in this bundle

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

  645. 

  646.     // Get all plugin URIs in this bundle

  647.     QStringList URIs;

  648. 

  649.     LILV_FOREACH(plugins, i, lilvPlugins)

  650.     {

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

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

  653.     }

  654. 

  655.     // Get & check every plugin-instance

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

  657.     {

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

  659.         CARLA_ASSERT(rdf_descriptor && rdf_descriptor->URI);

  660. 

  661.         if (! (rdf_descriptor && rdf_descriptor->URI))

  662.         {

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

  664.             continue;

  665.         }

  666. 

  667.         if (init)

  668.         {

  669.             // test if DLL is loadable

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

  671. 

  672.             if (! libHandle)

  673.             {

  674.                 print_lib_error(rdf_descriptor->Binary);

  675.                 delete rdf_descriptor;

  676.                 continue;

  677.             }

  678. 

  679.             lib_close(libHandle);

  680. 

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

  682.             bool supported = true;

  683. 

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

  685.             {

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

  687.                 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));

  688. 

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

  690.                 {

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

  692.                     supported = false;

  693.                     break;

  694.                 }

  695.             }

  696. 

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

  698.             {

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

  700. 

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

  702.                 {

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

  704.                     supported = false;

  705.                     break;

  706.                 }

  707.             }

  708. 

  709.             if (! supported)

  710.             {

  711.                 delete rdf_descriptor;

  712.                 continue;

  713.             }

  714.         }

  715. 

  716.         int hints = 0;

  717.         int audioIns = 0;

  718.         int audioOuts = 0;

  719.         int audioTotal = 0;

  720.         int midiIns = 0;

  721.         int midiOuts = 0;

  722.         int midiTotal = 0;

  723.         int parametersIns = 0;

  724.         int parametersOuts = 0;

  725.         int parametersTotal = 0;

  726. 

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

  728.         {

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

  730. 

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

  732.             {

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

  734.                     audioIns += 1;

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

  736.                     audioOuts += 1;

  737.                 audioTotal += 1;

  738.             }

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

  740.             {

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

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

  743.                 {

  744.                     pass();

  745.                 }

  746.                 else

  747.                 {

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

  749.                         parametersIns += 1;

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

  751.                         parametersOuts += 1;

  752.                     parametersTotal += 1;

  753.                 }

  754.             }

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

  756.             {

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

  758.                     midiIns += 1;

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

  760.                     midiOuts += 1;

  761.                 midiTotal += 1;

  762.             }

  763.         }

  764. 

  765.         if (rdf_descriptor->Type & LV2_CLASS_INSTRUMENT)

  766.             hints |= PLUGIN_IS_SYNTH;

  767. 

  768.         if (rdf_descriptor->UICount > 0)

  769.             hints |= PLUGIN_HAS_GUI;

  770. 

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

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

  773.         if (rdf_descriptor->Name)

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

  775.         if (rdf_descriptor->Author)

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

  777.         if (rdf_descriptor->License)

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

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

  780.         DISCOVERY_OUT("hints", hints);

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

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

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

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

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

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

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

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

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

  790.         DISCOVERY_OUT("build", BINARY_NATIVE);

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

  792. 

  793.         delete rdf_descriptor;

  794.     }

  795. #else

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

  797.     Q_UNUSED(bundle);

  798.     Q_UNUSED(init);

  799. #endif

  800. }

  801. 

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

  803. {

  804. #ifdef WANT_VST

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

  806. 

  807.     if (! vstFn)

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

  809. 

  810.     if (! vstFn)

  811.     {

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

  813.         return;

  814.     }

  815. 

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

  817. 

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

  819.     {

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

  821.         return;

  822.     }

  823. 

  824.     const char* cName;

  825.     const char* cProduct;

  826.     const char* cVendor;

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

  828. 

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

  830. 

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

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

  833. 

  834.     strBuf[0] = 0;

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

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

  837. 

  838.     strBuf[0] = 0;

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

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

  841. 

  842.     vstCurrentUniqueId = effect->uniqueID;

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

  844. 

  845.     while (true)

  846.     {

  847.         int hints = 0;

  848.         int audioIns = effect->numInputs;

  849.         int audioOuts = effect->numOutputs;

  850.         int audioTotal = audioIns + audioOuts;

  851.         int midiIns = 0;

  852.         int midiOuts = 0;

  853.         int midiTotal = 0;

  854.         int parametersIns = effect->numParams;

  855.         int parametersTotal = parametersIns;

  856.         int programsTotal = effect->numPrograms;

  857. 

  858.         if (effect->flags & effFlagsHasEditor)

  859.             hints |= PLUGIN_HAS_GUI;

  860. 

  861.         if (effect->flags & effFlagsIsSynth)

  862.             hints |= PLUGIN_IS_SYNTH;

  863. 

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

  865.             midiIns = 1;

  866. 

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

  868.             midiOuts = 1;

  869. 

  870.         midiTotal = midiIns + midiOuts;

  871. 

  872.         // -----------------------------------------------------------------------

  873.         // start crash-free plugin test

  874. 

  875.         if (init)

  876.         {

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

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

  879.             {

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

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

  882.             }

  883. 

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

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

  886.             {

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

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

  889.             }

  890. 

  891.             struct {

  892.                 int32_t numEvents;

  893.                 intptr_t reserved;

  894.                 VstEvent* data[2];

  895.             } events;

  896.             VstMidiEvent midiEvents[2];

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

  898. 

  899.             midiEvents[0].type = kVstMidiType;

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

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

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

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

  904. 

  905.             midiEvents[1].type = kVstMidiType;

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

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

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

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

  910. 

  911.             events.numEvents = 2;

  912.             events.reserved  = 0;

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

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

  915. 

  916. #if ! VST_FORCE_DEPRECATED

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

  918. #endif

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

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

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

  922. 

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

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

  925. 

  926.             if (midiIns > 0)

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

  928. 

  929. #if ! VST_FORCE_DEPRECATED

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

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

  932.             else

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

  934. #else

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

  936.             if (effect->flags & effFlagsCanReplacing)

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

  938. #endif

  939. 

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

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

  942. 

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

  944.                 delete[] bufferAudioIn[j];

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

  946.                 delete[] bufferAudioOut[j];

  947.             delete[] bufferAudioIn;

  948.             delete[] bufferAudioOut;

  949.         }

  950. 

  951.         // end crash-free plugin test

  952.         // -----------------------------------------------------------------------

  953. 

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

  955.         DISCOVERY_OUT("name", cName);

  956.         DISCOVERY_OUT("label", cProduct);

  957.         DISCOVERY_OUT("maker", cVendor);

  958.         DISCOVERY_OUT("copyright", cVendor);

  959.         DISCOVERY_OUT("unique_id", vstCurrentUniqueId);

  960.         DISCOVERY_OUT("hints", hints);

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

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

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

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

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

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

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

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

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

  970.         DISCOVERY_OUT("build", BINARY_NATIVE);

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

  972. 

  973.         if (vstCategory != kPlugCategShell)

  974.             break;

  975. 

  976.         strBuf[0] = 0;

  977.         vstWantsMidi = false;

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

  979. 

  980.         if (vstCurrentUniqueId != 0)

  981.         {

  982.             free((void*)cName);

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

  984.         }

  985.         else

  986.             break;

  987.     }

  988. 

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

  990. 

  991.     free((void*)cName);

  992.     free((void*)cProduct);

  993.     free((void*)cVendor);

  994. #else

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

  996.     Q_UNUSED(libHandle);

  997.     Q_UNUSED(init);

  998. #endif

  999. }

  1000. 

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

  1002. {

  1003. #ifdef WANT_FLUIDSYNTH

  1004.     if (! fluid_is_soundfont(filename))

  1005.     {

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

  1007.         return;

  1008.     }

  1009. 

  1010.     int programs = 0;

  1011. 

  1012.     if (init)

  1013.     {

  1014.         fluid_settings_t* const f_settings = new_fluid_settings();

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

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

  1017. 

  1018.         if (f_id < 0)

  1019.         {

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

  1021.             return;

  1022.         }

  1023. 

  1024.         fluid_sfont_t* f_sfont;

  1025.         fluid_preset_t f_preset;

  1026. 

  1027.         f_sfont = fluid_synth_get_sfont_by_id(f_synth, f_id);

  1028. 

  1029.         f_sfont->iteration_start(f_sfont);

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

  1031.             programs += 1;

  1032. 

  1033.         delete_fluid_synth(f_synth);

  1034.         delete_fluid_settings(f_settings);

  1035.     }

  1036. 

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

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

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

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

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

  1042.     DISCOVERY_OUT("hints", PLUGIN_IS_SYNTH);

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

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

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

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

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

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

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

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

  1051.     DISCOVERY_OUT("build", BINARY_NATIVE);

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

  1053. #else

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

  1055.     Q_UNUSED(filename);

  1056.     Q_UNUSED(init);

  1057. #endif

  1058. }

  1059. 

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

  1061. {

  1062. #ifdef WANT_LINUXSAMPLER

  1063.     const QFileInfo file(filename);

  1064. 

  1065.     if (! file.exists())

  1066.     {

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

  1068.         return;

  1069.     }

  1070. 

  1071.     if (! file.isFile())

  1072.     {

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

  1074.         return;

  1075.     }

  1076. 

  1077.     if (! file.isReadable())

  1078.     {

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

  1080.         return;

  1081.     }

  1082. 

  1083.     using namespace LinuxSampler;

  1084. 

  1085.     class LinuxSamplerScopedEngine {

  1086.     public:

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

  1088.         {

  1089.             engine = nullptr;

  1090. 

  1091.             try {

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

  1093.             }

  1094.             catch (const Exception& e)

  1095.             {

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

  1097.                 return;

  1098.             }

  1099. 

  1100.             if (! engine)

  1101.                 return;

  1102. 

  1103.             ins = engine->GetInstrumentManager();

  1104. 

  1105.             if (! ins)

  1106.             {

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

  1108.                 return;

  1109.             }

  1110. 

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

  1112. 

  1113.             try {

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

  1115.             }

  1116.             catch (const Exception& e)

  1117.             {

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

  1119.                 return;

  1120.             }

  1121. 

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

  1123.             {

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

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

  1126.             }

  1127.         }

  1128. 

  1129.         ~LinuxSamplerScopedEngine()

  1130.         {

  1131.             if (engine)

  1132.                 EngineFactory::Destroy(engine);

  1133.         }

  1134. 

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

  1136.         {

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

  1138. 

  1139.             if (info)

  1140.             {

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

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

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

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

  1145.             }

  1146.             else

  1147.             {

  1148.                 DISCOVERY_OUT("name", basename);

  1149.                 DISCOVERY_OUT("label", basename);

  1150.             }

  1151. 

  1152.             DISCOVERY_OUT("hints", PLUGIN_IS_SYNTH);

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

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

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

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

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

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

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

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

  1161.             DISCOVERY_OUT("build", BINARY_NATIVE);

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

  1163.         }

  1164. 

  1165.     private:

  1166.         Engine* engine;

  1167.         InstrumentManager* ins;

  1168.     };

  1169. 

  1170.     if (init)

  1171.         const LinuxSamplerScopedEngine engine(filename, stype);

  1172.     else

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

  1174. #else

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

  1176.     Q_UNUSED(filename);

  1177.     Q_UNUSED(init);

  1178. #endif

  1179. }

  1180. 

  1181. // ------------------------------ main entry point ------------------------------

  1182. 

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

  1184. {

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

  1186.     {

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

  1188.         printf("LADSPA: ");

  1189. #ifdef WANT_LADSPA

  1190.         printf("yes\n");

  1191. #else

  1192.         printf("no\n");

  1193. #endif

  1194.         printf("DSSI:   ");

  1195. #ifdef WANT_DSSI

  1196.         printf("yes\n");

  1197. #else

  1198.         printf("no\n");

  1199. #endif

  1200.         printf("LV2:    ");

  1201. #ifdef WANT_LV2

  1202.         printf("yes\n");

  1203. #else

  1204.         printf("no\n");

  1205. #endif

  1206.         printf("VST:    ");

  1207. #ifdef WANT_VST

  1208.         printf("yes\n");

  1209. #else

  1210.         printf("no\n");

  1211. #endif

  1212.         printf("\n");

  1213. 

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

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

  1216. #ifdef WANT_LINUXSAMPLER

  1217.         printf("yes\n");

  1218. #else

  1219.         printf("no\n");

  1220. #endif

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

  1222. #ifdef WANT_FLUIDSYNTH

  1223.         printf("yes\n");

  1224. #else

  1225.         printf("no\n");

  1226. #endif

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

  1228. #ifdef WANT_LINUXSAMPLER

  1229.         printf("yes\n");

  1230. #else

  1231.         printf("no\n");

  1232. #endif

  1233.         return 0;

  1234.     }

  1235. 

  1236.     if (argc != 3)

  1237.     {

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

  1239.         return 1;

  1240.     }

  1241. 

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

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

  1244. 

  1245.     bool openLib;

  1246.     PluginType type;

  1247.     void* handle = nullptr;

  1248. 

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

  1250.     {

  1251.         openLib = true;

  1252.         type = PLUGIN_LADSPA;

  1253.     }

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

  1255.     {

  1256.         openLib = true;

  1257.         type = PLUGIN_DSSI;

  1258.     }

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

  1260.     {

  1261.         openLib = false;

  1262.         type = PLUGIN_LV2;

  1263.     }

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

  1265.     {

  1266.         openLib = true;

  1267.         type = PLUGIN_VST;

  1268.     }

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

  1270.     {

  1271.         openLib = false;

  1272.         type = PLUGIN_GIG;

  1273.     }

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

  1275.     {

  1276.         openLib = false;

  1277.         type = PLUGIN_SF2;

  1278.     }

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

  1280.     {

  1281.         openLib = false;

  1282.         type = PLUGIN_SFZ;

  1283.     }

  1284.     else

  1285.     {

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

  1287.         return 1;

  1288.     }

  1289. 

  1290.     if (openLib)

  1291.     {

  1292.         handle = lib_open(filename);

  1293. 

  1294.         if (! handle)

  1295.         {

  1296.             print_lib_error(filename);

  1297.             return 1;

  1298.         }

  1299.     }

  1300. 

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

  1302. 

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

  1304.         doInit = false;

  1305. 

  1306.     switch (type)

  1307.     {

  1308.     case PLUGIN_LADSPA:

  1309.         do_ladspa_check(handle, doInit);

  1310.         break;

  1311.     case PLUGIN_DSSI:

  1312.         do_dssi_check(handle, doInit);

  1313.         break;

  1314.     case PLUGIN_LV2:

  1315.         do_lv2_check(filename, doInit);

  1316.         break;

  1317.     case PLUGIN_VST:

  1318.         do_vst_check(handle, doInit);

  1319.         break;

  1320.     case PLUGIN_GIG:

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

  1322.         break;

  1323.     case PLUGIN_SF2:

  1324.         do_fluidsynth_check(filename, doInit);

  1325.         break;

  1326.     case PLUGIN_SFZ:

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

  1328.         break;

  1329.     default:

  1330.         break;

  1331.     }

  1332. 

  1333.     if (openLib)

  1334.         lib_close(handle);

  1335. 

  1336.     return 0;

  1337. }