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

917 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. using namespace juce;

  21. 

  22. #include "vex/cArp.h"

  23. #include "vex/cChorus.h"

  24. #include "vex/cDelay.h"

  25. #include "vex/cReverb.h"

  26. #include "vex/cSyntModule.h"

  27. 

  28. // -----------------------------------------------------------------------

  29. 

  30. class VexArpPlugin : public PluginClass

  31. {

  32. public:

  33.     enum Params {

  34.         kParamOnOff = 0,

  35.         kParamLength,

  36.         kParamTimeMode,

  37.         kParamSyncMode,

  38.         kParamFailMode,

  39.         kParamVelMode,

  40.         kParamCount

  41.     };

  42. 

  43.     VexArpPlugin(const HostDescriptor* const host)

  44.         : PluginClass(host),

  45.           fSettings(),

  46.           fArp(&fSettings)

  47.     {

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

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

  50. 

  51.         fSettings.grid[1] = true;

  52.         fSettings.grid[2] = true;

  53.         fSettings.grid[3] = true;

  54. 

  55.         fSettings.grid[41] = true;

  56.         fSettings.grid[42] = true;

  57.         fSettings.grid[43] = true;

  58.         fSettings.grid[44] = true;

  59.         fSettings.grid[45] = true;

  60. 

  61.         fArp.setSampleRate(getSampleRate());

  62.         fMidiInBuffer.ensureSize(512*4);

  63.     }

  64. 

  65. protected:

  66.     // -------------------------------------------------------------------

  67.     // Plugin parameter calls

  68. 

  69.     uint32_t getParameterCount() const override

  70.     {

  71.         return kParamCount;

  72.     }

  73. 

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

  75.     {

  76.         static Parameter paramInfo;

  77.         static ParameterScalePoint scalePoints[4];

  78. 

  79.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE|PARAMETER_IS_INTEGER;

  80. 

  81.         paramInfo.name = nullptr;

  82.         paramInfo.unit = nullptr;

  83.         paramInfo.ranges.def       = 0.0f;

  84.         paramInfo.ranges.min       = 0.0f;

  85.         paramInfo.ranges.max       = 1.0f;

  86.         paramInfo.ranges.step      = 1.0f;

  87.         paramInfo.ranges.stepSmall = 1.0f;

  88.         paramInfo.ranges.stepLarge = 1.0f;

  89.         paramInfo.scalePointCount  = 0;

  90.         paramInfo.scalePoints      = nullptr;

  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 = "8";

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

  117.             scalePoints[2].label = "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.         paramInfo.hints = static_cast<ParameterHints>(hints);

  168. 

  169.         return &paramInfo;

  170.     }

  171. 

  172.     float getParameterValue(const uint32_t index) const override

  173.     {

  174.         switch (index)

  175.         {

  176.         case kParamOnOff:

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

  178.         case kParamLength:

  179.             return fSettings.length;

  180.         case kParamTimeMode:

  181.             return fSettings.timeMode;

  182.         case kParamSyncMode:

  183.             return fSettings.syncMode;

  184.         case kParamFailMode:

  185.             return fSettings.failMode;

  186.         case kParamVelMode:

  187.             return fSettings.velMode;

  188.         default:

  189.             return 0.0f;

  190.         }

  191.     }

  192. 

  193.     // -------------------------------------------------------------------

  194.     // Plugin state calls

  195. 

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

  197.     {

  198.         switch (index)

  199.         {

  200.         case kParamOnOff:

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

  202.             break;

  203.         case kParamLength:

  204.             fSettings.length = value;

  205.             break;

  206.         case kParamTimeMode:

  207.             fSettings.timeMode = value;

  208.             break;

  209.         case kParamSyncMode:

  210.             fSettings.syncMode = value;

  211.             break;

  212.         case kParamFailMode:

  213.             fSettings.failMode = value;

  214.             break;

  215.         case kParamVelMode:

  216.             fSettings.velMode = value;

  217.             break;

  218.         }

  219.     }

  220. 

  221.     // -------------------------------------------------------------------

  222.     // Plugin process calls

  223. 

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

  225.     {

  226.         if (! fSettings.on)

  227.         {

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

  229.                 writeMidiEvent(&midiEvents[i]);

  230. 

  231.             return;

  232.         }

  233. 

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

  235.         double ppqPos, barStartPos, bpm;

  236. 

  237.         if (timeInfo->bbt.valid)

  238.         {

  239.             ppqPos = 0.0;

  240.             barStartPos = 0.0;

  241.             bpm = timeInfo->bbt.beatsPerMinute;

  242.         }

  243.         else

  244.         {

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

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

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

  248. 

  249.             ppqPos = ppqBar + ppqBeat + ppqTick;

  250.             barStartPos = ppqBar;

  251.             bpm = 120.0;

  252.         }

  253. 

  254.         fMidiInBuffer.clear();

  255. 

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

  257.         {

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

  259.             fMidiInBuffer.addEvent(MidiMessage(midiEvent->data, midiEvent->size, midiEvent->time), timeInfo->frame);

  260.         }

  261. 

  262.         const MidiBuffer& outMidiBuffer(fArp.processMidi(fMidiInBuffer, timeInfo->playing, ppqPos, barStartPos, bpm, frames));

  263. 

  264.         MidiBuffer::Iterator outBufferIterator(outMidiBuffer);

  265.         MidiMessage midiMessage(0xf4);

  266.         int sampleNumber;

  267. 

  268.         MidiEvent tmpEvent;

  269.         tmpEvent.port = 0;

  270. 

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

  272.         {

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

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

  275. 

  276.             if (tmpEvent.size > 4)

  277.                 continue;

  278. 

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

  280.             writeMidiEvent(&tmpEvent);

  281.         }

  282.     }

  283. 

  284.     // -------------------------------------------------------------------

  285.     // Plugin dispatcher calls

  286. 

  287.     void sampleRateChanged(const double sampleRate) override

  288.     {

  289.         fArp.setSampleRate(sampleRate);

  290.     }

  291. 

  292. private:

  293.     VexArpSettings fSettings;

  294.     VexArp fArp;

  295.     MidiBuffer fMidiInBuffer;

  296. 

  297.     PluginClassEND(VexArpPlugin)

  298.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexArpPlugin)

  299. };

  300. 

  301. // -----------------------------------------------------------------------

  302. 

  303. class VexChorusPlugin : public PluginClass

  304. {

  305. public:

  306.     enum Params {

  307.         kParamDepth = 0,

  308.         kParamRate,

  309.         kParamCount

  310.     };

  311. 

  312.     VexChorusPlugin(const HostDescriptor* const host)

  313.         : PluginClass(host),

  314.           chorus(parameters)

  315.     {

  316.         parameters[0] = 0.6f;

  317.         parameters[1] = 0.3f;

  318. 

  319.         chorus.setSampleRate(getSampleRate());

  320.     }

  321. 

  322. protected:

  323.     // -------------------------------------------------------------------

  324.     // Plugin parameter calls

  325. 

  326.     uint32_t getParameterCount() const override

  327.     {

  328.         return kParamCount;

  329.     }

  330. 

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

  332.     {

  333.         static Parameter paramInfo;

  334. 

  335.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  336. 

  337.         paramInfo.name = nullptr;

  338.         paramInfo.unit = nullptr;

  339.         paramInfo.ranges.def       = 0.0f;

  340.         paramInfo.ranges.min       = 0.0f;

  341.         paramInfo.ranges.max       = 1.0f;

  342.         paramInfo.ranges.step      = 1.0f;

  343.         paramInfo.ranges.stepSmall = 1.0f;

  344.         paramInfo.ranges.stepLarge = 1.0f;

  345.         paramInfo.scalePointCount  = 0;

  346.         paramInfo.scalePoints      = nullptr;

  347. 

  348.         switch (index)

  349.         {

  350.         case kParamDepth:

  351.             paramInfo.name = "Depth";

  352.             paramInfo.ranges.def = 0.6f;

  353.             paramInfo.ranges.min = 0.0f;

  354.             paramInfo.ranges.max = 1.0f;

  355.             break;

  356.         case kParamRate:

  357.             paramInfo.name = "Rate";

  358.             paramInfo.ranges.def = 0.3f;

  359.             paramInfo.ranges.min = 0.0f;

  360.             paramInfo.ranges.max = 1.0f;

  361.             break;

  362.         }

  363. 

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

  365. 

  366.         return &paramInfo;

  367.     }

  368. 

  369.     float getParameterValue(const uint32_t index) const override

  370.     {

  371.         if (index < kParamCount)

  372.             return parameters[index];

  373.         return 0.0f;

  374.     }

  375. 

  376.     // -------------------------------------------------------------------

  377.     // Plugin state calls

  378. 

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

  380.     {

  381.         if (index < kParamCount)

  382.             parameters[index] = value;

  383.     }

  384. 

  385.     // -------------------------------------------------------------------

  386.     // Plugin process calls

  387. 

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

  389.     {

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

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

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

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

  394. 

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

  396.     }

  397. 

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

  399.     // Plugin dispatcher calls

  400. 

  401.     void sampleRateChanged(const double sampleRate) override

  402.     {

  403.         chorus.setSampleRate(sampleRate);

  404.     }

  405. 

  406. private:

  407.     VexChorus chorus;

  408.     float parameters[2];

  409. 

  410.     PluginClassEND(VexChorusPlugin)

  411.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexChorusPlugin)

  412. };

  413. 

  414. // -----------------------------------------------------------------------

  415. 

  416. class VexDelayPlugin : public PluginClass

  417. {

  418. public:

  419.     enum Params {

  420.         kParamTime = 0,

  421.         kParamFeedback,

  422.         kParamCount

  423.     };

  424. 

  425.     VexDelayPlugin(const HostDescriptor* const host)

  426.         : PluginClass(host),

  427.           delay(parameters)

  428.     {

  429.         parameters[0] = 4.0f;

  430.         parameters[1] = 40.0f;

  431. 

  432.         delay.setSampleRate(getSampleRate());

  433.     }

  434. 

  435. protected:

  436.     // -------------------------------------------------------------------

  437.     // Plugin parameter calls

  438. 

  439.     uint32_t getParameterCount() const override

  440.     {

  441.         return kParamCount;

  442.     }

  443. 

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

  445.     {

  446.         static Parameter paramInfo;

  447. 

  448.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  449. 

  450.         paramInfo.name = nullptr;

  451.         paramInfo.unit = nullptr;

  452.         paramInfo.ranges.def       = 0.0f;

  453.         paramInfo.ranges.min       = 0.0f;

  454.         paramInfo.ranges.max       = 1.0f;

  455.         paramInfo.ranges.step      = 1.0f;

  456.         paramInfo.ranges.stepSmall = 1.0f;

  457.         paramInfo.ranges.stepLarge = 1.0f;

  458.         paramInfo.scalePointCount  = 0;

  459.         paramInfo.scalePoints      = nullptr;

  460. 

  461.         switch (index)

  462.         {

  463.         case kParamTime:

  464.             hints |= PARAMETER_IS_INTEGER;

  465.             paramInfo.name = "Time";

  466.             paramInfo.ranges.def = 4.0f;

  467.             paramInfo.ranges.min = 0.0f;

  468.             paramInfo.ranges.max = 8.0f;

  469.             break;

  470.         case kParamFeedback:

  471.             paramInfo.name = "Feedback";

  472.             paramInfo.unit = "%";

  473.             paramInfo.ranges.def = 40.0f;

  474.             paramInfo.ranges.min = 0.0f;

  475.             paramInfo.ranges.max = 100.0f;

  476.             break;

  477.         }

  478. 

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

  480. 

  481.         return &paramInfo;

  482.     }

  483. 

  484.     float getParameterValue(const uint32_t index) const override

  485.     {

  486.         if (index < kParamCount)

  487.             return parameters[index];

  488.         return 0.0f;

  489.     }

  490. 

  491.     // -------------------------------------------------------------------

  492.     // Plugin state calls

  493. 

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

  495.     {

  496.         if (index < kParamCount)

  497.             parameters[index] = value;

  498.     }

  499. 

  500.     // -------------------------------------------------------------------

  501.     // Plugin process calls

  502. 

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

  504.     {

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

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

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

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

  509. 

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

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

  512. 

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

  514.     }

  515. 

  516.     // -------------------------------------------------------------------

  517.     // Plugin dispatcher calls

  518. 

  519.     void sampleRateChanged(const double sampleRate) override

  520.     {

  521.         delay.setSampleRate(sampleRate);

  522.     }

  523. 

  524. private:

  525.     VexDelay delay;

  526.     float parameters[2];

  527. 

  528.     PluginClassEND(VexDelayPlugin)

  529.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexDelayPlugin)

  530. };

  531. 

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

  533. 

  534. class VexReverbPlugin : public PluginClass

  535. {

  536. public:

  537.     enum Params {

  538.         kParamSize = 0,

  539.         kParamWidth,

  540.         kParamDamp,

  541.         kParamCount

  542.     };

  543. 

  544.     VexReverbPlugin(const HostDescriptor* const host)

  545.         : PluginClass(host),

  546.           reverb(parameters)

  547.     {

  548.         parameters[0] = 0.6f;

  549.         parameters[1] = 0.7f;

  550.         parameters[2] = 0.6f;

  551.     }

  552. 

  553. protected:

  554.     // -------------------------------------------------------------------

  555.     // Plugin parameter calls

  556. 

  557.     uint32_t getParameterCount() const override

  558.     {

  559.         return kParamCount;

  560.     }

  561. 

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

  563.     {

  564.         static Parameter paramInfo;

  565. 

  566.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  567. 

  568.         paramInfo.name = nullptr;

  569.         paramInfo.unit = nullptr;

  570.         paramInfo.ranges.def       = 0.0f;

  571.         paramInfo.ranges.min       = 0.0f;

  572.         paramInfo.ranges.max       = 1.0f;

  573.         paramInfo.ranges.step      = 1.0f;

  574.         paramInfo.ranges.stepSmall = 1.0f;

  575.         paramInfo.ranges.stepLarge = 1.0f;

  576.         paramInfo.scalePointCount  = 0;

  577.         paramInfo.scalePoints      = nullptr;

  578. 

  579.         switch (index)

  580.         {

  581.         case kParamSize:

  582.             paramInfo.name = "Size";

  583.             paramInfo.ranges.def = 0.6f;

  584.             paramInfo.ranges.min = 0.0f;

  585.             paramInfo.ranges.max = 1.0f;

  586.             break;

  587.         case kParamWidth:

  588.             paramInfo.name = "Width";

  589.             paramInfo.ranges.def = 0.7f;

  590.             paramInfo.ranges.min = 0.0f;

  591.             paramInfo.ranges.max = 1.0f;

  592.             break;

  593.         case kParamDamp:

  594.             paramInfo.name = "Damp";

  595.             paramInfo.ranges.def = 0.6f;

  596.             paramInfo.ranges.min = 0.0f;

  597.             paramInfo.ranges.max = 1.0f;

  598.             break;

  599.         }

  600. 

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

  602. 

  603.         return &paramInfo;

  604.     }

  605. 

  606.     float getParameterValue(const uint32_t index) const override

  607.     {

  608.         if (index < kParamCount)

  609.             return parameters[index];

  610.         return 0.0f;

  611.     }

  612. 

  613.     // -------------------------------------------------------------------

  614.     // Plugin state calls

  615. 

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

  617.     {

  618.         if (index < kParamCount)

  619.             parameters[index] = value;

  620.     }

  621. 

  622.     // -------------------------------------------------------------------

  623.     // Plugin process calls

  624. 

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

  626.     {

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

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

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

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

  631. 

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

  633.     }

  634. 

  635. private:

  636.     VexReverb reverb;

  637.     float parameters[3];

  638. 

  639.     PluginClassEND(VexReverbPlugin)

  640.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexReverbPlugin)

  641. };

  642. 

  643. // -----------------------------------------------------------------------

  644. 

  645. class VexSynthPlugin : public PluginClass

  646. {

  647. public:

  648.     static const unsigned int kParamCount = 1;

  649. 

  650.     VexSynthPlugin(const HostDescriptor* const host)

  651.         : PluginClass(host),

  652.           synth(parameters)

  653.     {

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

  655. 

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

  657.         {

  658.             const int offset = i * 24;

  659. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  684.         }

  685. 

  686.         parameters[89] = 1.0f;

  687. 

  688.         synth.setSampleRate(getSampleRate());

  689.         synth.update(89);

  690.     }

  691. 

  692. protected:

  693.     // -------------------------------------------------------------------

  694.     // Plugin parameter calls

  695. 

  696.     uint32_t getParameterCount() const override

  697.     {

  698.         return kParamCount;

  699.     }

  700. 

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

  702.     {

  703.         static Parameter paramInfo;

  704. 

  705.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  706. 

  707.         paramInfo.name = nullptr;

  708.         paramInfo.unit = nullptr;

  709.         paramInfo.ranges.def       = 0.0f;

  710.         paramInfo.ranges.min       = 0.0f;

  711.         paramInfo.ranges.max       = 1.0f;

  712.         paramInfo.ranges.step      = 1.0f;

  713.         paramInfo.ranges.stepSmall = 1.0f;

  714.         paramInfo.ranges.stepLarge = 1.0f;

  715.         paramInfo.scalePointCount  = 0;

  716.         paramInfo.scalePoints      = nullptr;

  717. 

  718.         switch (index)

  719.         {

  720.         case 0:

  721.             hints |= PARAMETER_IS_INTEGER;

  722.             paramInfo.name = "Wave";

  723.             paramInfo.ranges.def = 0.0f;

  724.             paramInfo.ranges.min = 0.0f;

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

  726.             break;

  727.         }

  728. 

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

  730. 

  731.         return &paramInfo;

  732.     }

  733. 

  734.     float getParameterValue(const uint32_t index) const override

  735.     {

  736.         if (index < kParamCount)

  737.             return parameters[index];

  738.         return 0.0f;

  739.     }

  740. 

  741.     // -------------------------------------------------------------------

  742.     // Plugin state calls

  743. 

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

  745.     {

  746.         if (index < kParamCount)

  747.         {

  748.             parameters[index] = value;

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

  750. 

  751.             //synth.update(index);

  752.         }

  753.     }

  754. 

  755.     // -------------------------------------------------------------------

  756.     // Plugin process calls

  757. 

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

  759.     {

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

  761.         {

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

  763. 

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

  765. 

  766.             if (status == MIDI_STATUS_NOTE_ON)

  767.             {

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

  769.             }

  770.             else if (status == MIDI_STATUS_NOTE_OFF)

  771.             {

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

  773.             }

  774.             else if (status == MIDI_STATUS_CONTROL_CHANGE)

  775.             {

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

  777. 

  778.                 if (control == MIDI_CONTROL_ALL_SOUND_OFF)

  779.                     synth.kill();

  780.                 else if (control == MIDI_CONTROL_ALL_NOTES_OFF)

  781.                     synth.releaseAll(1);

  782.             }

  783.         }

  784. 

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

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

  787. 

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

  789.     }

  790. 

  791.     // -------------------------------------------------------------------

  792.     // Plugin dispatcher calls

  793. 

  794.     void sampleRateChanged(const double sampleRate) override

  795.     {

  796.         synth.setSampleRate(sampleRate);

  797.     }

  798. 

  799. private:

  800.     VexSyntModule synth;

  801.     float parameters[92];

  802. 

  803.     PluginClassEND(VexSynthPlugin)

  804.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexSynthPlugin)

  805. };

  806. 

  807. // -----------------------------------------------------------------------

  808. 

  809. static const PluginDescriptor vexArpDesc = {

  810.     /* category  */ PLUGIN_CATEGORY_UTILITY,

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

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

  813.     /* audioIns  */ 0,

  814.     /* audioOuts */ 0,

  815.     /* midiIns   */ 1,

  816.     /* midiOuts  */ 1,

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

  818.     /* paramOuts */ 0,

  819.     /* name      */ "VexArp",

  820.     /* label     */ "vexArp",

  821.     /* maker     */ "falkTX",

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

  823.     PluginDescriptorFILL(VexArpPlugin)

  824. };

  825. 

  826. static const PluginDescriptor vexChorusDesc = {

  827.     /* category  */ PLUGIN_CATEGORY_MODULATOR,

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

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

  830.     /* audioIns  */ 2,

  831.     /* audioOuts */ 2,

  832.     /* midiIns   */ 0,

  833.     /* midiOuts  */ 0,

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

  835.     /* paramOuts */ 0,

  836.     /* name      */ "VexChorus",

  837.     /* label     */ "vexChorus",

  838.     /* maker     */ "falkTX",

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

  840.     PluginDescriptorFILL(VexChorusPlugin)

  841. };

  842. 

  843. static const PluginDescriptor vexDelayDesc = {

  844.     /* category  */ PLUGIN_CATEGORY_DELAY,

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

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

  847.     /* audioIns  */ 2,

  848.     /* audioOuts */ 2,

  849.     /* midiIns   */ 0,

  850.     /* midiOuts  */ 0,

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

  852.     /* paramOuts */ 0,

  853.     /* name      */ "VexDelay",

  854.     /* label     */ "vexDelay",

  855.     /* maker     */ "falkTX",

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

  857.     PluginDescriptorFILL(VexDelayPlugin)

  858. };

  859. 

  860. static const PluginDescriptor vexReverbDesc = {

  861.     /* category  */ PLUGIN_CATEGORY_DELAY,

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

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

  864.     /* audioIns  */ 2,

  865.     /* audioOuts */ 2,

  866.     /* midiIns   */ 0,

  867.     /* midiOuts  */ 0,

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

  869.     /* paramOuts */ 0,

  870.     /* name      */ "VexReverb",

  871.     /* label     */ "vexReverb",

  872.     /* maker     */ "falkTX",

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

  874.     PluginDescriptorFILL(VexReverbPlugin)

  875. };

  876. 

  877. static const PluginDescriptor vexSynthDesc = {

  878.     /* category  */ PLUGIN_CATEGORY_SYNTH,

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

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

  881.     /* audioIns  */ 0,

  882.     /* audioOuts */ 2,

  883.     /* midiIns   */ 1,

  884.     /* midiOuts  */ 0,

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

  886.     /* paramOuts */ 0,

  887.     /* name      */ "VexSynth",

  888.     /* label     */ "vexSynth",

  889.     /* maker     */ "falkTX",

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

  891.     PluginDescriptorFILL(VexSynthPlugin)

  892. };

  893. 

  894. // -----------------------------------------------------------------------

  895. 

  896. CARLA_EXPORT

  897. void carla_register_native_plugin_vex()

  898. {

  899.     carla_register_native_plugin(&vexArpDesc);

  900.     carla_register_native_plugin(&vexChorusDesc);

  901.     carla_register_native_plugin(&vexDelayDesc);

  902.     carla_register_native_plugin(&vexReverbDesc);

  903.     carla_register_native_plugin(&vexSynthDesc);

  904. }

  905. 

  906. // -----------------------------------------------------------------------

  907. 

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

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

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

  911. 

  912. #include "vex/cVoice.cpp"

  913. #include "vex/cWaveRenderer.cpp"

  914. #include "vex/ResourceFile.cpp"

  915. 

  916. // -----------------------------------------------------------------------