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

721 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)*92);

  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. 

  314.     ~VexSynthPlugin()

  315.     {

  316.         delete obf;

  317.         delete abf;

  318.         delete dbf1;

  319.         delete dbf2;

  320.         delete dbf3;

  321.     }

  322. 

  323. protected:

  324.     // -------------------------------------------------------------------

  325.     // Plugin parameter calls

  326. 

  327.     uint32_t getParameterCount() const override

  328.     {

  329.         return kParamCount;

  330.     }

  331. 

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

  333.     {

  334.         static Parameter paramInfo;

  335. 

  336.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  337. 

  338.         paramInfo.name = nullptr;

  339.         paramInfo.unit = nullptr;

  340.         paramInfo.ranges.def       = 0.0f;

  341.         paramInfo.ranges.min       = 0.0f;

  342.         paramInfo.ranges.max       = 1.0f;

  343.         paramInfo.ranges.step      = PARAMETER_RANGES_DEFAULT_STEP;

  344.         paramInfo.ranges.stepSmall = PARAMETER_RANGES_DEFAULT_STEP_SMALL;

  345.         paramInfo.ranges.stepLarge = PARAMETER_RANGES_DEFAULT_STEP_LARGE;

  346.         paramInfo.scalePointCount  = 0;

  347.         paramInfo.scalePoints      = nullptr;

  348. 

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

  350.         {

  351.             uint32_t ri = index % 24;

  352. 

  353.             switch (ri)

  354.             {

  355.             case 1:

  356.                 paramInfo.name = "oct";

  357.                 break;

  358.             case 2:

  359.                 paramInfo.name = "cent";

  360.                 break;

  361.             case 3:

  362.                 paramInfo.name = "phaseOffset";

  363.                 break;

  364.             case 4:

  365.                 paramInfo.name = "phaseIncOffset";

  366.                 break;

  367.             case 5:

  368.                 paramInfo.name = "filter";

  369.                 break;

  370.             case 6:

  371.                 paramInfo.name = "filter";

  372.                 break;

  373.             case 7:

  374.                 paramInfo.name = "filter";

  375.                 break;

  376.             case 8:

  377.                 paramInfo.name = "filter";

  378.                 break;

  379.             case 9:

  380.                 paramInfo.name = "F ADSR";

  381.                 break;

  382.             case 10:

  383.                 paramInfo.name = "F ADSR";

  384.                 break;

  385.             case 11:

  386.                 paramInfo.name = "F ADSR";

  387.                 break;

  388.             case 12:

  389.                 paramInfo.name = "F ADSR";

  390.                 break;

  391.             case 13:

  392.                 paramInfo.name = "F velocity";

  393.                 break;

  394.             case 14:

  395.                 paramInfo.name = "A ADSR";

  396.                 break;

  397.             case 15:

  398.                 paramInfo.name = "A ADSR";

  399.                 break;

  400.             case 16:

  401.                 paramInfo.name = "A ADSR";

  402.                 break;

  403.             case 17:

  404.                 paramInfo.name = "A ADSR";

  405.                 break;

  406.             case 18:

  407.                 paramInfo.name = "A velocity";

  408.                 break;

  409.             case 19:

  410.                 paramInfo.name = "lfoC";

  411.                 break;

  412.             case 20:

  413.                 paramInfo.name = "lfoA";

  414.                 break;

  415.             case 21:

  416.                 paramInfo.name = "lfoF";

  417.                 break;

  418.             case 22:

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

  420.                 break;

  421.             case 23:

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

  423.                 break;

  424.             case 24:

  425.             case 0:

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

  427.                 break;

  428.             default:

  429.                 paramInfo.name = "unknown2";

  430.                 break;

  431.             }

  432. 

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

  434.             return &paramInfo;

  435.         }

  436. 

  437.         switch (index)

  438.         {

  439.         case 0:

  440.             paramInfo.name = "Main volume";

  441.             break;

  442.         case 73:

  443.             paramInfo.name = "Delay Time";

  444.             break;

  445.         case 74:

  446.             paramInfo.name = "Delay Feedback";

  447.             break;

  448.         case 75:

  449.             paramInfo.name = "Delay Volume";

  450.             break;

  451.         case 76:

  452.             paramInfo.name = "Chorus Rate";

  453.             break;

  454.         case 77:

  455.             paramInfo.name = "Chorus Depth";

  456.             break;

  457.         case 78:

  458.             paramInfo.name = "Chorus Volume";

  459.             break;

  460.         case 79:

  461.             paramInfo.name = "Reverb Size";

  462.             break;

  463.         case 80:

  464.             paramInfo.name = "Reverb Width";

  465.             break;

  466.         case 81:

  467.             paramInfo.name = "Reverb Damp";

  468.             break;

  469.         case 82:

  470.             paramInfo.name = "Reverb Volume";

  471.             break;

  472.         case 83:

  473.             paramInfo.name = "Wave1 Panning";

  474.             break;

  475.         case 84:

  476.             paramInfo.name = "Wave2 Panning";

  477.             break;

  478.         case 85:

  479.             paramInfo.name = "Wave3 Panning";

  480.             break;

  481.         case 86:

  482.             paramInfo.name = "Wave1 Volume";

  483.             break;

  484.         case 87:

  485.             paramInfo.name = "Wave2 Volume";

  486.             break;

  487.         case 88:

  488.             paramInfo.name = "Wave3 Volume";

  489.             break;

  490.         case 89:

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

  492.             break;

  493.         case 90:

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

  495.             break;

  496.         case 91:

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

  498.             break;

  499.         default:

  500.             paramInfo.name = "unknown";

  501.             break;

  502.         }

  503. 

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

  505.         return &paramInfo;

  506.     }

  507. 

  508.     float getParameterValue(const uint32_t index) const override

  509.     {

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

  511.     }

  512. 

  513.     // -------------------------------------------------------------------

  514.     // Plugin state calls

  515. 

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

  517.     {

  518.         if (index < kParamCount)

  519.         {

  520.             fParameters[index] = value;

  521.             fSynth.update(index);

  522.         }

  523.     }

  524. 

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

  526.     // Plugin process calls

  527. 

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

  529.     {

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

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

  532. 

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

  534.         {

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

  536. 

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

  538. 

  539.             if (status == MIDI_STATUS_NOTE_ON)

  540.             {

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

  542.             }

  543.             else if (status == MIDI_STATUS_NOTE_OFF)

  544.             {

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

  546.             }

  547.             else if (status == MIDI_STATUS_CONTROL_CHANGE)

  548.             {

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

  550. 

  551.                 if (control == MIDI_CONTROL_ALL_SOUND_OFF)

  552.                     fSynth.kill();

  553.                 else if (control == MIDI_CONTROL_ALL_NOTES_OFF)

  554.                     fSynth.releaseAll(1);

  555.             }

  556.         }

  557. 

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

  559.         {

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

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

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

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

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

  565.         }

  566. 

  567.         obf ->clear();

  568.         dbf1->clear();

  569.         dbf2->clear();

  570.         dbf3->clear();

  571. 

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

  573. 

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

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

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

  577. 

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

  579.         output.clear();

  580. 

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

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

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

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

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

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

  587. 

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

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

  590.     }

  591. 

  592.     // -------------------------------------------------------------------

  593.     // Plugin UI calls

  594. 

  595.     void uiShow(const bool show) override

  596.     {

  597.         if (show)

  598.         {

  599.             if (fWindow == nullptr)

  600.             {

  601.                 fWindow = new HelperWindow2();

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

  603.             }

  604. 

  605.             if (fView == nullptr)

  606.                 fView = new VexEditorComponent();

  607. 

  608.             fWindow->show(fView);

  609.         }

  610.         else if (fWindow != nullptr)

  611.         {

  612.             fWindow->hide();

  613. 

  614.             fView = nullptr;

  615.             fWindow = nullptr;

  616.         }

  617.     }

  618. 

  619.     void uiIdle() override

  620.     {

  621.         if (fWindow == nullptr)

  622.             return;

  623. 

  624.         if (fWindow->wasClosedByUser())

  625.         {

  626.             uiShow(false);

  627.             uiClosed();

  628.         }

  629.     }

  630. 

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

  632.     {

  633.         if (fView == nullptr)

  634.             return;

  635. 

  636.         //fView->update();

  637.     }

  638. 

  639.     // -------------------------------------------------------------------

  640.     // Plugin dispatcher calls

  641. 

  642.     void bufferSizeChanged(const uint32_t bufferSize) override

  643.     {

  644.         delete obf;

  645.         delete abf;

  646.         delete dbf1;

  647.         delete dbf2;

  648.         delete dbf3;

  649. 

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

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

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

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

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

  655.     }

  656. 

  657.     void sampleRateChanged(const double sampleRate) override

  658.     {

  659.         fChorus.setSampleRate(sampleRate);

  660.         fDelay.setSampleRate(sampleRate);

  661.         fSynth.setSampleRate(sampleRate);

  662.     }

  663. 

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

  665.     {

  666.         if (fWindow == nullptr)

  667.             return;

  668. 

  669.         fWindow->setName(uiName);

  670.     }

  671. 

  672. private:

  673.     float fParameters[92];

  674. 

  675.     AudioSampleBuffer* obf;

  676.     AudioSampleBuffer* abf;

  677.     AudioSampleBuffer* dbf1; // delay

  678.     AudioSampleBuffer* dbf2; // chorus

  679.     AudioSampleBuffer* dbf3; // reverb

  680. 

  681.     VexChorus fChorus;

  682.     VexDelay fDelay;

  683.     VexReverb fReverb;

  684.     VexSyntModule fSynth;

  685. 

  686.     ScopedPointer<VexEditorComponent> fView;

  687.     ScopedPointer<HelperWindow2> fWindow;

  688. 

  689.     PluginClassEND(VexSynthPlugin)

  690.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexSynthPlugin)

  691. };

  692. 

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

  694. 

  695. static const PluginDescriptor vexSynthDesc = {

  696.     /* category  */ PLUGIN_CATEGORY_SYNTH,

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

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

  699.     /* audioIns  */ 0,

  700.     /* audioOuts */ 2,

  701.     /* midiIns   */ 1,

  702.     /* midiOuts  */ 0,

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

  704.     /* paramOuts */ 0,

  705.     /* name      */ "VexSynth",

  706.     /* label     */ "vexSynth",

  707.     /* maker     */ "falkTX",

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

  709.     PluginDescriptorFILL(VexSynthPlugin)

  710. };

  711. 

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

  713. 

  714. CARLA_EXPORT

  715. void carla_register_native_plugin_vex_synth()

  716. {

  717.     carla_register_native_plugin(&vexSynthDesc);

  718. }

  719. 

  720. // -----------------------------------------------------------------------