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

730 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 PluginClass

  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.         : PluginClass(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() const override

  69.     {

  70.         return kParamCount;

  71.     }

  72. 

  73.     const Parameter* getParameterInfo(const uint32_t index) const 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) const 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 MidiEvent* const midiEvents, const uint32_t midiEventCount) 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.     // -------------------------------------------------------------------

  284.     // Plugin dispatcher calls

  285. 

  286.     void sampleRateChanged(const double sampleRate) override

  287.     {

  288.         fArp.setSampleRate(sampleRate);

  289.     }

  290. 

  291. private:

  292.     VexArpSettings fSettings;

  293.     VexArp fArp;

  294.     MidiBuffer fMidiInBuffer;

  295. 

  296.     PluginClassEND(VexArpPlugin)

  297.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexArpPlugin)

  298. };

  299. 

  300. // -----------------------------------------------------------------------

  301. 

  302. class VexChorusPlugin : public PluginClass

  303. {

  304. public:

  305.     enum Params {

  306.         kParamDepth = 0,

  307.         kParamRate,

  308.         kParamCount

  309.     };

  310. 

  311.     VexChorusPlugin(const HostDescriptor* const host)

  312.         : PluginClass(host),

  313.           chorus(parameters)

  314.     {

  315.         parameters[0] = 0.6f;

  316.         parameters[1] = 0.3f;

  317. 

  318.         chorus.setSampleRate(getSampleRate());

  319.     }

  320. 

  321. protected:

  322.     // -------------------------------------------------------------------

  323.     // Plugin parameter calls

  324. 

  325.     uint32_t getParameterCount() const override

  326.     {

  327.         return kParamCount;

  328.     }

  329. 

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

  331.     {

  332.         static Parameter paramInfo;

  333. 

  334.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  335. 

  336.         paramInfo.name = nullptr;

  337.         paramInfo.unit = nullptr;

  338.         paramInfo.ranges.def       = 0.0f;

  339.         paramInfo.ranges.min       = 0.0f;

  340.         paramInfo.ranges.max       = 1.0f;

  341.         paramInfo.ranges.step      = 1.0f;

  342.         paramInfo.ranges.stepSmall = 1.0f;

  343.         paramInfo.ranges.stepLarge = 1.0f;

  344.         paramInfo.scalePointCount  = 0;

  345.         paramInfo.scalePoints      = nullptr;

  346. 

  347.         switch (index)

  348.         {

  349.         case kParamDepth:

  350.             paramInfo.name = "Depth";

  351.             paramInfo.ranges.def = 0.6f;

  352.             paramInfo.ranges.min = 0.0f;

  353.             paramInfo.ranges.max = 1.0f;

  354.             break;

  355.         case kParamRate:

  356.             paramInfo.name = "Rate";

  357.             paramInfo.ranges.def = 0.3f;

  358.             paramInfo.ranges.min = 0.0f;

  359.             paramInfo.ranges.max = 1.0f;

  360.             break;

  361.         }

  362. 

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

  364. 

  365.         return &paramInfo;

  366.     }

  367. 

  368.     float getParameterValue(const uint32_t index) const override

  369.     {

  370.         if (index < kParamCount)

  371.             return parameters[index];

  372.         return 0.0f;

  373.     }

  374. 

  375.     // -------------------------------------------------------------------

  376.     // Plugin state calls

  377. 

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

  379.     {

  380.         if (index < kParamCount)

  381.             parameters[index] = value;

  382.     }

  383. 

  384.     // -------------------------------------------------------------------

  385.     // Plugin process calls

  386. 

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

  388.     {

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

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

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

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

  393. 

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

  395.     }

  396. 

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

  398.     // Plugin dispatcher calls

  399. 

  400.     void sampleRateChanged(const double sampleRate) override

  401.     {

  402.         chorus.setSampleRate(sampleRate);

  403.     }

  404. 

  405. private:

  406.     VexChorus chorus;

  407.     float parameters[2];

  408. 

  409.     PluginClassEND(VexChorusPlugin)

  410.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexChorusPlugin)

  411. };

  412. 

  413. // -----------------------------------------------------------------------

  414. 

  415. class VexDelayPlugin : public PluginClass

  416. {

  417. public:

  418.     enum Params {

  419.         kParamTime = 0,

  420.         kParamFeedback,

  421.         kParamCount

  422.     };

  423. 

  424.     VexDelayPlugin(const HostDescriptor* const host)

  425.         : PluginClass(host),

  426.           delay(parameters)

  427.     {

  428.         parameters[0] = 4.0f;

  429.         parameters[1] = 40.0f;

  430. 

  431.         delay.setSampleRate(getSampleRate());

  432.     }

  433. 

  434. protected:

  435.     // -------------------------------------------------------------------

  436.     // Plugin parameter calls

  437. 

  438.     uint32_t getParameterCount() const override

  439.     {

  440.         return kParamCount;

  441.     }

  442. 

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

  444.     {

  445.         static Parameter paramInfo;

  446. 

  447.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  448. 

  449.         paramInfo.name = nullptr;

  450.         paramInfo.unit = nullptr;

  451.         paramInfo.ranges.def       = 0.0f;

  452.         paramInfo.ranges.min       = 0.0f;

  453.         paramInfo.ranges.max       = 1.0f;

  454.         paramInfo.ranges.step      = 1.0f;

  455.         paramInfo.ranges.stepSmall = 1.0f;

  456.         paramInfo.ranges.stepLarge = 1.0f;

  457.         paramInfo.scalePointCount  = 0;

  458.         paramInfo.scalePoints      = nullptr;

  459. 

  460.         switch (index)

  461.         {

  462.         case kParamTime:

  463.             hints |= PARAMETER_IS_INTEGER;

  464.             paramInfo.name = "Time";

  465.             paramInfo.ranges.def = 4.0f;

  466.             paramInfo.ranges.min = 0.0f;

  467.             paramInfo.ranges.max = 8.0f;

  468.             break;

  469.         case kParamFeedback:

  470.             paramInfo.name = "Feedback";

  471.             paramInfo.unit = "%";

  472.             paramInfo.ranges.def = 40.0f;

  473.             paramInfo.ranges.min = 0.0f;

  474.             paramInfo.ranges.max = 100.0f;

  475.             break;

  476.         }

  477. 

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

  479. 

  480.         return &paramInfo;

  481.     }

  482. 

  483.     float getParameterValue(const uint32_t index) const override

  484.     {

  485.         if (index < kParamCount)

  486.             return parameters[index];

  487.         return 0.0f;

  488.     }

  489. 

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

  491.     // Plugin state calls

  492. 

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

  494.     {

  495.         if (index < kParamCount)

  496.             parameters[index] = value;

  497.     }

  498. 

  499.     // -------------------------------------------------------------------

  500.     // Plugin process calls

  501. 

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

  503.     {

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

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

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

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

  508. 

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

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

  511. 

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

  513.     }

  514. 

  515.     // -------------------------------------------------------------------

  516.     // Plugin dispatcher calls

  517. 

  518.     void sampleRateChanged(const double sampleRate) override

  519.     {

  520.         delay.setSampleRate(sampleRate);

  521.     }

  522. 

  523. private:

  524.     VexDelay delay;

  525.     float parameters[2];

  526. 

  527.     PluginClassEND(VexDelayPlugin)

  528.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexDelayPlugin)

  529. };

  530. 

  531. // -----------------------------------------------------------------------

  532. 

  533. class VexReverbPlugin : public PluginClass

  534. {

  535. public:

  536.     enum Params {

  537.         kParamSize = 0,

  538.         kParamWidth,

  539.         kParamDamp,

  540.         kParamCount

  541.     };

  542. 

  543.     VexReverbPlugin(const HostDescriptor* const host)

  544.         : PluginClass(host),

  545.           reverb(parameters)

  546.     {

  547.         parameters[0] = 0.6f;

  548.         parameters[1] = 0.7f;

  549.         parameters[2] = 0.6f;

  550.     }

  551. 

  552. protected:

  553.     // -------------------------------------------------------------------

  554.     // Plugin parameter calls

  555. 

  556.     uint32_t getParameterCount() const override

  557.     {

  558.         return kParamCount;

  559.     }

  560. 

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

  562.     {

  563.         static Parameter paramInfo;

  564. 

  565.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  566. 

  567.         paramInfo.name = nullptr;

  568.         paramInfo.unit = nullptr;

  569.         paramInfo.ranges.def       = 0.0f;

  570.         paramInfo.ranges.min       = 0.0f;

  571.         paramInfo.ranges.max       = 1.0f;

  572.         paramInfo.ranges.step      = 1.0f;

  573.         paramInfo.ranges.stepSmall = 1.0f;

  574.         paramInfo.ranges.stepLarge = 1.0f;

  575.         paramInfo.scalePointCount  = 0;

  576.         paramInfo.scalePoints      = nullptr;

  577. 

  578.         switch (index)

  579.         {

  580.         case kParamSize:

  581.             paramInfo.name = "Size";

  582.             paramInfo.ranges.def = 0.6f;

  583.             paramInfo.ranges.min = 0.0f;

  584.             paramInfo.ranges.max = 1.0f;

  585.             break;

  586.         case kParamWidth:

  587.             paramInfo.name = "Width";

  588.             paramInfo.ranges.def = 0.7f;

  589.             paramInfo.ranges.min = 0.0f;

  590.             paramInfo.ranges.max = 1.0f;

  591.             break;

  592.         case kParamDamp:

  593.             paramInfo.name = "Damp";

  594.             paramInfo.ranges.def = 0.6f;

  595.             paramInfo.ranges.min = 0.0f;

  596.             paramInfo.ranges.max = 1.0f;

  597.             break;

  598.         }

  599. 

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

  601. 

  602.         return &paramInfo;

  603.     }

  604. 

  605.     float getParameterValue(const uint32_t index) const override

  606.     {

  607.         if (index < kParamCount)

  608.             return parameters[index];

  609.         return 0.0f;

  610.     }

  611. 

  612.     // -------------------------------------------------------------------

  613.     // Plugin state calls

  614. 

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

  616.     {

  617.         if (index < kParamCount)

  618.             parameters[index] = value;

  619.     }

  620. 

  621.     // -------------------------------------------------------------------

  622.     // Plugin process calls

  623. 

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

  625.     {

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

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

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

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

  630. 

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

  632.     }

  633. 

  634. private:

  635.     VexReverb reverb;

  636.     float parameters[3];

  637. 

  638.     PluginClassEND(VexReverbPlugin)

  639.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexReverbPlugin)

  640. };

  641. 

  642. // -----------------------------------------------------------------------

  643. 

  644. static const PluginDescriptor vexArpDesc = {

  645.     /* category  */ PLUGIN_CATEGORY_UTILITY,

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

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

  648.     /* audioIns  */ 0,

  649.     /* audioOuts */ 0,

  650.     /* midiIns   */ 1,

  651.     /* midiOuts  */ 1,

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

  653.     /* paramOuts */ 0,

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

  655.     /* label     */ "vexArp",

  656.     /* maker     */ "falkTX",

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

  658.     PluginDescriptorFILL(VexArpPlugin)

  659. };

  660. 

  661. static const PluginDescriptor vexChorusDesc = {

  662.     /* category  */ PLUGIN_CATEGORY_MODULATOR,

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

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

  665.     /* audioIns  */ 2,

  666.     /* audioOuts */ 2,

  667.     /* midiIns   */ 0,

  668.     /* midiOuts  */ 0,

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

  670.     /* paramOuts */ 0,

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

  672.     /* label     */ "vexChorus",

  673.     /* maker     */ "falkTX",

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

  675.     PluginDescriptorFILL(VexChorusPlugin)

  676. };

  677. 

  678. static const PluginDescriptor vexDelayDesc = {

  679.     /* category  */ PLUGIN_CATEGORY_DELAY,

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

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

  682.     /* audioIns  */ 2,

  683.     /* audioOuts */ 2,

  684.     /* midiIns   */ 0,

  685.     /* midiOuts  */ 0,

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

  687.     /* paramOuts */ 0,

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

  689.     /* label     */ "vexDelay",

  690.     /* maker     */ "falkTX",

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

  692.     PluginDescriptorFILL(VexDelayPlugin)

  693. };

  694. 

  695. static const PluginDescriptor vexReverbDesc = {

  696.     /* category  */ PLUGIN_CATEGORY_DELAY,

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

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

  699.     /* audioIns  */ 2,

  700.     /* audioOuts */ 2,

  701.     /* midiIns   */ 0,

  702.     /* midiOuts  */ 0,

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

  704.     /* paramOuts */ 0,

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

  706.     /* label     */ "vexReverb",

  707.     /* maker     */ "falkTX",

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

  709.     PluginDescriptorFILL(VexReverbPlugin)

  710. };

  711. 

  712. // -----------------------------------------------------------------------

  713. 

  714. CARLA_EXPORT

  715. void carla_register_native_plugin_vex()

  716. {

  717.     carla_register_native_plugin(&vexArpDesc);

  718.     carla_register_native_plugin(&vexChorusDesc);

  719.     carla_register_native_plugin(&vexDelayDesc);

  720.     carla_register_native_plugin(&vexReverbDesc);

  721. }

  722. 

  723. // -----------------------------------------------------------------------

  724. 

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

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

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

  728. 

  729. // -----------------------------------------------------------------------