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.
854 Commits
17 Branches
381MB
Tree: 985dda61a3
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '985dda61a3'
${ noResults }
Carla/source/backend/native/vex.cpp

706 lines
21KB
Raw Blame History 

  1. /*

  2.  * Carla Native Plugins

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

  4.  *

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

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

  7.  * published by the Free Software Foundation; either version 2 of

  8.  * the License, or 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 doc/GPL.txt file.

  16.  */

  17. 

  18. #include "CarlaNative.hpp"

  19. 

  20. using namespace juce;

  21. 

  22. #include "vex/cArp.h"

  23. #include "vex/cChorus.h"

  24. #include "vex/cDelay.h"

  25. #include "vex/cReverb.h"

  26. 

  27. // -----------------------------------------------------------------------

  28. 

  29. class VexArpPlugin : public PluginDescriptorClass

  30. {

  31. public:

  32.     enum Params {

  33.         kParamOnOff = 0,

  34.         kParamLength,

  35.         kParamTimeMode,

  36.         kParamSyncMode,

  37.         kParamFailMode,

  38.         kParamVelMode,

  39.         kParamCount

  40.     };

  41. 

  42.     VexArpPlugin(const HostDescriptor* const host)

  43.         : PluginDescriptorClass(host),

  44.           fSettings(),

  45.           fArp(&fSettings)

  46.     {

  47.         for (int i=0; i < 8; ++i)

  48.             fSettings.grid[i*10] = true;

  49. 

  50.         fSettings.grid[1] = true;

  51.         fSettings.grid[2] = true;

  52.         fSettings.grid[3] = true;

  53. 

  54.         fSettings.grid[41] = true;

  55.         fSettings.grid[42] = true;

  56.         fSettings.grid[43] = true;

  57.         fSettings.grid[44] = true;

  58.         fSettings.grid[45] = true;

  59. 

  60.         fArp.setSampleRate(getSampleRate());

  61.         fMidiInBuffer.ensureSize(512*4);

  62.     }

  63. 

  64. protected:

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

  66.     // Plugin parameter calls

  67. 

  68.     uint32_t getParameterCount() override

  69.     {

  70.         return kParamCount;

  71.     }

  72. 

  73.     const Parameter* getParameterInfo(const uint32_t index) override

  74.     {

  75.         static Parameter paramInfo;

  76.         static ParameterScalePoint scalePoints[4];

  77. 

  78.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE|PARAMETER_IS_INTEGER;

  79. 

  80.         paramInfo.name = nullptr;

  81.         paramInfo.unit = nullptr;

  82.         paramInfo.ranges.def       = 0.0f;

  83.         paramInfo.ranges.min       = 0.0f;

  84.         paramInfo.ranges.max       = 1.0f;

  85.         paramInfo.ranges.step      = 1.0f;

  86.         paramInfo.ranges.stepSmall = 1.0f;

  87.         paramInfo.ranges.stepLarge = 1.0f;

  88.         paramInfo.scalePointCount  = 0;

  89.         paramInfo.scalePoints      = nullptr;

  90. 

  91.         switch (index)

  92.         {

  93.         case kParamOnOff:

  94.             hints |= PARAMETER_IS_BOOLEAN;

  95.             paramInfo.name = "On/Off";

  96.             paramInfo.ranges.def = 0.0f;

  97.             paramInfo.ranges.min = 0.0f;

  98.             paramInfo.ranges.max = 1.0f;

  99.             break;

  100.         case kParamLength:

  101.             paramInfo.name = "Length";

  102.             paramInfo.ranges.def = 8.0f;

  103.             paramInfo.ranges.min = 1.0f;

  104.             paramInfo.ranges.max = 16.0f;

  105.             break;

  106.         case kParamTimeMode:

  107.             hints |= PARAMETER_USES_SCALEPOINTS;

  108.             paramInfo.name = "Time Signature";

  109.             paramInfo.ranges.def = 2.0f;

  110.             paramInfo.ranges.min = 1.0f;

  111.             paramInfo.ranges.max = 3.0f;

  112.             paramInfo.scalePointCount = 3;

  113.             paramInfo.scalePoints     = scalePoints;

  114.             scalePoints[0].label = "8";

  115.             scalePoints[1].label = "16";

  116.             scalePoints[2].label = "32";

  117.             scalePoints[0].value = 1.0f;

  118.             scalePoints[1].value = 2.0f;

  119.             scalePoints[2].value = 3.0f;

  120.             break;

  121.         case kParamSyncMode:

  122.             hints |= PARAMETER_USES_SCALEPOINTS;

  123.             paramInfo.name = "Sync Mode";

  124.             paramInfo.ranges.def = 1.0f;

  125.             paramInfo.ranges.min = 1.0f;

  126.             paramInfo.ranges.max = 2.0f;

  127.             paramInfo.scalePointCount = 2;

  128.             paramInfo.scalePoints     = scalePoints;

  129.             scalePoints[0].label = "Key Sync";

  130.             scalePoints[1].label = "Bar Sync";

  131.             scalePoints[0].value = 1.0f;

  132.             scalePoints[1].value = 2.0f;

  133.             break;

  134.         case kParamFailMode:

  135.             hints |= PARAMETER_USES_SCALEPOINTS;

  136.             paramInfo.name = "Fail Mode";

  137.             paramInfo.ranges.def = 1.0f;

  138.             paramInfo.ranges.min = 1.0f;

  139.             paramInfo.ranges.max = 3.0f;

  140.             paramInfo.scalePointCount = 3;

  141.             paramInfo.scalePoints     = scalePoints;

  142.             scalePoints[0].label = "Silent Step";

  143.             scalePoints[1].label = "Skip One";

  144.             scalePoints[2].label = "Skip Two";

  145.             scalePoints[0].value = 1.0f;

  146.             scalePoints[1].value = 2.0f;

  147.             scalePoints[2].value = 3.0f;

  148.             break;

  149.         case kParamVelMode:

  150.             hints |= PARAMETER_USES_SCALEPOINTS;

  151.             paramInfo.name = "Velocity Mode";

  152.             paramInfo.ranges.def = 1.0f;

  153.             paramInfo.ranges.min = 1.0f;

  154.             paramInfo.ranges.max = 3.0f;

  155.             paramInfo.scalePointCount = 3;

  156.             paramInfo.scalePoints     = scalePoints;

  157.             scalePoints[0].label = "Pattern Velocity";

  158.             scalePoints[1].label = "Input Velocity";

  159.             scalePoints[2].label = "Sum Velocities";

  160.             scalePoints[0].value = 1.0f;

  161.             scalePoints[1].value = 2.0f;

  162.             scalePoints[2].value = 3.0f;

  163.             break;

  164.         }

  165. 

  166.         paramInfo.hints = static_cast<ParameterHints>(hints);

  167. 

  168.         return &paramInfo;

  169.     }

  170. 

  171.     float getParameterValue(const uint32_t index) override

  172.     {

  173.         switch (index)

  174.         {

  175.         case kParamOnOff:

  176.             return fSettings.on ? 1.0f : 0.0f;

  177.         case kParamLength:

  178.             return fSettings.length;

  179.         case kParamTimeMode:

  180.             return fSettings.timeMode;

  181.         case kParamSyncMode:

  182.             return fSettings.syncMode;

  183.         case kParamFailMode:

  184.             return fSettings.failMode;

  185.         case kParamVelMode:

  186.             return fSettings.velMode;

  187.         default:

  188.             return 0.0f;

  189.         }

  190.     }

  191. 

  192.     // -------------------------------------------------------------------

  193.     // Plugin state calls

  194. 

  195.     void setParameterValue(const uint32_t index, const float value)

  196.     {

  197.         switch (index)

  198.         {

  199.         case kParamOnOff:

  200.             fSettings.on = (value > 0.5f);

  201.             break;

  202.         case kParamLength:

  203.             fSettings.length = value;

  204.             break;

  205.         case kParamTimeMode:

  206.             fSettings.timeMode = value;

  207.             break;

  208.         case kParamSyncMode:

  209.             fSettings.syncMode = value;

  210.             break;

  211.         case kParamFailMode:

  212.             fSettings.failMode = value;

  213.             break;

  214.         case kParamVelMode:

  215.             fSettings.velMode = value;

  216.             break;

  217.         }

  218.     }

  219. 

  220.     // -------------------------------------------------------------------

  221.     // Plugin process calls

  222. 

  223.     void process(float**, float**, const uint32_t frames, const uint32_t midiEventCount, const MidiEvent* const midiEvents) override

  224.     {

  225.         if (! fSettings.on)

  226.         {

  227.             for (uint32_t i=0; i < midiEventCount; ++i)

  228.                 writeMidiEvent(&midiEvents[i]);

  229. 

  230.             return;

  231.         }

  232. 

  233.         const TimeInfo* const timeInfo(getTimeInfo());

  234.         double ppqPos, barStartPos, bpm;

  235. 

  236.         if (timeInfo->bbt.valid)

  237.         {

  238.             ppqPos = 0.0;

  239.             barStartPos = 0.0;

  240.             bpm = timeInfo->bbt.beatsPerMinute;

  241.         }

  242.         else

  243.         {

  244.             double ppqBar  = double(timeInfo->bbt.bar - 1) * timeInfo->bbt.beatsPerBar;

  245.             double ppqBeat = double(timeInfo->bbt.beat - 1);

  246.             double ppqTick = double(timeInfo->bbt.tick) / timeInfo->bbt.ticksPerBeat;

  247. 

  248.             ppqPos = ppqBar + ppqBeat + ppqTick;

  249.             barStartPos = ppqBar;

  250.             bpm = 120.0;

  251.         }

  252. 

  253.         fMidiInBuffer.clear();

  254. 

  255.         for (uint32_t i=0; i < midiEventCount; ++i)

  256.         {

  257.             const MidiEvent* const midiEvent(&midiEvents[i]);

  258.             fMidiInBuffer.addEvent(MidiMessage(midiEvent->data, midiEvent->size, midiEvent->time), timeInfo->frame);

  259.         }

  260. 

  261.         const MidiBuffer& outMidiBuffer(fArp.processMidi(fMidiInBuffer, timeInfo->playing, ppqPos, barStartPos, bpm, frames));

  262. 

  263.         MidiBuffer::Iterator outBufferIterator(outMidiBuffer);

  264.         MidiMessage midiMessage(0xf4);

  265.         int sampleNumber;

  266. 

  267.         MidiEvent tmpEvent;

  268.         tmpEvent.port = 0;

  269. 

  270.         while (outBufferIterator.getNextEvent(midiMessage, sampleNumber))

  271.         {

  272.             tmpEvent.size = midiMessage.getRawDataSize();

  273.             tmpEvent.time = midiMessage.getTimeStamp();

  274. 

  275.             if (tmpEvent.size > 4)

  276.                 continue;

  277. 

  278.             std::memcpy(tmpEvent.data, midiMessage.getRawData(), sizeof(uint8_t)*tmpEvent.size);

  279.             writeMidiEvent(&tmpEvent);

  280.         }

  281.     }

  282. 

  283. private:

  284.     VexArpSettings fSettings;

  285.     VexArp fArp;

  286.     MidiBuffer fMidiInBuffer;

  287. 

  288.     PluginDescriptorClassEND(VexArpPlugin)

  289.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexArpPlugin)

  290. };

  291. 

  292. // -----------------------------------------------------------------------

  293. 

  294. class VexChorusPlugin : public PluginDescriptorClass

  295. {

  296. public:

  297.     enum Params {

  298.         kParamDepth = 0,

  299.         kParamRate,

  300.         kParamCount

  301.     };

  302. 

  303.     VexChorusPlugin(const HostDescriptor* const host)

  304.         : PluginDescriptorClass(host),

  305.           chorus(parameters)

  306.     {

  307.         parameters[0] = 0.6f;

  308.         parameters[1] = 0.3f;

  309. 

  310.         chorus.setSampleRate(getSampleRate());

  311.     }

  312. 

  313. protected:

  314.     // -------------------------------------------------------------------

  315.     // Plugin parameter calls

  316. 

  317.     uint32_t getParameterCount() override

  318.     {

  319.         return kParamCount;

  320.     }

  321. 

  322.     const Parameter* getParameterInfo(const uint32_t index) override

  323.     {

  324.         static Parameter paramInfo;

  325. 

  326.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  327. 

  328.         paramInfo.name = nullptr;

  329.         paramInfo.unit = nullptr;

  330.         paramInfo.ranges.def       = 0.0f;

  331.         paramInfo.ranges.min       = 0.0f;

  332.         paramInfo.ranges.max       = 1.0f;

  333.         paramInfo.ranges.step      = 1.0f;

  334.         paramInfo.ranges.stepSmall = 1.0f;

  335.         paramInfo.ranges.stepLarge = 1.0f;

  336.         paramInfo.scalePointCount  = 0;

  337.         paramInfo.scalePoints      = nullptr;

  338. 

  339.         switch (index)

  340.         {

  341.         case kParamDepth:

  342.             paramInfo.name = "Depth";

  343.             paramInfo.ranges.def = 0.6f;

  344.             paramInfo.ranges.min = 0.0f;

  345.             paramInfo.ranges.max = 1.0f;

  346.             break;

  347.         case kParamRate:

  348.             paramInfo.name = "Rate";

  349.             paramInfo.ranges.def = 0.3f;

  350.             paramInfo.ranges.min = 0.0f;

  351.             paramInfo.ranges.max = 1.0f;

  352.             break;

  353.         }

  354. 

  355.         paramInfo.hints = static_cast<ParameterHints>(hints);

  356. 

  357.         return &paramInfo;

  358.     }

  359. 

  360.     float getParameterValue(const uint32_t index) override

  361.     {

  362.         if (index < kParamCount)

  363.             return parameters[index];

  364.         return 0.0f;

  365.     }

  366. 

  367.     // -------------------------------------------------------------------

  368.     // Plugin state calls

  369. 

  370.     void setParameterValue(const uint32_t index, const float value)

  371.     {

  372.         if (index < kParamCount)

  373.             parameters[index] = value;

  374.     }

  375. 

  376.     // -------------------------------------------------------------------

  377.     // Plugin process calls

  378. 

  379.     void process(float** const inBuffer, float** const outBuffer, const uint32_t frames, const uint32_t, const MidiEvent* const) override

  380.     {

  381.         if (inBuffer[0] != outBuffer[0])

  382.             carla_copyFloat(outBuffer[0], inBuffer[0], frames);

  383.         if (inBuffer[1] != outBuffer[1])

  384.             carla_copyFloat(outBuffer[1], inBuffer[1], frames);

  385. 

  386.         chorus.processBlock(outBuffer[0], outBuffer[1], frames);

  387.     }

  388. 

  389. private:

  390.     VexChorus chorus;

  391.     float parameters[2];

  392. 

  393.     PluginDescriptorClassEND(VexChorusPlugin)

  394.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexChorusPlugin)

  395. };

  396. 

  397. // -----------------------------------------------------------------------

  398. 

  399. class VexDelayPlugin : public PluginDescriptorClass

  400. {

  401. public:

  402.     enum Params {

  403.         kParamTime = 0,

  404.         kParamFeedback,

  405.         kParamCount

  406.     };

  407. 

  408.     VexDelayPlugin(const HostDescriptor* const host)

  409.         : PluginDescriptorClass(host),

  410.           delay(parameters)

  411.     {

  412.         parameters[0] = 4.0f;

  413.         parameters[1] = 40.0f;

  414. 

  415.         delay.setSampleRate(getSampleRate());

  416.     }

  417. 

  418. protected:

  419.     // -------------------------------------------------------------------

  420.     // Plugin parameter calls

  421. 

  422.     uint32_t getParameterCount() override

  423.     {

  424.         return kParamCount;

  425.     }

  426. 

  427.     const Parameter* getParameterInfo(const uint32_t index) override

  428.     {

  429.         static Parameter paramInfo;

  430. 

  431.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  432. 

  433.         paramInfo.name = nullptr;

  434.         paramInfo.unit = nullptr;

  435.         paramInfo.ranges.def       = 0.0f;

  436.         paramInfo.ranges.min       = 0.0f;

  437.         paramInfo.ranges.max       = 1.0f;

  438.         paramInfo.ranges.step      = 1.0f;

  439.         paramInfo.ranges.stepSmall = 1.0f;

  440.         paramInfo.ranges.stepLarge = 1.0f;

  441.         paramInfo.scalePointCount  = 0;

  442.         paramInfo.scalePoints      = nullptr;

  443. 

  444.         switch (index)

  445.         {

  446.         case kParamTime:

  447.             hints |= PARAMETER_IS_INTEGER;

  448.             paramInfo.name = "Time";

  449.             paramInfo.ranges.def = 4.0f;

  450.             paramInfo.ranges.min = 0.0f;

  451.             paramInfo.ranges.max = 8.0f;

  452.             break;

  453.         case kParamFeedback:

  454.             paramInfo.name = "Feedback";

  455.             paramInfo.unit = "%";

  456.             paramInfo.ranges.def = 40.0f;

  457.             paramInfo.ranges.min = 0.0f;

  458.             paramInfo.ranges.max = 100.0f;

  459.             break;

  460.         }

  461. 

  462.         paramInfo.hints = static_cast<ParameterHints>(hints);

  463. 

  464.         return &paramInfo;

  465.     }

  466. 

  467.     float getParameterValue(const uint32_t index) override

  468.     {

  469.         if (index < kParamCount)

  470.             return parameters[index];

  471.         return 0.0f;

  472.     }

  473. 

  474.     // -------------------------------------------------------------------

  475.     // Plugin state calls

  476. 

  477.     void setParameterValue(const uint32_t index, const float value)

  478.     {

  479.         if (index < kParamCount)

  480.             parameters[index] = value;

  481.     }

  482. 

  483.     // -------------------------------------------------------------------

  484.     // Plugin process calls

  485. 

  486.     void process(float** const inBuffer, float** const outBuffer, const uint32_t frames, const uint32_t, const MidiEvent* const) override

  487.     {

  488.         if (inBuffer[0] != outBuffer[0])

  489.             carla_copyFloat(outBuffer[0], inBuffer[0], frames);

  490.         if (inBuffer[1] != outBuffer[1])

  491.             carla_copyFloat(outBuffer[1], inBuffer[1], frames);

  492. 

  493.         const TimeInfo* const timeInfo(getTimeInfo());

  494.         const double bpm(timeInfo->bbt.valid ? timeInfo->bbt.beatsPerMinute : 120.0);

  495. 

  496.         delay.processBlock(outBuffer[0], outBuffer[1], frames, bpm);

  497.     }

  498. 

  499. private:

  500.     VexDelay delay;

  501.     float parameters[2];

  502. 

  503.     PluginDescriptorClassEND(VexDelayPlugin)

  504.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexDelayPlugin)

  505. };

  506. 

  507. // -----------------------------------------------------------------------

  508. 

  509. class VexReverbPlugin : public PluginDescriptorClass

  510. {

  511. public:

  512.     enum Params {

  513.         kParamSize = 0,

  514.         kParamWidth,

  515.         kParamDamp,

  516.         kParamCount

  517.     };

  518. 

  519.     VexReverbPlugin(const HostDescriptor* const host)

  520.         : PluginDescriptorClass(host),

  521.           reverb(parameters)

  522.     {

  523.         parameters[0] = 0.6f;

  524.         parameters[1] = 0.7f;

  525.         parameters[2] = 0.6f;

  526.     }

  527. 

  528. protected:

  529.     // -------------------------------------------------------------------

  530.     // Plugin parameter calls

  531. 

  532.     uint32_t getParameterCount() override

  533.     {

  534.         return kParamCount;

  535.     }

  536. 

  537.     const Parameter* getParameterInfo(const uint32_t index) override

  538.     {

  539.         static Parameter paramInfo;

  540. 

  541.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  542. 

  543.         paramInfo.name = nullptr;

  544.         paramInfo.unit = nullptr;

  545.         paramInfo.ranges.def       = 0.0f;

  546.         paramInfo.ranges.min       = 0.0f;

  547.         paramInfo.ranges.max       = 1.0f;

  548.         paramInfo.ranges.step      = 1.0f;

  549.         paramInfo.ranges.stepSmall = 1.0f;

  550.         paramInfo.ranges.stepLarge = 1.0f;

  551.         paramInfo.scalePointCount  = 0;

  552.         paramInfo.scalePoints      = nullptr;

  553. 

  554.         switch (index)

  555.         {

  556.         case kParamSize:

  557.             paramInfo.name = "Size";

  558.             paramInfo.ranges.def = 0.6f;

  559.             paramInfo.ranges.min = 0.0f;

  560.             paramInfo.ranges.max = 1.0f;

  561.             break;

  562.         case kParamWidth:

  563.             paramInfo.name = "Width";

  564.             paramInfo.ranges.def = 0.7f;

  565.             paramInfo.ranges.min = 0.0f;

  566.             paramInfo.ranges.max = 1.0f;

  567.             break;

  568.         case kParamDamp:

  569.             paramInfo.name = "Damp";

  570.             paramInfo.ranges.def = 0.6f;

  571.             paramInfo.ranges.min = 0.0f;

  572.             paramInfo.ranges.max = 1.0f;

  573.             break;

  574.         }

  575. 

  576.         paramInfo.hints = static_cast<ParameterHints>(hints);

  577. 

  578.         return &paramInfo;

  579.     }

  580. 

  581.     float getParameterValue(const uint32_t index) override

  582.     {

  583.         if (index < kParamCount)

  584.             return parameters[index];

  585.         return 0.0f;

  586.     }

  587. 

  588.     // -------------------------------------------------------------------

  589.     // Plugin state calls

  590. 

  591.     void setParameterValue(const uint32_t index, const float value)

  592.     {

  593.         if (index < kParamCount)

  594.             parameters[index] = value;

  595.     }

  596. 

  597.     // -------------------------------------------------------------------

  598.     // Plugin process calls

  599. 

  600.     void process(float** const inBuffer, float** const outBuffer, const uint32_t frames, const uint32_t, const MidiEvent* const) override

  601.     {

  602.         for (uint32_t i=0; i< frames; ++i)

  603.             outBuffer[0][i] = inBuffer[0][i]/2.0f;

  604.         for (uint32_t i=0; i< frames; ++i)

  605.             outBuffer[1][i] = inBuffer[1][i]/2.0f;

  606. 

  607.         reverb.processBlock(outBuffer[0], outBuffer[1], frames);

  608.     }

  609. 

  610. private:

  611.     VexReverb reverb;

  612.     float parameters[3];

  613. 

  614.     PluginDescriptorClassEND(VexReverbPlugin)

  615.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexReverbPlugin)

  616. };

  617. 

  618. // -----------------------------------------------------------------------

  619. 

  620. static const PluginDescriptor vexArpDesc = {

  621.     /* category  */ PLUGIN_CATEGORY_UTILITY,

  622.     /* hints     */ static_cast<PluginHints>(0x0),

  623.     /* supports  */ static_cast<PluginSupports>(PLUGIN_SUPPORTS_EVERYTHING),

  624.     /* audioIns  */ 0,

  625.     /* audioOuts */ 0,

  626.     /* midiIns   */ 1,

  627.     /* midiOuts  */ 1,

  628.     /* paramIns  */ VexArpPlugin::kParamCount,

  629.     /* paramOuts */ 0,

  630.     /* name      */ "Vex Arp",

  631.     /* label     */ "vexArp",

  632.     /* maker     */ "falkTX",

  633.     /* copyright */ "GNU GPL v2+",

  634.     PluginDescriptorFILL(VexArpPlugin)

  635. };

  636. 

  637. static const PluginDescriptor vexChorusDesc = {

  638.     /* category  */ PLUGIN_CATEGORY_MODULATOR,

  639.     /* hints     */ static_cast<PluginHints>(PLUGIN_IS_RTSAFE),

  640.     /* supports  */ static_cast<PluginSupports>(0x0),

  641.     /* audioIns  */ 2,

  642.     /* audioOuts */ 2,

  643.     /* midiIns   */ 0,

  644.     /* midiOuts  */ 0,

  645.     /* paramIns  */ VexChorusPlugin::kParamCount,

  646.     /* paramOuts */ 0,

  647.     /* name      */ "Vex Chorus",

  648.     /* label     */ "vexChorus",

  649.     /* maker     */ "falkTX",

  650.     /* copyright */ "GNU GPL v2+",

  651.     PluginDescriptorFILL(VexChorusPlugin)

  652. };

  653. 

  654. static const PluginDescriptor vexDelayDesc = {

  655.     /* category  */ PLUGIN_CATEGORY_DELAY,

  656.     /* hints     */ static_cast<PluginHints>(PLUGIN_IS_RTSAFE),

  657.     /* supports  */ static_cast<PluginSupports>(0x0),

  658.     /* audioIns  */ 2,

  659.     /* audioOuts */ 2,

  660.     /* midiIns   */ 0,

  661.     /* midiOuts  */ 0,

  662.     /* paramIns  */ VexDelayPlugin::kParamCount,

  663.     /* paramOuts */ 0,

  664.     /* name      */ "Vex Delay",

  665.     /* label     */ "vexDelay",

  666.     /* maker     */ "falkTX",

  667.     /* copyright */ "GNU GPL v2+",

  668.     PluginDescriptorFILL(VexDelayPlugin)

  669. };

  670. 

  671. static const PluginDescriptor vexReverbDesc = {

  672.     /* category  */ PLUGIN_CATEGORY_DELAY,

  673.     /* hints     */ static_cast<PluginHints>(PLUGIN_IS_RTSAFE),

  674.     /* supports  */ static_cast<PluginSupports>(0x0),

  675.     /* audioIns  */ 2,

  676.     /* audioOuts */ 2,

  677.     /* midiIns   */ 0,

  678.     /* midiOuts  */ 0,

  679.     /* paramIns  */ VexReverbPlugin::kParamCount,

  680.     /* paramOuts */ 0,

  681.     /* name      */ "Vex Reverb",

  682.     /* label     */ "vexReverb",

  683.     /* maker     */ "falkTX",

  684.     /* copyright */ "GNU GPL v2+",

  685.     PluginDescriptorFILL(VexReverbPlugin)

  686. };

  687. 

  688. // -----------------------------------------------------------------------

  689. 

  690. CARLA_EXPORT

  691. void carla_register_native_plugin_vex()

  692. {

  693.     carla_register_native_plugin(&vexArpDesc);

  694.     carla_register_native_plugin(&vexChorusDesc);

  695.     carla_register_native_plugin(&vexDelayDesc);

  696.     carla_register_native_plugin(&vexReverbDesc);

  697. }

  698. 

  699. // -----------------------------------------------------------------------

  700. 

  701. #include "vex/freeverb/allpass.cpp"

  702. #include "vex/freeverb/comb.cpp"

  703. #include "vex/freeverb/revmodel.cpp"

  704. 

  705. // -----------------------------------------------------------------------