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.
907 Commits
16 Branches
274MB
Tree: 30fd6d7140
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '30fd6d7140'
${ noResults }
Carla/source/modules/carla_native/vex.cpp

922 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. 

  236.         int    timeFrame   = 0;

  237.         bool   timePlaying = false;

  238.         double ppqPos      = 0.0;

  239.         double barStartPos = 0.0;

  240.         double bpm         = 120.0;

  241. 

  242.         if (timeInfo != nullptr)

  243.         {

  244.             timeFrame   = timeInfo->frame;

  245.             timePlaying = timeInfo->playing;

  246. 

  247.             if (timeInfo->bbt.valid)

  248.             {

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

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

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

  252. 

  253.                 ppqPos      = ppqBar + ppqBeat + ppqTick;

  254.                 barStartPos = ppqBar;

  255.                 bpm         = timeInfo->bbt.beatsPerMinute;

  256.             }

  257.         }

  258. 

  259.         fMidiInBuffer.clear();

  260. 

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

  262.         {

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

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

  265.         }

  266. 

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

  268. 

  269.         MidiBuffer::Iterator outBufferIterator(outMidiBuffer);

  270.         MidiMessage midiMessage(0xf4);

  271.         int sampleNumber;

  272. 

  273.         MidiEvent tmpEvent;

  274.         tmpEvent.port = 0;

  275. 

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

  277.         {

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

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

  280. 

  281.             if (tmpEvent.size > 4)

  282.                 continue;

  283. 

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

  285.             writeMidiEvent(&tmpEvent);

  286.         }

  287.     }

  288. 

  289.     // -------------------------------------------------------------------

  290.     // Plugin dispatcher calls

  291. 

  292.     void sampleRateChanged(const double sampleRate) override

  293.     {

  294.         fArp.setSampleRate(sampleRate);

  295.     }

  296. 

  297. private:

  298.     VexArpSettings fSettings;

  299.     VexArp fArp;

  300.     MidiBuffer fMidiInBuffer;

  301. 

  302.     PluginClassEND(VexArpPlugin)

  303.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexArpPlugin)

  304. };

  305. 

  306. // -----------------------------------------------------------------------

  307. 

  308. class VexChorusPlugin : public PluginClass

  309. {

  310. public:

  311.     enum Params {

  312.         kParamDepth = 0,

  313.         kParamRate,

  314.         kParamCount

  315.     };

  316. 

  317.     VexChorusPlugin(const HostDescriptor* const host)

  318.         : PluginClass(host),

  319.           chorus(parameters)

  320.     {

  321.         parameters[0] = 0.6f;

  322.         parameters[1] = 0.3f;

  323. 

  324.         chorus.setSampleRate(getSampleRate());

  325.     }

  326. 

  327. protected:

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

  329.     // Plugin parameter calls

  330. 

  331.     uint32_t getParameterCount() const override

  332.     {

  333.         return kParamCount;

  334.     }

  335. 

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

  337.     {

  338.         static Parameter paramInfo;

  339. 

  340.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  341. 

  342.         paramInfo.name = nullptr;

  343.         paramInfo.unit = nullptr;

  344.         paramInfo.ranges.def       = 0.0f;

  345.         paramInfo.ranges.min       = 0.0f;

  346.         paramInfo.ranges.max       = 1.0f;

  347.         paramInfo.ranges.step      = 1.0f;

  348.         paramInfo.ranges.stepSmall = 1.0f;

  349.         paramInfo.ranges.stepLarge = 1.0f;

  350.         paramInfo.scalePointCount  = 0;

  351.         paramInfo.scalePoints      = nullptr;

  352. 

  353.         switch (index)

  354.         {

  355.         case kParamDepth:

  356.             paramInfo.name = "Depth";

  357.             paramInfo.ranges.def = 0.6f;

  358.             paramInfo.ranges.min = 0.0f;

  359.             paramInfo.ranges.max = 1.0f;

  360.             break;

  361.         case kParamRate:

  362.             paramInfo.name = "Rate";

  363.             paramInfo.ranges.def = 0.3f;

  364.             paramInfo.ranges.min = 0.0f;

  365.             paramInfo.ranges.max = 1.0f;

  366.             break;

  367.         }

  368. 

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

  370. 

  371.         return &paramInfo;

  372.     }

  373. 

  374.     float getParameterValue(const uint32_t index) const override

  375.     {

  376.         if (index < kParamCount)

  377.             return parameters[index];

  378.         return 0.0f;

  379.     }

  380. 

  381.     // -------------------------------------------------------------------

  382.     // Plugin state calls

  383. 

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

  385.     {

  386.         if (index < kParamCount)

  387.             parameters[index] = value;

  388.     }

  389. 

  390.     // -------------------------------------------------------------------

  391.     // Plugin process calls

  392. 

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

  394.     {

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

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

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

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

  399. 

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

  401.     }

  402. 

  403.     // -------------------------------------------------------------------

  404.     // Plugin dispatcher calls

  405. 

  406.     void sampleRateChanged(const double sampleRate) override

  407.     {

  408.         chorus.setSampleRate(sampleRate);

  409.     }

  410. 

  411. private:

  412.     VexChorus chorus;

  413.     float parameters[2];

  414. 

  415.     PluginClassEND(VexChorusPlugin)

  416.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexChorusPlugin)

  417. };

  418. 

  419. // -----------------------------------------------------------------------

  420. 

  421. class VexDelayPlugin : public PluginClass

  422. {

  423. public:

  424.     enum Params {

  425.         kParamTime = 0,

  426.         kParamFeedback,

  427.         kParamCount

  428.     };

  429. 

  430.     VexDelayPlugin(const HostDescriptor* const host)

  431.         : PluginClass(host),

  432.           delay(parameters)

  433.     {

  434.         parameters[0] = 4.0f;

  435.         parameters[1] = 40.0f;

  436. 

  437.         delay.setSampleRate(getSampleRate());

  438.     }

  439. 

  440. protected:

  441.     // -------------------------------------------------------------------

  442.     // Plugin parameter calls

  443. 

  444.     uint32_t getParameterCount() const override

  445.     {

  446.         return kParamCount;

  447.     }

  448. 

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

  450.     {

  451.         static Parameter paramInfo;

  452. 

  453.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  454. 

  455.         paramInfo.name = nullptr;

  456.         paramInfo.unit = nullptr;

  457.         paramInfo.ranges.def       = 0.0f;

  458.         paramInfo.ranges.min       = 0.0f;

  459.         paramInfo.ranges.max       = 1.0f;

  460.         paramInfo.ranges.step      = 1.0f;

  461.         paramInfo.ranges.stepSmall = 1.0f;

  462.         paramInfo.ranges.stepLarge = 1.0f;

  463.         paramInfo.scalePointCount  = 0;

  464.         paramInfo.scalePoints      = nullptr;

  465. 

  466.         switch (index)

  467.         {

  468.         case kParamTime:

  469.             hints |= PARAMETER_IS_INTEGER;

  470.             paramInfo.name = "Time";

  471.             paramInfo.ranges.def = 4.0f;

  472.             paramInfo.ranges.min = 0.0f;

  473.             paramInfo.ranges.max = 8.0f;

  474.             break;

  475.         case kParamFeedback:

  476.             paramInfo.name = "Feedback";

  477.             paramInfo.unit = "%";

  478.             paramInfo.ranges.def = 40.0f;

  479.             paramInfo.ranges.min = 0.0f;

  480.             paramInfo.ranges.max = 100.0f;

  481.             break;

  482.         }

  483. 

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

  485. 

  486.         return &paramInfo;

  487.     }

  488. 

  489.     float getParameterValue(const uint32_t index) const override

  490.     {

  491.         if (index < kParamCount)

  492.             return parameters[index];

  493.         return 0.0f;

  494.     }

  495. 

  496.     // -------------------------------------------------------------------

  497.     // Plugin state calls

  498. 

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

  500.     {

  501.         if (index < kParamCount)

  502.             parameters[index] = value;

  503.     }

  504. 

  505.     // -------------------------------------------------------------------

  506.     // Plugin process calls

  507. 

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

  509.     {

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

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

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

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

  514. 

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

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

  517. 

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

  519.     }

  520. 

  521.     // -------------------------------------------------------------------

  522.     // Plugin dispatcher calls

  523. 

  524.     void sampleRateChanged(const double sampleRate) override

  525.     {

  526.         delay.setSampleRate(sampleRate);

  527.     }

  528. 

  529. private:

  530.     VexDelay delay;

  531.     float parameters[2];

  532. 

  533.     PluginClassEND(VexDelayPlugin)

  534.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexDelayPlugin)

  535. };

  536. 

  537. // -----------------------------------------------------------------------

  538. 

  539. class VexReverbPlugin : public PluginClass

  540. {

  541. public:

  542.     enum Params {

  543.         kParamSize = 0,

  544.         kParamWidth,

  545.         kParamDamp,

  546.         kParamCount

  547.     };

  548. 

  549.     VexReverbPlugin(const HostDescriptor* const host)

  550.         : PluginClass(host),

  551.           reverb(parameters)

  552.     {

  553.         parameters[0] = 0.6f;

  554.         parameters[1] = 0.7f;

  555.         parameters[2] = 0.6f;

  556.     }

  557. 

  558. protected:

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

  560.     // Plugin parameter calls

  561. 

  562.     uint32_t getParameterCount() const override

  563.     {

  564.         return kParamCount;

  565.     }

  566. 

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

  568.     {

  569.         static Parameter paramInfo;

  570. 

  571.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  572. 

  573.         paramInfo.name = nullptr;

  574.         paramInfo.unit = nullptr;

  575.         paramInfo.ranges.def       = 0.0f;

  576.         paramInfo.ranges.min       = 0.0f;

  577.         paramInfo.ranges.max       = 1.0f;

  578.         paramInfo.ranges.step      = 1.0f;

  579.         paramInfo.ranges.stepSmall = 1.0f;

  580.         paramInfo.ranges.stepLarge = 1.0f;

  581.         paramInfo.scalePointCount  = 0;

  582.         paramInfo.scalePoints      = nullptr;

  583. 

  584.         switch (index)

  585.         {

  586.         case kParamSize:

  587.             paramInfo.name = "Size";

  588.             paramInfo.ranges.def = 0.6f;

  589.             paramInfo.ranges.min = 0.0f;

  590.             paramInfo.ranges.max = 1.0f;

  591.             break;

  592.         case kParamWidth:

  593.             paramInfo.name = "Width";

  594.             paramInfo.ranges.def = 0.7f;

  595.             paramInfo.ranges.min = 0.0f;

  596.             paramInfo.ranges.max = 1.0f;

  597.             break;

  598.         case kParamDamp:

  599.             paramInfo.name = "Damp";

  600.             paramInfo.ranges.def = 0.6f;

  601.             paramInfo.ranges.min = 0.0f;

  602.             paramInfo.ranges.max = 1.0f;

  603.             break;

  604.         }

  605. 

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

  607. 

  608.         return &paramInfo;

  609.     }

  610. 

  611.     float getParameterValue(const uint32_t index) const override

  612.     {

  613.         if (index < kParamCount)

  614.             return parameters[index];

  615.         return 0.0f;

  616.     }

  617. 

  618.     // -------------------------------------------------------------------

  619.     // Plugin state calls

  620. 

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

  622.     {

  623.         if (index < kParamCount)

  624.             parameters[index] = value;

  625.     }

  626. 

  627.     // -------------------------------------------------------------------

  628.     // Plugin process calls

  629. 

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

  631.     {

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

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

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

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

  636. 

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

  638.     }

  639. 

  640. private:

  641.     VexReverb reverb;

  642.     float parameters[3];

  643. 

  644.     PluginClassEND(VexReverbPlugin)

  645.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexReverbPlugin)

  646. };

  647. 

  648. // -----------------------------------------------------------------------

  649. 

  650. class VexSynthPlugin : public PluginClass

  651. {

  652. public:

  653.     static const unsigned int kParamCount = 1;

  654. 

  655.     VexSynthPlugin(const HostDescriptor* const host)

  656.         : PluginClass(host),

  657.           synth(parameters)

  658.     {

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

  660. 

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

  662.         {

  663.             const int offset = i * 24;

  664. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  689.         }

  690. 

  691.         parameters[89] = 1.0f;

  692. 

  693.         synth.setSampleRate(getSampleRate());

  694.         synth.update(89);

  695.     }

  696. 

  697. protected:

  698.     // -------------------------------------------------------------------

  699.     // Plugin parameter calls

  700. 

  701.     uint32_t getParameterCount() const override

  702.     {

  703.         return kParamCount;

  704.     }

  705. 

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

  707.     {

  708.         static Parameter paramInfo;

  709. 

  710.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  711. 

  712.         paramInfo.name = nullptr;

  713.         paramInfo.unit = nullptr;

  714.         paramInfo.ranges.def       = 0.0f;

  715.         paramInfo.ranges.min       = 0.0f;

  716.         paramInfo.ranges.max       = 1.0f;

  717.         paramInfo.ranges.step      = 1.0f;

  718.         paramInfo.ranges.stepSmall = 1.0f;

  719.         paramInfo.ranges.stepLarge = 1.0f;

  720.         paramInfo.scalePointCount  = 0;

  721.         paramInfo.scalePoints      = nullptr;

  722. 

  723.         switch (index)

  724.         {

  725.         case 0:

  726.             hints |= PARAMETER_IS_INTEGER;

  727.             paramInfo.name = "Wave";

  728.             paramInfo.ranges.def = 0.0f;

  729.             paramInfo.ranges.min = 0.0f;

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

  731.             break;

  732.         }

  733. 

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

  735. 

  736.         return &paramInfo;

  737.     }

  738. 

  739.     float getParameterValue(const uint32_t index) const override

  740.     {

  741.         if (index < kParamCount)

  742.             return parameters[index];

  743.         return 0.0f;

  744.     }

  745. 

  746.     // -------------------------------------------------------------------

  747.     // Plugin state calls

  748. 

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

  750.     {

  751.         if (index < kParamCount)

  752.         {

  753.             parameters[index] = value;

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

  755. 

  756.             //synth.update(index);

  757.         }

  758.     }

  759. 

  760.     // -------------------------------------------------------------------

  761.     // Plugin process calls

  762. 

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

  764.     {

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

  766.         {

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

  768. 

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

  770. 

  771.             if (status == MIDI_STATUS_NOTE_ON)

  772.             {

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

  774.             }

  775.             else if (status == MIDI_STATUS_NOTE_OFF)

  776.             {

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

  778.             }

  779.             else if (status == MIDI_STATUS_CONTROL_CHANGE)

  780.             {

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

  782. 

  783.                 if (control == MIDI_CONTROL_ALL_SOUND_OFF)

  784.                     synth.kill();

  785.                 else if (control == MIDI_CONTROL_ALL_NOTES_OFF)

  786.                     synth.releaseAll(1);

  787.             }

  788.         }

  789. 

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

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

  792. 

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

  794.     }

  795. 

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

  797.     // Plugin dispatcher calls

  798. 

  799.     void sampleRateChanged(const double sampleRate) override

  800.     {

  801.         synth.setSampleRate(sampleRate);

  802.     }

  803. 

  804. private:

  805.     VexSyntModule synth;

  806.     float parameters[92];

  807. 

  808.     PluginClassEND(VexSynthPlugin)

  809.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexSynthPlugin)

  810. };

  811. 

  812. // -----------------------------------------------------------------------

  813. 

  814. static const PluginDescriptor vexArpDesc = {

  815.     /* category  */ PLUGIN_CATEGORY_UTILITY,

  816.     /* hints     */ static_cast<PluginHints>(PLUGIN_USES_TIMEPOS),

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

  818.     /* audioIns  */ 0,

  819.     /* audioOuts */ 0,

  820.     /* midiIns   */ 1,

  821.     /* midiOuts  */ 1,

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

  823.     /* paramOuts */ 0,

  824.     /* name      */ "VexArp",

  825.     /* label     */ "vexArp",

  826.     /* maker     */ "falkTX",

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

  828.     PluginDescriptorFILL(VexArpPlugin)

  829. };

  830. 

  831. static const PluginDescriptor vexChorusDesc = {

  832.     /* category  */ PLUGIN_CATEGORY_MODULATOR,

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

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

  835.     /* audioIns  */ 2,

  836.     /* audioOuts */ 2,

  837.     /* midiIns   */ 0,

  838.     /* midiOuts  */ 0,

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

  840.     /* paramOuts */ 0,

  841.     /* name      */ "VexChorus",

  842.     /* label     */ "vexChorus",

  843.     /* maker     */ "falkTX",

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

  845.     PluginDescriptorFILL(VexChorusPlugin)

  846. };

  847. 

  848. static const PluginDescriptor vexDelayDesc = {

  849.     /* category  */ PLUGIN_CATEGORY_DELAY,

  850.     /* hints     */ static_cast<PluginHints>(PLUGIN_IS_RTSAFE|PLUGIN_USES_TIMEPOS),

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

  852.     /* audioIns  */ 2,

  853.     /* audioOuts */ 2,

  854.     /* midiIns   */ 0,

  855.     /* midiOuts  */ 0,

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

  857.     /* paramOuts */ 0,

  858.     /* name      */ "VexDelay",

  859.     /* label     */ "vexDelay",

  860.     /* maker     */ "falkTX",

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

  862.     PluginDescriptorFILL(VexDelayPlugin)

  863. };

  864. 

  865. static const PluginDescriptor vexReverbDesc = {

  866.     /* category  */ PLUGIN_CATEGORY_DELAY,

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

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

  869.     /* audioIns  */ 2,

  870.     /* audioOuts */ 2,

  871.     /* midiIns   */ 0,

  872.     /* midiOuts  */ 0,

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

  874.     /* paramOuts */ 0,

  875.     /* name      */ "VexReverb",

  876.     /* label     */ "vexReverb",

  877.     /* maker     */ "falkTX",

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

  879.     PluginDescriptorFILL(VexReverbPlugin)

  880. };

  881. 

  882. static const PluginDescriptor vexSynthDesc = {

  883.     /* category  */ PLUGIN_CATEGORY_SYNTH,

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

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

  886.     /* audioIns  */ 0,

  887.     /* audioOuts */ 2,

  888.     /* midiIns   */ 1,

  889.     /* midiOuts  */ 0,

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

  891.     /* paramOuts */ 0,

  892.     /* name      */ "VexSynth",

  893.     /* label     */ "vexSynth",

  894.     /* maker     */ "falkTX",

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

  896.     PluginDescriptorFILL(VexSynthPlugin)

  897. };

  898. 

  899. // -----------------------------------------------------------------------

  900. 

  901. CARLA_EXPORT

  902. void carla_register_native_plugin_vex()

  903. {

  904.     carla_register_native_plugin(&vexArpDesc);

  905.     carla_register_native_plugin(&vexChorusDesc);

  906.     carla_register_native_plugin(&vexDelayDesc);

  907.     carla_register_native_plugin(&vexReverbDesc);

  908.     carla_register_native_plugin(&vexSynthDesc);

  909. }

  910. 

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

  912. 

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

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

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

  916. 

  917. #include "vex/cVoice.cpp"

  918. #include "vex/cWaveRenderer.cpp"

  919. #include "vex/ResourceFile.cpp"

  920. 

  921. // -----------------------------------------------------------------------