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.
2691 Commits
16 Branches
275MB
Tree: 15a33efb90
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '15a33efb90'
${ noResults }
Carla/source/native-plugins/zita-at1.cpp

454 lines
14KB
Raw Blame History 

  1. /*

  2.  * Carla Native Plugins

  3.  * Copyright (C) 2012-2015 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. #include "CarlaMathUtils.hpp"

  20. #include "CarlaJuceUtils.hpp"

  21. 

  22. #include "juce_audio_basics.h"

  23. 

  24. #include "zita-common.hpp"

  25. #include "zita-at1/button.cc"

  26. #include "zita-at1/guiclass.cc"

  27. #include "zita-at1/jclient.cc"

  28. #include "zita-at1/mainwin.cc"

  29. #include "zita-at1/png2img.cc"

  30. #include "zita-at1/retuner.cc"

  31. #include "zita-at1/rotary.cc"

  32. #include "zita-at1/styles.cc"

  33. #include "zita-at1/tmeter.cc"

  34. 

  35. using juce::FloatVectorOperations;

  36. using juce::ScopedPointer;

  37. 

  38. using namespace AT1;

  39. 

  40. // -----------------------------------------------------------------------

  41. // AT1 Plugin

  42. 

  43. class AT1Plugin : public NativePluginClass,

  44.                   private Mainwin::ValueChangedCallback

  45. {

  46. public:

  47.     enum Parameters {

  48.         // rotary knobs

  49.         kParameterR_TUNE,

  50.         kParameterR_FILT,

  51.         kParameterR_BIAS,

  52.         kParameterR_CORR,

  53.         kParameterR_OFFS,

  54.         // knob count

  55.         kParameterNROTARY,

  56.         // midi channel

  57.         kParameterM_CHANNEL = kParameterNROTARY,

  58.         // final count

  59.         kNumParameters

  60.     };

  61. 

  62.     AT1Plugin(const NativeHostDescriptor* const host)

  63.         : NativePluginClass(host),

  64.           fJackClient(),

  65.           xresman(),

  66.           jclient(nullptr),

  67.           display(nullptr),

  68.           rootwin(nullptr),

  69.           mainwin(nullptr),

  70.           handler(nullptr),

  71.           handlerThread(),

  72.           leakDetector_AT1Plugin()

  73.     {

  74.         CARLA_SAFE_ASSERT(host != nullptr);

  75. 

  76.         carla_zeroStruct(fJackClient);

  77. 

  78.         fJackClient.clientName = "at1";

  79.         fJackClient.bufferSize = getBufferSize();

  80.         fJackClient.sampleRate = getSampleRate();

  81. 

  82.         int   argc   = 1;

  83.         char* argv[] = { (char*)"at1" };

  84.         xresman.init(&argc, argv, (char*)"at1", nullptr, 0);

  85. 

  86.         jclient = new Jclient(xresman.rname(), &fJackClient);

  87. 

  88.         // set initial values

  89.         fParameters[kParameterR_TUNE] = 440.0f;

  90.         fParameters[kParameterR_FILT] = 0.1f;

  91.         fParameters[kParameterR_BIAS] = 0.5f;

  92.         fParameters[kParameterR_CORR] = 1.0f;

  93.         fParameters[kParameterR_OFFS] = 0.0f;

  94. 

  95.         fParameters[kParameterM_CHANNEL] = 0.0f;

  96. 

  97.         Retuner* const retuner(jclient->retuner());

  98. 

  99.         jclient->set_midichan(-1);

  100.         retuner->set_refpitch(fParameters[kParameterR_TUNE]);

  101.         retuner->set_corrfilt(fParameters[kParameterR_FILT]);

  102.         retuner->set_notebias(fParameters[kParameterR_BIAS]);

  103.         retuner->set_corrgain(fParameters[kParameterR_CORR]);

  104.         retuner->set_corroffs(fParameters[kParameterR_OFFS]);

  105.     }

  106. 

  107.     // -------------------------------------------------------------------

  108.     // Plugin parameter calls

  109. 

  110.     uint32_t getParameterCount() const override

  111.     {

  112.         return kNumParameters;

  113.     }

  114. 

  115.     const NativeParameter* getParameterInfo(const uint32_t index) const override

  116.     {

  117.         CARLA_SAFE_ASSERT_RETURN(index < kNumParameters, nullptr);

  118. 

  119.         static NativeParameter param;

  120.         static NativeParameterScalePoint scalePoints[17];

  121. 

  122.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_AUTOMABLE;

  123. 

  124.         // reset

  125.         param.name = nullptr;

  126.         param.unit = nullptr;

  127.         param.ranges.def       = 0.0f;

  128.         param.ranges.min       = 0.0f;

  129.         param.ranges.max       = 1.0f;

  130.         param.ranges.step      = 1.0f;

  131.         param.ranges.stepSmall = 1.0f;

  132.         param.ranges.stepLarge = 1.0f;

  133.         param.scalePointCount  = 0;

  134.         param.scalePoints      = nullptr;

  135. 

  136.         switch (index)

  137.         {

  138.         case kParameterR_TUNE:

  139.             param.name = "Tuning";

  140.             param.ranges.def = 440.0f;

  141.             param.ranges.min = 400.0f;

  142.             param.ranges.max = 480.0f;

  143.             break;

  144.         case kParameterR_FILT:

  145.             hints |= NATIVE_PARAMETER_IS_LOGARITHMIC;

  146.             param.name = "Filter";

  147.             param.ranges.def = 0.1f;

  148.             param.ranges.min = 0.02f;

  149.             param.ranges.max = 0.5f;

  150.             break;

  151.         case kParameterR_BIAS:

  152.             param.name = "Bias";

  153.             param.ranges.def = 0.5f;

  154.             param.ranges.min = 0.0f;

  155.             param.ranges.max = 1.0f;

  156.             break;

  157.         case kParameterR_CORR:

  158.             param.name = "Correction";

  159.             param.ranges.def = 1.0f;

  160.             param.ranges.min = 0.0f;

  161.             param.ranges.max = 1.0f;

  162.             break;

  163.         case kParameterR_OFFS:

  164.             param.name = "OfOfset";

  165.             param.ranges.def = 0.0f;

  166.             param.ranges.min = -2.0f;

  167.             param.ranges.max = 2.0f;

  168.             break;

  169.         case kParameterM_CHANNEL:

  170.             hints |= NATIVE_PARAMETER_USES_SCALEPOINTS;

  171.             param.name = "MIDI Channel";

  172.             param.ranges.def = 0.0f;

  173.             param.ranges.min = 0.0f;

  174.             param.ranges.max = 16.0f;

  175.             param.scalePointCount = 17;

  176.             param.scalePoints     = scalePoints;

  177.             scalePoints[ 0].value = 0.0f;

  178.             scalePoints[ 0].label = "Omni";

  179.             scalePoints[ 1].value = 1.0f;

  180.             scalePoints[ 1].label = "1";

  181.             scalePoints[ 2].value = 2.0f;

  182.             scalePoints[ 2].label = "2";

  183.             scalePoints[ 3].value = 3.0f;

  184.             scalePoints[ 3].label = "3";

  185.             scalePoints[ 4].value = 4.0f;

  186.             scalePoints[ 4].label = "4";

  187.             scalePoints[ 5].value = 5.0f;

  188.             scalePoints[ 5].label = "5";

  189.             scalePoints[ 6].value = 6.0f;

  190.             scalePoints[ 6].label = "6";

  191.             scalePoints[ 7].value = 7.0f;

  192.             scalePoints[ 7].label = "7";

  193.             scalePoints[ 8].value = 8.0f;

  194.             scalePoints[ 8].label = "8";

  195.             scalePoints[ 9].value = 9.0f;

  196.             scalePoints[ 9].label = "9";

  197.             scalePoints[10].value = 10.0f;

  198.             scalePoints[10].label = "10";

  199.             scalePoints[11].value = 11.0f;

  200.             scalePoints[11].label = "11";

  201.             scalePoints[12].value = 12.0f;

  202.             scalePoints[12].label = "12";

  203.             scalePoints[13].value = 13.0f;

  204.             scalePoints[13].label = "13";

  205.             scalePoints[14].value = 14.0f;

  206.             scalePoints[14].label = "14";

  207.             scalePoints[15].value = 15.0f;

  208.             scalePoints[15].label = "15";

  209.             scalePoints[16].value = 16.0f;

  210.             scalePoints[16].label = "16";

  211.             break;

  212.         }

  213. 

  214.         param.hints = static_cast<NativeParameterHints>(hints);

  215. 

  216.         return &param;

  217.     }

  218. 

  219.     float getParameterValue(const uint32_t index) const override

  220.     {

  221.         CARLA_SAFE_ASSERT_RETURN(index < kNumParameters, 0.0f);

  222. 

  223.         return fParameters[index];

  224.     }

  225. 

  226.     // -------------------------------------------------------------------

  227.     // Plugin state calls

  228. 

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

  230.     {

  231.         CARLA_SAFE_ASSERT_RETURN(index < kNumParameters,);

  232. 

  233.         fParameters[index] = value;

  234. 

  235.         Retuner* const retuner(jclient->retuner());

  236. 

  237.         switch (index)

  238.         {

  239.         case kParameterR_TUNE:

  240.             retuner->set_refpitch(value);

  241.             break;

  242.         case kParameterR_FILT:

  243.             retuner->set_corrfilt(value);

  244.             break;

  245.         case kParameterR_BIAS:

  246.             retuner->set_notebias(value);

  247.             break;

  248.         case kParameterR_CORR:

  249.             retuner->set_corrgain(value);

  250.             break;

  251.         case kParameterR_OFFS:

  252.             retuner->set_corroffs(value);

  253.             break;

  254.         case kParameterM_CHANNEL:

  255.             jclient->set_midichan(value-1.0f);

  256.             break;

  257.         }

  258.     }

  259. 

  260.     // -------------------------------------------------------------------

  261.     // Plugin process calls

  262. 

  263.     void process(float** const inBuffer, float** const outBuffer, const uint32_t frames,

  264.                  const NativeMidiEvent* const midiEvents, const uint32_t midiEventCount) override

  265.     {

  266.         if (! fJackClient.active)

  267.         {

  268.             FloatVectorOperations::clear(outBuffer[0], static_cast<int>(frames));

  269.             return;

  270.         }

  271. 

  272.         fJackClient.portsAudioIn [0].buffer.audio = inBuffer [0];

  273.         fJackClient.portsAudioOut[0].buffer.audio = outBuffer[0];

  274. 

  275.         fJackClient.portsMidiIn[0].buffer.midi.count  = midiEventCount;

  276.         fJackClient.portsMidiIn[0].buffer.midi.events = const_cast<NativeMidiEvent*>(midiEvents);

  277. 

  278.         fJackClient.processCallback(frames, fJackClient.processPtr);

  279.     }

  280. 

  281.     // -------------------------------------------------------------------

  282.     // Plugin UI calls

  283. 

  284.     void uiShow(const bool show) override

  285.     {

  286.         if (show)

  287.         {

  288.             if (display != nullptr)

  289.                 return;

  290. 

  291.             display = new X_display(nullptr);

  292. 

  293.             if (display->dpy() == nullptr)

  294.                 return hostUiUnavailable();

  295. 

  296.             styles_init(display, &xresman, getResourceDir());

  297. 

  298.             rootwin = new X_rootwin(display);

  299.             mainwin = new Mainwin(rootwin, &xresman, 0, 0, jclient, this);

  300.             rootwin->handle_event();

  301.             mainwin->x_set_title(getUiName());

  302. 

  303.             handler = new X_handler(display, mainwin, EV_X11);

  304. 

  305.             if (const uintptr_t winId = getUiParentId())

  306.                 XSetTransientForHint(display->dpy(), mainwin->win(), static_cast<Window>(winId));

  307. 

  308.             handler->next_event();

  309.             XFlush(display->dpy());

  310. 

  311.             handlerThread.setupAndRun(handler, rootwin, mainwin);

  312.         }

  313.         else

  314.         {

  315.             if (handlerThread.isThreadRunning())

  316.                 handlerThread.stopThread();

  317. 

  318.             handler = nullptr;

  319.             mainwin = nullptr;

  320.             rootwin = nullptr;

  321.             display = nullptr;

  322.         }

  323.     }

  324. 

  325.     void uiIdle() override

  326.     {

  327.         if (mainwin == nullptr)

  328.             return;

  329. 

  330.         if (handlerThread.wasClosed())

  331.         {

  332.             {

  333.                 const CarlaMutexLocker cml(handlerThread.getLock());

  334.                 handler = nullptr;

  335.                 mainwin = nullptr;

  336.                 rootwin = nullptr;

  337.                 display = nullptr;

  338.             }

  339.             uiClosed();

  340.         }

  341.     }

  342. 

  343.     void uiSetParameterValue(const uint32_t index, const float value) override

  344.     {

  345.         CARLA_SAFE_ASSERT_RETURN(index < kNumParameters,);

  346. 

  347.         if (mainwin == nullptr)

  348.             return;

  349. 

  350.         const CarlaMutexLocker cml(handlerThread.getLock());

  351. 

  352.         if (index < kParameterNROTARY)

  353.         {

  354.             mainwin->_rotary[index]->set_value(value);

  355.             return;

  356.         }

  357.         if (index == kParameterM_CHANNEL)

  358.         {

  359.             mainwin->setchan_ui(value);

  360.             return;

  361.         }

  362.     }

  363. 

  364.     // -------------------------------------------------------------------

  365.     // Plugin dispatcher calls

  366. 

  367.     void bufferSizeChanged(const uint32_t bufferSize) override

  368.     {

  369.         fJackClient.bufferSize = bufferSize;

  370.     }

  371. 

  372.     void sampleRateChanged(const double sampleRate) override

  373.     {

  374.         fJackClient.sampleRate = sampleRate;

  375.     }

  376. 

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

  378.     {

  379.         CARLA_SAFE_ASSERT_RETURN(uiName != nullptr && uiName[0] != '\0',);

  380. 

  381.         if (mainwin == nullptr)

  382.             return;

  383. 

  384.         const CarlaMutexLocker cml(handlerThread.getLock());

  385. 

  386.         mainwin->x_set_title(uiName);

  387.     }

  388. 

  389.     // -------------------------------------------------------------------

  390.     // Mainwin callbacks

  391. 

  392.     void valueChangedCallback(uint index, float value) override

  393.     {

  394.         fParameters[index] = value;

  395.         uiParameterChanged(index, value);

  396.     }

  397. 

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

  399. 

  400. private:

  401.     // Fake jack client

  402.     jack_client_t fJackClient;

  403. 

  404.     // Zita stuff (core)

  405.     X_resman xresman;

  406.     ScopedPointer<Jclient>   jclient;

  407.     ScopedPointer<X_display> display;

  408.     ScopedPointer<X_rootwin> rootwin;

  409.     ScopedPointer<Mainwin>   mainwin;

  410.     ScopedPointer<X_handler> handler;

  411.     X_handler_thread<Mainwin> handlerThread;

  412. 

  413.     float fParameters[kNumParameters];

  414. 

  415.     PluginClassEND(AT1Plugin)

  416.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(AT1Plugin)

  417. };

  418. 

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

  420. 

  421. static const NativePluginDescriptor at1Desc = {

  422.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

  423.     /* hints     */ static_cast<NativePluginHints>(NATIVE_PLUGIN_IS_RTSAFE

  424.                                                   |NATIVE_PLUGIN_HAS_UI

  425.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS

  426.                                                   |NATIVE_PLUGIN_NEEDS_UI_MAIN_THREAD

  427.                                                   |NATIVE_PLUGIN_USES_PARENT_ID),

  428.     /* supports  */ static_cast<NativePluginSupports>(0x0),

  429.     /* audioIns  */ 1,

  430.     /* audioOuts */ 1,

  431.     /* midiIns   */ 1,

  432.     /* midiOuts  */ 0,

  433.     /* paramIns  */ AT1Plugin::kNumParameters,

  434.     /* paramOuts */ 0,

  435.     /* name      */ "AT1",

  436.     /* label     */ "at1",

  437.     /* maker     */ "falkTX, Fons Adriaensen",

  438.     /* copyright */ "GPL v2+",

  439.     PluginDescriptorFILL(AT1Plugin)

  440. };

  441. 

  442. // -----------------------------------------------------------------------

  443. 

  444. CARLA_EXPORT

  445. void carla_register_native_plugin_zita_at1();

  446. 

  447. CARLA_EXPORT

  448. void carla_register_native_plugin_zita_at1()

  449. {

  450.     carla_register_native_plugin(&at1Desc);

  451. }

  452. 

  453. // -----------------------------------------------------------------------