falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
13 Commits
17 Branches
166MB
Tree: 3e599ecce0
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '3e599ecce0'
${ noResults }
Carla/source/discovery/carla-discovery.cpp

1444 lines
45KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin discovery code

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

  4.  *

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

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

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

  8.  * any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the COPYING file

  16.  */

  17. 

  18. #include "carla_backend.hpp"

  19. #include "carla_lib_utils.hpp"

  20. #include "carla_midi.h"

  21. 

  22. #ifdef WANT_LADSPA

  23. # include "carla_ladspa_utils.hpp"

  24. #endif

  25. #ifdef WANT_DSSI

  26. # include "carla_ladspa_utils.hpp"

  27. # include "dssi/dssi.h"

  28. #endif

  29. #ifdef WANT_LV2

  30. # include <QtCore/QDir>

  31. # include <QtCore/QUrl>

  32. # include "carla_lv2_utils.hpp"

  33. #endif

  34. #ifdef WANT_VST

  35. # include "carla_vst_utils.hpp"

  36. #endif

  37. #ifdef WANT_FLUIDSYNTH

  38. # include <fluidsynth.h>

  39. #endif

  40. #ifdef WANT_LINUXSAMPLER

  41. # include <QtCore/QFileInfo>

  42. # include "linuxsampler/EngineFactory.h"

  43. #endif

  44. 

  45. #include <iostream>

  46. 

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

  48. 

  49. CARLA_BACKEND_USE_NAMESPACE

  50. 

  51. #ifdef WANT_LV2

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

  53. // Our LV2 World class object

  54. 

  55. Lv2WorldClass lv2World;

  56. #endif

  57. 

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

  59. // Dummy values to test plugins with

  60. 

  61. const uint32_t bufferSize = 512;

  62. const double   sampleRate = 44100.0;

  63. 

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

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

  66. 

  67. void print_lib_error(const char* const filename)

  68. {

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

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

  71.         DISCOVERY_OUT("error", error);

  72. }

  73. 

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

  75. // VST stuff

  76. 

  77. #ifdef WANT_VST

  78. // Check if plugin wants midi

  79. bool vstWantsMidi = false;

  80. 

  81. // Check if plugin is processing

  82. bool vstIsProcessing = false;

  83. 

  84. // Current uniqueId for vst shell plugins

  85. intptr_t vstCurrentUniqueId = 0;

  86. 

  87. // Supported Carla features

  88. intptr_t vstHostCanDo(const char* const feature)

  89. {

  90. #if DEBUG

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

  92. #endif

  93. 

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

  95.         return 1;

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

  97.         return 1;

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

  99.         return 1;

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

  101.         return 1;

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

  103.         return 1;

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

  105.         return 1;

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

  107.         return 1;

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

  109.         return -1;

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

  111.         return -1;

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

  113.         return 1;

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

  115.         return 1;

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

  117.         return -1;

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

  119.         return -1;

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

  121.         return -1;

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

  123.         return 1;

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

  125.         return 1;

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

  127.         return 1;

  128. 

  129.     // unimplemented

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

  131.     return 0;

  132. }

  133. 

  134. // Host-side callback

  135. intptr_t VSTCALLBACK vstHostCallback(AEffect* const effect, const int32_t opcode, const int32_t index, const intptr_t value, void* const ptr, const float opt)

  136. {

  137. #if DEBUG

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

  139. #endif

  140. 

  141.     intptr_t ret = 0;

  142. 

  143.     switch (opcode)

  144.     {

  145.     case audioMasterAutomate:

  146.         if (effect)

  147.         {

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

  149.             ret = 1;

  150.         }

  151.         break;

  152. 

  153.     case audioMasterVersion:

  154.         ret = kVstVersion;

  155.         break;

  156. 

  157.     case audioMasterCurrentId:

  158.         ret = vstCurrentUniqueId;

  159.         break;

  160. 

  161. #if ! VST_FORCE_DEPRECATED

  162.     case audioMasterWantMidi:

  163.         vstWantsMidi = true;

  164.         ret = 1;

  165.         break;

  166. #endif

  167. 

  168.     case audioMasterGetTime:

  169.         static VstTimeInfo_R timeInfo;

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

  171.         timeInfo.sampleRate = sampleRate;

  172. 

  173.         // Tempo

  174.         timeInfo.tempo  = 120.0;

  175.         timeInfo.flags |= kVstTempoValid;

  176. 

  177.         // Time Signature

  178.         timeInfo.timeSigNumerator   = 4;

  179.         timeInfo.timeSigDenominator = 4;

  180.         timeInfo.flags |= kVstTimeSigValid;

  181. 

  182.         ret = (intptr_t)&timeInfo;

  183.         break;

  184. 

  185. #if ! VST_FORCE_DEPRECATED

  186.     case audioMasterTempoAt:

  187.         ret = 120 * 10000;

  188.         break;

  189. 

  190.     case audioMasterGetNumAutomatableParameters:

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

  192.         break;

  193. 

  194.     case audioMasterGetParameterQuantization:

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

  196.         break;

  197. #endif

  198. 

  199.     case audioMasterGetSampleRate:

  200.         ret = sampleRate;

  201.         break;

  202. 

  203.     case audioMasterGetBlockSize:

  204.         ret = bufferSize;

  205.         break;

  206. 

  207. #if ! VST_FORCE_DEPRECATED

  208.     case audioMasterWillReplaceOrAccumulate:

  209.         ret = 1; // replace

  210.         break;

  211. #endif

  212. 

  213.     case audioMasterGetCurrentProcessLevel:

  214.         ret = vstIsProcessing ? kVstProcessLevelRealtime : kVstProcessLevelUser;

  215.         break;

  216. 

  217.     case audioMasterGetAutomationState:

  218.         ret = kVstAutomationOff;

  219.         break;

  220. 

  221.     case audioMasterGetVendorString:

  222.         if (ptr)

  223.         {

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

  225.             ret = 1;

  226.         }

  227.         break;

  228. 

  229.     case audioMasterGetProductString:

  230.         if (ptr)

  231.         {

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

  233.             ret = 1;

  234.         }

  235.         break;

  236. 

  237.     case audioMasterGetVendorVersion:

  238.         ret = 0x050; // 0.5.0

  239.         break;

  240. 

  241.     case audioMasterCanDo:

  242.         if (ptr)

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

  244.         break;

  245. 

  246.     case audioMasterGetLanguage:

  247.         ret = kVstLangEnglish;

  248.         break;

  249. 

  250.     default:

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

  252.         break;

  253.     }

  254. 

  255.     return ret;

  256. }

  257. #endif

  258. 

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

  260. 

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

  262. {

  263. #ifdef WANT_LADSPA

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

  265. 

  266.     if (! descFn)

  267.     {

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

  269.         return;

  270.     }

  271. 

  272.     unsigned long i = 0;

  273.     const LADSPA_Descriptor* descriptor;

  274. 

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

  276.     {

  277.         CARLA_ASSERT(descriptor->run);

  278. 

  279.         int hints = 0;

  280.         int audioIns = 0;

  281.         int audioOuts = 0;

  282.         int audioTotal = 0;

  283.         int parametersIns = 0;

  284.         int parametersOuts = 0;

  285.         int parametersTotal = 0;

  286. 

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

  288.         {

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

  290. 

  291.             if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  292.             {

  293.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  294.                     audioIns += 1;

  295.                 else if (LADSPA_IS_PORT_OUTPUT(portDescriptor))

  296.                     audioOuts += 1;

  297.                 audioTotal += 1;

  298.             }

  299.             else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  300.             {

  301.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  302.                     parametersIns += 1;

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

  304.                     parametersOuts += 1;

  305.                 parametersTotal += 1;

  306.             }

  307.         }

  308. 

  309.         if (init)

  310.         {

  311.             // -----------------------------------------------------------------------

  312.             // start crash-free plugin test

  313. 

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

  315. 

  316.             if (! handle)

  317.             {

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

  319.                 continue;

  320.             }

  321. 

  322.             LADSPA_Data bufferAudio[bufferSize][audioTotal];

  323.             LADSPA_Data bufferParams[parametersTotal];

  324.             LADSPA_Data min, max, def;

  325. 

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

  327.             {

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

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

  330. 

  331.                 if (LADSPA_IS_PORT_AUDIO(portType))

  332.                 {

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

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

  335.                 }

  336.                 else if (LADSPA_IS_PORT_CONTROL(portType))

  337.                 {

  338.                     // min value

  339.                     if (LADSPA_IS_HINT_BOUNDED_BELOW(portHints.HintDescriptor))

  340.                         min = portHints.LowerBound;

  341.                     else

  342.                         min = 0.0f;

  343. 

  344.                     // max value

  345.                     if (LADSPA_IS_HINT_BOUNDED_ABOVE(portHints.HintDescriptor))

  346.                         max = portHints.UpperBound;

  347.                     else

  348.                         max = 1.0f;

  349. 

  350.                     if (min > max)

  351.                         max = min;

  352.                     else if (max < min)

  353.                         min = max;

  354. 

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

  356.                     {

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

  358.                         max = min + 0.1f;

  359.                     }

  360. 

  361.                     // default value

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

  363. 

  364.                     if (LADSPA_IS_HINT_SAMPLE_RATE(portHints.HintDescriptor))

  365.                     {

  366.                         min *= sampleRate;

  367.                         max *= sampleRate;

  368.                         def *= sampleRate;

  369.                     }

  370. 

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

  372.                     {

  373.                         // latency parameter

  374.                         min = 0.0f;

  375.                         max = sampleRate;

  376.                         def = 0.0f;

  377.                     }

  378. 

  379.                     if (def < min)

  380.                         def = min;

  381.                     else if (def > max)

  382.                         def = max;

  383. 

  384.                     bufferParams[iP] = def;

  385. 

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

  387.                 }

  388.             }

  389. 

  390.             if (descriptor->activate)

  391.                 descriptor->activate(handle);

  392. 

  393.             if (descriptor->run)

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

  395. 

  396.             if (descriptor->deactivate)

  397.                 descriptor->deactivate(handle);

  398. 

  399.             if (descriptor->cleanup)

  400.                 descriptor->cleanup(handle);

  401. 

  402.             // end crash-free plugin test

  403.             // -----------------------------------------------------------------------

  404.         }

  405. 

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

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

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

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

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

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

  412.         DISCOVERY_OUT("hints", hints);

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

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

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

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

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

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

  419.         DISCOVERY_OUT("build", BINARY_NATIVE);

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

  421.     }

  422. #else

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

  424.     Q_UNUSED(libHandle);

  425.     Q_UNUSED(init);

  426. #endif

  427. }

  428. 

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

  430. {

  431. #ifdef WANT_DSSI

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

  433. 

  434.     if (! descFn)

  435.     {

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

  437.         return;

  438.     }

  439. 

  440.     unsigned long i = 0;

  441.     const DSSI_Descriptor* descriptor;

  442. 

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

  444.     {

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

  446.         CARLA_ASSERT(ldescriptor);

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

  448. 

  449.         int hints = 0;

  450.         int audioIns = 0;

  451.         int audioOuts = 0;

  452.         int audioTotal = 0;

  453.         int midiIns = 0;

  454.         int midiTotal = 0;

  455.         int parametersIns = 0;

  456.         int parametersOuts = 0;

  457.         int parametersTotal = 0;

  458.         int programsTotal = 0;

  459. 

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

  461.         {

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

  463. 

  464.             if (LADSPA_IS_PORT_AUDIO(portDescriptor))

  465.             {

  466.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  467.                     audioIns += 1;

  468.                 else if (LADSPA_IS_PORT_OUTPUT(portDescriptor))

  469.                     audioOuts += 1;

  470.                 audioTotal += 1;

  471.             }

  472.             else if (LADSPA_IS_PORT_CONTROL(portDescriptor))

  473.             {

  474.                 if (LADSPA_IS_PORT_INPUT(portDescriptor))

  475.                     parametersIns += 1;

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

  477.                     parametersOuts += 1;

  478.                 parametersTotal += 1;

  479.             }

  480.         }

  481. 

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

  483.             midiIns = midiTotal = 1;

  484. 

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

  486.             hints |= PLUGIN_IS_SYNTH;

  487. 

  488.         if (init)

  489.         {

  490.             // -----------------------------------------------------------------------

  491.             // start crash-free plugin test

  492. 

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

  494. 

  495.             if (! handle)

  496.             {

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

  498.                 continue;

  499.             }

  500. 

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

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

  503.             {

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

  505.                     continue;

  506.             }

  507. 

  508.             LADSPA_Data bufferAudio[bufferSize][audioTotal];

  509.             LADSPA_Data bufferParams[parametersTotal];

  510.             LADSPA_Data min, max, def;

  511. 

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

  513.             {

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

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

  516. 

  517.                 if (LADSPA_IS_PORT_AUDIO(portType))

  518.                 {

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

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

  521.                 }

  522.                 else if (LADSPA_IS_PORT_CONTROL(portType))

  523.                 {

  524.                     // min value

  525.                     if (LADSPA_IS_HINT_BOUNDED_BELOW(portHints.HintDescriptor))

  526.                         min = portHints.LowerBound;

  527.                     else

  528.                         min = 0.0f;

  529. 

  530.                     // max value

  531.                     if (LADSPA_IS_HINT_BOUNDED_ABOVE(portHints.HintDescriptor))

  532.                         max = portHints.UpperBound;

  533.                     else

  534.                         max = 1.0f;

  535. 

  536.                     if (min > max)

  537.                         max = min;

  538.                     else if (max < min)

  539.                         min = max;

  540. 

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

  542.                     {

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

  544.                         max = min + 0.1f;

  545.                     }

  546. 

  547.                     // default value

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

  549. 

  550.                     if (LADSPA_IS_HINT_SAMPLE_RATE(portHints.HintDescriptor))

  551.                     {

  552.                         min *= sampleRate;

  553.                         max *= sampleRate;

  554.                         def *= sampleRate;

  555.                     }

  556. 

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

  558.                     {

  559.                         // latency parameter

  560.                         min = 0.0f;

  561.                         max = sampleRate;

  562.                         def = 0.0f;

  563.                     }

  564. 

  565.                     if (def < min)

  566.                         def = min;

  567.                     else if (def > max)

  568.                         def = max;

  569. 

  570.                     bufferParams[iP] = def;

  571. 

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

  573.                 }

  574.             }

  575. 

  576.             // select first midi-program if available

  577.             if (programsTotal > 0)

  578.             {

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

  580.                 CARLA_ASSERT(pDesc);

  581. 

  582.                 if (pDesc)

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

  584.             }

  585. 

  586.             if (ldescriptor->activate)

  587.                 ldescriptor->activate(handle);

  588. 

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

  590.             {

  591.                 snd_seq_event_t midiEvents[2];

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

  593. 

  594.                 const unsigned long midiEventCount = 2;

  595. 

  596.                 midiEvents[0].type = SND_SEQ_EVENT_NOTEON;

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

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

  599. 

  600.                 midiEvents[1].type = SND_SEQ_EVENT_NOTEOFF;

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

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

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

  604. 

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

  606.                 {

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

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

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

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

  611.                 }

  612.                 else

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

  614.             }

  615.             else if (ldescriptor->run)

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

  617. 

  618.             if (ldescriptor->deactivate)

  619.                 ldescriptor->deactivate(handle);

  620. 

  621.             if (ldescriptor->cleanup)

  622.                 ldescriptor->cleanup(handle);

  623. 

  624.             // end crash-free plugin test

  625.             // -----------------------------------------------------------------------

  626.         }

  627. 

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

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

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

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

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

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

  634.         DISCOVERY_OUT("hints", hints);

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

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

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

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

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

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

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

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

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

  644.         DISCOVERY_OUT("build", BINARY_NATIVE);

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

  646.     }

  647. #else

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

  649.     Q_UNUSED(libHandle);

  650.     Q_UNUSED(init);

  651. #endif

  652. }

  653. 

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

  655. {

  656. #ifdef WANT_LV2

  657.     // Convert bundle filename to URI

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

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

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

  661. 

  662.     // Load bundle

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

  664.     lv2World.load_bundle(lilvBundle);

  665. 

  666.     // Load plugins in this bundle

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

  668. 

  669.     // Get all plugin URIs in this bundle

  670.     QStringList URIs;

  671. 

  672.     LILV_FOREACH(plugins, i, lilvPlugins)

  673.     {

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

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

  676.     }

  677. 

  678.     // Get & check every plugin-instance

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

  680.     {

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

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

  683. 

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

  685.         {

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

  687.             continue;

  688.         }

  689. 

  690.         if (init)

  691.         {

  692.             // test if DLL is loadable

  693.             {

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

  695. 

  696.                 if (! libHandle)

  697.                 {

  698.                     print_lib_error(rdfDescriptor->Binary);

  699.                     delete rdfDescriptor;

  700.                     continue;

  701.                 }

  702. 

  703.                 lib_close(libHandle);

  704.             }

  705. 

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

  707.             {

  708.                 bool supported = true;

  709. 

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

  711.                 {

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

  713. 

  714.                     if (LV2_IS_PORT_CONTROL(rdfPort->Types))

  715.                     {

  716.                         pass();

  717.                     }

  718.                     else if (LV2_IS_PORT_AUDIO(rdfPort->Types))

  719.                     {

  720.                         pass();

  721.                     }

  722.                     else if (LV2_IS_PORT_ATOM_SEQUENCE(rdfPort->Types))

  723.                     {

  724.                         pass();

  725.                     }

  726.                     //else if (LV2_IS_PORT_CV(rdfPort->Types))

  727.                     //    pass();

  728.                     else if (LV2_IS_PORT_EVENT(rdfPort->Types))

  729.                     {

  730.                         pass();

  731.                     }

  732.                     else if (LV2_IS_PORT_MIDI_LL(rdfPort->Types))

  733.                     {

  734.                         pass();

  735.                     }

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

  737.                     {

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

  739.                         supported = false;

  740.                         break;

  741.                     }

  742.                 }

  743. 

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

  745.                 {

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

  747. 

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

  749.                     {

  750.                         pass();

  751.                     }

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

  753.                     {

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

  755.                         supported = false;

  756.                         break;

  757.                     }

  758.                 }

  759. 

  760.                 if (! supported)

  761.                 {

  762.                     delete rdfDescriptor;

  763.                     continue;

  764.                 }

  765.             }

  766.         }

  767. 

  768.         int hints = 0;

  769.         int audioIns = 0;

  770.         int audioOuts = 0;

  771.         int audioTotal = 0;

  772.         int midiIns = 0;

  773.         int midiOuts = 0;

  774.         int midiTotal = 0;

  775.         int parametersIns = 0;

  776.         int parametersOuts = 0;

  777.         int parametersTotal = 0;

  778.         int programsTotal = rdfDescriptor->PresetCount;

  779. 

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

  781.         {

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

  783. 

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

  785.             {

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

  787.                     audioIns += 1;

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

  789.                     audioOuts += 1;

  790.                 audioTotal += 1;

  791.             }

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

  793.             {

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

  795.                 {

  796.                     pass();

  797.                 }

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

  799.                 {

  800.                     pass();

  801.                 }

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

  803.                 {

  804.                     pass();

  805.                 }

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

  807.                 {

  808.                     pass();

  809.                 }

  810.                 else

  811.                 {

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

  813.                         parametersIns += 1;

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

  815.                         parametersOuts += 1;

  816.                     parametersTotal += 1;

  817.                 }

  818.             }

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

  820.             {

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

  822.                     midiIns += 1;

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

  824.                     midiOuts += 1;

  825.                 midiTotal += 1;

  826.             }

  827.         }

  828. 

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

  830.             hints |= PLUGIN_IS_SYNTH;

  831. 

  832.         if (rdfDescriptor->UICount > 0)

  833.             hints |= PLUGIN_HAS_GUI;

  834. 

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

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

  837.         if (rdfDescriptor->Name)

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

  839.         if (rdfDescriptor->Author)

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

  841.         if (rdfDescriptor->License)

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

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

  844.         DISCOVERY_OUT("hints", hints);

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

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

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

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

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

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

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

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

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

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

  855.         DISCOVERY_OUT("build", BINARY_NATIVE);

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

  857. 

  858.         delete rdfDescriptor;

  859.     }

  860. #else

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

  862.     Q_UNUSED(bundle);

  863.     Q_UNUSED(init);

  864. #endif

  865. }

  866. 

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

  868. {

  869. #ifdef WANT_VST

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

  871. 

  872.     if (! vstFn)

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

  874. 

  875.     if (! vstFn)

  876.     {

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

  878.         return;

  879.     }

  880. 

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

  882. 

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

  884.     {

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

  886.         return;

  887.     }

  888. 

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

  890.     CarlaString cName;

  891.     CarlaString cProduct;

  892.     CarlaString cVendor;

  893. 

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

  895. 

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

  897. 

  898.     if (vstCategory == kPlugCategShell)

  899.     {

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

  901.             cName = strBuf;

  902.     }

  903.     else

  904.     {

  905.         vstCurrentUniqueId = effect->uniqueID;

  906. 

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

  908.             cName = strBuf;

  909.     }

  910. 

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

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

  913.         cVendor = strBuf;

  914. 

  915.     // FIXME: Waves crash during processing

  916.     if (cVendor == "Waves")

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

  918. 

  919.     if (vstCurrentUniqueId == 0)

  920.     {

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

  922.         return;

  923.     }

  924. 

  925.     while (vstCurrentUniqueId != 0)

  926.     {

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

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

  929.             cProduct = strBuf;

  930.         else

  931.             cProduct.clear();

  932. 

  933.         vstWantsMidi = false;

  934. 

  935.         int hints = 0;

  936.         int audioIns = effect->numInputs;

  937.         int audioOuts = effect->numOutputs;

  938.         int audioTotal = audioIns + audioOuts;

  939.         int midiIns = 0;

  940.         int midiOuts = 0;

  941.         int midiTotal = 0;

  942.         int parametersIns = effect->numParams;

  943.         int parametersTotal = parametersIns;

  944.         int programsTotal = effect->numPrograms;

  945. 

  946.         if (effect->flags & effFlagsHasEditor)

  947.             hints |= PLUGIN_HAS_GUI;

  948. 

  949.         if (effect->flags & effFlagsIsSynth)

  950.             hints |= PLUGIN_IS_SYNTH;

  951. 

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

  953.             midiIns = 1;

  954. 

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

  956.             midiOuts = 1;

  957. 

  958.         midiTotal = midiIns + midiOuts;

  959. 

  960.         // -----------------------------------------------------------------------

  961.         // start crash-free plugin test

  962. 

  963.         if (init)

  964.         {

  965. #if ! VST_FORCE_DEPRECATED

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

  967. #endif

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

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

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

  971. 

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

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

  974. 

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

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

  977.             {

  978.                 midiIns = 1;

  979.                 midiTotal = midiIns + midiOuts;

  980.             }

  981. 

  982.             float* bufferAudioIn[audioIns];

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

  984.             {

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

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

  987.             }

  988. 

  989.             float* bufferAudioOut[audioOuts];

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

  991.             {

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

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

  994.             }

  995. 

  996.             struct VstEventsFixed {

  997.                 int32_t numEvents;

  998.                 intptr_t reserved;

  999.                 VstEvent* data[2];

  1000.             };

  1001.             VstEventsFixed events;

  1002.             VstMidiEvent   midiEvents[2];

  1003. 

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

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

  1006. 

  1007.             midiEvents[0].type = kVstMidiType;

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

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

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

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

  1012. 

  1013.             midiEvents[1].type = kVstMidiType;

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

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

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

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

  1018. 

  1019.             events.numEvents = 2;

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

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

  1022. 

  1023.             // processing

  1024.             {

  1025.                 vstIsProcessing = true;

  1026. 

  1027.                 if (midiIns > 0)

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

  1029. 

  1030. #if ! VST_FORCE_DEPRECATED

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

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

  1033.                 else if (effect->process)

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

  1035.                 else

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

  1037. #else

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

  1039.                 if (effect->flags & effFlagsCanReplacing)

  1040.                 {

  1041.                     if (effect->processReplacing)

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

  1043.                     else

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

  1045.                 }

  1046.                 else

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

  1048. #endif

  1049. 

  1050.                 vstIsProcessing = false;

  1051.             }

  1052. 

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

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

  1055. 

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

  1057.                 delete[] bufferAudioIn[j];

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

  1059.                 delete[] bufferAudioOut[j];

  1060.         }

  1061. 

  1062.         // end crash-free plugin test

  1063.         // -----------------------------------------------------------------------

  1064. 

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

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

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

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

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

  1070.         DISCOVERY_OUT("unique_id", vstCurrentUniqueId);

  1071.         DISCOVERY_OUT("hints", hints);

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

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

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

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

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

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

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

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

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

  1081.         DISCOVERY_OUT("build", BINARY_NATIVE);

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

  1083. 

  1084.         if (vstCategory != kPlugCategShell)

  1085.             break;

  1086. 

  1087.         // request next Unique ID

  1088.         intptr_t nextUniqueId = vstCurrentUniqueId;

  1089. 

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

  1091.         while (nextUniqueId == vstCurrentUniqueId)

  1092.         {

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

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

  1095.                 cName = strBuf;

  1096.         }

  1097.     }

  1098. 

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

  1100. #else

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

  1102.     Q_UNUSED(libHandle);

  1103.     Q_UNUSED(init);

  1104. #endif

  1105. }

  1106. 

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

  1108. {

  1109. #ifdef WANT_FLUIDSYNTH

  1110.     if (! fluid_is_soundfont(filename))

  1111.     {

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

  1113.         return;

  1114.     }

  1115. 

  1116.     int programs = 0;

  1117. 

  1118.     if (init)

  1119.     {

  1120.         fluid_settings_t* const f_settings = new_fluid_settings();

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

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

  1123. 

  1124.         if (f_id < 0)

  1125.         {

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

  1127.             return;

  1128.         }

  1129. 

  1130.         fluid_sfont_t* f_sfont;

  1131.         fluid_preset_t f_preset;

  1132. 

  1133.         f_sfont = fluid_synth_get_sfont_by_id(f_synth, f_id);

  1134. 

  1135.         f_sfont->iteration_start(f_sfont);

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

  1137.             programs += 1;

  1138. 

  1139.         delete_fluid_synth(f_synth);

  1140.         delete_fluid_settings(f_settings);

  1141.     }

  1142. 

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

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

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

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

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

  1148.     DISCOVERY_OUT("hints", PLUGIN_IS_SYNTH);

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

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

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

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

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

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

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

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

  1157.     DISCOVERY_OUT("build", BINARY_NATIVE);

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

  1159. #else

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

  1161.     Q_UNUSED(filename);

  1162.     Q_UNUSED(init);

  1163. #endif

  1164. }

  1165. 

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

  1167. {

  1168. #ifdef WANT_LINUXSAMPLER

  1169.     const QFileInfo file(filename);

  1170. 

  1171.     if (! file.exists())

  1172.     {

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

  1174.         return;

  1175.     }

  1176. 

  1177.     if (! file.isFile())

  1178.     {

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

  1180.         return;

  1181.     }

  1182. 

  1183.     if (! file.isReadable())

  1184.     {

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

  1186.         return;

  1187.     }

  1188. 

  1189.     using namespace LinuxSampler;

  1190. 

  1191.     class LinuxSamplerScopedEngine {

  1192.     public:

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

  1194.         {

  1195.             engine = nullptr;

  1196. 

  1197.             try {

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

  1199.             }

  1200.             catch (const Exception& e)

  1201.             {

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

  1203.                 return;

  1204.             }

  1205. 

  1206.             if (! engine)

  1207.                 return;

  1208. 

  1209.             ins = engine->GetInstrumentManager();

  1210. 

  1211.             if (! ins)

  1212.             {

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

  1214.                 return;

  1215.             }

  1216. 

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

  1218. 

  1219.             try {

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

  1221.             }

  1222.             catch (const Exception& e)

  1223.             {

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

  1225.                 return;

  1226.             }

  1227. 

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

  1229.             {

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

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

  1232.             }

  1233.         }

  1234. 

  1235.         ~LinuxSamplerScopedEngine()

  1236.         {

  1237.             if (engine)

  1238.                 EngineFactory::Destroy(engine);

  1239.         }

  1240. 

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

  1242.         {

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

  1244. 

  1245.             if (info)

  1246.             {

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

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

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

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

  1251.             }

  1252.             else

  1253.             {

  1254.                 DISCOVERY_OUT("name", basename);

  1255.                 DISCOVERY_OUT("label", basename);

  1256.             }

  1257. 

  1258.             DISCOVERY_OUT("hints", PLUGIN_IS_SYNTH);

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

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

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

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

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

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

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

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

  1267.             DISCOVERY_OUT("build", BINARY_NATIVE);

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

  1269.         }

  1270. 

  1271.     private:

  1272.         Engine* engine;

  1273.         InstrumentManager* ins;

  1274.     };

  1275. 

  1276.     if (init)

  1277.         const LinuxSamplerScopedEngine engine(filename, stype);

  1278.     else

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

  1280. #else

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

  1282.     Q_UNUSED(filename);

  1283.     Q_UNUSED(init);

  1284. #endif

  1285. }

  1286. 

  1287. // ------------------------------ main entry point ------------------------------

  1288. 

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

  1290. {

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

  1292.     {

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

  1294.         printf("LADSPA: ");

  1295. #ifdef WANT_LADSPA

  1296.         printf("yes\n");

  1297. #else

  1298.         printf("no\n");

  1299. #endif

  1300.         printf("DSSI:   ");

  1301. #ifdef WANT_DSSI

  1302.         printf("yes\n");

  1303. #else

  1304.         printf("no\n");

  1305. #endif

  1306.         printf("LV2:    ");

  1307. #ifdef WANT_LV2

  1308.         printf("yes\n");

  1309. #else

  1310.         printf("no\n");

  1311. #endif

  1312.         printf("VST:    ");

  1313. #ifdef WANT_VST

  1314.         printf("yes\n");

  1315. #else

  1316.         printf("no\n");

  1317. #endif

  1318.         printf("\n");

  1319. 

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

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

  1322. #ifdef WANT_LINUXSAMPLER

  1323.         printf("yes\n");

  1324. #else

  1325.         printf("no\n");

  1326. #endif

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

  1328. #ifdef WANT_FLUIDSYNTH

  1329.         printf("yes\n");

  1330. #else

  1331.         printf("no\n");

  1332. #endif

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

  1334. #ifdef WANT_LINUXSAMPLER

  1335.         printf("yes\n");

  1336. #else

  1337.         printf("no\n");

  1338. #endif

  1339.         return 0;

  1340.     }

  1341. 

  1342.     if (argc != 3)

  1343.     {

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

  1345.         return 1;

  1346.     }

  1347. 

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

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

  1350. 

  1351.     bool openLib;

  1352.     PluginType type;

  1353.     void* handle = nullptr;

  1354. 

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

  1356.     {

  1357.         openLib = true;

  1358.         type = PLUGIN_LADSPA;

  1359.     }

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

  1361.     {

  1362.         openLib = true;

  1363.         type = PLUGIN_DSSI;

  1364.     }

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

  1366.     {

  1367.         openLib = false;

  1368.         type = PLUGIN_LV2;

  1369.     }

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

  1371.     {

  1372.         openLib = true;

  1373.         type = PLUGIN_VST;

  1374.     }

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

  1376.     {

  1377.         openLib = false;

  1378.         type = PLUGIN_GIG;

  1379.     }

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

  1381.     {

  1382.         openLib = false;

  1383.         type = PLUGIN_SF2;

  1384.     }

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

  1386.     {

  1387.         openLib = false;

  1388.         type = PLUGIN_SFZ;

  1389.     }

  1390.     else

  1391.     {

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

  1393.         return 1;

  1394.     }

  1395. 

  1396.     if (openLib)

  1397.     {

  1398.         handle = lib_open(filename);

  1399. 

  1400.         if (! handle)

  1401.         {

  1402.             print_lib_error(filename);

  1403.             return 1;

  1404.         }

  1405.     }

  1406. 

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

  1408. 

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

  1410.         doInit = false;

  1411. 

  1412.     switch (type)

  1413.     {

  1414.     case PLUGIN_LADSPA:

  1415.         do_ladspa_check(handle, doInit);

  1416.         break;

  1417.     case PLUGIN_DSSI:

  1418.         do_dssi_check(handle, doInit);

  1419.         break;

  1420.     case PLUGIN_LV2:

  1421.         do_lv2_check(filename, doInit);

  1422.         break;

  1423.     case PLUGIN_VST:

  1424.         do_vst_check(handle, doInit);

  1425.         break;

  1426.     case PLUGIN_GIG:

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

  1428.         break;

  1429.     case PLUGIN_SF2:

  1430.         do_fluidsynth_check(filename, doInit);

  1431.         break;

  1432.     case PLUGIN_SFZ:

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

  1434.         break;

  1435.     default:

  1436.         break;

  1437.     }

  1438. 

  1439.     if (openLib)

  1440.         lib_close(handle);

  1441. 

  1442.     return 0;

  1443. }