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

1573 lines
46KB
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/VexArp.h"

  25. #include "vex/VexChorus.h"

  26. #include "vex/VexDelay.h"

  27. #include "vex/VexReverb.h"

  28. #include "vex/VexSyntModule.h"

  29. 

  30. #include "vex/PeggyViewComponent.h"

  31. #include "vex/lookandfeel/MyLookAndFeel.h"

  32. #include "vex/resources/Resources.h"

  33. 

  34. #include "vex/resources/Resources.cpp"

  35. 

  36. // -----------------------------------------------------------------------

  37. 

  38. class HelperWindow : public DocumentWindow

  39. {

  40. public:

  41.     HelperWindow()

  42.         : DocumentWindow("PlugWindow", Colour(50, 50, 200), DocumentWindow::closeButton, false),

  43.           fClosed(false)

  44.     {

  45.         setVisible(false);

  46.         setAlwaysOnTop(true);

  47.         setDropShadowEnabled(false);

  48.         setOpaque(true);

  49.         //setResizable(false, false);

  50.         //setUsingNativeTitleBar(false);

  51.     }

  52. 

  53.     void show(Component* const comp)

  54.     {

  55.         fClosed = false;

  56. 

  57.         const int width  = comp->getWidth();

  58.         const int height = comp->getHeight()+getTitleBarHeight();

  59. 

  60.         centreWithSize(width, height);

  61.         setContentNonOwned(comp, false);

  62.         setSize(width, height);

  63. 

  64.         if (! isOnDesktop())

  65.             addToDesktop();

  66. 

  67.         setVisible(true);

  68.     }

  69. 

  70.     void hide()

  71.     {

  72.         setVisible(false);

  73. 

  74.         if (isOnDesktop())

  75.             removeFromDesktop();

  76. 

  77.         clearContentComponent();

  78.     }

  79. 

  80.     bool wasClosedByUser() const

  81.     {

  82.         return fClosed;

  83.     }

  84. 

  85. protected:

  86.     void closeButtonPressed() override

  87.     {

  88.         fClosed = true;

  89.     }

  90. 

  91. private:

  92.     bool fClosed;

  93. 

  94.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(HelperWindow)

  95. };

  96. 

  97. // -----------------------------------------------------------------------

  98. 

  99. class VexEditorComponent : public ComboBox::Listener,

  100.                            public Slider::Listener,

  101.                            public Button::Listener,

  102.                            public ChangeListener,

  103.                            public Component,

  104.                            public PeggyViewComponent::Callback

  105. {

  106. public:

  107.     VexEditorComponent()

  108.     {

  109.         internalCachedImage1 = ImageCache::getFromMemory(Resources::vex3_png, Resources::vex3_pngSize);

  110. 

  111.         // Comboboxes, wave selection

  112.         addAndMakeVisible(comboBox1 = new ComboBox (String::empty));

  113.         comboBox1->setEditableText(false);

  114.         comboBox1->setJustificationType(Justification::centredLeft);

  115.         comboBox1->setTextWhenNothingSelected(String("silent"));

  116.         comboBox1->setTextWhenNoChoicesAvailable(String("silent"));

  117.         comboBox1->addListener(this);

  118.         comboBox1->setColour(ComboBox::backgroundColourId, Colours::black);

  119.         comboBox1->setColour(ComboBox::textColourId, Colours::lightgrey);

  120.         comboBox1->setColour(ComboBox::outlineColourId, Colours::grey);

  121.         comboBox1->setColour(ComboBox::buttonColourId, Colours::grey);

  122.         comboBox1->setWantsKeyboardFocus(false);

  123.         comboBox1->setLookAndFeel(&mlaf);

  124. 

  125.         addAndMakeVisible (comboBox2 = new ComboBox (String::empty));

  126.         comboBox2->setEditableText (false);

  127.         comboBox2->setJustificationType (Justification::centredLeft);

  128.         comboBox2->setTextWhenNothingSelected (String("silent"));

  129.         comboBox2->setTextWhenNoChoicesAvailable (String("silent"));

  130.         comboBox2->addListener (this);

  131.         comboBox2->setColour(ComboBox::backgroundColourId, Colours::black);

  132.         comboBox2->setColour(ComboBox::textColourId, Colours::lightgrey);

  133.         comboBox2->setColour(ComboBox::outlineColourId, Colours::grey);

  134.         comboBox2->setColour(ComboBox::buttonColourId, Colours::grey);

  135.         comboBox2->setWantsKeyboardFocus(false);

  136.         comboBox2->setLookAndFeel(&mlaf);

  137. 

  138.         addAndMakeVisible (comboBox3 = new ComboBox (String::empty));

  139.         comboBox3->setEditableText (false);

  140.         comboBox3->setJustificationType (Justification::centredLeft);

  141.         comboBox3->setTextWhenNothingSelected (String("silent"));

  142.         comboBox3->setTextWhenNoChoicesAvailable (String("silent"));

  143.         comboBox3->addListener (this);

  144.         comboBox3->setColour(ComboBox::backgroundColourId, Colours::black);

  145.         comboBox3->setColour(ComboBox::textColourId, Colours::lightgrey);

  146.         comboBox3->setColour(ComboBox::outlineColourId, Colours::grey);

  147.         comboBox3->setColour(ComboBox::buttonColourId, Colours::grey);

  148.         comboBox3->setWantsKeyboardFocus(false);

  149.         comboBox3->setLookAndFeel(&mlaf);

  150. 

  151.         for (int i = 0, tableSize = WaveRenderer::getWaveTableSize(); i < tableSize; ++i)

  152.         {

  153.             String tableName(WaveRenderer::getWaveTableName(i));

  154. 

  155.             comboBox1->addItem(tableName, i + 1);

  156.             comboBox2->addItem(tableName, i + 1);

  157.             comboBox3->addItem(tableName, i + 1);

  158.         }

  159. 

  160.         addChildComponent(p1 = new PeggyViewComponent(1, _d, this));

  161.         p1->setLookAndFeel(&mlaf);

  162.         addChildComponent(p2 = new PeggyViewComponent(2, _d, this));

  163.         p2->setLookAndFeel(&mlaf);

  164.         addChildComponent(p3 = new PeggyViewComponent(3, _d, this));

  165.         p3->setLookAndFeel(&mlaf);

  166. 

  167.         //ownerFilter->addChangeListener (this);

  168.         setSize(800,500);

  169.     }

  170. 

  171.     ~VexEditorComponent()

  172.     {

  173.         removeAllChildren();

  174.     }

  175. 

  176. protected:

  177.     void paint(Graphics& g) override

  178.     {

  179.         g.drawImage(internalCachedImage1,

  180.                     0, 0, 800, 500,

  181.                     0, 0, internalCachedImage1.getWidth(), internalCachedImage1.getHeight());

  182.     }

  183. 

  184.     void resized() override

  185.     {

  186.         comboBox1->setBounds(13, 38, 173, 23);

  187.         comboBox2->setBounds(213, 38, 173, 23);

  188.         comboBox3->setBounds(413, 38, 173, 23);

  189. 

  190.         p1->setBounds(10, 20, 207, 280);

  191.         p2->setBounds(210, 20, 207, 280);

  192.         p3->setBounds(410, 20, 207, 280);

  193.     }

  194. 

  195.     void changeListenerCallback(ChangeBroadcaster* source) override

  196.     {

  197.     }

  198. 

  199.     void comboBoxChanged(ComboBox* comboBoxThatHasChanged) override

  200.     {

  201.     }

  202. 

  203.     void sliderValueChanged(Slider* sliderThatWasMoved) override

  204.     {

  205.     }

  206. 

  207.     void buttonClicked(Button* buttonThatWasClicked) override

  208.     {

  209.     }

  210. 

  211.     void somethingChanged(const uint32_t id) override

  212.     {

  213.     }

  214. 

  215. private:

  216.     Image internalCachedImage1;

  217.     MyLookAndFeel mlaf;

  218. 

  219.     ScopedPointer<ComboBox> comboBox1;

  220.     ScopedPointer<ComboBox> comboBox2;

  221.     ScopedPointer<ComboBox> comboBox3;

  222. 

  223.     ScopedPointer<PeggyViewComponent> p1;

  224.     ScopedPointer<PeggyViewComponent> p2;

  225.     ScopedPointer<PeggyViewComponent> p3;

  226. 

  227.     VexArpSettings _d;

  228. };

  229. 

  230. // -----------------------------------------------------------------------

  231. 

  232. class VexArpPlugin : public PluginClass,

  233.                      public PeggyViewComponent::Callback

  234. {

  235. public:

  236.     enum Params {

  237.         kParamOnOff = 0,

  238.         kParamLength,

  239.         kParamTimeMode,

  240.         kParamSyncMode,

  241.         kParamFailMode,

  242.         kParamVelMode,

  243.         kParamLast,

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

  245.     };

  246. 

  247.     VexArpPlugin(const HostDescriptor* const host)

  248.         : PluginClass(host),

  249.           fArp(&fSettings)

  250.     {

  251.         fArp.setSampleRate(getSampleRate());

  252.         fMidiInBuffer.ensureSize(512*4);

  253.     }

  254. 

  255. protected:

  256.     // -------------------------------------------------------------------

  257.     // Plugin parameter calls

  258. 

  259.     uint32_t getParameterCount() const override

  260.     {

  261.         return kParamCount;

  262.     }

  263. 

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

  265.     {

  266.         static Parameter paramInfo;

  267.         static ParameterScalePoint scalePoints[4];

  268.         static char bufName[24+1];

  269. 

  270.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  271. 

  272.         paramInfo.name = nullptr;

  273.         paramInfo.unit = nullptr;

  274.         paramInfo.ranges.def       = 0.0f;

  275.         paramInfo.ranges.min       = 0.0f;

  276.         paramInfo.ranges.max       = 1.0f;

  277.         paramInfo.ranges.step      = PARAMETER_RANGES_DEFAULT_STEP;

  278.         paramInfo.ranges.stepSmall = PARAMETER_RANGES_DEFAULT_STEP_SMALL;

  279.         paramInfo.ranges.stepLarge = PARAMETER_RANGES_DEFAULT_STEP_LARGE;

  280.         paramInfo.scalePointCount  = 0;

  281.         paramInfo.scalePoints      = nullptr;

  282. 

  283.         if (index < kParamLast)

  284.         {

  285.             hints |= PARAMETER_IS_INTEGER;

  286.             paramInfo.ranges.step      = 1.0f;

  287.             paramInfo.ranges.stepSmall = 1.0f;

  288.             paramInfo.ranges.stepLarge = 1.0f;

  289. 

  290.             switch (index)

  291.             {

  292.             case kParamOnOff:

  293.                 hints |= PARAMETER_IS_BOOLEAN;

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

  295.                 paramInfo.ranges.def = 0.0f;

  296.                 paramInfo.ranges.min = 0.0f;

  297.                 paramInfo.ranges.max = 1.0f;

  298.                 break;

  299.             case kParamLength:

  300.                 paramInfo.name = "Length";

  301.                 paramInfo.ranges.def = 8.0f;

  302.                 paramInfo.ranges.min = 1.0f;

  303.                 paramInfo.ranges.max = 16.0f;

  304.                 break;

  305.             case kParamTimeMode:

  306.                 hints |= PARAMETER_USES_SCALEPOINTS;

  307.                 paramInfo.name = "Time Signature";

  308.                 paramInfo.ranges.def = 2.0f;

  309.                 paramInfo.ranges.min = 1.0f;

  310.                 paramInfo.ranges.max = 3.0f;

  311.                 paramInfo.scalePointCount = 3;

  312.                 paramInfo.scalePoints     = scalePoints;

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

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

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

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

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

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

  319.                 break;

  320.             case kParamSyncMode:

  321.                 hints |= PARAMETER_USES_SCALEPOINTS;

  322.                 paramInfo.name = "Sync Mode";

  323.                 paramInfo.ranges.def = 1.0f;

  324.                 paramInfo.ranges.min = 1.0f;

  325.                 paramInfo.ranges.max = 2.0f;

  326.                 paramInfo.scalePointCount = 2;

  327.                 paramInfo.scalePoints     = scalePoints;

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

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

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

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

  332.                 break;

  333.             case kParamFailMode:

  334.                 hints |= PARAMETER_USES_SCALEPOINTS;

  335.                 paramInfo.name = "Fail Mode";

  336.                 paramInfo.ranges.def = 1.0f;

  337.                 paramInfo.ranges.min = 1.0f;

  338.                 paramInfo.ranges.max = 3.0f;

  339.                 paramInfo.scalePointCount = 3;

  340.                 paramInfo.scalePoints     = scalePoints;

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

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

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

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

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

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

  347.                 break;

  348.             case kParamVelMode:

  349.                 hints |= PARAMETER_USES_SCALEPOINTS;

  350.                 paramInfo.name = "Velocity Mode";

  351.                 paramInfo.ranges.def = 1.0f;

  352.                 paramInfo.ranges.min = 1.0f;

  353.                 paramInfo.ranges.max = 3.0f;

  354.                 paramInfo.scalePointCount = 3;

  355.                 paramInfo.scalePoints     = scalePoints;

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

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

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

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

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

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

  362.                 break;

  363.             }

  364.         }

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

  366.         {

  367.             carla_zeroChar(bufName, 24+1);

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

  369.             paramInfo.name = bufName;

  370.         }

  371.         else

  372.         {

  373.             carla_zeroChar(bufName, 24+1);

  374.             hints |= PARAMETER_IS_BOOLEAN|PARAMETER_IS_INTEGER;

  375.             paramInfo.ranges.step      = 1.0f;

  376.             paramInfo.ranges.stepSmall = 1.0f;

  377.             paramInfo.ranges.stepLarge = 1.0f;

  378. 

  379.             carla_zeroChar(bufName, 24+1);

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

  381.             paramInfo.name = bufName;

  382.         }

  383. 

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

  385.         return &paramInfo;

  386.     }

  387. 

  388.     float getParameterValue(const uint32_t index) const override

  389.     {

  390.         if (index < kParamLast)

  391.         {

  392.             switch (index)

  393.             {

  394.             case kParamOnOff:

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

  396.             case kParamLength:

  397.                 return fSettings.length;

  398.             case kParamTimeMode:

  399.                 return fSettings.timeMode;

  400.             case kParamSyncMode:

  401.                 return fSettings.syncMode;

  402.             case kParamFailMode:

  403.                 return fSettings.failMode;

  404.             case kParamVelMode:

  405.                 return fSettings.velMode;

  406.             default:

  407.                 return 0.0f;

  408.             }

  409.         }

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

  411.         {

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

  413.         }

  414.         else

  415.         {

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

  417.         }

  418.     }

  419. 

  420.     // -------------------------------------------------------------------

  421.     // Plugin state calls

  422. 

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

  424.     {

  425.         if (index < kParamLast)

  426.         {

  427.             switch (index)

  428.             {

  429.             case kParamOnOff:

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

  431.                 break;

  432.             case kParamLength:

  433.                 fSettings.length = value;

  434.                 break;

  435.             case kParamTimeMode:

  436.                 fSettings.timeMode = value;

  437.                 break;

  438.             case kParamSyncMode:

  439.                 fSettings.syncMode = value;

  440.                 break;

  441.             case kParamFailMode:

  442.                 fSettings.failMode = value;

  443.                 break;

  444.             case kParamVelMode:

  445.                 fSettings.velMode = value;

  446.                 break;

  447.             }

  448.         }

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

  450.         {

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

  452.         }

  453.         else

  454.         {

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

  456.         }

  457.     }

  458. 

  459.     // -------------------------------------------------------------------

  460.     // Plugin process calls

  461. 

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

  463.     {

  464.         if (! fSettings.on)

  465.         {

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

  467.                 writeMidiEvent(&midiEvents[i]);

  468. 

  469.             return;

  470.         }

  471. 

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

  473. 

  474.         bool   timePlaying = false;

  475.         double ppqPos      = 0.0;

  476.         double barStartPos = 0.0;

  477.         double bpm         = 120.0;

  478. 

  479.         if (timeInfo != nullptr)

  480.         {

  481.             timePlaying = timeInfo->playing;

  482. 

  483.             if (timeInfo->bbt.valid)

  484.             {

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

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

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

  488. 

  489.                 ppqPos      = ppqBar + ppqBeat + ppqTick;

  490.                 barStartPos = ppqBar;

  491.                 bpm         = timeInfo->bbt.beatsPerMinute;

  492.             }

  493.         }

  494. 

  495.         fMidiInBuffer.clear();

  496. 

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

  498.         {

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

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

  501.         }

  502. 

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

  504. 

  505.         MidiBuffer::Iterator outBufferIterator(outMidiBuffer);

  506.         MidiMessage midiMessage(0xf4);

  507.         int sampleNumber;

  508. 

  509.         MidiEvent tmpEvent;

  510.         tmpEvent.port = 0;

  511. 

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

  513.         {

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

  515.             tmpEvent.time = sampleNumber;

  516. 

  517.             if (tmpEvent.size > 4)

  518.                 continue;

  519. 

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

  521.             writeMidiEvent(&tmpEvent);

  522.         }

  523.     }

  524. 

  525.     // -------------------------------------------------------------------

  526.     // Plugin UI calls

  527. 

  528.     void uiShow(const bool show) override

  529.     {

  530.         if (show)

  531.         {

  532.             if (fWindow == nullptr)

  533.             {

  534.                 fWindow = new HelperWindow();

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

  536.             }

  537. 

  538.             if (fView == nullptr)

  539.             {

  540.                 fView = new PeggyViewComponent(1, fSettings, this);

  541.                 fView->setSize(207, 320);

  542.             }

  543. 

  544.             fWindow->show(fView);

  545.         }

  546.         else if (fWindow != nullptr)

  547.         {

  548.             fWindow->hide();

  549. 

  550.             fView = nullptr;

  551.             fWindow = nullptr;

  552.         }

  553.     }

  554. 

  555.     void uiIdle() override

  556.     {

  557.         if (fWindow == nullptr)

  558.             return;

  559. 

  560.         if (fWindow->wasClosedByUser())

  561.         {

  562.             uiShow(false);

  563.             uiClosed();

  564.         }

  565.     }

  566. 

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

  568.     {

  569.         if (fView == nullptr)

  570.             return;

  571. 

  572.         fView->update();

  573.     }

  574. 

  575.     // -------------------------------------------------------------------

  576.     // Plugin dispatcher calls

  577. 

  578.     void sampleRateChanged(const double sampleRate) override

  579.     {

  580.         fArp.setSampleRate(sampleRate);

  581.     }

  582. 

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

  584.     {

  585.         if (fWindow == nullptr)

  586.             return;

  587. 

  588.         fWindow->setName(uiName);

  589.     }

  590. 

  591.     // -------------------------------------------------------------------

  592.     // Peggy callback

  593. 

  594.     void somethingChanged(const uint32_t id) override

  595.     {

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

  597.     }

  598. 

  599. private:

  600.     VexArpSettings fSettings;

  601.     VexArp fArp;

  602.     MidiBuffer fMidiInBuffer;

  603. 

  604.     ScopedPointer<PeggyViewComponent> fView;

  605.     ScopedPointer<HelperWindow> fWindow;

  606. 

  607.     PluginClassEND(VexArpPlugin)

  608.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexArpPlugin)

  609. };

  610. 

  611. // -----------------------------------------------------------------------

  612. 

  613. class VexChorusPlugin : public PluginClass

  614. {

  615. public:

  616.     enum Params {

  617.         kParamRate = 0,

  618.         kParamDepth,

  619.         kParamCount

  620.     };

  621. 

  622.     VexChorusPlugin(const HostDescriptor* const host)

  623.         : PluginClass(host),

  624.           fChorus(fParameters)

  625.     {

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

  627. 

  628.         fParameters[76] = 0.3f;

  629.         fParameters[77] = 0.6f;

  630. 

  631.         fChorus.setSampleRate(getSampleRate());

  632.     }

  633. 

  634. protected:

  635.     // -------------------------------------------------------------------

  636.     // Plugin parameter calls

  637. 

  638.     uint32_t getParameterCount() const override

  639.     {

  640.         return kParamCount;

  641.     }

  642. 

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

  644.     {

  645.         static Parameter paramInfo;

  646. 

  647.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  648. 

  649.         paramInfo.name = nullptr;

  650.         paramInfo.unit = nullptr;

  651.         paramInfo.ranges.def       = 0.0f;

  652.         paramInfo.ranges.min       = 0.0f;

  653.         paramInfo.ranges.max       = 1.0f;

  654.         paramInfo.ranges.step      = PARAMETER_RANGES_DEFAULT_STEP;

  655.         paramInfo.ranges.stepSmall = PARAMETER_RANGES_DEFAULT_STEP_SMALL;

  656.         paramInfo.ranges.stepLarge = PARAMETER_RANGES_DEFAULT_STEP_LARGE;

  657.         paramInfo.scalePointCount  = 0;

  658.         paramInfo.scalePoints      = nullptr;

  659. 

  660.         switch (index)

  661.         {

  662.         case kParamRate:

  663.             paramInfo.name = "Rate";

  664.             paramInfo.ranges.def = 0.3f;

  665.             paramInfo.ranges.min = 0.0f;

  666.             paramInfo.ranges.max = 1.0f;

  667.             break;

  668.         case kParamDepth:

  669.             paramInfo.name = "Depth";

  670.             paramInfo.ranges.def = 0.6f;

  671.             paramInfo.ranges.min = 0.0f;

  672.             paramInfo.ranges.max = 1.0f;

  673.             break;

  674.         }

  675. 

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

  677. 

  678.         return &paramInfo;

  679.     }

  680. 

  681.     float getParameterValue(const uint32_t index) const override

  682.     {

  683.         switch (index)

  684.         {

  685.         case kParamRate:

  686.             return fParameters[76];

  687.         case kParamDepth:

  688.             return fParameters[77];

  689.         default:

  690.             return 0.0f;

  691.         }

  692.     }

  693. 

  694.     // -------------------------------------------------------------------

  695.     // Plugin state calls

  696. 

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

  698.     {

  699.         switch (index)

  700.         {

  701.         case kParamRate:

  702.             fParameters[76] = value;

  703.             break;

  704.         case kParamDepth:

  705.             fParameters[77] = value;

  706.             break;

  707.         default:

  708.             break;

  709.         }

  710.     }

  711. 

  712.     // -------------------------------------------------------------------

  713.     // Plugin process calls

  714. 

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

  716.     {

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

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

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

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

  721. 

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

  723.     }

  724. 

  725.     // -------------------------------------------------------------------

  726.     // Plugin dispatcher calls

  727. 

  728.     void sampleRateChanged(const double sampleRate) override

  729.     {

  730.         fChorus.setSampleRate(sampleRate);

  731.     }

  732. 

  733. private:

  734.     VexChorus fChorus;

  735.     float fParameters[92];

  736. 

  737.     PluginClassEND(VexChorusPlugin)

  738.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexChorusPlugin)

  739. };

  740. 

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

  742. 

  743. class VexDelayPlugin : public PluginClass

  744. {

  745. public:

  746.     enum Params {

  747.         kParamTime = 0,

  748.         kParamFeedback,

  749.         kParamCount

  750.     };

  751. 

  752.     VexDelayPlugin(const HostDescriptor* const host)

  753.         : PluginClass(host),

  754.           fDelay(fParameters)

  755.     {

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

  757. 

  758.         fParameters[73] = 0.5f * 8.0f;

  759.         fParameters[74] = 0.4f * 100.0f;

  760. 

  761.         fDelay.setSampleRate(getSampleRate());

  762.     }

  763. 

  764. protected:

  765.     // -------------------------------------------------------------------

  766.     // Plugin parameter calls

  767. 

  768.     uint32_t getParameterCount() const override

  769.     {

  770.         return kParamCount;

  771.     }

  772. 

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

  774.     {

  775.         static Parameter paramInfo;

  776. 

  777.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  778. 

  779.         paramInfo.name = nullptr;

  780.         paramInfo.unit = nullptr;

  781.         paramInfo.ranges.def       = 0.0f;

  782.         paramInfo.ranges.min       = 0.0f;

  783.         paramInfo.ranges.max       = 1.0f;

  784.         paramInfo.ranges.step      = PARAMETER_RANGES_DEFAULT_STEP;

  785.         paramInfo.ranges.stepSmall = PARAMETER_RANGES_DEFAULT_STEP_SMALL;

  786.         paramInfo.ranges.stepLarge = PARAMETER_RANGES_DEFAULT_STEP_LARGE;

  787.         paramInfo.scalePointCount  = 0;

  788.         paramInfo.scalePoints      = nullptr;

  789. 

  790.         switch (index)

  791.         {

  792.         case kParamTime:

  793.             hints |= PARAMETER_IS_INTEGER;

  794.             paramInfo.name = "Time";

  795.             paramInfo.ranges.def = 4.0f;

  796.             paramInfo.ranges.min = 0.0f;

  797.             paramInfo.ranges.max = 8.0f;

  798.             break;

  799.         case kParamFeedback:

  800.             paramInfo.name = "Feedback";

  801.             paramInfo.unit = "%";

  802.             paramInfo.ranges.def = 40.0f;

  803.             paramInfo.ranges.min = 0.0f;

  804.             paramInfo.ranges.max = 100.0f;

  805.             break;

  806.         }

  807. 

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

  809. 

  810.         return &paramInfo;

  811.     }

  812. 

  813.     float getParameterValue(const uint32_t index) const override

  814.     {

  815.         switch (index)

  816.         {

  817.         case kParamTime:

  818.             return fParameters[73] * 8.0f;

  819.         case kParamFeedback:

  820.             return fParameters[74] * 100.0f;

  821.         default:

  822.             return 0.0f;

  823.         }

  824.     }

  825. 

  826.     // -------------------------------------------------------------------

  827.     // Plugin state calls

  828. 

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

  830.     {

  831.         switch (index)

  832.         {

  833.         case kParamTime:

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

  835.             break;

  836.         case kParamFeedback:

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

  838.             break;

  839.         default:

  840.             break;

  841.         }

  842.     }

  843. 

  844.     // -------------------------------------------------------------------

  845.     // Plugin process calls

  846. 

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

  848.     {

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

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

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

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

  853. 

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

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

  856. 

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

  858.     }

  859. 

  860.     // -------------------------------------------------------------------

  861.     // Plugin dispatcher calls

  862. 

  863.     void sampleRateChanged(const double sampleRate) override

  864.     {

  865.         fDelay.setSampleRate(sampleRate);

  866.     }

  867. 

  868. private:

  869.     VexDelay fDelay;

  870.     float fParameters[92];

  871. 

  872.     PluginClassEND(VexDelayPlugin)

  873.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexDelayPlugin)

  874. };

  875. 

  876. // -----------------------------------------------------------------------

  877. 

  878. class VexReverbPlugin : public PluginClass

  879. {

  880. public:

  881.     enum Params {

  882.         kParamSize = 0,

  883.         kParamWidth,

  884.         kParamDamp,

  885.         kParamCount

  886.     };

  887. 

  888.     VexReverbPlugin(const HostDescriptor* const host)

  889.         : PluginClass(host),

  890.           fReverb(fParameters)

  891.     {

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

  893. 

  894.         // FIXME?

  895.         fParameters[79] = 0.6f;

  896.         fParameters[80] = 0.6f;

  897.         fParameters[81] = 0.7f;

  898.     }

  899. 

  900. protected:

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

  902.     // Plugin parameter calls

  903. 

  904.     uint32_t getParameterCount() const override

  905.     {

  906.         return kParamCount;

  907.     }

  908. 

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

  910.     {

  911.         static Parameter paramInfo;

  912. 

  913.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  914. 

  915.         paramInfo.name = nullptr;

  916.         paramInfo.unit = nullptr;

  917.         paramInfo.ranges.def       = 0.0f;

  918.         paramInfo.ranges.min       = 0.0f;

  919.         paramInfo.ranges.max       = 1.0f;

  920.         paramInfo.ranges.step      = PARAMETER_RANGES_DEFAULT_STEP;

  921.         paramInfo.ranges.stepSmall = PARAMETER_RANGES_DEFAULT_STEP_SMALL;

  922.         paramInfo.ranges.stepLarge = PARAMETER_RANGES_DEFAULT_STEP_LARGE;

  923.         paramInfo.scalePointCount  = 0;

  924.         paramInfo.scalePoints      = nullptr;

  925. 

  926.         switch (index)

  927.         {

  928.         case kParamSize:

  929.             paramInfo.name = "Size";

  930.             paramInfo.ranges.def = 0.6f;

  931.             paramInfo.ranges.min = 0.0f;

  932.             paramInfo.ranges.max = 1.0f;

  933.             break;

  934.         case kParamWidth:

  935.             paramInfo.name = "Width";

  936.             paramInfo.ranges.def = 0.7f;

  937.             paramInfo.ranges.min = 0.0f;

  938.             paramInfo.ranges.max = 1.0f;

  939.             break;

  940.         case kParamDamp:

  941.             paramInfo.name = "Damp";

  942.             paramInfo.ranges.def = 0.6f;

  943.             paramInfo.ranges.min = 0.0f;

  944.             paramInfo.ranges.max = 1.0f;

  945.             break;

  946.         }

  947. 

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

  949. 

  950.         return &paramInfo;

  951.     }

  952. 

  953.     float getParameterValue(const uint32_t index) const override

  954.     {

  955.         switch (index)

  956.         {

  957.         case kParamSize:

  958.             return fParameters[79];

  959.         case kParamWidth:

  960.             return fParameters[80];

  961.         case kParamDamp:

  962.             return fParameters[81];

  963.         default:

  964.             return 0.0f;

  965.         }

  966.     }

  967. 

  968.     // -------------------------------------------------------------------

  969.     // Plugin state calls

  970. 

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

  972.     {

  973.         switch (index)

  974.         {

  975.         case kParamSize:

  976.             fParameters[79] = value;

  977.             break;

  978.         case kParamWidth:

  979.             fParameters[80] = value;

  980.             break;

  981.         case kParamDamp:

  982.             fParameters[81] = value;

  983.             break;

  984.         default:

  985.             break;

  986.         }

  987.     }

  988. 

  989.     // -------------------------------------------------------------------

  990.     // Plugin process calls

  991. 

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

  993.     {

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

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

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

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

  998. 

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

  1000.     }

  1001. 

  1002. private:

  1003.     VexReverb fReverb;

  1004.     float fParameters[92];

  1005. 

  1006.     PluginClassEND(VexReverbPlugin)

  1007.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexReverbPlugin)

  1008. };

  1009. 

  1010. // -----------------------------------------------------------------------

  1011. 

  1012. class VexSynthPlugin : public PluginClass

  1013. {

  1014. public:

  1015.     static const unsigned int kParamCount = 92;

  1016. 

  1017.     VexSynthPlugin(const HostDescriptor* const host)

  1018.         : PluginClass(host),

  1019.           obf(nullptr),

  1020.           abf(nullptr),

  1021.           dbf1(nullptr),

  1022.           dbf2(nullptr),

  1023.           dbf3(nullptr),

  1024.           fChorus(fParameters),

  1025.           fDelay(fParameters),

  1026.           fReverb(fParameters),

  1027.           fSynth(fParameters)

  1028.     {

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

  1030. 

  1031.         fParameters[0] = 1.0f; // main volume

  1032. 

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

  1034.         {

  1035.             const int offset = i * 24;

  1036. 

  1037.             fParameters[offset +  1] = 0.5f;

  1038.             fParameters[offset +  2] = 0.5f;

  1039.             fParameters[offset +  3] = 0.5f;

  1040.             fParameters[offset +  4] = 0.5f;

  1041.             fParameters[offset +  5] = 0.9f;

  1042.             fParameters[offset +  6] = 0.0f;

  1043.             fParameters[offset +  7] = 1.0f;

  1044.             fParameters[offset +  8] = 0.5f;

  1045.             fParameters[offset +  9] = 0.0f;

  1046.             fParameters[offset + 10] = 0.2f;

  1047.             fParameters[offset + 11] = 0.0f;

  1048.             fParameters[offset + 12] = 0.5f;

  1049.             fParameters[offset + 13] = 0.5f;

  1050.             fParameters[offset + 14] = 0.0f;

  1051.             fParameters[offset + 15] = 0.3f;

  1052.             fParameters[offset + 16] = 0.7f;

  1053.             fParameters[offset + 17] = 0.1f;

  1054.             fParameters[offset + 18] = 0.5f;

  1055.             fParameters[offset + 19] = 0.5f;

  1056.             fParameters[offset + 20] = 0.0f;

  1057.             fParameters[offset + 21] = 0.0f;

  1058.             fParameters[offset + 22] = 0.5f;

  1059.             fParameters[offset + 23] = 0.5f;

  1060.             fParameters[offset + 24] = 0.5f;

  1061.         }

  1062. 

  1063.         // ^1 - 72

  1064. 

  1065.         fParameters[73] = 0.5f; // Delay Time

  1066.         fParameters[74] = 0.4f; // Delay Feedback

  1067.         fParameters[75] = 0.0f; // Delay Volume

  1068. 

  1069.         fParameters[76] = 0.3f; // Chorus Rate

  1070.         fParameters[77] = 0.6f; // Chorus Depth

  1071.         fParameters[78] = 0.5f; // Chorus Volume

  1072. 

  1073.         fParameters[79] = 0.6f; // Reverb Size

  1074.         fParameters[80] = 0.7f; // Reverb Width

  1075.         fParameters[81] = 0.6f; // Reverb Damp

  1076.         fParameters[82] = 0.0f; // Reverb Volume

  1077. 

  1078.         fParameters[83] = 0.5f; // wave1 panning

  1079.         fParameters[84] = 0.5f; // wave2 panning

  1080.         fParameters[85] = 0.5f; // wave3 panning

  1081. 

  1082.         fParameters[86] = 0.5f; // wave1 volume

  1083.         fParameters[87] = 0.5f; // wave2 volume

  1084.         fParameters[88] = 0.5f; // wave3 volume

  1085. 

  1086.         fParameters[89] = 1.0f; // wave1 on/off

  1087.         fParameters[90] = 1.0f; // wave2 on/off

  1088.         fParameters[91] = 1.0f; // wave3 on/off

  1089. 

  1090.         bufferSizeChanged(getBufferSize());

  1091.         sampleRateChanged(getSampleRate());

  1092.     }

  1093. 

  1094.     ~VexSynthPlugin()

  1095.     {

  1096.         delete obf;

  1097.         delete abf;

  1098.         delete dbf1;

  1099.         delete dbf2;

  1100.         delete dbf3;

  1101.     }

  1102. 

  1103. protected:

  1104.     // -------------------------------------------------------------------

  1105.     // Plugin parameter calls

  1106. 

  1107.     uint32_t getParameterCount() const override

  1108.     {

  1109.         return kParamCount;

  1110.     }

  1111. 

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

  1113.     {

  1114.         static Parameter paramInfo;

  1115. 

  1116.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  1117. 

  1118.         paramInfo.name = nullptr;

  1119.         paramInfo.unit = nullptr;

  1120.         paramInfo.ranges.def       = 0.0f;

  1121.         paramInfo.ranges.min       = 0.0f;

  1122.         paramInfo.ranges.max       = 1.0f;

  1123.         paramInfo.ranges.step      = PARAMETER_RANGES_DEFAULT_STEP;

  1124.         paramInfo.ranges.stepSmall = PARAMETER_RANGES_DEFAULT_STEP_SMALL;

  1125.         paramInfo.ranges.stepLarge = PARAMETER_RANGES_DEFAULT_STEP_LARGE;

  1126.         paramInfo.scalePointCount  = 0;

  1127.         paramInfo.scalePoints      = nullptr;

  1128. 

  1129.         if (index >= 1 && index <= 72)

  1130.         {

  1131.             uint32_t ri = index % 24;

  1132. 

  1133.             switch (ri)

  1134.             {

  1135.             case 1:

  1136.                 paramInfo.name = "oct";

  1137.                 break;

  1138.             case 2:

  1139.                 paramInfo.name = "cent";

  1140.                 break;

  1141.             case 3:

  1142.                 paramInfo.name = "phaseOffset";

  1143.                 break;

  1144.             case 4:

  1145.                 paramInfo.name = "phaseIncOffset";

  1146.                 break;

  1147.             case 5:

  1148.                 paramInfo.name = "filter";

  1149.                 break;

  1150.             case 6:

  1151.                 paramInfo.name = "filter";

  1152.                 break;

  1153.             case 7:

  1154.                 paramInfo.name = "filter";

  1155.                 break;

  1156.             case 8:

  1157.                 paramInfo.name = "filter";

  1158.                 break;

  1159.             case 9:

  1160.                 paramInfo.name = "F ADSR";

  1161.                 break;

  1162.             case 10:

  1163.                 paramInfo.name = "F ADSR";

  1164.                 break;

  1165.             case 11:

  1166.                 paramInfo.name = "F ADSR";

  1167.                 break;

  1168.             case 12:

  1169.                 paramInfo.name = "F ADSR";

  1170.                 break;

  1171.             case 13:

  1172.                 paramInfo.name = "F velocity";

  1173.                 break;

  1174.             case 14:

  1175.                 paramInfo.name = "A ADSR";

  1176.                 break;

  1177.             case 15:

  1178.                 paramInfo.name = "A ADSR";

  1179.                 break;

  1180.             case 16:

  1181.                 paramInfo.name = "A ADSR";

  1182.                 break;

  1183.             case 17:

  1184.                 paramInfo.name = "A ADSR";

  1185.                 break;

  1186.             case 18:

  1187.                 paramInfo.name = "A velocity";

  1188.                 break;

  1189.             case 19:

  1190.                 paramInfo.name = "lfoC";

  1191.                 break;

  1192.             case 20:

  1193.                 paramInfo.name = "lfoA";

  1194.                 break;

  1195.             case 21:

  1196.                 paramInfo.name = "lfoF";

  1197.                 break;

  1198.             case 22:

  1199.                 paramInfo.name = "fx vol D";

  1200.                 break;

  1201.             case 23:

  1202.                 paramInfo.name = "fx vol C";

  1203.                 break;

  1204.             case 24:

  1205.             case 0:

  1206.                 paramInfo.name = "fx vol R";

  1207.                 break;

  1208.             default:

  1209.                 paramInfo.name = "unknown2";

  1210.                 break;

  1211.             }

  1212. 

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

  1214.             return &paramInfo;

  1215.         }

  1216. 

  1217.         switch (index)

  1218.         {

  1219.         case 0:

  1220.             paramInfo.name = "Main volume";

  1221.             break;

  1222.         case 73:

  1223.             paramInfo.name = "Delay Time";

  1224.             break;

  1225.         case 74:

  1226.             paramInfo.name = "Delay Feedback";

  1227.             break;

  1228.         case 75:

  1229.             paramInfo.name = "Delay Volume";

  1230.             break;

  1231.         case 76:

  1232.             paramInfo.name = "Chorus Rate";

  1233.             break;

  1234.         case 77:

  1235.             paramInfo.name = "Chorus Depth";

  1236.             break;

  1237.         case 78:

  1238.             paramInfo.name = "Chorus Volume";

  1239.             break;

  1240.         case 79:

  1241.             paramInfo.name = "Reverb Size";

  1242.             break;

  1243.         case 80:

  1244.             paramInfo.name = "Reverb Width";

  1245.             break;

  1246.         case 81:

  1247.             paramInfo.name = "Reverb Damp";

  1248.             break;

  1249.         case 82:

  1250.             paramInfo.name = "Reverb Volume";

  1251.             break;

  1252.         case 83:

  1253.             paramInfo.name = "Wave1 Panning";

  1254.             break;

  1255.         case 84:

  1256.             paramInfo.name = "Wave2 Panning";

  1257.             break;

  1258.         case 85:

  1259.             paramInfo.name = "Wave3 Panning";

  1260.             break;

  1261.         case 86:

  1262.             paramInfo.name = "Wave1 Volume";

  1263.             break;

  1264.         case 87:

  1265.             paramInfo.name = "Wave2 Volume";

  1266.             break;

  1267.         case 88:

  1268.             paramInfo.name = "Wave3 Volume";

  1269.             break;

  1270.         case 89:

  1271.             paramInfo.name = "Wave1 on/off";

  1272.             break;

  1273.         case 90:

  1274.             paramInfo.name = "Wave2 on/off";

  1275.             break;

  1276.         case 91:

  1277.             paramInfo.name = "Wave3 on/off";

  1278.             break;

  1279.         default:

  1280.             paramInfo.name = "unknown";

  1281.             break;

  1282.         }

  1283. 

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

  1285.         return &paramInfo;

  1286.     }

  1287. 

  1288.     float getParameterValue(const uint32_t index) const override

  1289.     {

  1290.         return (index < kParamCount) ? fParameters[index] : 0.0f;

  1291.     }

  1292. 

  1293.     // -------------------------------------------------------------------

  1294.     // Plugin state calls

  1295. 

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

  1297.     {

  1298.         if (index < kParamCount)

  1299.         {

  1300.             fParameters[index] = value;

  1301.             fSynth.update(index);

  1302.         }

  1303.     }

  1304. 

  1305.     // -------------------------------------------------------------------

  1306.     // Plugin process calls

  1307. 

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

  1309.     {

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

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

  1312. 

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

  1314.         {

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

  1316. 

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

  1318. 

  1319.             if (status == MIDI_STATUS_NOTE_ON)

  1320.             {

  1321.                 fSynth.playNote(midiEvent->data[1], midiEvent->data[2], 0, 1);

  1322.             }

  1323.             else if (status == MIDI_STATUS_NOTE_OFF)

  1324.             {

  1325.                 fSynth.releaseNote(midiEvent->data[1], 0, 1);

  1326.             }

  1327.             else if (status == MIDI_STATUS_CONTROL_CHANGE)

  1328.             {

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

  1330. 

  1331.                 if (control == MIDI_CONTROL_ALL_SOUND_OFF)

  1332.                     fSynth.kill();

  1333.                 else if (control == MIDI_CONTROL_ALL_NOTES_OFF)

  1334.                     fSynth.releaseAll(1);

  1335.             }

  1336.         }

  1337. 

  1338.         if (obf->getNumSamples() != (int)frames)

  1339.         {

  1340.                 obf->setSize(2,  frames, 0, 0, 1);

  1341.                 abf->setSize(2,  frames, 0, 0, 1);

  1342.                 dbf1->setSize(2, frames, 0, 0, 1);

  1343.                 dbf2->setSize(2, frames, 0, 0, 1);

  1344.                 dbf3->setSize(2, frames, 0, 0, 1);

  1345.         }

  1346. 

  1347.         obf ->clear();

  1348.         dbf1->clear();

  1349.         dbf2->clear();

  1350.         dbf3->clear();

  1351. 

  1352.         fSynth.doProcess(*obf, *abf, *dbf1, *dbf2, *dbf3);

  1353. 

  1354.         if (fParameters[75] > 0.001f) fDelay.processBlock(dbf1, bpm);

  1355.         if (fParameters[78] > 0.001f) fChorus.processBlock(dbf2);

  1356.         if (fParameters[82] > 0.001f) fReverb.processBlock(dbf3);

  1357. 

  1358.         AudioSampleBuffer output(outBuffer, 2, 0, frames);

  1359.         output.clear();

  1360. 

  1361.         obf->addFrom(0, 0, *dbf1, 0, 0, frames, fParameters[75]);

  1362.         obf->addFrom(1, 0, *dbf1, 1, 0, frames, fParameters[75]);

  1363.         obf->addFrom(0, 0, *dbf2, 0, 0, frames, fParameters[78]);

  1364.         obf->addFrom(1, 0, *dbf2, 1, 0, frames, fParameters[78]);

  1365.         obf->addFrom(0, 0, *dbf3, 0, 0, frames, fParameters[82]);

  1366.         obf->addFrom(1, 0, *dbf3, 1, 0, frames, fParameters[82]);

  1367. 

  1368.         output.addFrom(0, 0, *obf, 0, 0, frames, fParameters[0]);

  1369.         output.addFrom(1, 0, *obf, 1, 0, frames, fParameters[0]);

  1370.     }

  1371. 

  1372.     // -------------------------------------------------------------------

  1373.     // Plugin UI calls

  1374. 

  1375.     void uiShow(const bool show) override

  1376.     {

  1377.         if (show)

  1378.         {

  1379.             if (fWindow == nullptr)

  1380.             {

  1381.                 fWindow = new HelperWindow();

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

  1383.             }

  1384. 

  1385.             if (fView == nullptr)

  1386.                 fView = new VexEditorComponent();

  1387. 

  1388.             fWindow->show(fView);

  1389.         }

  1390.         else if (fWindow != nullptr)

  1391.         {

  1392.             fWindow->hide();

  1393. 

  1394.             fView = nullptr;

  1395.             fWindow = nullptr;

  1396.         }

  1397.     }

  1398. 

  1399.     void uiIdle() override

  1400.     {

  1401.         if (fWindow == nullptr)

  1402.             return;

  1403. 

  1404.         if (fWindow->wasClosedByUser())

  1405.         {

  1406.             uiShow(false);

  1407.             uiClosed();

  1408.         }

  1409.     }

  1410. 

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

  1412.     {

  1413.         if (fView == nullptr)

  1414.             return;

  1415. 

  1416.         //fView->update();

  1417.     }

  1418. 

  1419.     // -------------------------------------------------------------------

  1420.     // Plugin dispatcher calls

  1421. 

  1422.     void bufferSizeChanged(const uint32_t bufferSize) override

  1423.     {

  1424.         delete obf;

  1425.         delete abf;

  1426.         delete dbf1;

  1427.         delete dbf2;

  1428.         delete dbf3;

  1429. 

  1430.         obf  = new AudioSampleBuffer(2, bufferSize);

  1431.         abf  = new AudioSampleBuffer(2, bufferSize);

  1432.         dbf1 = new AudioSampleBuffer(2, bufferSize);

  1433.         dbf2 = new AudioSampleBuffer(2, bufferSize);

  1434.         dbf3 = new AudioSampleBuffer(2, bufferSize);

  1435.     }

  1436. 

  1437.     void sampleRateChanged(const double sampleRate) override

  1438.     {

  1439.         fChorus.setSampleRate(sampleRate);

  1440.         fDelay.setSampleRate(sampleRate);

  1441.         fSynth.setSampleRate(sampleRate);

  1442.     }

  1443. 

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

  1445.     {

  1446.         if (fWindow == nullptr)

  1447.             return;

  1448. 

  1449.         fWindow->setName(uiName);

  1450.     }

  1451. 

  1452. private:

  1453.     float fParameters[92];

  1454. 

  1455.     AudioSampleBuffer* obf;

  1456.     AudioSampleBuffer* abf;

  1457.     AudioSampleBuffer* dbf1; // delay

  1458.     AudioSampleBuffer* dbf2; // chorus

  1459.     AudioSampleBuffer* dbf3; // reverb

  1460. 

  1461.     VexChorus fChorus;

  1462.     VexDelay fDelay;

  1463.     VexReverb fReverb;

  1464.     VexSyntModule fSynth;

  1465. 

  1466.     ScopedPointer<VexEditorComponent> fView;

  1467.     ScopedPointer<HelperWindow> fWindow;

  1468. 

  1469.     PluginClassEND(VexSynthPlugin)

  1470.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexSynthPlugin)

  1471. };

  1472. 

  1473. // -----------------------------------------------------------------------

  1474. 

  1475. static const PluginDescriptor vexArpDesc = {

  1476.     /* category  */ PLUGIN_CATEGORY_UTILITY,

  1477.     /* hints     */ static_cast<PluginHints>(PLUGIN_HAS_GUI|PLUGIN_NEEDS_SINGLE_THREAD|PLUGIN_USES_TIME),

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

  1479.     /* audioIns  */ 0,

  1480.     /* audioOuts */ 0,

  1481.     /* midiIns   */ 1,

  1482.     /* midiOuts  */ 1,

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

  1484.     /* paramOuts */ 0,

  1485.     /* name      */ "VexArp",

  1486.     /* label     */ "vexArp",

  1487.     /* maker     */ "falkTX",

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

  1489.     PluginDescriptorFILL(VexArpPlugin)

  1490. };

  1491. 

  1492. static const PluginDescriptor vexChorusDesc = {

  1493.     /* category  */ PLUGIN_CATEGORY_MODULATOR,

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

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

  1496.     /* audioIns  */ 2,

  1497.     /* audioOuts */ 2,

  1498.     /* midiIns   */ 0,

  1499.     /* midiOuts  */ 0,

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

  1501.     /* paramOuts */ 0,

  1502.     /* name      */ "VexChorus",

  1503.     /* label     */ "vexChorus",

  1504.     /* maker     */ "falkTX",

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

  1506.     PluginDescriptorFILL(VexChorusPlugin)

  1507. };

  1508. 

  1509. static const PluginDescriptor vexDelayDesc = {

  1510.     /* category  */ PLUGIN_CATEGORY_DELAY,

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

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

  1513.     /* audioIns  */ 2,

  1514.     /* audioOuts */ 2,

  1515.     /* midiIns   */ 0,

  1516.     /* midiOuts  */ 0,

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

  1518.     /* paramOuts */ 0,

  1519.     /* name      */ "VexDelay",

  1520.     /* label     */ "vexDelay",

  1521.     /* maker     */ "falkTX",

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

  1523.     PluginDescriptorFILL(VexDelayPlugin)

  1524. };

  1525. 

  1526. static const PluginDescriptor vexReverbDesc = {

  1527.     /* category  */ PLUGIN_CATEGORY_DELAY,

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

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

  1530.     /* audioIns  */ 2,

  1531.     /* audioOuts */ 2,

  1532.     /* midiIns   */ 0,

  1533.     /* midiOuts  */ 0,

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

  1535.     /* paramOuts */ 0,

  1536.     /* name      */ "VexReverb",

  1537.     /* label     */ "vexReverb",

  1538.     /* maker     */ "falkTX",

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

  1540.     PluginDescriptorFILL(VexReverbPlugin)

  1541. };

  1542. 

  1543. static const PluginDescriptor vexSynthDesc = {

  1544.     /* category  */ PLUGIN_CATEGORY_SYNTH,

  1545.     /* hints     */ static_cast<PluginHints>(PLUGIN_HAS_GUI|PLUGIN_NEEDS_SINGLE_THREAD|PLUGIN_USES_TIME),

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

  1547.     /* audioIns  */ 0,

  1548.     /* audioOuts */ 2,

  1549.     /* midiIns   */ 1,

  1550.     /* midiOuts  */ 0,

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

  1552.     /* paramOuts */ 0,

  1553.     /* name      */ "VexSynth",

  1554.     /* label     */ "vexSynth",

  1555.     /* maker     */ "falkTX",

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

  1557.     PluginDescriptorFILL(VexSynthPlugin)

  1558. };

  1559. 

  1560. // -----------------------------------------------------------------------

  1561. 

  1562. CARLA_EXPORT

  1563. void carla_register_native_plugin_vex()

  1564. {

  1565.     carla_register_native_plugin(&vexArpDesc);

  1566.     carla_register_native_plugin(&vexChorusDesc);

  1567.     carla_register_native_plugin(&vexDelayDesc);

  1568.     carla_register_native_plugin(&vexReverbDesc);

  1569.     carla_register_native_plugin(&vexSynthDesc);

  1570. }

  1571. 

  1572. // -----------------------------------------------------------------------