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

924 lines
27KB
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/cArp.h"

  25. #include "vex/cChorus.h"

  26. #include "vex/cDelay.h"

  27. #include "vex/cReverb.h"

  28. #include "vex/cSyntModule.h"

  29. 

  30. // -----------------------------------------------------------------------

  31. 

  32. class VexArpPlugin : public PluginClass

  33. {

  34. public:

  35.     enum Params {

  36.         kParamOnOff = 0,

  37.         kParamLength,

  38.         kParamTimeMode,

  39.         kParamSyncMode,

  40.         kParamFailMode,

  41.         kParamVelMode,

  42.         kParamCount

  43.     };

  44. 

  45.     VexArpPlugin(const HostDescriptor* const host)

  46.         : PluginClass(host),

  47.           fSettings(),

  48.           fArp(&fSettings)

  49.     {

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

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

  52. 

  53.         fSettings.grid[1] = true;

  54.         fSettings.grid[2] = true;

  55.         fSettings.grid[3] = true;

  56. 

  57.         fSettings.grid[41] = true;

  58.         fSettings.grid[42] = true;

  59.         fSettings.grid[43] = true;

  60.         fSettings.grid[44] = true;

  61.         fSettings.grid[45] = true;

  62. 

  63.         fArp.setSampleRate(getSampleRate());

  64.         fMidiInBuffer.ensureSize(512*4);

  65.     }

  66. 

  67. protected:

  68.     // -------------------------------------------------------------------

  69.     // Plugin parameter calls

  70. 

  71.     uint32_t getParameterCount() const override

  72.     {

  73.         return kParamCount;

  74.     }

  75. 

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

  77.     {

  78.         static Parameter paramInfo;

  79.         static ParameterScalePoint scalePoints[4];

  80. 

  81.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE|PARAMETER_IS_INTEGER;

  82. 

  83.         paramInfo.name = nullptr;

  84.         paramInfo.unit = nullptr;

  85.         paramInfo.ranges.def       = 0.0f;

  86.         paramInfo.ranges.min       = 0.0f;

  87.         paramInfo.ranges.max       = 1.0f;

  88.         paramInfo.ranges.step      = 1.0f;

  89.         paramInfo.ranges.stepSmall = 1.0f;

  90.         paramInfo.ranges.stepLarge = 1.0f;

  91.         paramInfo.scalePointCount  = 0;

  92.         paramInfo.scalePoints      = nullptr;

  93. 

  94.         switch (index)

  95.         {

  96.         case kParamOnOff:

  97.             hints |= PARAMETER_IS_BOOLEAN;

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

  99.             paramInfo.ranges.def = 0.0f;

  100.             paramInfo.ranges.min = 0.0f;

  101.             paramInfo.ranges.max = 1.0f;

  102.             break;

  103.         case kParamLength:

  104.             paramInfo.name = "Length";

  105.             paramInfo.ranges.def = 8.0f;

  106.             paramInfo.ranges.min = 1.0f;

  107.             paramInfo.ranges.max = 16.0f;

  108.             break;

  109.         case kParamTimeMode:

  110.             hints |= PARAMETER_USES_SCALEPOINTS;

  111.             paramInfo.name = "Time Signature";

  112.             paramInfo.ranges.def = 2.0f;

  113.             paramInfo.ranges.min = 1.0f;

  114.             paramInfo.ranges.max = 3.0f;

  115.             paramInfo.scalePointCount = 3;

  116.             paramInfo.scalePoints     = scalePoints;

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

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

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

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

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

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

  123.             break;

  124.         case kParamSyncMode:

  125.             hints |= PARAMETER_USES_SCALEPOINTS;

  126.             paramInfo.name = "Sync Mode";

  127.             paramInfo.ranges.def = 1.0f;

  128.             paramInfo.ranges.min = 1.0f;

  129.             paramInfo.ranges.max = 2.0f;

  130.             paramInfo.scalePointCount = 2;

  131.             paramInfo.scalePoints     = scalePoints;

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

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

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

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

  136.             break;

  137.         case kParamFailMode:

  138.             hints |= PARAMETER_USES_SCALEPOINTS;

  139.             paramInfo.name = "Fail Mode";

  140.             paramInfo.ranges.def = 1.0f;

  141.             paramInfo.ranges.min = 1.0f;

  142.             paramInfo.ranges.max = 3.0f;

  143.             paramInfo.scalePointCount = 3;

  144.             paramInfo.scalePoints     = scalePoints;

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

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

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

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

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

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

  151.             break;

  152.         case kParamVelMode:

  153.             hints |= PARAMETER_USES_SCALEPOINTS;

  154.             paramInfo.name = "Velocity Mode";

  155.             paramInfo.ranges.def = 1.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 = "Pattern Velocity";

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

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

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

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

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

  166.             break;

  167.         }

  168. 

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

  170. 

  171.         return &paramInfo;

  172.     }

  173. 

  174.     float getParameterValue(const uint32_t index) const override

  175.     {

  176.         switch (index)

  177.         {

  178.         case kParamOnOff:

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

  180.         case kParamLength:

  181.             return fSettings.length;

  182.         case kParamTimeMode:

  183.             return fSettings.timeMode;

  184.         case kParamSyncMode:

  185.             return fSettings.syncMode;

  186.         case kParamFailMode:

  187.             return fSettings.failMode;

  188.         case kParamVelMode:

  189.             return fSettings.velMode;

  190.         default:

  191.             return 0.0f;

  192.         }

  193.     }

  194. 

  195.     // -------------------------------------------------------------------

  196.     // Plugin state calls

  197. 

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

  199.     {

  200.         switch (index)

  201.         {

  202.         case kParamOnOff:

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

  204.             break;

  205.         case kParamLength:

  206.             fSettings.length = value;

  207.             break;

  208.         case kParamTimeMode:

  209.             fSettings.timeMode = value;

  210.             break;

  211.         case kParamSyncMode:

  212.             fSettings.syncMode = value;

  213.             break;

  214.         case kParamFailMode:

  215.             fSettings.failMode = value;

  216.             break;

  217.         case kParamVelMode:

  218.             fSettings.velMode = value;

  219.             break;

  220.         }

  221.     }

  222. 

  223.     // -------------------------------------------------------------------

  224.     // Plugin process calls

  225. 

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

  227.     {

  228.         if (! fSettings.on)

  229.         {

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

  231.                 writeMidiEvent(&midiEvents[i]);

  232. 

  233.             return;

  234.         }

  235. 

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

  237. 

  238.         int    timeFrame   = 0;

  239.         bool   timePlaying = false;

  240.         double ppqPos      = 0.0;

  241.         double barStartPos = 0.0;

  242.         double bpm         = 120.0;

  243. 

  244.         if (timeInfo != nullptr)

  245.         {

  246.             timeFrame   = timeInfo->frame;

  247.             timePlaying = timeInfo->playing;

  248. 

  249.             if (timeInfo->bbt.valid)

  250.             {

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

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

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

  254. 

  255.                 ppqPos      = ppqBar + ppqBeat + ppqTick;

  256.                 barStartPos = ppqBar;

  257.                 bpm         = timeInfo->bbt.beatsPerMinute;

  258.             }

  259.         }

  260. 

  261.         fMidiInBuffer.clear();

  262. 

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

  264.         {

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

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

  267.         }

  268. 

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

  270. 

  271.         MidiBuffer::Iterator outBufferIterator(outMidiBuffer);

  272.         MidiMessage midiMessage(0xf4);

  273.         int sampleNumber;

  274. 

  275.         MidiEvent tmpEvent;

  276.         tmpEvent.port = 0;

  277. 

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

  279.         {

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

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

  282. 

  283.             if (tmpEvent.size > 4)

  284.                 continue;

  285. 

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

  287.             writeMidiEvent(&tmpEvent);

  288.         }

  289.     }

  290. 

  291.     // -------------------------------------------------------------------

  292.     // Plugin dispatcher calls

  293. 

  294.     void sampleRateChanged(const double sampleRate) override

  295.     {

  296.         fArp.setSampleRate(sampleRate);

  297.     }

  298. 

  299. private:

  300.     VexArpSettings fSettings;

  301.     VexArp fArp;

  302.     MidiBuffer fMidiInBuffer;

  303. 

  304.     PluginClassEND(VexArpPlugin)

  305.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexArpPlugin)

  306. };

  307. 

  308. // -----------------------------------------------------------------------

  309. 

  310. class VexChorusPlugin : public PluginClass

  311. {

  312. public:

  313.     enum Params {

  314.         kParamDepth = 0,

  315.         kParamRate,

  316.         kParamCount

  317.     };

  318. 

  319.     VexChorusPlugin(const HostDescriptor* const host)

  320.         : PluginClass(host),

  321.           chorus(parameters)

  322.     {

  323.         parameters[0] = 0.6f;

  324.         parameters[1] = 0.3f;

  325. 

  326.         chorus.setSampleRate(getSampleRate());

  327.     }

  328. 

  329. protected:

  330.     // -------------------------------------------------------------------

  331.     // Plugin parameter calls

  332. 

  333.     uint32_t getParameterCount() const override

  334.     {

  335.         return kParamCount;

  336.     }

  337. 

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

  339.     {

  340.         static Parameter paramInfo;

  341. 

  342.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  343. 

  344.         paramInfo.name = nullptr;

  345.         paramInfo.unit = nullptr;

  346.         paramInfo.ranges.def       = 0.0f;

  347.         paramInfo.ranges.min       = 0.0f;

  348.         paramInfo.ranges.max       = 1.0f;

  349.         paramInfo.ranges.step      = 1.0f;

  350.         paramInfo.ranges.stepSmall = 1.0f;

  351.         paramInfo.ranges.stepLarge = 1.0f;

  352.         paramInfo.scalePointCount  = 0;

  353.         paramInfo.scalePoints      = nullptr;

  354. 

  355.         switch (index)

  356.         {

  357.         case kParamDepth:

  358.             paramInfo.name = "Depth";

  359.             paramInfo.ranges.def = 0.6f;

  360.             paramInfo.ranges.min = 0.0f;

  361.             paramInfo.ranges.max = 1.0f;

  362.             break;

  363.         case kParamRate:

  364.             paramInfo.name = "Rate";

  365.             paramInfo.ranges.def = 0.3f;

  366.             paramInfo.ranges.min = 0.0f;

  367.             paramInfo.ranges.max = 1.0f;

  368.             break;

  369.         }

  370. 

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

  372. 

  373.         return &paramInfo;

  374.     }

  375. 

  376.     float getParameterValue(const uint32_t index) const override

  377.     {

  378.         if (index < kParamCount)

  379.             return parameters[index];

  380.         return 0.0f;

  381.     }

  382. 

  383.     // -------------------------------------------------------------------

  384.     // Plugin state calls

  385. 

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

  387.     {

  388.         if (index < kParamCount)

  389.             parameters[index] = value;

  390.     }

  391. 

  392.     // -------------------------------------------------------------------

  393.     // Plugin process calls

  394. 

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

  396.     {

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

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

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

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

  401. 

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

  403.     }

  404. 

  405.     // -------------------------------------------------------------------

  406.     // Plugin dispatcher calls

  407. 

  408.     void sampleRateChanged(const double sampleRate) override

  409.     {

  410.         chorus.setSampleRate(sampleRate);

  411.     }

  412. 

  413. private:

  414.     VexChorus chorus;

  415.     float parameters[2];

  416. 

  417.     PluginClassEND(VexChorusPlugin)

  418.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexChorusPlugin)

  419. };

  420. 

  421. // -----------------------------------------------------------------------

  422. 

  423. class VexDelayPlugin : public PluginClass

  424. {

  425. public:

  426.     enum Params {

  427.         kParamTime = 0,

  428.         kParamFeedback,

  429.         kParamCount

  430.     };

  431. 

  432.     VexDelayPlugin(const HostDescriptor* const host)

  433.         : PluginClass(host),

  434.           delay(parameters)

  435.     {

  436.         parameters[0] = 4.0f;

  437.         parameters[1] = 40.0f;

  438. 

  439.         delay.setSampleRate(getSampleRate());

  440.     }

  441. 

  442. protected:

  443.     // -------------------------------------------------------------------

  444.     // Plugin parameter calls

  445. 

  446.     uint32_t getParameterCount() const override

  447.     {

  448.         return kParamCount;

  449.     }

  450. 

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

  452.     {

  453.         static Parameter paramInfo;

  454. 

  455.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  456. 

  457.         paramInfo.name = nullptr;

  458.         paramInfo.unit = nullptr;

  459.         paramInfo.ranges.def       = 0.0f;

  460.         paramInfo.ranges.min       = 0.0f;

  461.         paramInfo.ranges.max       = 1.0f;

  462.         paramInfo.ranges.step      = 1.0f;

  463.         paramInfo.ranges.stepSmall = 1.0f;

  464.         paramInfo.ranges.stepLarge = 1.0f;

  465.         paramInfo.scalePointCount  = 0;

  466.         paramInfo.scalePoints      = nullptr;

  467. 

  468.         switch (index)

  469.         {

  470.         case kParamTime:

  471.             hints |= PARAMETER_IS_INTEGER;

  472.             paramInfo.name = "Time";

  473.             paramInfo.ranges.def = 4.0f;

  474.             paramInfo.ranges.min = 0.0f;

  475.             paramInfo.ranges.max = 8.0f;

  476.             break;

  477.         case kParamFeedback:

  478.             paramInfo.name = "Feedback";

  479.             paramInfo.unit = "%";

  480.             paramInfo.ranges.def = 40.0f;

  481.             paramInfo.ranges.min = 0.0f;

  482.             paramInfo.ranges.max = 100.0f;

  483.             break;

  484.         }

  485. 

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

  487. 

  488.         return &paramInfo;

  489.     }

  490. 

  491.     float getParameterValue(const uint32_t index) const override

  492.     {

  493.         if (index < kParamCount)

  494.             return parameters[index];

  495.         return 0.0f;

  496.     }

  497. 

  498.     // -------------------------------------------------------------------

  499.     // Plugin state calls

  500. 

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

  502.     {

  503.         if (index < kParamCount)

  504.             parameters[index] = value;

  505.     }

  506. 

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

  508.     // Plugin process calls

  509. 

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

  511.     {

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

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

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

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

  516. 

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

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

  519. 

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

  521.     }

  522. 

  523.     // -------------------------------------------------------------------

  524.     // Plugin dispatcher calls

  525. 

  526.     void sampleRateChanged(const double sampleRate) override

  527.     {

  528.         delay.setSampleRate(sampleRate);

  529.     }

  530. 

  531. private:

  532.     VexDelay delay;

  533.     float parameters[2];

  534. 

  535.     PluginClassEND(VexDelayPlugin)

  536.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexDelayPlugin)

  537. };

  538. 

  539. // -----------------------------------------------------------------------

  540. 

  541. class VexReverbPlugin : public PluginClass

  542. {

  543. public:

  544.     enum Params {

  545.         kParamSize = 0,

  546.         kParamWidth,

  547.         kParamDamp,

  548.         kParamCount

  549.     };

  550. 

  551.     VexReverbPlugin(const HostDescriptor* const host)

  552.         : PluginClass(host),

  553.           reverb(parameters)

  554.     {

  555.         parameters[0] = 0.6f;

  556.         parameters[1] = 0.7f;

  557.         parameters[2] = 0.6f;

  558.     }

  559. 

  560. protected:

  561.     // -------------------------------------------------------------------

  562.     // Plugin parameter calls

  563. 

  564.     uint32_t getParameterCount() const override

  565.     {

  566.         return kParamCount;

  567.     }

  568. 

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

  570.     {

  571.         static Parameter paramInfo;

  572. 

  573.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  574. 

  575.         paramInfo.name = nullptr;

  576.         paramInfo.unit = nullptr;

  577.         paramInfo.ranges.def       = 0.0f;

  578.         paramInfo.ranges.min       = 0.0f;

  579.         paramInfo.ranges.max       = 1.0f;

  580.         paramInfo.ranges.step      = 1.0f;

  581.         paramInfo.ranges.stepSmall = 1.0f;

  582.         paramInfo.ranges.stepLarge = 1.0f;

  583.         paramInfo.scalePointCount  = 0;

  584.         paramInfo.scalePoints      = nullptr;

  585. 

  586.         switch (index)

  587.         {

  588.         case kParamSize:

  589.             paramInfo.name = "Size";

  590.             paramInfo.ranges.def = 0.6f;

  591.             paramInfo.ranges.min = 0.0f;

  592.             paramInfo.ranges.max = 1.0f;

  593.             break;

  594.         case kParamWidth:

  595.             paramInfo.name = "Width";

  596.             paramInfo.ranges.def = 0.7f;

  597.             paramInfo.ranges.min = 0.0f;

  598.             paramInfo.ranges.max = 1.0f;

  599.             break;

  600.         case kParamDamp:

  601.             paramInfo.name = "Damp";

  602.             paramInfo.ranges.def = 0.6f;

  603.             paramInfo.ranges.min = 0.0f;

  604.             paramInfo.ranges.max = 1.0f;

  605.             break;

  606.         }

  607. 

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

  609. 

  610.         return &paramInfo;

  611.     }

  612. 

  613.     float getParameterValue(const uint32_t index) const override

  614.     {

  615.         if (index < kParamCount)

  616.             return parameters[index];

  617.         return 0.0f;

  618.     }

  619. 

  620.     // -------------------------------------------------------------------

  621.     // Plugin state calls

  622. 

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

  624.     {

  625.         if (index < kParamCount)

  626.             parameters[index] = value;

  627.     }

  628. 

  629.     // -------------------------------------------------------------------

  630.     // Plugin process calls

  631. 

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

  633.     {

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

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

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

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

  638. 

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

  640.     }

  641. 

  642. private:

  643.     VexReverb reverb;

  644.     float parameters[3];

  645. 

  646.     PluginClassEND(VexReverbPlugin)

  647.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexReverbPlugin)

  648. };

  649. 

  650. // -----------------------------------------------------------------------

  651. 

  652. class VexSynthPlugin : public PluginClass

  653. {

  654. public:

  655.     static const unsigned int kParamCount = 1;

  656. 

  657.     VexSynthPlugin(const HostDescriptor* const host)

  658.         : PluginClass(host),

  659.           synth(parameters)

  660.     {

  661.         std::memset(parameters, 0, sizeof(float)*92);

  662. 

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

  664.         {

  665.             const int offset = i * 24;

  666. 

  667.             parameters[offset +  1] = 0.5f;

  668.             parameters[offset +  2] = 0.5f;

  669.             parameters[offset +  3] = 0.5f;

  670.             parameters[offset +  4] = 0.5f;

  671.             parameters[offset +  5] = 0.9f;

  672.             parameters[offset +  6] = 0.0f;

  673.             parameters[offset +  7] = 1.0f;

  674.             parameters[offset +  8] = 0.5f;

  675.             parameters[offset +  9] = 0.0f;

  676.             parameters[offset + 10] = 0.2f;

  677.             parameters[offset + 11] = 0.0f;

  678.             parameters[offset + 12] = 0.5f;

  679.             parameters[offset + 13] = 0.5f;

  680.             parameters[offset + 14] = 0.0f;

  681.             parameters[offset + 15] = 0.3f;

  682.             parameters[offset + 16] = 0.7f;

  683.             parameters[offset + 17] = 0.1f;

  684.             parameters[offset + 18] = 0.5f;

  685.             parameters[offset + 19] = 0.5f;

  686.             parameters[offset + 20] = 0.0f;

  687.             parameters[offset + 21] = 0.0f;

  688.             parameters[offset + 22] = 0.5f;

  689.             parameters[offset + 23] = 0.5f;

  690.             parameters[offset + 24] = 0.5f;

  691.         }

  692. 

  693.         parameters[89] = 1.0f;

  694. 

  695.         synth.setSampleRate(getSampleRate());

  696.         synth.update(89);

  697.     }

  698. 

  699. protected:

  700.     // -------------------------------------------------------------------

  701.     // Plugin parameter calls

  702. 

  703.     uint32_t getParameterCount() const override

  704.     {

  705.         return kParamCount;

  706.     }

  707. 

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

  709.     {

  710.         static Parameter paramInfo;

  711. 

  712.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  713. 

  714.         paramInfo.name = nullptr;

  715.         paramInfo.unit = nullptr;

  716.         paramInfo.ranges.def       = 0.0f;

  717.         paramInfo.ranges.min       = 0.0f;

  718.         paramInfo.ranges.max       = 1.0f;

  719.         paramInfo.ranges.step      = 1.0f;

  720.         paramInfo.ranges.stepSmall = 1.0f;

  721.         paramInfo.ranges.stepLarge = 1.0f;

  722.         paramInfo.scalePointCount  = 0;

  723.         paramInfo.scalePoints      = nullptr;

  724. 

  725.         switch (index)

  726.         {

  727.         case 0:

  728.             hints |= PARAMETER_IS_INTEGER;

  729.             paramInfo.name = "Wave";

  730.             paramInfo.ranges.def = 0.0f;

  731.             paramInfo.ranges.min = 0.0f;

  732.             paramInfo.ranges.max = WaveRenderer::getWaveTableSize();

  733.             break;

  734.         }

  735. 

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

  737. 

  738.         return &paramInfo;

  739.     }

  740. 

  741.     float getParameterValue(const uint32_t index) const override

  742.     {

  743.         if (index < kParamCount)

  744.             return parameters[index];

  745.         return 0.0f;

  746.     }

  747. 

  748.     // -------------------------------------------------------------------

  749.     // Plugin state calls

  750. 

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

  752.     {

  753.         if (index < kParamCount)

  754.         {

  755.             parameters[index] = value;

  756.             synth.setWaveLater(1, WaveRenderer::getWaveTableName(value));

  757. 

  758.             //synth.update(index);

  759.         }

  760.     }

  761. 

  762.     // -------------------------------------------------------------------

  763.     // Plugin process calls

  764. 

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

  766.     {

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

  768.         {

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

  770. 

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

  772. 

  773.             if (status == MIDI_STATUS_NOTE_ON)

  774.             {

  775.                 synth.playNote(midiEvent->data[1], midiEvent->data[2], 0, 1);

  776.             }

  777.             else if (status == MIDI_STATUS_NOTE_OFF)

  778.             {

  779.                 synth.releaseNote(midiEvent->data[1], 0, 1);

  780.             }

  781.             else if (status == MIDI_STATUS_CONTROL_CHANGE)

  782.             {

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

  784. 

  785.                 if (control == MIDI_CONTROL_ALL_SOUND_OFF)

  786.                     synth.kill();

  787.                 else if (control == MIDI_CONTROL_ALL_NOTES_OFF)

  788.                     synth.releaseAll(1);

  789.             }

  790.         }

  791. 

  792.         carla_zeroFloat(outBuffer[0], frames);

  793.         carla_zeroFloat(outBuffer[1], frames);

  794. 

  795.         synth.doProcess(outBuffer[0], outBuffer[1], frames);

  796.     }

  797. 

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

  799.     // Plugin dispatcher calls

  800. 

  801.     void sampleRateChanged(const double sampleRate) override

  802.     {

  803.         synth.setSampleRate(sampleRate);

  804.     }

  805. 

  806. private:

  807.     VexSyntModule synth;

  808.     float parameters[92];

  809. 

  810.     PluginClassEND(VexSynthPlugin)

  811.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexSynthPlugin)

  812. };

  813. 

  814. // -----------------------------------------------------------------------

  815. 

  816. static const PluginDescriptor vexArpDesc = {

  817.     /* category  */ PLUGIN_CATEGORY_UTILITY,

  818.     /* hints     */ static_cast<PluginHints>(PLUGIN_USES_TIME),

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

  820.     /* audioIns  */ 0,

  821.     /* audioOuts */ 0,

  822.     /* midiIns   */ 1,

  823.     /* midiOuts  */ 1,

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

  825.     /* paramOuts */ 0,

  826.     /* name      */ "VexArp",

  827.     /* label     */ "vexArp",

  828.     /* maker     */ "falkTX",

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

  830.     PluginDescriptorFILL(VexArpPlugin)

  831. };

  832. 

  833. static const PluginDescriptor vexChorusDesc = {

  834.     /* category  */ PLUGIN_CATEGORY_MODULATOR,

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

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

  837.     /* audioIns  */ 2,

  838.     /* audioOuts */ 2,

  839.     /* midiIns   */ 0,

  840.     /* midiOuts  */ 0,

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

  842.     /* paramOuts */ 0,

  843.     /* name      */ "VexChorus",

  844.     /* label     */ "vexChorus",

  845.     /* maker     */ "falkTX",

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

  847.     PluginDescriptorFILL(VexChorusPlugin)

  848. };

  849. 

  850. static const PluginDescriptor vexDelayDesc = {

  851.     /* category  */ PLUGIN_CATEGORY_DELAY,

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

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

  854.     /* audioIns  */ 2,

  855.     /* audioOuts */ 2,

  856.     /* midiIns   */ 0,

  857.     /* midiOuts  */ 0,

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

  859.     /* paramOuts */ 0,

  860.     /* name      */ "VexDelay",

  861.     /* label     */ "vexDelay",

  862.     /* maker     */ "falkTX",

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

  864.     PluginDescriptorFILL(VexDelayPlugin)

  865. };

  866. 

  867. static const PluginDescriptor vexReverbDesc = {

  868.     /* category  */ PLUGIN_CATEGORY_DELAY,

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

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

  871.     /* audioIns  */ 2,

  872.     /* audioOuts */ 2,

  873.     /* midiIns   */ 0,

  874.     /* midiOuts  */ 0,

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

  876.     /* paramOuts */ 0,

  877.     /* name      */ "VexReverb",

  878.     /* label     */ "vexReverb",

  879.     /* maker     */ "falkTX",

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

  881.     PluginDescriptorFILL(VexReverbPlugin)

  882. };

  883. 

  884. static const PluginDescriptor vexSynthDesc = {

  885.     /* category  */ PLUGIN_CATEGORY_SYNTH,

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

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

  888.     /* audioIns  */ 0,

  889.     /* audioOuts */ 2,

  890.     /* midiIns   */ 1,

  891.     /* midiOuts  */ 0,

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

  893.     /* paramOuts */ 0,

  894.     /* name      */ "VexSynth",

  895.     /* label     */ "vexSynth",

  896.     /* maker     */ "falkTX",

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

  898.     PluginDescriptorFILL(VexSynthPlugin)

  899. };

  900. 

  901. // -----------------------------------------------------------------------

  902. 

  903. CARLA_EXPORT

  904. void carla_register_native_plugin_vex()

  905. {

  906.     carla_register_native_plugin(&vexArpDesc);

  907.     carla_register_native_plugin(&vexChorusDesc);

  908.     carla_register_native_plugin(&vexDelayDesc);

  909.     carla_register_native_plugin(&vexReverbDesc);

  910.     carla_register_native_plugin(&vexSynthDesc);

  911. }

  912. 

  913. // -----------------------------------------------------------------------

  914. 

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

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

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

  918. 

  919. #include "vex/cVoice.cpp"

  920. #include "vex/cWaveRenderer.cpp"

  921. #include "vex/ResourceFile.cpp"

  922. 

  923. // -----------------------------------------------------------------------