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

724 lines
21KB
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_gui_basics.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 HelperWindow2 : public DocumentWindow

  39. {

  40. public:

  41.     HelperWindow2()

  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(HelperWindow2)

  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 VexSynthPlugin : public PluginClass

  233. {

  234. public:

  235.     static const unsigned int kParamCount = 92;

  236. 

  237.     VexSynthPlugin(const HostDescriptor* const host)

  238.         : PluginClass(host),

  239.           obf(nullptr),

  240.           abf(nullptr),

  241.           dbf1(nullptr),

  242.           dbf2(nullptr),

  243.           dbf3(nullptr),

  244.           fChorus(fParameters),

  245.           fDelay(fParameters),

  246.           fReverb(fParameters),

  247.           fSynth(fParameters)

  248.     {

  249.         std::memset(fParameters, 0, sizeof(float)*kParamCount);

  250. 

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

  252. 

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

  254.         {

  255.             const int offset = i * 24;

  256. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  281.         }

  282. 

  283.         // ^1 - 72

  284. 

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

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

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

  288. 

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

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

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

  292. 

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

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

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

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

  297. 

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

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

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

  301. 

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

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

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

  305. 

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

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

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

  309. 

  310.         bufferSizeChanged(getBufferSize());

  311.         sampleRateChanged(getSampleRate());

  312. 

  313.         for (int i = 0; i < kParamCount; ++i)

  314.             fSynth.update(i);

  315.     }

  316. 

  317.     ~VexSynthPlugin()

  318.     {

  319.         delete obf;

  320.         delete abf;

  321.         delete dbf1;

  322.         delete dbf2;

  323.         delete dbf3;

  324.     }

  325. 

  326. protected:

  327.     // -------------------------------------------------------------------

  328.     // Plugin parameter calls

  329. 

  330.     uint32_t getParameterCount() const override

  331.     {

  332.         return kParamCount;

  333.     }

  334. 

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

  336.     {

  337.         static Parameter paramInfo;

  338. 

  339.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  340. 

  341.         paramInfo.name = nullptr;

  342.         paramInfo.unit = nullptr;

  343.         paramInfo.ranges.def       = 0.0f;

  344.         paramInfo.ranges.min       = 0.0f;

  345.         paramInfo.ranges.max       = 1.0f;

  346.         paramInfo.ranges.step      = PARAMETER_RANGES_DEFAULT_STEP;

  347.         paramInfo.ranges.stepSmall = PARAMETER_RANGES_DEFAULT_STEP_SMALL;

  348.         paramInfo.ranges.stepLarge = PARAMETER_RANGES_DEFAULT_STEP_LARGE;

  349.         paramInfo.scalePointCount  = 0;

  350.         paramInfo.scalePoints      = nullptr;

  351. 

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

  353.         {

  354.             uint32_t ri = index % 24;

  355. 

  356.             switch (ri)

  357.             {

  358.             case 1:

  359.                 paramInfo.name = "oct";

  360.                 break;

  361.             case 2:

  362.                 paramInfo.name = "cent";

  363.                 break;

  364.             case 3:

  365.                 paramInfo.name = "phaseOffset";

  366.                 break;

  367.             case 4:

  368.                 paramInfo.name = "phaseIncOffset";

  369.                 break;

  370.             case 5:

  371.                 paramInfo.name = "filter";

  372.                 break;

  373.             case 6:

  374.                 paramInfo.name = "filter";

  375.                 break;

  376.             case 7:

  377.                 paramInfo.name = "filter";

  378.                 break;

  379.             case 8:

  380.                 paramInfo.name = "filter";

  381.                 break;

  382.             case 9:

  383.                 paramInfo.name = "F ADSR";

  384.                 break;

  385.             case 10:

  386.                 paramInfo.name = "F ADSR";

  387.                 break;

  388.             case 11:

  389.                 paramInfo.name = "F ADSR";

  390.                 break;

  391.             case 12:

  392.                 paramInfo.name = "F ADSR";

  393.                 break;

  394.             case 13:

  395.                 paramInfo.name = "F velocity";

  396.                 break;

  397.             case 14:

  398.                 paramInfo.name = "A ADSR";

  399.                 break;

  400.             case 15:

  401.                 paramInfo.name = "A ADSR";

  402.                 break;

  403.             case 16:

  404.                 paramInfo.name = "A ADSR";

  405.                 break;

  406.             case 17:

  407.                 paramInfo.name = "A ADSR";

  408.                 break;

  409.             case 18:

  410.                 paramInfo.name = "A velocity";

  411.                 break;

  412.             case 19:

  413.                 paramInfo.name = "lfoC";

  414.                 break;

  415.             case 20:

  416.                 paramInfo.name = "lfoA";

  417.                 break;

  418.             case 21:

  419.                 paramInfo.name = "lfoF";

  420.                 break;

  421.             case 22:

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

  423.                 break;

  424.             case 23:

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

  426.                 break;

  427.             case 24:

  428.             case 0:

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

  430.                 break;

  431.             default:

  432.                 paramInfo.name = "unknown2";

  433.                 break;

  434.             }

  435. 

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

  437.             return &paramInfo;

  438.         }

  439. 

  440.         switch (index)

  441.         {

  442.         case 0:

  443.             paramInfo.name = "Main volume";

  444.             break;

  445.         case 73:

  446.             paramInfo.name = "Delay Time";

  447.             break;

  448.         case 74:

  449.             paramInfo.name = "Delay Feedback";

  450.             break;

  451.         case 75:

  452.             paramInfo.name = "Delay Volume";

  453.             break;

  454.         case 76:

  455.             paramInfo.name = "Chorus Rate";

  456.             break;

  457.         case 77:

  458.             paramInfo.name = "Chorus Depth";

  459.             break;

  460.         case 78:

  461.             paramInfo.name = "Chorus Volume";

  462.             break;

  463.         case 79:

  464.             paramInfo.name = "Reverb Size";

  465.             break;

  466.         case 80:

  467.             paramInfo.name = "Reverb Width";

  468.             break;

  469.         case 81:

  470.             paramInfo.name = "Reverb Damp";

  471.             break;

  472.         case 82:

  473.             paramInfo.name = "Reverb Volume";

  474.             break;

  475.         case 83:

  476.             paramInfo.name = "Wave1 Panning";

  477.             break;

  478.         case 84:

  479.             paramInfo.name = "Wave2 Panning";

  480.             break;

  481.         case 85:

  482.             paramInfo.name = "Wave3 Panning";

  483.             break;

  484.         case 86:

  485.             paramInfo.name = "Wave1 Volume";

  486.             break;

  487.         case 87:

  488.             paramInfo.name = "Wave2 Volume";

  489.             break;

  490.         case 88:

  491.             paramInfo.name = "Wave3 Volume";

  492.             break;

  493.         case 89:

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

  495.             break;

  496.         case 90:

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

  498.             break;

  499.         case 91:

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

  501.             break;

  502.         default:

  503.             paramInfo.name = "unknown";

  504.             break;

  505.         }

  506. 

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

  508.         return &paramInfo;

  509.     }

  510. 

  511.     float getParameterValue(const uint32_t index) const override

  512.     {

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

  514.     }

  515. 

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

  517.     // Plugin state calls

  518. 

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

  520.     {

  521.         if (index < kParamCount)

  522.         {

  523.             fParameters[index] = value;

  524.             fSynth.update(index);

  525.         }

  526.     }

  527. 

  528.     // -------------------------------------------------------------------

  529.     // Plugin process calls

  530. 

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

  532.     {

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

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

  535. 

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

  537.         {

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

  539. 

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

  541. 

  542.             if (status == MIDI_STATUS_NOTE_ON)

  543.             {

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

  545.             }

  546.             else if (status == MIDI_STATUS_NOTE_OFF)

  547.             {

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

  549.             }

  550.             else if (status == MIDI_STATUS_CONTROL_CHANGE)

  551.             {

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

  553. 

  554.                 if (control == MIDI_CONTROL_ALL_SOUND_OFF)

  555.                     fSynth.kill();

  556.                 else if (control == MIDI_CONTROL_ALL_NOTES_OFF)

  557.                     fSynth.releaseAll(1);

  558.             }

  559.         }

  560. 

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

  562.         {

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

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

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

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

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

  568.         }

  569. 

  570.         obf ->clear();

  571.         dbf1->clear();

  572.         dbf2->clear();

  573.         dbf3->clear();

  574. 

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

  576. 

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

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

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

  580. 

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

  582.         output.clear();

  583. 

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

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

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

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

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

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

  590. 

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

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

  593.     }

  594. 

  595.     // -------------------------------------------------------------------

  596.     // Plugin UI calls

  597. 

  598.     void uiShow(const bool show) override

  599.     {

  600.         if (show)

  601.         {

  602.             if (fWindow == nullptr)

  603.             {

  604.                 fWindow = new HelperWindow2();

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

  606.             }

  607. 

  608.             if (fView == nullptr)

  609.                 fView = new VexEditorComponent();

  610. 

  611.             fWindow->show(fView);

  612.         }

  613.         else if (fWindow != nullptr)

  614.         {

  615.             fWindow->hide();

  616. 

  617.             fView = nullptr;

  618.             fWindow = nullptr;

  619.         }

  620.     }

  621. 

  622.     void uiIdle() override

  623.     {

  624.         if (fWindow == nullptr)

  625.             return;

  626. 

  627.         if (fWindow->wasClosedByUser())

  628.         {

  629.             uiShow(false);

  630.             uiClosed();

  631.         }

  632.     }

  633. 

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

  635.     {

  636.         if (fView == nullptr)

  637.             return;

  638. 

  639.         //fView->update();

  640.     }

  641. 

  642.     // -------------------------------------------------------------------

  643.     // Plugin dispatcher calls

  644. 

  645.     void bufferSizeChanged(const uint32_t bufferSize) override

  646.     {

  647.         delete obf;

  648.         delete abf;

  649.         delete dbf1;

  650.         delete dbf2;

  651.         delete dbf3;

  652. 

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

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

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

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

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

  658.     }

  659. 

  660.     void sampleRateChanged(const double sampleRate) override

  661.     {

  662.         fChorus.setSampleRate(sampleRate);

  663.         fDelay.setSampleRate(sampleRate);

  664.         fSynth.setSampleRate(sampleRate);

  665.     }

  666. 

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

  668.     {

  669.         if (fWindow == nullptr)

  670.             return;

  671. 

  672.         fWindow->setName(uiName);

  673.     }

  674. 

  675. private:

  676.     float fParameters[kParamCount];

  677. 

  678.     AudioSampleBuffer* obf;

  679.     AudioSampleBuffer* abf;

  680.     AudioSampleBuffer* dbf1; // delay

  681.     AudioSampleBuffer* dbf2; // chorus

  682.     AudioSampleBuffer* dbf3; // reverb

  683. 

  684.     VexChorus fChorus;

  685.     VexDelay fDelay;

  686.     VexReverb fReverb;

  687.     VexSyntModule fSynth;

  688. 

  689.     ScopedPointer<VexEditorComponent> fView;

  690.     ScopedPointer<HelperWindow2> fWindow;

  691. 

  692.     PluginClassEND(VexSynthPlugin)

  693.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexSynthPlugin)

  694. };

  695. 

  696. // -----------------------------------------------------------------------

  697. 

  698. static const PluginDescriptor vexSynthDesc = {

  699.     /* category  */ PLUGIN_CATEGORY_SYNTH,

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

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

  702.     /* audioIns  */ 0,

  703.     /* audioOuts */ 2,

  704.     /* midiIns   */ 1,

  705.     /* midiOuts  */ 0,

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

  707.     /* paramOuts */ 0,

  708.     /* name      */ "VexSynth",

  709.     /* label     */ "vexSynth",

  710.     /* maker     */ "falkTX",

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

  712.     PluginDescriptorFILL(VexSynthPlugin)

  713. };

  714. 

  715. // -----------------------------------------------------------------------

  716. 

  717. CARLA_EXPORT

  718. void carla_register_native_plugin_vex_synth()

  719. {

  720.     carla_register_native_plugin(&vexSynthDesc);

  721. }

  722. 

  723. // -----------------------------------------------------------------------