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.
937 Commits
17 Branches
890MB
Tree: b0f5706efe
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b0f5706efe'
${ noResults }
Carla/source/modules/carla_native/vex.cpp

1322 lines
38KB
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. #include "juce_core.h"

  21. 

  22. using namespace juce;

  23. 

  24. #include "vex/VexArp.h"

  25. #include "vex/VexChorus.h"

  26. #include "vex/VexDelay.h"

  27. #include "vex/VexReverb.h"

  28. #include "vex/VexSyntModule.h"

  29. 

  30. #include "vex/PeggyViewComponent.h"

  31. 

  32. // -----------------------------------------------------------------------

  33. 

  34. class HelperWindow : public DocumentWindow

  35. {

  36. public:

  37.     HelperWindow()

  38.         : DocumentWindow("PlugWindow", Colour(0, 0, 0), DocumentWindow::closeButton, false),

  39.           fClosed(false)

  40.     {

  41.         setDropShadowEnabled(false);

  42.         setOpaque(true);

  43.         setResizable(false, false);

  44.         //setUsingNativeTitleBar(true);

  45.         setVisible(false);

  46.     }

  47. 

  48.     void show(Component* const comp)

  49.     {

  50.         fClosed = false;

  51. 

  52.         setContentNonOwned(comp, true);

  53.         centreWithSize(comp->getWidth(), comp->getHeight());

  54. 

  55.         if (! isOnDesktop())

  56.             addToDesktop();

  57. 

  58.         setVisible(true);

  59.     }

  60. 

  61.     void hide()

  62.     {

  63.         setVisible(false);

  64. 

  65.         if (isOnDesktop())

  66.             removeFromDesktop();

  67. 

  68.         clearContentComponent();

  69.     }

  70. 

  71.     bool wasClosedByUser() const

  72.     {

  73.         return fClosed;

  74.     }

  75. 

  76. protected:

  77.     void closeButtonPressed() override

  78.     {

  79.         fClosed = true;

  80.     }

  81. 

  82. private:

  83.     bool fClosed;

  84. };

  85. 

  86. // -----------------------------------------------------------------------

  87. 

  88. class VexArpPlugin : public PluginClass,

  89.                      public PeggyViewComponent::Callback

  90. {

  91. public:

  92.     enum Params {

  93.         kParamOnOff = 0,

  94.         kParamLength,

  95.         kParamTimeMode,

  96.         kParamSyncMode,

  97.         kParamFailMode,

  98.         kParamVelMode,

  99.         kParamCount

  100.     };

  101. 

  102.     VexArpPlugin(const HostDescriptor* const host)

  103.         : PluginClass(host),

  104.           fArp(&fSettings)

  105.     {

  106.         fArp.setSampleRate(getSampleRate());

  107.         fMidiInBuffer.ensureSize(512*4);

  108.     }

  109. 

  110. protected:

  111.     // -------------------------------------------------------------------

  112.     // Plugin parameter calls

  113. 

  114.     uint32_t getParameterCount() const override

  115.     {

  116.         return kParamCount;

  117.     }

  118. 

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

  120.     {

  121.         static Parameter paramInfo;

  122.         static ParameterScalePoint scalePoints[4];

  123. 

  124.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE|PARAMETER_IS_INTEGER;

  125. 

  126.         paramInfo.name = nullptr;

  127.         paramInfo.unit = nullptr;

  128.         paramInfo.ranges.def       = 0.0f;

  129.         paramInfo.ranges.min       = 0.0f;

  130.         paramInfo.ranges.max       = 1.0f;

  131.         paramInfo.ranges.step      = 1.0f;

  132.         paramInfo.ranges.stepSmall = 1.0f;

  133.         paramInfo.ranges.stepLarge = 1.0f;

  134.         paramInfo.scalePointCount  = 0;

  135.         paramInfo.scalePoints      = nullptr;

  136. 

  137.         switch (index)

  138.         {

  139.         case kParamOnOff:

  140.             hints |= PARAMETER_IS_BOOLEAN;

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

  142.             paramInfo.ranges.def = 0.0f;

  143.             paramInfo.ranges.min = 0.0f;

  144.             paramInfo.ranges.max = 1.0f;

  145.             break;

  146.         case kParamLength:

  147.             paramInfo.name = "Length";

  148.             paramInfo.ranges.def = 8.0f;

  149.             paramInfo.ranges.min = 1.0f;

  150.             paramInfo.ranges.max = 16.0f;

  151.             break;

  152.         case kParamTimeMode:

  153.             hints |= PARAMETER_USES_SCALEPOINTS;

  154.             paramInfo.name = "Time Signature";

  155.             paramInfo.ranges.def = 2.0f;

  156.             paramInfo.ranges.min = 1.0f;

  157.             paramInfo.ranges.max = 3.0f;

  158.             paramInfo.scalePointCount = 3;

  159.             paramInfo.scalePoints     = scalePoints;

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

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

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

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

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

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

  166.             break;

  167.         case kParamSyncMode:

  168.             hints |= PARAMETER_USES_SCALEPOINTS;

  169.             paramInfo.name = "Sync Mode";

  170.             paramInfo.ranges.def = 1.0f;

  171.             paramInfo.ranges.min = 1.0f;

  172.             paramInfo.ranges.max = 2.0f;

  173.             paramInfo.scalePointCount = 2;

  174.             paramInfo.scalePoints     = scalePoints;

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

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

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

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

  179.             break;

  180.         case kParamFailMode:

  181.             hints |= PARAMETER_USES_SCALEPOINTS;

  182.             paramInfo.name = "Fail Mode";

  183.             paramInfo.ranges.def = 1.0f;

  184.             paramInfo.ranges.min = 1.0f;

  185.             paramInfo.ranges.max = 3.0f;

  186.             paramInfo.scalePointCount = 3;

  187.             paramInfo.scalePoints     = scalePoints;

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

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

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

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

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

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

  194.             break;

  195.         case kParamVelMode:

  196.             hints |= PARAMETER_USES_SCALEPOINTS;

  197.             paramInfo.name = "Velocity Mode";

  198.             paramInfo.ranges.def = 1.0f;

  199.             paramInfo.ranges.min = 1.0f;

  200.             paramInfo.ranges.max = 3.0f;

  201.             paramInfo.scalePointCount = 3;

  202.             paramInfo.scalePoints     = scalePoints;

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

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

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

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

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

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

  209.             break;

  210.         }

  211. 

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

  213. 

  214.         return &paramInfo;

  215.     }

  216. 

  217.     float getParameterValue(const uint32_t index) const override

  218.     {

  219.         switch (index)

  220.         {

  221.         case kParamOnOff:

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

  223.         case kParamLength:

  224.             return fSettings.length;

  225.         case kParamTimeMode:

  226.             return fSettings.timeMode;

  227.         case kParamSyncMode:

  228.             return fSettings.syncMode;

  229.         case kParamFailMode:

  230.             return fSettings.failMode;

  231.         case kParamVelMode:

  232.             return fSettings.velMode;

  233.         default:

  234.             return 0.0f;

  235.         }

  236.     }

  237. 

  238.     // -------------------------------------------------------------------

  239.     // Plugin state calls

  240. 

  241.     void setParameterValue(const uint32_t index, const float value) override

  242.     {

  243.         switch (index)

  244.         {

  245.         case kParamOnOff:

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

  247.             break;

  248.         case kParamLength:

  249.             fSettings.length = value;

  250.             break;

  251.         case kParamTimeMode:

  252.             fSettings.timeMode = value;

  253.             break;

  254.         case kParamSyncMode:

  255.             fSettings.syncMode = value;

  256.             break;

  257.         case kParamFailMode:

  258.             fSettings.failMode = value;

  259.             break;

  260.         case kParamVelMode:

  261.             fSettings.velMode = value;

  262.             break;

  263.         }

  264.     }

  265. 

  266.     // -------------------------------------------------------------------

  267.     // Plugin process calls

  268. 

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

  270.     {

  271.         if (! fSettings.on)

  272.         {

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

  274.                 writeMidiEvent(&midiEvents[i]);

  275. 

  276.             return;

  277.         }

  278. 

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

  280. 

  281.         bool   timePlaying = false;

  282.         double ppqPos      = 0.0;

  283.         double barStartPos = 0.0;

  284.         double bpm         = 120.0;

  285. 

  286.         if (timeInfo != nullptr)

  287.         {

  288.             timePlaying = timeInfo->playing;

  289. 

  290.             if (timeInfo->bbt.valid)

  291.             {

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

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

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

  295. 

  296.                 ppqPos      = ppqBar + ppqBeat + ppqTick;

  297.                 barStartPos = ppqBar;

  298.                 bpm         = timeInfo->bbt.beatsPerMinute;

  299.             }

  300.         }

  301. 

  302.         fMidiInBuffer.clear();

  303. 

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

  305.         {

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

  307.             fMidiInBuffer.addEvent(MidiMessage(midiEvent->data, midiEvent->size), midiEvent->time);

  308.         }

  309. 

  310.         const MidiBuffer& outMidiBuffer(fArp.processMidi(fMidiInBuffer, timePlaying, ppqPos, barStartPos, bpm, frames));

  311. 

  312.         MidiBuffer::Iterator outBufferIterator(outMidiBuffer);

  313.         MidiMessage midiMessage(0xf4);

  314.         int sampleNumber;

  315. 

  316.         MidiEvent tmpEvent;

  317.         tmpEvent.port = 0;

  318. 

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

  320.         {

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

  322.             tmpEvent.time = sampleNumber;

  323. 

  324.             if (tmpEvent.size > 4)

  325.                 continue;

  326. 

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

  328.             writeMidiEvent(&tmpEvent);

  329.         }

  330.     }

  331. 

  332.     // -------------------------------------------------------------------

  333.     // Plugin UI calls

  334. 

  335.     void uiShow(const bool show) override

  336.     {

  337.         if (show)

  338.         {

  339.             if (fWindow == nullptr)

  340.             {

  341.                 fWindow = new HelperWindow();

  342.                 fWindow->setName(getUiName());

  343.             }

  344. 

  345.             if (fView == nullptr)

  346.             {

  347.                 fView = new PeggyViewComponent(1, fSettings, this);

  348.                 fView->setSize(207, 280);

  349.             }

  350. 

  351.             fWindow->show(fView);

  352.         }

  353.         else if (fWindow != nullptr)

  354.         {

  355.             fWindow->hide();

  356. 

  357.             fView = nullptr;

  358.             fWindow = nullptr;

  359.         }

  360.     }

  361. 

  362.     void uiIdle() override

  363.     {

  364.         if (fWindow == nullptr)

  365.             return;

  366. 

  367.         if (fWindow->wasClosedByUser())

  368.         {

  369.             uiShow(false);

  370.             uiClosed();

  371.         }

  372.     }

  373. 

  374.     void uiSetParameterValue(const uint32_t, const float) override

  375.     {

  376.         if (fView == nullptr)

  377.             return;

  378. 

  379.         fView->update();

  380.     }

  381. 

  382.     // -------------------------------------------------------------------

  383.     // Plugin dispatcher calls

  384. 

  385.     void sampleRateChanged(const double sampleRate) override

  386.     {

  387.         fArp.setSampleRate(sampleRate);

  388.     }

  389. 

  390.     void uiNameChanged(const char* const uiName) override

  391.     {

  392.         if (fWindow == nullptr)

  393.             return;

  394. 

  395.         fWindow->setName(uiName);

  396.     }

  397. 

  398.     // -------------------------------------------------------------------

  399.     // Peggy callback

  400. 

  401.     void somethingChanged(const uint32_t id) override

  402.     {

  403.         uiParameterChanged(id, getParameterValue(id));

  404.     }

  405. 

  406. private:

  407.     VexArpSettings fSettings;

  408.     VexArp fArp;

  409.     MidiBuffer fMidiInBuffer;

  410. 

  411.     ScopedPointer<PeggyViewComponent> fView;

  412.     ScopedPointer<HelperWindow> fWindow;

  413. 

  414.     PluginClassEND(VexArpPlugin)

  415.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexArpPlugin)

  416. };

  417. 

  418. // -----------------------------------------------------------------------

  419. 

  420. class VexChorusPlugin : public PluginClass

  421. {

  422. public:

  423.     enum Params {

  424.         kParamRate = 0,

  425.         kParamDepth,

  426.         kParamCount

  427.     };

  428. 

  429.     VexChorusPlugin(const HostDescriptor* const host)

  430.         : PluginClass(host),

  431.           fChorus(fParameters)

  432.     {

  433.         std::memset(fParameters, 0, sizeof(float)*92);

  434. 

  435.         fParameters[76] = 0.3f;

  436.         fParameters[77] = 0.6f;

  437. 

  438.         fChorus.setSampleRate(getSampleRate());

  439.     }

  440. 

  441. protected:

  442.     // -------------------------------------------------------------------

  443.     // Plugin parameter calls

  444. 

  445.     uint32_t getParameterCount() const override

  446.     {

  447.         return kParamCount;

  448.     }

  449. 

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

  451.     {

  452.         static Parameter paramInfo;

  453. 

  454.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  455. 

  456.         paramInfo.name = nullptr;

  457.         paramInfo.unit = nullptr;

  458.         paramInfo.ranges.def       = 0.0f;

  459.         paramInfo.ranges.min       = 0.0f;

  460.         paramInfo.ranges.max       = 1.0f;

  461.         paramInfo.ranges.step      = PARAMETER_RANGES_DEFAULT_STEP;

  462.         paramInfo.ranges.stepSmall = PARAMETER_RANGES_DEFAULT_STEP_SMALL;

  463.         paramInfo.ranges.stepLarge = PARAMETER_RANGES_DEFAULT_STEP_LARGE;

  464.         paramInfo.scalePointCount  = 0;

  465.         paramInfo.scalePoints      = nullptr;

  466. 

  467.         switch (index)

  468.         {

  469.         case kParamRate:

  470.             paramInfo.name = "Rate";

  471.             paramInfo.ranges.def = 0.3f;

  472.             paramInfo.ranges.min = 0.0f;

  473.             paramInfo.ranges.max = 1.0f;

  474.             break;

  475.         case kParamDepth:

  476.             paramInfo.name = "Depth";

  477.             paramInfo.ranges.def = 0.6f;

  478.             paramInfo.ranges.min = 0.0f;

  479.             paramInfo.ranges.max = 1.0f;

  480.             break;

  481.         }

  482. 

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

  484. 

  485.         return &paramInfo;

  486.     }

  487. 

  488.     float getParameterValue(const uint32_t index) const override

  489.     {

  490.         switch (index)

  491.         {

  492.         case kParamRate:

  493.             return fParameters[76];

  494.         case kParamDepth:

  495.             return fParameters[77];

  496.         default:

  497.             return 0.0f;

  498.         }

  499.     }

  500. 

  501.     // -------------------------------------------------------------------

  502.     // Plugin state calls

  503. 

  504.     void setParameterValue(const uint32_t index, const float value) override

  505.     {

  506.         switch (index)

  507.         {

  508.         case kParamRate:

  509.             fParameters[76] = value;

  510.             break;

  511.         case kParamDepth:

  512.             fParameters[77] = value;

  513.             break;

  514.         default:

  515.             break;

  516.         }

  517.     }

  518. 

  519.     // -------------------------------------------------------------------

  520.     // Plugin process calls

  521. 

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

  523.     {

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

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

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

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

  528. 

  529.         fChorus.processBlock(outBuffer[0], outBuffer[1], frames);

  530.     }

  531. 

  532.     // -------------------------------------------------------------------

  533.     // Plugin dispatcher calls

  534. 

  535.     void sampleRateChanged(const double sampleRate) override

  536.     {

  537.         fChorus.setSampleRate(sampleRate);

  538.     }

  539. 

  540. private:

  541.     VexChorus fChorus;

  542.     float fParameters[92];

  543. 

  544.     PluginClassEND(VexChorusPlugin)

  545.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexChorusPlugin)

  546. };

  547. 

  548. // -----------------------------------------------------------------------

  549. 

  550. class VexDelayPlugin : public PluginClass

  551. {

  552. public:

  553.     enum Params {

  554.         kParamTime = 0,

  555.         kParamFeedback,

  556.         kParamCount

  557.     };

  558. 

  559.     VexDelayPlugin(const HostDescriptor* const host)

  560.         : PluginClass(host),

  561.           fDelay(fParameters)

  562.     {

  563.         std::memset(fParameters, 0, sizeof(float)*92);

  564. 

  565.         fParameters[73] = 0.5f * 8.0f;

  566.         fParameters[74] = 0.4f * 100.0f;

  567. 

  568.         fDelay.setSampleRate(getSampleRate());

  569.     }

  570. 

  571. protected:

  572.     // -------------------------------------------------------------------

  573.     // Plugin parameter calls

  574. 

  575.     uint32_t getParameterCount() const override

  576.     {

  577.         return kParamCount;

  578.     }

  579. 

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

  581.     {

  582.         static Parameter paramInfo;

  583. 

  584.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  585. 

  586.         paramInfo.name = nullptr;

  587.         paramInfo.unit = nullptr;

  588.         paramInfo.ranges.def       = 0.0f;

  589.         paramInfo.ranges.min       = 0.0f;

  590.         paramInfo.ranges.max       = 1.0f;

  591.         paramInfo.ranges.step      = PARAMETER_RANGES_DEFAULT_STEP;

  592.         paramInfo.ranges.stepSmall = PARAMETER_RANGES_DEFAULT_STEP_SMALL;

  593.         paramInfo.ranges.stepLarge = PARAMETER_RANGES_DEFAULT_STEP_LARGE;

  594.         paramInfo.scalePointCount  = 0;

  595.         paramInfo.scalePoints      = nullptr;

  596. 

  597.         switch (index)

  598.         {

  599.         case kParamTime:

  600.             hints |= PARAMETER_IS_INTEGER;

  601.             paramInfo.name = "Time";

  602.             paramInfo.ranges.def = 4.0f;

  603.             paramInfo.ranges.min = 0.0f;

  604.             paramInfo.ranges.max = 8.0f;

  605.             break;

  606.         case kParamFeedback:

  607.             paramInfo.name = "Feedback";

  608.             paramInfo.unit = "%";

  609.             paramInfo.ranges.def = 40.0f;

  610.             paramInfo.ranges.min = 0.0f;

  611.             paramInfo.ranges.max = 100.0f;

  612.             break;

  613.         }

  614. 

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

  616. 

  617.         return &paramInfo;

  618.     }

  619. 

  620.     float getParameterValue(const uint32_t index) const override

  621.     {

  622.         switch (index)

  623.         {

  624.         case kParamTime:

  625.             return fParameters[73] * 8.0f;

  626.         case kParamFeedback:

  627.             return fParameters[74] * 100.0f;

  628.         default:

  629.             return 0.0f;

  630.         }

  631.     }

  632. 

  633.     // -------------------------------------------------------------------

  634.     // Plugin state calls

  635. 

  636.     void setParameterValue(const uint32_t index, const float value) override

  637.     {

  638.         switch (index)

  639.         {

  640.         case kParamTime:

  641.             fParameters[73] = value/8.0f;

  642.             break;

  643.         case kParamFeedback:

  644.             fParameters[74] = value/100.0f;

  645.             break;

  646.         default:

  647.             break;

  648.         }

  649.     }

  650. 

  651.     // -------------------------------------------------------------------

  652.     // Plugin process calls

  653. 

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

  655.     {

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

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

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

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

  660. 

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

  662.         const double bpm((timeInfo != nullptr && timeInfo->bbt.valid) ? timeInfo->bbt.beatsPerMinute : 120.0);

  663. 

  664.         fDelay.processBlock(outBuffer[0], outBuffer[1], frames, bpm);

  665.     }

  666. 

  667.     // -------------------------------------------------------------------

  668.     // Plugin dispatcher calls

  669. 

  670.     void sampleRateChanged(const double sampleRate) override

  671.     {

  672.         fDelay.setSampleRate(sampleRate);

  673.     }

  674. 

  675. private:

  676.     VexDelay fDelay;

  677.     float fParameters[92];

  678. 

  679.     PluginClassEND(VexDelayPlugin)

  680.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexDelayPlugin)

  681. };

  682. 

  683. // -----------------------------------------------------------------------

  684. 

  685. class VexReverbPlugin : public PluginClass

  686. {

  687. public:

  688.     enum Params {

  689.         kParamSize = 0,

  690.         kParamWidth,

  691.         kParamDamp,

  692.         kParamCount

  693.     };

  694. 

  695.     VexReverbPlugin(const HostDescriptor* const host)

  696.         : PluginClass(host),

  697.           fReverb(fParameters)

  698.     {

  699.         std::memset(fParameters, 0, sizeof(float)*92);

  700. 

  701.         // FIXME?

  702.         fParameters[79] = 0.6f;

  703.         fParameters[80] = 0.6f;

  704.         fParameters[81] = 0.7f;

  705.     }

  706. 

  707. protected:

  708.     // -------------------------------------------------------------------

  709.     // Plugin parameter calls

  710. 

  711.     uint32_t getParameterCount() const override

  712.     {

  713.         return kParamCount;

  714.     }

  715. 

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

  717.     {

  718.         static Parameter paramInfo;

  719. 

  720.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  721. 

  722.         paramInfo.name = nullptr;

  723.         paramInfo.unit = nullptr;

  724.         paramInfo.ranges.def       = 0.0f;

  725.         paramInfo.ranges.min       = 0.0f;

  726.         paramInfo.ranges.max       = 1.0f;

  727.         paramInfo.ranges.step      = PARAMETER_RANGES_DEFAULT_STEP;

  728.         paramInfo.ranges.stepSmall = PARAMETER_RANGES_DEFAULT_STEP_SMALL;

  729.         paramInfo.ranges.stepLarge = PARAMETER_RANGES_DEFAULT_STEP_LARGE;

  730.         paramInfo.scalePointCount  = 0;

  731.         paramInfo.scalePoints      = nullptr;

  732. 

  733.         switch (index)

  734.         {

  735.         case kParamSize:

  736.             paramInfo.name = "Size";

  737.             paramInfo.ranges.def = 0.6f;

  738.             paramInfo.ranges.min = 0.0f;

  739.             paramInfo.ranges.max = 1.0f;

  740.             break;

  741.         case kParamWidth:

  742.             paramInfo.name = "Width";

  743.             paramInfo.ranges.def = 0.7f;

  744.             paramInfo.ranges.min = 0.0f;

  745.             paramInfo.ranges.max = 1.0f;

  746.             break;

  747.         case kParamDamp:

  748.             paramInfo.name = "Damp";

  749.             paramInfo.ranges.def = 0.6f;

  750.             paramInfo.ranges.min = 0.0f;

  751.             paramInfo.ranges.max = 1.0f;

  752.             break;

  753.         }

  754. 

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

  756. 

  757.         return &paramInfo;

  758.     }

  759. 

  760.     float getParameterValue(const uint32_t index) const override

  761.     {

  762.         switch (index)

  763.         {

  764.         case kParamSize:

  765.             return fParameters[79];

  766.         case kParamWidth:

  767.             return fParameters[80];

  768.         case kParamDamp:

  769.             return fParameters[81];

  770.         default:

  771.             return 0.0f;

  772.         }

  773.     }

  774. 

  775.     // -------------------------------------------------------------------

  776.     // Plugin state calls

  777. 

  778.     void setParameterValue(const uint32_t index, const float value) override

  779.     {

  780.         switch (index)

  781.         {

  782.         case kParamSize:

  783.             fParameters[79] = value;

  784.             break;

  785.         case kParamWidth:

  786.             fParameters[80] = value;

  787.             break;

  788.         case kParamDamp:

  789.             fParameters[81] = value;

  790.             break;

  791.         default:

  792.             break;

  793.         }

  794.     }

  795. 

  796.     // -------------------------------------------------------------------

  797.     // Plugin process calls

  798. 

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

  800.     {

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

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

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

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

  805. 

  806.         fReverb.processBlock(outBuffer[0], outBuffer[1], frames);

  807.     }

  808. 

  809. private:

  810.     VexReverb fReverb;

  811.     float fParameters[92];

  812. 

  813.     PluginClassEND(VexReverbPlugin)

  814.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexReverbPlugin)

  815. };

  816. 

  817. // -----------------------------------------------------------------------

  818. 

  819. class VexSynthPlugin : public PluginClass

  820. {

  821. public:

  822.     static const unsigned int kParamCount = 92;

  823. 

  824.     VexSynthPlugin(const HostDescriptor* const host)

  825.         : PluginClass(host),

  826.           obf(nullptr),

  827.           abf(nullptr),

  828.           dbf1(nullptr),

  829.           dbf2(nullptr),

  830.           dbf3(nullptr),

  831.           fChorus(fParameters),

  832.           fDelay(fParameters),

  833.           fReverb(fParameters),

  834.           fSynth(fParameters)

  835.     {

  836.         std::memset(fParameters, 0, sizeof(float)*92);

  837. 

  838.         fParameters[0] = 1.0f; // main volume

  839. 

  840.         for (int i = 0; i < 3; ++i)

  841.         {

  842.             const int offset = i * 24;

  843. 

  844.             fParameters[offset +  1] = 0.5f;

  845.             fParameters[offset +  2] = 0.5f;

  846.             fParameters[offset +  3] = 0.5f;

  847.             fParameters[offset +  4] = 0.5f;

  848.             fParameters[offset +  5] = 0.9f;

  849.             fParameters[offset +  6] = 0.0f;

  850.             fParameters[offset +  7] = 1.0f;

  851.             fParameters[offset +  8] = 0.5f;

  852.             fParameters[offset +  9] = 0.0f;

  853.             fParameters[offset + 10] = 0.2f;

  854.             fParameters[offset + 11] = 0.0f;

  855.             fParameters[offset + 12] = 0.5f;

  856.             fParameters[offset + 13] = 0.5f;

  857.             fParameters[offset + 14] = 0.0f;

  858.             fParameters[offset + 15] = 0.3f;

  859.             fParameters[offset + 16] = 0.7f;

  860.             fParameters[offset + 17] = 0.1f;

  861.             fParameters[offset + 18] = 0.5f;

  862.             fParameters[offset + 19] = 0.5f;

  863.             fParameters[offset + 20] = 0.0f;

  864.             fParameters[offset + 21] = 0.0f;

  865.             fParameters[offset + 22] = 0.5f;

  866.             fParameters[offset + 23] = 0.5f;

  867.             fParameters[offset + 24] = 0.5f;

  868.         }

  869. 

  870.         // ^1 - 72

  871. 

  872.         fParameters[73] = 0.5f; // Delay Time

  873.         fParameters[74] = 0.4f; // Delay Feedback

  874.         fParameters[75] = 0.0f; // Delay Volume

  875. 

  876.         fParameters[76] = 0.3f; // Chorus Rate

  877.         fParameters[77] = 0.6f; // Chorus Depth

  878.         fParameters[78] = 0.5f; // Chorus Volume

  879. 

  880.         fParameters[79] = 0.6f; // Reverb Size

  881.         fParameters[80] = 0.7f; // Reverb Width

  882.         fParameters[81] = 0.6f; // Reverb Damp

  883.         fParameters[82] = 0.0f; // Reverb Volume

  884. 

  885.         fParameters[83] = 0.5f; // wave1 panning

  886.         fParameters[84] = 0.5f; // wave2 panning

  887.         fParameters[85] = 0.5f; // wave3 panning

  888. 

  889.         fParameters[86] = 0.5f; // wave1 volume

  890.         fParameters[87] = 0.5f; // wave2 volume

  891.         fParameters[88] = 0.5f; // wave3 volume

  892. 

  893.         fParameters[89] = 1.0f; // wave1 on/off

  894.         fParameters[90] = 1.0f; // wave2 on/off

  895.         fParameters[91] = 1.0f; // wave3 on/off

  896. 

  897.         bufferSizeChanged(getBufferSize());

  898.         sampleRateChanged(getSampleRate());

  899.     }

  900. 

  901.     ~VexSynthPlugin()

  902.     {

  903.         delete obf;

  904.         delete abf;

  905.         delete dbf1;

  906.         delete dbf2;

  907.         delete dbf3;

  908.     }

  909. 

  910. protected:

  911.     // -------------------------------------------------------------------

  912.     // Plugin parameter calls

  913. 

  914.     uint32_t getParameterCount() const override

  915.     {

  916.         return kParamCount;

  917.     }

  918. 

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

  920.     {

  921.         static Parameter paramInfo;

  922. 

  923.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  924. 

  925.         paramInfo.name = nullptr;

  926.         paramInfo.unit = nullptr;

  927.         paramInfo.ranges.def       = 0.0f;

  928.         paramInfo.ranges.min       = 0.0f;

  929.         paramInfo.ranges.max       = 1.0f;

  930.         paramInfo.ranges.step      = PARAMETER_RANGES_DEFAULT_STEP;

  931.         paramInfo.ranges.stepSmall = PARAMETER_RANGES_DEFAULT_STEP_SMALL;

  932.         paramInfo.ranges.stepLarge = PARAMETER_RANGES_DEFAULT_STEP_LARGE;

  933.         paramInfo.scalePointCount  = 0;

  934.         paramInfo.scalePoints      = nullptr;

  935. 

  936.         if (index >= 1 && index <= 72)

  937.         {

  938.             uint32_t ri = index % 24;

  939. 

  940.             switch (ri)

  941.             {

  942.             case 1:

  943.                 paramInfo.name = "oct";

  944.                 break;

  945.             case 2:

  946.                 paramInfo.name = "cent";

  947.                 break;

  948.             case 3:

  949.                 paramInfo.name = "phaseOffset";

  950.                 break;

  951.             case 4:

  952.                 paramInfo.name = "phaseIncOffset";

  953.                 break;

  954.             case 5:

  955.                 paramInfo.name = "filter";

  956.                 break;

  957.             case 6:

  958.                 paramInfo.name = "filter";

  959.                 break;

  960.             case 7:

  961.                 paramInfo.name = "filter";

  962.                 break;

  963.             case 8:

  964.                 paramInfo.name = "filter";

  965.                 break;

  966.             case 9:

  967.                 paramInfo.name = "F ADSR";

  968.                 break;

  969.             case 10:

  970.                 paramInfo.name = "F ADSR";

  971.                 break;

  972.             case 11:

  973.                 paramInfo.name = "F ADSR";

  974.                 break;

  975.             case 12:

  976.                 paramInfo.name = "F ADSR";

  977.                 break;

  978.             case 13:

  979.                 paramInfo.name = "F velocity";

  980.                 break;

  981.             case 14:

  982.                 paramInfo.name = "A ADSR";

  983.                 break;

  984.             case 15:

  985.                 paramInfo.name = "A ADSR";

  986.                 break;

  987.             case 16:

  988.                 paramInfo.name = "A ADSR";

  989.                 break;

  990.             case 17:

  991.                 paramInfo.name = "A ADSR";

  992.                 break;

  993.             case 18:

  994.                 paramInfo.name = "A velocity";

  995.                 break;

  996.             case 19:

  997.                 paramInfo.name = "lfoC";

  998.                 break;

  999.             case 20:

  1000.                 paramInfo.name = "lfoA";

  1001.                 break;

  1002.             case 21:

  1003.                 paramInfo.name = "lfoF";

  1004.                 break;

  1005.             case 22:

  1006.                 paramInfo.name = "fx vol D";

  1007.                 break;

  1008.             case 23:

  1009.                 paramInfo.name = "fx vol C";

  1010.                 break;

  1011.             case 24:

  1012.             case 0:

  1013.                 paramInfo.name = "fx vol R";

  1014.                 break;

  1015.             default:

  1016.                 paramInfo.name = "unknown2";

  1017.                 break;

  1018.             }

  1019. 

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

  1021.             return &paramInfo;

  1022.         }

  1023. 

  1024.         switch (index)

  1025.         {

  1026.         case 0:

  1027.             paramInfo.name = "Main volume";

  1028.             break;

  1029.         case 73:

  1030.             paramInfo.name = "Delay Time";

  1031.             break;

  1032.         case 74:

  1033.             paramInfo.name = "Delay Feedback";

  1034.             break;

  1035.         case 75:

  1036.             paramInfo.name = "Delay Volume";

  1037.             break;

  1038.         case 76:

  1039.             paramInfo.name = "Chorus Rate";

  1040.             break;

  1041.         case 77:

  1042.             paramInfo.name = "Chorus Depth";

  1043.             break;

  1044.         case 78:

  1045.             paramInfo.name = "Chorus Volume";

  1046.             break;

  1047.         case 79:

  1048.             paramInfo.name = "Reverb Size";

  1049.             break;

  1050.         case 80:

  1051.             paramInfo.name = "Reverb Width";

  1052.             break;

  1053.         case 81:

  1054.             paramInfo.name = "Reverb Damp";

  1055.             break;

  1056.         case 82:

  1057.             paramInfo.name = "Reverb Volume";

  1058.             break;

  1059.         case 83:

  1060.             paramInfo.name = "Wave1 Panning";

  1061.             break;

  1062.         case 84:

  1063.             paramInfo.name = "Wave2 Panning";

  1064.             break;

  1065.         case 85:

  1066.             paramInfo.name = "Wave3 Panning";

  1067.             break;

  1068.         case 86:

  1069.             paramInfo.name = "Wave1 Volume";

  1070.             break;

  1071.         case 87:

  1072.             paramInfo.name = "Wave2 Volume";

  1073.             break;

  1074.         case 88:

  1075.             paramInfo.name = "Wave3 Volume";

  1076.             break;

  1077.         case 89:

  1078.             paramInfo.name = "Wave1 on/off";

  1079.             break;

  1080.         case 90:

  1081.             paramInfo.name = "Wave2 on/off";

  1082.             break;

  1083.         case 91:

  1084.             paramInfo.name = "Wave3 on/off";

  1085.             break;

  1086.         default:

  1087.             paramInfo.name = "unknown";

  1088.             break;

  1089.         }

  1090. 

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

  1092.         return &paramInfo;

  1093.     }

  1094. 

  1095.     float getParameterValue(const uint32_t index) const override

  1096.     {

  1097.         return (index < kParamCount) ? fParameters[index] : 0.0f;

  1098.     }

  1099. 

  1100.     // -------------------------------------------------------------------

  1101.     // Plugin state calls

  1102. 

  1103.     void setParameterValue(const uint32_t index, const float value) override

  1104.     {

  1105.         if (index < kParamCount)

  1106.         {

  1107.             fParameters[index] = value;

  1108.             fSynth.update(index);

  1109.         }

  1110.     }

  1111. 

  1112.     // -------------------------------------------------------------------

  1113.     // Plugin process calls

  1114. 

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

  1116.     {

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

  1118.         const double bpm((timeInfo != nullptr && timeInfo->bbt.valid) ? timeInfo->bbt.beatsPerMinute : 120.0);

  1119. 

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

  1121.         {

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

  1123. 

  1124.             const uint8_t status(MIDI_GET_STATUS_FROM_DATA(midiEvent->data));

  1125. 

  1126.             if (status == MIDI_STATUS_NOTE_ON)

  1127.             {

  1128.                 fSynth.playNote(midiEvent->data[1], midiEvent->data[2], 0, 1);

  1129.             }

  1130.             else if (status == MIDI_STATUS_NOTE_OFF)

  1131.             {

  1132.                 fSynth.releaseNote(midiEvent->data[1], 0, 1);

  1133.             }

  1134.             else if (status == MIDI_STATUS_CONTROL_CHANGE)

  1135.             {

  1136.                 const uint8_t control(midiEvent->data[1]);

  1137. 

  1138.                 if (control == MIDI_CONTROL_ALL_SOUND_OFF)

  1139.                     fSynth.kill();

  1140.                 else if (control == MIDI_CONTROL_ALL_NOTES_OFF)

  1141.                     fSynth.releaseAll(1);

  1142.             }

  1143.         }

  1144. 

  1145.         if (obf->getNumSamples() != (int)frames)

  1146.         {

  1147.                 obf->setSize(2,  frames, 0, 0, 1);

  1148.                 abf->setSize(2,  frames, 0, 0, 1);

  1149.                 dbf1->setSize(2, frames, 0, 0, 1);

  1150.                 dbf2->setSize(2, frames, 0, 0, 1);

  1151.                 dbf3->setSize(2, frames, 0, 0, 1);

  1152.         }

  1153. 

  1154.         obf ->clear();

  1155.         dbf1->clear();

  1156.         dbf2->clear();

  1157.         dbf3->clear();

  1158. 

  1159.         fSynth.doProcess(*obf, *abf, *dbf1, *dbf2, *dbf3);

  1160. 

  1161.         if (fParameters[75] > 0.001f) fDelay.processBlock(dbf1, bpm);

  1162.         if (fParameters[78] > 0.001f) fChorus.processBlock(dbf2);

  1163.         if (fParameters[82] > 0.001f) fReverb.processBlock(dbf3);

  1164. 

  1165.         AudioSampleBuffer output(outBuffer, 2, 0, frames);

  1166.         output.clear();

  1167. 

  1168.         obf->addFrom(0, 0, *dbf1, 0, 0, frames, fParameters[75]);

  1169.         obf->addFrom(1, 0, *dbf1, 1, 0, frames, fParameters[75]);

  1170.         obf->addFrom(0, 0, *dbf2, 0, 0, frames, fParameters[78]);

  1171.         obf->addFrom(1, 0, *dbf2, 1, 0, frames, fParameters[78]);

  1172.         obf->addFrom(0, 0, *dbf3, 0, 0, frames, fParameters[82]);

  1173.         obf->addFrom(1, 0, *dbf3, 1, 0, frames, fParameters[82]);

  1174. 

  1175.         output.addFrom(0, 0, *obf, 0, 0, frames, fParameters[0]);

  1176.         output.addFrom(1, 0, *obf, 1, 0, frames, fParameters[0]);

  1177.     }

  1178. 

  1179.     // -------------------------------------------------------------------

  1180.     // Plugin dispatcher calls

  1181. 

  1182.     void bufferSizeChanged(const uint32_t bufferSize) override

  1183.     {

  1184.         delete obf;

  1185.         delete abf;

  1186.         delete dbf1;

  1187.         delete dbf2;

  1188.         delete dbf3;

  1189. 

  1190.         obf  = new AudioSampleBuffer(2, bufferSize);

  1191.         abf  = new AudioSampleBuffer(2, bufferSize);

  1192.         dbf1 = new AudioSampleBuffer(2, bufferSize);

  1193.         dbf2 = new AudioSampleBuffer(2, bufferSize);

  1194.         dbf3 = new AudioSampleBuffer(2, bufferSize);

  1195.     }

  1196. 

  1197.     void sampleRateChanged(const double sampleRate) override

  1198.     {

  1199.         fChorus.setSampleRate(sampleRate);

  1200.         fDelay.setSampleRate(sampleRate);

  1201.         fSynth.setSampleRate(sampleRate);

  1202.     }

  1203. 

  1204. private:

  1205.     float fParameters[92];

  1206. 

  1207.     AudioSampleBuffer* obf;

  1208.     AudioSampleBuffer* abf;

  1209.     AudioSampleBuffer* dbf1; // delay

  1210.     AudioSampleBuffer* dbf2; // chorus

  1211.     AudioSampleBuffer* dbf3; // reverb

  1212. 

  1213.     VexChorus fChorus;

  1214.     VexDelay fDelay;

  1215.     VexReverb fReverb;

  1216.     VexSyntModule fSynth;

  1217. 

  1218.     PluginClassEND(VexSynthPlugin)

  1219.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexSynthPlugin)

  1220. };

  1221. 

  1222. // -----------------------------------------------------------------------

  1223. 

  1224. static const PluginDescriptor vexArpDesc = {

  1225.     /* category  */ PLUGIN_CATEGORY_UTILITY,

  1226.     /* hints     */ static_cast<PluginHints>(PLUGIN_HAS_GUI|PLUGIN_NEEDS_SINGLE_THREAD|PLUGIN_USES_TIME),

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

  1228.     /* audioIns  */ 0,

  1229.     /* audioOuts */ 0,

  1230.     /* midiIns   */ 1,

  1231.     /* midiOuts  */ 1,

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

  1233.     /* paramOuts */ 0,

  1234.     /* name      */ "VexArp",

  1235.     /* label     */ "vexArp",

  1236.     /* maker     */ "falkTX",

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

  1238.     PluginDescriptorFILL(VexArpPlugin)

  1239. };

  1240. 

  1241. static const PluginDescriptor vexChorusDesc = {

  1242.     /* category  */ PLUGIN_CATEGORY_MODULATOR,

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

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

  1245.     /* audioIns  */ 2,

  1246.     /* audioOuts */ 2,

  1247.     /* midiIns   */ 0,

  1248.     /* midiOuts  */ 0,

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

  1250.     /* paramOuts */ 0,

  1251.     /* name      */ "VexChorus",

  1252.     /* label     */ "vexChorus",

  1253.     /* maker     */ "falkTX",

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

  1255.     PluginDescriptorFILL(VexChorusPlugin)

  1256. };

  1257. 

  1258. static const PluginDescriptor vexDelayDesc = {

  1259.     /* category  */ PLUGIN_CATEGORY_DELAY,

  1260.     /* hints     */ static_cast<PluginHints>(PLUGIN_IS_RTSAFE|PLUGIN_USES_TIME),

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

  1262.     /* audioIns  */ 2,

  1263.     /* audioOuts */ 2,

  1264.     /* midiIns   */ 0,

  1265.     /* midiOuts  */ 0,

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

  1267.     /* paramOuts */ 0,

  1268.     /* name      */ "VexDelay",

  1269.     /* label     */ "vexDelay",

  1270.     /* maker     */ "falkTX",

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

  1272.     PluginDescriptorFILL(VexDelayPlugin)

  1273. };

  1274. 

  1275. static const PluginDescriptor vexReverbDesc = {

  1276.     /* category  */ PLUGIN_CATEGORY_DELAY,

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

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

  1279.     /* audioIns  */ 2,

  1280.     /* audioOuts */ 2,

  1281.     /* midiIns   */ 0,

  1282.     /* midiOuts  */ 0,

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

  1284.     /* paramOuts */ 0,

  1285.     /* name      */ "VexReverb",

  1286.     /* label     */ "vexReverb",

  1287.     /* maker     */ "falkTX",

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

  1289.     PluginDescriptorFILL(VexReverbPlugin)

  1290. };

  1291. 

  1292. static const PluginDescriptor vexSynthDesc = {

  1293.     /* category  */ PLUGIN_CATEGORY_SYNTH,

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

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

  1296.     /* audioIns  */ 0,

  1297.     /* audioOuts */ 2,

  1298.     /* midiIns   */ 1,

  1299.     /* midiOuts  */ 0,

  1300.     /* paramIns  */ VexSynthPlugin::kParamCount,

  1301.     /* paramOuts */ 0,

  1302.     /* name      */ "VexSynth",

  1303.     /* label     */ "vexSynth",

  1304.     /* maker     */ "falkTX",

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

  1306.     PluginDescriptorFILL(VexSynthPlugin)

  1307. };

  1308. 

  1309. // -----------------------------------------------------------------------

  1310. 

  1311. CARLA_EXPORT

  1312. void carla_register_native_plugin_vex()

  1313. {

  1314.     carla_register_native_plugin(&vexArpDesc);

  1315.     carla_register_native_plugin(&vexChorusDesc);

  1316.     carla_register_native_plugin(&vexDelayDesc);

  1317.     carla_register_native_plugin(&vexReverbDesc);

  1318.     carla_register_native_plugin(&vexSynthDesc);

  1319. }

  1320. 

  1321. // -----------------------------------------------------------------------