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.
995 Commits
16 Branches
14GB
Tree: 6194dd6a11
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '6194dd6a11'
${ noResults }
Carla/source/modules/carla_native/vex-fx.cpp

901 lines
26KB
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 "JucePluginWindow.hpp"

  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. 

  29. #include "vex/PeggyViewComponent.h"

  30. 

  31. // -----------------------------------------------------------------------

  32. 

  33. class VexArpPlugin : public PluginClass,

  34.                      public PeggyViewComponent::Callback

  35. {

  36. public:

  37.     enum Params {

  38.         kParamOnOff = 0,

  39.         kParamLength,

  40.         kParamTimeMode,

  41.         kParamSyncMode,

  42.         kParamFailMode,

  43.         kParamVelMode,

  44.         kParamLast,

  45.         kParamCount = kParamLast + VexArpSettings::kVelocitiesSize + VexArpSettings::kGridSize

  46.     };

  47. 

  48.     VexArpPlugin(const HostDescriptor* const host)

  49.         : PluginClass(host),

  50.           fArp(&fSettings),

  51.           fNeedsUpdate(true)

  52.     {

  53.         fArp.setSampleRate(getSampleRate());

  54.         fMidiInBuffer.ensureSize(512*4);

  55.     }

  56. 

  57. protected:

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

  59.     // Plugin parameter calls

  60. 

  61.     uint32_t getParameterCount() const override

  62.     {

  63.         return kParamCount;

  64.     }

  65. 

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

  67.     {

  68.         static Parameter paramInfo;

  69.         static ParameterScalePoint scalePoints[4];

  70.         static char bufName[24+1];

  71. 

  72.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  73. 

  74.         paramInfo.name = nullptr;

  75.         paramInfo.unit = nullptr;

  76.         paramInfo.ranges.def       = 0.0f;

  77.         paramInfo.ranges.min       = 0.0f;

  78.         paramInfo.ranges.max       = 1.0f;

  79.         paramInfo.ranges.step      = PARAMETER_RANGES_DEFAULT_STEP;

  80.         paramInfo.ranges.stepSmall = PARAMETER_RANGES_DEFAULT_STEP_SMALL;

  81.         paramInfo.ranges.stepLarge = PARAMETER_RANGES_DEFAULT_STEP_LARGE;

  82.         paramInfo.scalePointCount  = 0;

  83.         paramInfo.scalePoints      = nullptr;

  84. 

  85.         if (index < kParamLast)

  86.         {

  87.             hints |= PARAMETER_IS_INTEGER;

  88.             paramInfo.ranges.step      = 1.0f;

  89.             paramInfo.ranges.stepSmall = 1.0f;

  90.             paramInfo.ranges.stepLarge = 1.0f;

  91. 

  92.             switch (index)

  93.             {

  94.             case kParamOnOff:

  95.                 hints |= PARAMETER_IS_BOOLEAN;

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

  97.                 paramInfo.ranges.def = 0.0f;

  98.                 paramInfo.ranges.min = 0.0f;

  99.                 paramInfo.ranges.max = 1.0f;

  100.                 break;

  101.             case kParamLength:

  102.                 paramInfo.name = "Length";

  103.                 paramInfo.ranges.def = 8.0f;

  104.                 paramInfo.ranges.min = 1.0f;

  105.                 paramInfo.ranges.max = 16.0f;

  106.                 break;

  107.             case kParamTimeMode:

  108.                 hints |= PARAMETER_USES_SCALEPOINTS;

  109.                 paramInfo.name = "Time Signature";

  110.                 paramInfo.ranges.def = 2.0f;

  111.                 paramInfo.ranges.min = 1.0f;

  112.                 paramInfo.ranges.max = 3.0f;

  113.                 paramInfo.scalePointCount = 3;

  114.                 paramInfo.scalePoints     = scalePoints;

  115.                 scalePoints[0].label = "1/8";

  116.                 scalePoints[1].label = "1/16";

  117.                 scalePoints[2].label = "1/32";

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

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

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

  121.                 break;

  122.             case kParamSyncMode:

  123.                 hints |= PARAMETER_USES_SCALEPOINTS;

  124.                 paramInfo.name = "Sync Mode";

  125.                 paramInfo.ranges.def = 1.0f;

  126.                 paramInfo.ranges.min = 1.0f;

  127.                 paramInfo.ranges.max = 2.0f;

  128.                 paramInfo.scalePointCount = 2;

  129.                 paramInfo.scalePoints     = scalePoints;

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

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

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

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

  134.                 break;

  135.             case kParamFailMode:

  136.                 hints |= PARAMETER_USES_SCALEPOINTS;

  137.                 paramInfo.name = "Fail Mode";

  138.                 paramInfo.ranges.def = 1.0f;

  139.                 paramInfo.ranges.min = 1.0f;

  140.                 paramInfo.ranges.max = 3.0f;

  141.                 paramInfo.scalePointCount = 3;

  142.                 paramInfo.scalePoints     = scalePoints;

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

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

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

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

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

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

  149.                 break;

  150.             case kParamVelMode:

  151.                 hints |= PARAMETER_USES_SCALEPOINTS;

  152.                 paramInfo.name = "Velocity Mode";

  153.                 paramInfo.ranges.def = 1.0f;

  154.                 paramInfo.ranges.min = 1.0f;

  155.                 paramInfo.ranges.max = 3.0f;

  156.                 paramInfo.scalePointCount = 3;

  157.                 paramInfo.scalePoints     = scalePoints;

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

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

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

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

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

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

  164.                 break;

  165.             }

  166.         }

  167.         else if (index < kParamLast + VexArpSettings::kVelocitiesSize)

  168.         {

  169.             carla_zeroChar(bufName, 24+1);

  170.             std::snprintf(bufName, 24, "Grid Velocity %i", index - kParamLast);

  171.             paramInfo.name = bufName;

  172.         }

  173.         else

  174.         {

  175.             carla_zeroChar(bufName, 24+1);

  176.             hints |= PARAMETER_IS_BOOLEAN|PARAMETER_IS_INTEGER;

  177.             paramInfo.ranges.step      = 1.0f;

  178.             paramInfo.ranges.stepSmall = 1.0f;

  179.             paramInfo.ranges.stepLarge = 1.0f;

  180. 

  181.             carla_zeroChar(bufName, 24+1);

  182.             std::snprintf(bufName, 24, "Grid on/off %i", index - (kParamLast + VexArpSettings::kVelocitiesSize));

  183.             paramInfo.name = bufName;

  184.         }

  185. 

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

  187.         return &paramInfo;

  188.     }

  189. 

  190.     float getParameterValue(const uint32_t index) const override

  191.     {

  192.         if (index < kParamLast)

  193.         {

  194.             switch (index)

  195.             {

  196.             case kParamOnOff:

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

  198.             case kParamLength:

  199.                 return fSettings.length;

  200.             case kParamTimeMode:

  201.                 return fSettings.timeMode;

  202.             case kParamSyncMode:

  203.                 return fSettings.syncMode;

  204.             case kParamFailMode:

  205.                 return fSettings.failMode;

  206.             case kParamVelMode:

  207.                 return fSettings.velMode;

  208.             default:

  209.                 return 0.0f;

  210.             }

  211.         }

  212.         else if (index < kParamLast + VexArpSettings::kVelocitiesSize)

  213.         {

  214.             return fSettings.velocities[index-kParamLast];

  215.         }

  216.         else

  217.         {

  218.             return fSettings.grid[index-(kParamLast+VexArpSettings::kVelocitiesSize)] ? 1.0f : 0.0f;

  219.         }

  220.     }

  221. 

  222.     // -------------------------------------------------------------------

  223.     // Plugin state calls

  224. 

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

  226.     {

  227.         if (index < kParamLast)

  228.         {

  229.             switch (index)

  230.             {

  231.             case kParamOnOff:

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

  233.                 break;

  234.             case kParamLength:

  235.                 fSettings.length = value;

  236.                 break;

  237.             case kParamTimeMode:

  238.                 fSettings.timeMode = value;

  239.                 break;

  240.             case kParamSyncMode:

  241.                 fSettings.syncMode = value;

  242.                 break;

  243.             case kParamFailMode:

  244.                 fSettings.failMode = value;

  245.                 break;

  246.             case kParamVelMode:

  247.                 fSettings.velMode = value;

  248.                 break;

  249.             }

  250.         }

  251.         else if (index < kParamLast + VexArpSettings::kVelocitiesSize)

  252.         {

  253.             fSettings.velocities[index-kParamLast] = value;

  254.         }

  255.         else

  256.         {

  257.             fSettings.grid[index-(kParamLast+VexArpSettings::kVelocitiesSize)] = (value >= 0.5f);

  258.         }

  259.     }

  260. 

  261.     // -------------------------------------------------------------------

  262.     // Plugin process calls

  263. 

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

  265.     {

  266.         if (! fSettings.on)

  267.         {

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

  269.                 writeMidiEvent(&midiEvents[i]);

  270. 

  271.             return;

  272.         }

  273. 

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

  275. 

  276.         bool   timePlaying = false;

  277.         double ppqPos      = 0.0;

  278.         double barStartPos = 0.0;

  279.         double bpm         = 120.0;

  280. 

  281.         if (timeInfo != nullptr)

  282.         {

  283.             timePlaying = timeInfo->playing;

  284. 

  285.             if (timeInfo->bbt.valid)

  286.             {

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

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

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

  290. 

  291.                 ppqPos      = ppqBar + ppqBeat + ppqTick;

  292.                 barStartPos = ppqBar;

  293.                 bpm         = timeInfo->bbt.beatsPerMinute;

  294.             }

  295.         }

  296. 

  297.         fMidiInBuffer.clear();

  298. 

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

  300.         {

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

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

  303.         }

  304. 

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

  306. 

  307.         MidiBuffer::Iterator outBufferIterator(outMidiBuffer);

  308.         const uint8_t* midiData;

  309.         int numBytes;

  310.         int sampleNumber;

  311. 

  312.         MidiEvent tmpEvent;

  313.         tmpEvent.port = 0;

  314. 

  315.         while (outBufferIterator.getNextEvent(midiData, numBytes, sampleNumber))

  316.         {

  317.             if (numBytes <= 0 || numBytes > 4)

  318.                 continue;

  319. 

  320.             tmpEvent.size = numBytes;

  321.             tmpEvent.time = sampleNumber;

  322. 

  323.             std::memcpy(tmpEvent.data, midiData, sizeof(uint8_t)*tmpEvent.size);

  324.             writeMidiEvent(&tmpEvent);

  325.         }

  326.     }

  327. 

  328.     // -------------------------------------------------------------------

  329.     // Plugin UI calls

  330. 

  331.     void uiShow(const bool show) override

  332.     {

  333.         MessageManagerLock mmLock;

  334. 

  335.         if (show)

  336.         {

  337.             if (fWindow == nullptr)

  338.             {

  339.                 fWindow = new JucePluginWindow();

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

  341.             }

  342. 

  343.             if (fView == nullptr)

  344.             {

  345.                 fView = new PeggyViewComponent(fSettings, this, true);

  346.                 fView->setSize(202, 275);

  347.             }

  348. 

  349.             fWindow->show(fView);

  350.         }

  351.         else if (fWindow != nullptr)

  352.         {

  353.             fWindow->hide();

  354. 

  355.             fView = nullptr;

  356.             fWindow = nullptr;

  357.         }

  358.     }

  359. 

  360.     void uiIdle() override

  361.     {

  362.         if (fWindow == nullptr)

  363.             return;

  364. 

  365.         if (fNeedsUpdate)

  366.         {

  367.             if (fView != nullptr)

  368.             {

  369.                 MessageManagerLock mmLock;

  370.                 fView->update();

  371.             }

  372. 

  373.             fNeedsUpdate = false;

  374.         }

  375. 

  376.         if (fWindow->wasClosedByUser())

  377.         {

  378.             uiShow(false);

  379.             uiClosed();

  380.         }

  381.     }

  382. 

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

  384.     {

  385.         if (fView == nullptr)

  386.             return;

  387. 

  388.         fNeedsUpdate = true;

  389.     }

  390. 

  391.     // -------------------------------------------------------------------

  392.     // Plugin dispatcher calls

  393. 

  394.     void sampleRateChanged(const double sampleRate) override

  395.     {

  396.         fArp.setSampleRate(sampleRate);

  397.     }

  398. 

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

  400.     {

  401.         if (fWindow == nullptr)

  402.             return;

  403. 

  404.         MessageManagerLock mmLock;

  405.         fWindow->setName(uiName);

  406.     }

  407. 

  408.     // -------------------------------------------------------------------

  409.     // Peggy callback

  410. 

  411.     void arpParameterChanged(const uint32_t id) override

  412.     {

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

  414.     }

  415. 

  416. private:

  417.     VexArpSettings fSettings;

  418.     VexArp fArp;

  419.     MidiBuffer fMidiInBuffer;

  420. 

  421.     volatile bool fNeedsUpdate;

  422. 

  423.     ScopedPointer<PeggyViewComponent> fView;

  424.     ScopedPointer<JucePluginWindow> fWindow;

  425. 

  426.     PluginClassEND(VexArpPlugin)

  427.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexArpPlugin)

  428. };

  429. 

  430. // -----------------------------------------------------------------------

  431. 

  432. class VexChorusPlugin : public PluginClass

  433. {

  434. public:

  435.     enum Params {

  436.         kParamRate = 0,

  437.         kParamDepth,

  438.         kParamCount

  439.     };

  440. 

  441.     VexChorusPlugin(const HostDescriptor* const host)

  442.         : PluginClass(host),

  443.           fChorus(fParameters)

  444.     {

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

  446. 

  447.         fParameters[76] = 0.3f;

  448.         fParameters[77] = 0.6f;

  449. 

  450.         fChorus.setSampleRate(getSampleRate());

  451.     }

  452. 

  453. protected:

  454.     // -------------------------------------------------------------------

  455.     // Plugin parameter calls

  456. 

  457.     uint32_t getParameterCount() const override

  458.     {

  459.         return kParamCount;

  460.     }

  461. 

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

  463.     {

  464.         static Parameter paramInfo;

  465. 

  466.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  467. 

  468.         paramInfo.name = nullptr;

  469.         paramInfo.unit = nullptr;

  470.         paramInfo.ranges.def       = 0.0f;

  471.         paramInfo.ranges.min       = 0.0f;

  472.         paramInfo.ranges.max       = 1.0f;

  473.         paramInfo.ranges.step      = PARAMETER_RANGES_DEFAULT_STEP;

  474.         paramInfo.ranges.stepSmall = PARAMETER_RANGES_DEFAULT_STEP_SMALL;

  475.         paramInfo.ranges.stepLarge = PARAMETER_RANGES_DEFAULT_STEP_LARGE;

  476.         paramInfo.scalePointCount  = 0;

  477.         paramInfo.scalePoints      = nullptr;

  478. 

  479.         switch (index)

  480.         {

  481.         case kParamRate:

  482.             paramInfo.name = "Rate";

  483.             paramInfo.ranges.def = 0.3f;

  484.             break;

  485.         case kParamDepth:

  486.             paramInfo.name = "Depth";

  487.             paramInfo.ranges.def = 0.6f;

  488.             break;

  489.         }

  490. 

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

  492. 

  493.         return &paramInfo;

  494.     }

  495. 

  496.     float getParameterValue(const uint32_t index) const override

  497.     {

  498.         switch (index)

  499.         {

  500.         case kParamRate:

  501.             return fParameters[76];

  502.         case kParamDepth:

  503.             return fParameters[77];

  504.         default:

  505.             return 0.0f;

  506.         }

  507.     }

  508. 

  509.     // -------------------------------------------------------------------

  510.     // Plugin state calls

  511. 

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

  513.     {

  514.         switch (index)

  515.         {

  516.         case kParamRate:

  517.             fParameters[76] = value;

  518.             break;

  519.         case kParamDepth:

  520.             fParameters[77] = value;

  521.             break;

  522.         default:

  523.             break;

  524.         }

  525.     }

  526. 

  527.     // -------------------------------------------------------------------

  528.     // Plugin process calls

  529. 

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

  531.     {

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

  533.             FloatVectorOperations::copy(outBuffer[0], inBuffer[0], frames);

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

  535.             FloatVectorOperations::copy(outBuffer[1], inBuffer[1], frames);

  536. 

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

  538.     }

  539. 

  540.     // -------------------------------------------------------------------

  541.     // Plugin dispatcher calls

  542. 

  543.     void sampleRateChanged(const double sampleRate) override

  544.     {

  545.         fChorus.setSampleRate(sampleRate);

  546.     }

  547. 

  548. private:

  549.     VexChorus fChorus;

  550.     float fParameters[92];

  551. 

  552.     PluginClassEND(VexChorusPlugin)

  553.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexChorusPlugin)

  554. };

  555. 

  556. // -----------------------------------------------------------------------

  557. 

  558. class VexDelayPlugin : public PluginClass

  559. {

  560. public:

  561.     enum Params {

  562.         kParamTime = 0,

  563.         kParamFeedback,

  564.         kParamCount

  565.     };

  566. 

  567.     VexDelayPlugin(const HostDescriptor* const host)

  568.         : PluginClass(host),

  569.           fDelay(fParameters)

  570.     {

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

  572. 

  573.         fParameters[73] = 0.5f;

  574.         fParameters[74] = 0.4f;

  575. 

  576.         fDelay.setSampleRate(getSampleRate());

  577.     }

  578. 

  579. protected:

  580.     // -------------------------------------------------------------------

  581.     // Plugin parameter calls

  582. 

  583.     uint32_t getParameterCount() const override

  584.     {

  585.         return kParamCount;

  586.     }

  587. 

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

  589.     {

  590.         static Parameter paramInfo;

  591. 

  592.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  593. 

  594.         paramInfo.name = nullptr;

  595.         paramInfo.unit = nullptr;

  596.         paramInfo.ranges.def       = 0.0f;

  597.         paramInfo.ranges.min       = 0.0f;

  598.         paramInfo.ranges.max       = 1.0f;

  599.         paramInfo.ranges.step      = PARAMETER_RANGES_DEFAULT_STEP;

  600.         paramInfo.ranges.stepSmall = PARAMETER_RANGES_DEFAULT_STEP_SMALL;

  601.         paramInfo.ranges.stepLarge = PARAMETER_RANGES_DEFAULT_STEP_LARGE;

  602.         paramInfo.scalePointCount  = 0;

  603.         paramInfo.scalePoints      = nullptr;

  604. 

  605.         switch (index)

  606.         {

  607.         case kParamTime:

  608.             hints |= PARAMETER_IS_INTEGER;

  609.             paramInfo.name = "Time";

  610.             paramInfo.unit = "steps";

  611.             paramInfo.ranges.def = 4.0f;

  612.             paramInfo.ranges.min = 0.0f;

  613.             paramInfo.ranges.max = 8.0f;

  614.             break;

  615.         case kParamFeedback:

  616.             paramInfo.name = "Feedback";

  617.             paramInfo.unit = "%";

  618.             paramInfo.ranges.def = 40.0f;

  619.             paramInfo.ranges.min = 0.0f;

  620.             paramInfo.ranges.max = 100.0f;

  621.             break;

  622.         }

  623. 

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

  625. 

  626.         return &paramInfo;

  627.     }

  628. 

  629.     float getParameterValue(const uint32_t index) const override

  630.     {

  631.         switch (index)

  632.         {

  633.         case kParamTime:

  634.             return fParameters[73] * 8.0f;

  635.         case kParamFeedback:

  636.             return fParameters[74] * 100.0f;

  637.         default:

  638.             return 0.0f;

  639.         }

  640.     }

  641. 

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

  643.     // Plugin state calls

  644. 

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

  646.     {

  647.         switch (index)

  648.         {

  649.         case kParamTime:

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

  651.             break;

  652.         case kParamFeedback:

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

  654.             break;

  655.         default:

  656.             break;

  657.         }

  658.     }

  659. 

  660.     // -------------------------------------------------------------------

  661.     // Plugin process calls

  662. 

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

  664.     {

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

  666.             FloatVectorOperations::copy(outBuffer[0], inBuffer[0], frames);

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

  668.             FloatVectorOperations::copy(outBuffer[1], inBuffer[1], frames);

  669. 

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

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

  672. 

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

  674.     }

  675. 

  676.     // -------------------------------------------------------------------

  677.     // Plugin dispatcher calls

  678. 

  679.     void sampleRateChanged(const double sampleRate) override

  680.     {

  681.         fDelay.setSampleRate(sampleRate);

  682.     }

  683. 

  684. private:

  685.     VexDelay fDelay;

  686.     float fParameters[92];

  687. 

  688.     PluginClassEND(VexDelayPlugin)

  689.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexDelayPlugin)

  690. };

  691. 

  692. // -----------------------------------------------------------------------

  693. 

  694. class VexReverbPlugin : public PluginClass

  695. {

  696. public:

  697.     enum Params {

  698.         kParamSize = 0,

  699.         kParamWidth,

  700.         kParamDamp,

  701.         kParamCount

  702.     };

  703. 

  704.     VexReverbPlugin(const HostDescriptor* const host)

  705.         : PluginClass(host),

  706.           fReverb(fParameters)

  707.     {

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

  709. 

  710.         fParameters[79] = 0.6f;

  711.         fParameters[80] = 0.7f;

  712.         fParameters[81] = 0.6f;

  713.     }

  714. 

  715. protected:

  716.     // -------------------------------------------------------------------

  717.     // Plugin parameter calls

  718. 

  719.     uint32_t getParameterCount() const override

  720.     {

  721.         return kParamCount;

  722.     }

  723. 

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

  725.     {

  726.         static Parameter paramInfo;

  727. 

  728.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  729. 

  730.         paramInfo.name = nullptr;

  731.         paramInfo.unit = nullptr;

  732.         paramInfo.ranges.def       = 0.0f;

  733.         paramInfo.ranges.min       = 0.0f;

  734.         paramInfo.ranges.max       = 1.0f;

  735.         paramInfo.ranges.step      = PARAMETER_RANGES_DEFAULT_STEP;

  736.         paramInfo.ranges.stepSmall = PARAMETER_RANGES_DEFAULT_STEP_SMALL;

  737.         paramInfo.ranges.stepLarge = PARAMETER_RANGES_DEFAULT_STEP_LARGE;

  738.         paramInfo.scalePointCount  = 0;

  739.         paramInfo.scalePoints      = nullptr;

  740. 

  741.         switch (index)

  742.         {

  743.         case kParamSize:

  744.             paramInfo.name = "Size";

  745.             paramInfo.ranges.def = 0.6f;

  746.             break;

  747.         case kParamWidth:

  748.             paramInfo.name = "Width";

  749.             paramInfo.ranges.def = 0.7f;

  750.             break;

  751.         case kParamDamp:

  752.             paramInfo.name = "Damp";

  753.             paramInfo.ranges.def = 0.6f;

  754.             break;

  755.         }

  756. 

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

  758. 

  759.         return &paramInfo;

  760.     }

  761. 

  762.     float getParameterValue(const uint32_t index) const override

  763.     {

  764.         switch (index)

  765.         {

  766.         case kParamSize:

  767.             return fParameters[79];

  768.         case kParamWidth:

  769.             return fParameters[80];

  770.         case kParamDamp:

  771.             return fParameters[81];

  772.         default:

  773.             return 0.0f;

  774.         }

  775.     }

  776. 

  777.     // -------------------------------------------------------------------

  778.     // Plugin state calls

  779. 

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

  781.     {

  782.         switch (index)

  783.         {

  784.         case kParamSize:

  785.             fParameters[79] = value;

  786.             break;

  787.         case kParamWidth:

  788.             fParameters[80] = value;

  789.             break;

  790.         case kParamDamp:

  791.             fParameters[81] = value;

  792.             break;

  793.         default:

  794.             break;

  795.         }

  796.     }

  797. 

  798.     // -------------------------------------------------------------------

  799.     // Plugin process calls

  800. 

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

  802.     {

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

  804.             FloatVectorOperations::copyWithMultiply(outBuffer[0], inBuffer[0], 0.5f, frames);

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

  806.             FloatVectorOperations::copyWithMultiply(outBuffer[1], inBuffer[1], 0.5f, frames);

  807. 

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

  809.     }

  810. 

  811. private:

  812.     VexReverb fReverb;

  813.     float fParameters[92];

  814. 

  815.     PluginClassEND(VexReverbPlugin)

  816.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexReverbPlugin)

  817. };

  818. 

  819. // -----------------------------------------------------------------------

  820. 

  821. static const PluginDescriptor vexArpDesc = {

  822.     /* category  */ PLUGIN_CATEGORY_UTILITY,

  823.     /* hints     */ static_cast<PluginHints>(PLUGIN_HAS_GUI|PLUGIN_NEEDS_UI_JUCE|PLUGIN_USES_TIME),

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

  825.     /* audioIns  */ 0,

  826.     /* audioOuts */ 0,

  827.     /* midiIns   */ 1,

  828.     /* midiOuts  */ 1,

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

  830.     /* paramOuts */ 0,

  831.     /* name      */ "VexArp",

  832.     /* label     */ "vexArp",

  833.     /* maker     */ "falkTX",

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

  835.     PluginDescriptorFILL(VexArpPlugin)

  836. };

  837. 

  838. static const PluginDescriptor vexChorusDesc = {

  839.     /* category  */ PLUGIN_CATEGORY_MODULATOR,

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

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

  842.     /* audioIns  */ 2,

  843.     /* audioOuts */ 2,

  844.     /* midiIns   */ 0,

  845.     /* midiOuts  */ 0,

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

  847.     /* paramOuts */ 0,

  848.     /* name      */ "VexChorus",

  849.     /* label     */ "vexChorus",

  850.     /* maker     */ "falkTX",

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

  852.     PluginDescriptorFILL(VexChorusPlugin)

  853. };

  854. 

  855. static const PluginDescriptor vexDelayDesc = {

  856.     /* category  */ PLUGIN_CATEGORY_DELAY,

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

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

  859.     /* audioIns  */ 2,

  860.     /* audioOuts */ 2,

  861.     /* midiIns   */ 0,

  862.     /* midiOuts  */ 0,

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

  864.     /* paramOuts */ 0,

  865.     /* name      */ "VexDelay",

  866.     /* label     */ "vexDelay",

  867.     /* maker     */ "falkTX",

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

  869.     PluginDescriptorFILL(VexDelayPlugin)

  870. };

  871. 

  872. static const PluginDescriptor vexReverbDesc = {

  873.     /* category  */ PLUGIN_CATEGORY_DELAY,

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

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

  876.     /* audioIns  */ 2,

  877.     /* audioOuts */ 2,

  878.     /* midiIns   */ 0,

  879.     /* midiOuts  */ 0,

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

  881.     /* paramOuts */ 0,

  882.     /* name      */ "VexReverb",

  883.     /* label     */ "vexReverb",

  884.     /* maker     */ "falkTX",

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

  886.     PluginDescriptorFILL(VexReverbPlugin)

  887. };

  888. 

  889. // -----------------------------------------------------------------------

  890. 

  891. CARLA_EXPORT

  892. void carla_register_native_plugin_vex_fx()

  893. {

  894.     carla_register_native_plugin(&vexArpDesc);

  895.     carla_register_native_plugin(&vexChorusDesc);

  896.     carla_register_native_plugin(&vexDelayDesc);

  897.     carla_register_native_plugin(&vexReverbDesc);

  898. }

  899. 

  900. // -----------------------------------------------------------------------