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.
1796 Commits
16 Branches
14GB
Tree: 9dfcdf7d66
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '9dfcdf7d66'
${ noResults }
Carla/source/modules/native-plugins/vex-fx.cpp

904 lines
27KB
Raw Blame History 

  1. /*

  2.  * Carla Native Plugins

  3.  * Copyright (C) 2012-2014 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 NativePluginClass,

  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 NativeHostDescriptor* const host)

  49.         : NativePluginClass(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 NativeParameter* getParameterInfo(const uint32_t index) const override

  67.     {

  68.         static NativeParameter paramInfo;

  69.         static NativeParameterScalePoint 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<NativeParameterHints>(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 NativeMidiEvent* 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 NativeTimeInfo* 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 NativeMidiEvent* 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.         NativeMidiEvent tmpEvent;

  313.         tmpEvent.port = 0;

  314. 

  315.         for (; 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.         const 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.             if (const uintptr_t winId = getUiParentId())

  352.                 fWindow->setTransientWinId(winId);

  353.         }

  354.         else if (fWindow != nullptr)

  355.         {

  356.             fWindow->hide();

  357. 

  358.             fView = nullptr;

  359.             fWindow = nullptr;

  360.         }

  361.     }

  362. 

  363.     void uiIdle() override

  364.     {

  365.         if (fWindow == nullptr)

  366.             return;

  367. 

  368.         if (fNeedsUpdate)

  369.         {

  370.             if (fView != nullptr)

  371.             {

  372.                 const MessageManagerLock mmLock;

  373.                 fView->update();

  374.             }

  375. 

  376.             fNeedsUpdate = false;

  377.         }

  378. 

  379.         if (fWindow->wasClosedByUser())

  380.         {

  381.             uiShow(false);

  382.             uiClosed();

  383.         }

  384.     }

  385. 

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

  387.     {

  388.         if (fView == nullptr)

  389.             return;

  390. 

  391.         fNeedsUpdate = true;

  392.     }

  393. 

  394.     // -------------------------------------------------------------------

  395.     // Plugin dispatcher calls

  396. 

  397.     void sampleRateChanged(const double sampleRate) override

  398.     {

  399.         fArp.setSampleRate(sampleRate);

  400.     }

  401. 

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

  403.     {

  404.         if (fWindow == nullptr)

  405.             return;

  406. 

  407.         const MessageManagerLock mmLock;

  408.         fWindow->setName(uiName);

  409.     }

  410. 

  411.     // -------------------------------------------------------------------

  412.     // Peggy callback

  413. 

  414.     void arpParameterChanged(const uint32_t id) override

  415.     {

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

  417.     }

  418. 

  419. private:

  420.     VexArpSettings fSettings;

  421.     VexArp fArp;

  422.     MidiBuffer fMidiInBuffer;

  423. 

  424.     volatile bool fNeedsUpdate;

  425. 

  426.     ScopedPointer<PeggyViewComponent> fView;

  427.     ScopedPointer<JucePluginWindow> fWindow;

  428. 

  429.     PluginClassEND(VexArpPlugin)

  430.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexArpPlugin)

  431. };

  432. 

  433. // -----------------------------------------------------------------------

  434. 

  435. class VexChorusPlugin : public NativePluginClass

  436. {

  437. public:

  438.     enum Params {

  439.         kParamRate = 0,

  440.         kParamDepth,

  441.         kParamCount

  442.     };

  443. 

  444.     VexChorusPlugin(const NativeHostDescriptor* const host)

  445.         : NativePluginClass(host),

  446.           fChorus(fParameters)

  447.     {

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

  449. 

  450.         fParameters[76] = 0.3f;

  451.         fParameters[77] = 0.6f;

  452. 

  453.         fChorus.setSampleRate(getSampleRate());

  454.     }

  455. 

  456. protected:

  457.     // -------------------------------------------------------------------

  458.     // Plugin parameter calls

  459. 

  460.     uint32_t getParameterCount() const override

  461.     {

  462.         return kParamCount;

  463.     }

  464. 

  465.     const NativeParameter* getParameterInfo(const uint32_t index) const override

  466.     {

  467.         static NativeParameter paramInfo;

  468. 

  469.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  470. 

  471.         paramInfo.name = nullptr;

  472.         paramInfo.unit = nullptr;

  473.         paramInfo.ranges.def       = 0.0f;

  474.         paramInfo.ranges.min       = 0.0f;

  475.         paramInfo.ranges.max       = 1.0f;

  476.         paramInfo.ranges.step      = PARAMETER_RANGES_DEFAULT_STEP;

  477.         paramInfo.ranges.stepSmall = PARAMETER_RANGES_DEFAULT_STEP_SMALL;

  478.         paramInfo.ranges.stepLarge = PARAMETER_RANGES_DEFAULT_STEP_LARGE;

  479.         paramInfo.scalePointCount  = 0;

  480.         paramInfo.scalePoints      = nullptr;

  481. 

  482.         switch (index)

  483.         {

  484.         case kParamRate:

  485.             paramInfo.name = "Rate";

  486.             paramInfo.ranges.def = 0.3f;

  487.             break;

  488.         case kParamDepth:

  489.             paramInfo.name = "Depth";

  490.             paramInfo.ranges.def = 0.6f;

  491.             break;

  492.         }

  493. 

  494.         paramInfo.hints = static_cast<NativeParameterHints>(hints);

  495. 

  496.         return &paramInfo;

  497.     }

  498. 

  499.     float getParameterValue(const uint32_t index) const override

  500.     {

  501.         switch (index)

  502.         {

  503.         case kParamRate:

  504.             return fParameters[76];

  505.         case kParamDepth:

  506.             return fParameters[77];

  507.         default:

  508.             return 0.0f;

  509.         }

  510.     }

  511. 

  512.     // -------------------------------------------------------------------

  513.     // Plugin state calls

  514. 

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

  516.     {

  517.         switch (index)

  518.         {

  519.         case kParamRate:

  520.             fParameters[76] = value;

  521.             break;

  522.         case kParamDepth:

  523.             fParameters[77] = value;

  524.             break;

  525.         default:

  526.             break;

  527.         }

  528.     }

  529. 

  530.     // -------------------------------------------------------------------

  531.     // Plugin process calls

  532. 

  533.     void process(float** const inBuffer, float** const outBuffer, const uint32_t frames, const NativeMidiEvent* const, const uint32_t) override

  534.     {

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

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

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

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

  539. 

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

  541.     }

  542. 

  543.     // -------------------------------------------------------------------

  544.     // Plugin dispatcher calls

  545. 

  546.     void sampleRateChanged(const double sampleRate) override

  547.     {

  548.         fChorus.setSampleRate(sampleRate);

  549.     }

  550. 

  551. private:

  552.     VexChorus fChorus;

  553.     float fParameters[92];

  554. 

  555.     PluginClassEND(VexChorusPlugin)

  556.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexChorusPlugin)

  557. };

  558. 

  559. // -----------------------------------------------------------------------

  560. 

  561. class VexDelayPlugin : public NativePluginClass

  562. {

  563. public:

  564.     enum Params {

  565.         kParamTime = 0,

  566.         kParamFeedback,

  567.         kParamCount

  568.     };

  569. 

  570.     VexDelayPlugin(const NativeHostDescriptor* const host)

  571.         : NativePluginClass(host),

  572.           fDelay(fParameters)

  573.     {

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

  575. 

  576.         fParameters[73] = 0.5f;

  577.         fParameters[74] = 0.4f;

  578. 

  579.         fDelay.setSampleRate(getSampleRate());

  580.     }

  581. 

  582. protected:

  583.     // -------------------------------------------------------------------

  584.     // Plugin parameter calls

  585. 

  586.     uint32_t getParameterCount() const override

  587.     {

  588.         return kParamCount;

  589.     }

  590. 

  591.     const NativeParameter* getParameterInfo(const uint32_t index) const override

  592.     {

  593.         static NativeParameter paramInfo;

  594. 

  595.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  596. 

  597.         paramInfo.name = nullptr;

  598.         paramInfo.unit = nullptr;

  599.         paramInfo.ranges.def       = 0.0f;

  600.         paramInfo.ranges.min       = 0.0f;

  601.         paramInfo.ranges.max       = 1.0f;

  602.         paramInfo.ranges.step      = PARAMETER_RANGES_DEFAULT_STEP;

  603.         paramInfo.ranges.stepSmall = PARAMETER_RANGES_DEFAULT_STEP_SMALL;

  604.         paramInfo.ranges.stepLarge = PARAMETER_RANGES_DEFAULT_STEP_LARGE;

  605.         paramInfo.scalePointCount  = 0;

  606.         paramInfo.scalePoints      = nullptr;

  607. 

  608.         switch (index)

  609.         {

  610.         case kParamTime:

  611.             hints |= PARAMETER_IS_INTEGER;

  612.             paramInfo.name = "Time";

  613.             paramInfo.unit = "steps";

  614.             paramInfo.ranges.def = 4.0f;

  615.             paramInfo.ranges.min = 0.0f;

  616.             paramInfo.ranges.max = 8.0f;

  617.             break;

  618.         case kParamFeedback:

  619.             paramInfo.name = "Feedback";

  620.             paramInfo.unit = "%";

  621.             paramInfo.ranges.def = 40.0f;

  622.             paramInfo.ranges.min = 0.0f;

  623.             paramInfo.ranges.max = 100.0f;

  624.             break;

  625.         }

  626. 

  627.         paramInfo.hints = static_cast<NativeParameterHints>(hints);

  628. 

  629.         return &paramInfo;

  630.     }

  631. 

  632.     float getParameterValue(const uint32_t index) const override

  633.     {

  634.         switch (index)

  635.         {

  636.         case kParamTime:

  637.             return fParameters[73] * 8.0f;

  638.         case kParamFeedback:

  639.             return fParameters[74] * 100.0f;

  640.         default:

  641.             return 0.0f;

  642.         }

  643.     }

  644. 

  645.     // -------------------------------------------------------------------

  646.     // Plugin state calls

  647. 

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

  649.     {

  650.         switch (index)

  651.         {

  652.         case kParamTime:

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

  654.             break;

  655.         case kParamFeedback:

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

  657.             break;

  658.         default:

  659.             break;

  660.         }

  661.     }

  662. 

  663.     // -------------------------------------------------------------------

  664.     // Plugin process calls

  665. 

  666.     void process(float** const inBuffer, float** const outBuffer, const uint32_t frames, const NativeMidiEvent* const, const uint32_t) override

  667.     {

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

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

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

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

  672. 

  673.         const NativeTimeInfo* const timeInfo(getTimeInfo());

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

  675. 

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

  677.     }

  678. 

  679.     // -------------------------------------------------------------------

  680.     // Plugin dispatcher calls

  681. 

  682.     void sampleRateChanged(const double sampleRate) override

  683.     {

  684.         fDelay.setSampleRate(sampleRate);

  685.     }

  686. 

  687. private:

  688.     VexDelay fDelay;

  689.     float fParameters[92];

  690. 

  691.     PluginClassEND(VexDelayPlugin)

  692.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexDelayPlugin)

  693. };

  694. 

  695. // -----------------------------------------------------------------------

  696. 

  697. class VexReverbPlugin : public NativePluginClass

  698. {

  699. public:

  700.     enum Params {

  701.         kParamSize = 0,

  702.         kParamWidth,

  703.         kParamDamp,

  704.         kParamCount

  705.     };

  706. 

  707.     VexReverbPlugin(const NativeHostDescriptor* const host)

  708.         : NativePluginClass(host),

  709.           fReverb(fParameters)

  710.     {

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

  712. 

  713.         fParameters[79] = 0.6f;

  714.         fParameters[80] = 0.7f;

  715.         fParameters[81] = 0.6f;

  716.     }

  717. 

  718. protected:

  719.     // -------------------------------------------------------------------

  720.     // Plugin parameter calls

  721. 

  722.     uint32_t getParameterCount() const override

  723.     {

  724.         return kParamCount;

  725.     }

  726. 

  727.     const NativeParameter* getParameterInfo(const uint32_t index) const override

  728.     {

  729.         static NativeParameter paramInfo;

  730. 

  731.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  732. 

  733.         paramInfo.name = nullptr;

  734.         paramInfo.unit = nullptr;

  735.         paramInfo.ranges.def       = 0.0f;

  736.         paramInfo.ranges.min       = 0.0f;

  737.         paramInfo.ranges.max       = 1.0f;

  738.         paramInfo.ranges.step      = PARAMETER_RANGES_DEFAULT_STEP;

  739.         paramInfo.ranges.stepSmall = PARAMETER_RANGES_DEFAULT_STEP_SMALL;

  740.         paramInfo.ranges.stepLarge = PARAMETER_RANGES_DEFAULT_STEP_LARGE;

  741.         paramInfo.scalePointCount  = 0;

  742.         paramInfo.scalePoints      = nullptr;

  743. 

  744.         switch (index)

  745.         {

  746.         case kParamSize:

  747.             paramInfo.name = "Size";

  748.             paramInfo.ranges.def = 0.6f;

  749.             break;

  750.         case kParamWidth:

  751.             paramInfo.name = "Width";

  752.             paramInfo.ranges.def = 0.7f;

  753.             break;

  754.         case kParamDamp:

  755.             paramInfo.name = "Damp";

  756.             paramInfo.ranges.def = 0.6f;

  757.             break;

  758.         }

  759. 

  760.         paramInfo.hints = static_cast<NativeParameterHints>(hints);

  761. 

  762.         return &paramInfo;

  763.     }

  764. 

  765.     float getParameterValue(const uint32_t index) const override

  766.     {

  767.         switch (index)

  768.         {

  769.         case kParamSize:

  770.             return fParameters[79];

  771.         case kParamWidth:

  772.             return fParameters[80];

  773.         case kParamDamp:

  774.             return fParameters[81];

  775.         default:

  776.             return 0.0f;

  777.         }

  778.     }

  779. 

  780.     // -------------------------------------------------------------------

  781.     // Plugin state calls

  782. 

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

  784.     {

  785.         switch (index)

  786.         {

  787.         case kParamSize:

  788.             fParameters[79] = value;

  789.             break;

  790.         case kParamWidth:

  791.             fParameters[80] = value;

  792.             break;

  793.         case kParamDamp:

  794.             fParameters[81] = value;

  795.             break;

  796.         default:

  797.             break;

  798.         }

  799.     }

  800. 

  801.     // -------------------------------------------------------------------

  802.     // Plugin process calls

  803. 

  804.     void process(float** const inBuffer, float** const outBuffer, const uint32_t frames, const NativeMidiEvent* const, const uint32_t) override

  805.     {

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

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

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

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

  810. 

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

  812.     }

  813. 

  814. private:

  815.     VexReverb fReverb;

  816.     float fParameters[92];

  817. 

  818.     PluginClassEND(VexReverbPlugin)

  819.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexReverbPlugin)

  820. };

  821. 

  822. // -----------------------------------------------------------------------

  823. 

  824. static const NativePluginDescriptor vexArpDesc = {

  825.     /* category  */ PLUGIN_CATEGORY_UTILITY,

  826.     /* hints     */ static_cast<NativePluginHints>(PLUGIN_HAS_UI|PLUGIN_NEEDS_UI_JUCE|PLUGIN_USES_TIME|PLUGIN_USES_PARENT_ID),

  827.     /* supports  */ static_cast<NativePluginSupports>(PLUGIN_SUPPORTS_EVERYTHING),

  828.     /* audioIns  */ 0,

  829.     /* audioOuts */ 0,

  830.     /* midiIns   */ 1,

  831.     /* midiOuts  */ 1,

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

  833.     /* paramOuts */ 0,

  834.     /* name      */ "VexArp",

  835.     /* label     */ "vexarp",

  836.     /* maker     */ "falkTX, Lucio Asnaghi, rockhardbuns",

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

  838.     PluginDescriptorFILL(VexArpPlugin)

  839. };

  840. 

  841. static const NativePluginDescriptor vexChorusDesc = {

  842.     /* category  */ PLUGIN_CATEGORY_MODULATOR,

  843.     /* hints     */ static_cast<NativePluginHints>(PLUGIN_IS_RTSAFE),

  844.     /* supports  */ static_cast<NativePluginSupports>(0x0),

  845.     /* audioIns  */ 2,

  846.     /* audioOuts */ 2,

  847.     /* midiIns   */ 0,

  848.     /* midiOuts  */ 0,

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

  850.     /* paramOuts */ 0,

  851.     /* name      */ "VexChorus",

  852.     /* label     */ "vexchorus",

  853.     /* maker     */ "falkTX, Lucio Asnaghi, rockhardbuns",

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

  855.     PluginDescriptorFILL(VexChorusPlugin)

  856. };

  857. 

  858. static const NativePluginDescriptor vexDelayDesc = {

  859.     /* category  */ PLUGIN_CATEGORY_DELAY,

  860.     /* hints     */ static_cast<NativePluginHints>(PLUGIN_IS_RTSAFE|PLUGIN_USES_TIME),

  861.     /* supports  */ static_cast<NativePluginSupports>(0x0),

  862.     /* audioIns  */ 2,

  863.     /* audioOuts */ 2,

  864.     /* midiIns   */ 0,

  865.     /* midiOuts  */ 0,

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

  867.     /* paramOuts */ 0,

  868.     /* name      */ "VexDelay",

  869.     /* label     */ "vexdelay",

  870.     /* maker     */ "falkTX, Lucio Asnaghi, rockhardbuns",

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

  872.     PluginDescriptorFILL(VexDelayPlugin)

  873. };

  874. 

  875. static const NativePluginDescriptor vexReverbDesc = {

  876.     /* category  */ PLUGIN_CATEGORY_DELAY,

  877.     /* hints     */ static_cast<NativePluginHints>(PLUGIN_IS_RTSAFE),

  878.     /* supports  */ static_cast<NativePluginSupports>(0x0),

  879.     /* audioIns  */ 2,

  880.     /* audioOuts */ 2,

  881.     /* midiIns   */ 0,

  882.     /* midiOuts  */ 0,

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

  884.     /* paramOuts */ 0,

  885.     /* name      */ "VexReverb",

  886.     /* label     */ "vexreverb",

  887.     /* maker     */ "falkTX, Lucio Asnaghi, rockhardbuns",

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

  889.     PluginDescriptorFILL(VexReverbPlugin)

  890. };

  891. 

  892. // -----------------------------------------------------------------------

  893. 

  894. CARLA_EXPORT

  895. void carla_register_native_plugin_vex_fx()

  896. {

  897.     carla_register_native_plugin(&vexArpDesc);

  898.     carla_register_native_plugin(&vexChorusDesc);

  899.     carla_register_native_plugin(&vexDelayDesc);

  900.     carla_register_native_plugin(&vexReverbDesc);

  901. }

  902. 

  903. // -----------------------------------------------------------------------