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.
2850 Commits
17 Branches
264MB
Tree: 3509edb43d
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '3509edb43d'
${ noResults }
Carla/source/native-plugins/zita-at1.cpp

464 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.                   public X_handler_thread<Mainwin>::SetValueCallback,

  45.                   private Mainwin::ValueChangedCallback

  46. {

  47. public:

  48.     enum Parameters {

  49.         // rotary knobs

  50.         kParameterR_TUNE,

  51.         kParameterR_FILT,

  52.         kParameterR_BIAS,

  53.         kParameterR_CORR,

  54.         kParameterR_OFFS,

  55.         // knob count

  56.         kParameterNROTARY,

  57.         // midi channel

  58.         kParameterM_CHANNEL = kParameterNROTARY,

  59.         // final count

  60.         kNumParameters

  61.     };

  62. 

  63.     AT1Plugin(const NativeHostDescriptor* const host)

  64.         : NativePluginClass(host),

  65.           fJackClient(),

  66.           xresman(),

  67.           jclient(nullptr),

  68.           display(nullptr),

  69.           rootwin(nullptr),

  70.           mainwin(nullptr),

  71.           handler(nullptr),

  72.           handlerThread(this),

  73.           leakDetector_AT1Plugin()

  74.     {

  75.         CARLA_SAFE_ASSERT(host != nullptr);

  76. 

  77.         carla_zeroStruct(fJackClient);

  78. 

  79.         fJackClient.clientName = "at1";

  80.         fJackClient.bufferSize = getBufferSize();

  81.         fJackClient.sampleRate = getSampleRate();

  82. 

  83.         int   argc   = 1;

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

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

  86. 

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

  88. 

  89.         // set initial values

  90.         fParameters[kParameterR_TUNE] = 440.0f;

  91.         fParameters[kParameterR_FILT] = 0.1f;

  92.         fParameters[kParameterR_BIAS] = 0.5f;

  93.         fParameters[kParameterR_CORR] = 1.0f;

  94.         fParameters[kParameterR_OFFS] = 0.0f;

  95. 

  96.         fParameters[kParameterM_CHANNEL] = 0.0f;

  97. 

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

  99. 

  100.         jclient->set_midichan(-1);

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

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

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

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

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

  106.     }

  107. 

  108.     // -------------------------------------------------------------------

  109.     // Plugin parameter calls

  110. 

  111.     uint32_t getParameterCount() const override

  112.     {

  113.         return kNumParameters;

  114.     }

  115. 

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

  117.     {

  118.         CARLA_SAFE_ASSERT_RETURN(index < kNumParameters, nullptr);

  119. 

  120.         static NativeParameter param;

  121.         static NativeParameterScalePoint scalePoints[17];

  122. 

  123.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_AUTOMABLE;

  124. 

  125.         // reset

  126.         param.name = nullptr;

  127.         param.unit = nullptr;

  128.         param.ranges.def       = 0.0f;

  129.         param.ranges.min       = 0.0f;

  130.         param.ranges.max       = 1.0f;

  131.         param.ranges.step      = 1.0f;

  132.         param.ranges.stepSmall = 1.0f;

  133.         param.ranges.stepLarge = 1.0f;

  134.         param.scalePointCount  = 0;

  135.         param.scalePoints      = nullptr;

  136. 

  137.         switch (index)

  138.         {

  139.         case kParameterR_TUNE:

  140.             param.name = "Tuning";

  141.             param.ranges.def = 440.0f;

  142.             param.ranges.min = 400.0f;

  143.             param.ranges.max = 480.0f;

  144.             break;

  145.         case kParameterR_FILT:

  146.             hints |= NATIVE_PARAMETER_IS_LOGARITHMIC;

  147.             param.name = "Filter";

  148.             param.ranges.def = 0.1f;

  149.             param.ranges.min = 0.02f;

  150.             param.ranges.max = 0.5f;

  151.             break;

  152.         case kParameterR_BIAS:

  153.             param.name = "Bias";

  154.             param.ranges.def = 0.5f;

  155.             param.ranges.min = 0.0f;

  156.             param.ranges.max = 1.0f;

  157.             break;

  158.         case kParameterR_CORR:

  159.             param.name = "Correction";

  160.             param.ranges.def = 1.0f;

  161.             param.ranges.min = 0.0f;

  162.             param.ranges.max = 1.0f;

  163.             break;

  164.         case kParameterR_OFFS:

  165.             param.name = "OfOfset";

  166.             param.ranges.def = 0.0f;

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

  168.             param.ranges.max = 2.0f;

  169.             break;

  170.         case kParameterM_CHANNEL:

  171.             hints |= NATIVE_PARAMETER_USES_SCALEPOINTS;

  172.             param.name = "MIDI Channel";

  173.             param.ranges.def = 0.0f;

  174.             param.ranges.min = 0.0f;

  175.             param.ranges.max = 16.0f;

  176.             param.scalePointCount = 17;

  177.             param.scalePoints     = scalePoints;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  212.             break;

  213.         }

  214. 

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

  216. 

  217.         return &param;

  218.     }

  219. 

  220.     float getParameterValue(const uint32_t index) const override

  221.     {

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

  223. 

  224.         return fParameters[index];

  225.     }

  226. 

  227.     // -------------------------------------------------------------------

  228.     // Plugin state calls

  229. 

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

  231.     {

  232.         CARLA_SAFE_ASSERT_RETURN(index < kNumParameters,);

  233. 

  234.         fParameters[index] = value;

  235. 

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

  237. 

  238.         switch (index)

  239.         {

  240.         case kParameterR_TUNE:

  241.             retuner->set_refpitch(value);

  242.             break;

  243.         case kParameterR_FILT:

  244.             retuner->set_corrfilt(value);

  245.             break;

  246.         case kParameterR_BIAS:

  247.             retuner->set_notebias(value);

  248.             break;

  249.         case kParameterR_CORR:

  250.             retuner->set_corrgain(value);

  251.             break;

  252.         case kParameterR_OFFS:

  253.             retuner->set_corroffs(value);

  254.             break;

  255.         case kParameterM_CHANNEL:

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

  257.             break;

  258.         }

  259.     }

  260. 

  261.     // -------------------------------------------------------------------

  262.     // Plugin process calls

  263. 

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

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

  266.     {

  267.         if (! fJackClient.active)

  268.         {

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

  270.             return;

  271.         }

  272. 

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

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

  275. 

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

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

  278. 

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

  280.     }

  281. 

  282.     // -------------------------------------------------------------------

  283.     // Plugin UI calls

  284. 

  285.     void uiShow(const bool show) override

  286.     {

  287.         if (show)

  288.         {

  289.             if (display != nullptr)

  290.                 return;

  291. 

  292.             display = new X_display(nullptr);

  293. 

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

  295.                 return hostUiUnavailable();

  296. 

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

  298. 

  299.             rootwin = new X_rootwin(display);

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

  301. 

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

  303. 

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

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

  306. 

  307.             rootwin->handle_event();

  308. 

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

  310.             handler->next_event();

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

  312. 

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

  314.         }

  315.         else

  316.         {

  317.             if (handlerThread.isThreadRunning())

  318.                 handlerThread.stopThread();

  319. 

  320.             handler = nullptr;

  321.             mainwin = nullptr;

  322.             rootwin = nullptr;

  323.             display = nullptr;

  324.         }

  325.     }

  326. 

  327.     void uiIdle() override

  328.     {

  329.         if (mainwin == nullptr)

  330.             return;

  331. 

  332.         if (handlerThread.wasClosed())

  333.         {

  334.             {

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

  336.                 handler = nullptr;

  337.                 mainwin = nullptr;

  338.                 rootwin = nullptr;

  339.                 display = nullptr;

  340.             }

  341.             uiClosed();

  342.         }

  343.     }

  344. 

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

  346.     {

  347.         CARLA_SAFE_ASSERT_RETURN(index < kNumParameters,);

  348. 

  349.         if (mainwin == nullptr)

  350.             return;

  351. 

  352.         handlerThread.setParameterValueLater(index, value);

  353.     }

  354. 

  355.     // -------------------------------------------------------------------

  356.     // Plugin dispatcher calls

  357. 

  358.     void bufferSizeChanged(const uint32_t bufferSize) override

  359.     {

  360.         fJackClient.bufferSize = bufferSize;

  361.     }

  362. 

  363.     void sampleRateChanged(const double sampleRate) override

  364.     {

  365.         fJackClient.sampleRate = sampleRate;

  366.     }

  367. 

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

  369.     {

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

  371. 

  372.         if (mainwin == nullptr)

  373.             return;

  374. 

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

  376. 

  377.         mainwin->x_set_title(uiName);

  378.     }

  379. 

  380.     // -------------------------------------------------------------------

  381.     // Mainwin callbacks

  382. 

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

  384.     {

  385.         fParameters[index] = value;

  386.         uiParameterChanged(index, value);

  387.     }

  388. 

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

  390.     // X_handler_thread callbacks

  391. 

  392.     void setParameterValueFromHandlerThread(uint32_t index, float value) override

  393.     {

  394.         CARLA_SAFE_ASSERT_RETURN(mainwin != nullptr,);

  395. 

  396.         if (index < kParameterNROTARY)

  397.         {

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

  399.             return;

  400.         }

  401.         if (index == kParameterM_CHANNEL)

  402.         {

  403.             mainwin->setchan_ui(value);

  404.             return;

  405.         }

  406.     }

  407. 

  408.     // -------------------------------------------------------------------

  409. 

  410. private:

  411.     // Fake jack client

  412.     jack_client_t fJackClient;

  413. 

  414.     // Zita stuff (core)

  415.     X_resman xresman;

  416.     ScopedPointer<Jclient>   jclient;

  417.     ScopedPointer<X_display> display;

  418.     ScopedPointer<X_rootwin> rootwin;

  419.     ScopedPointer<Mainwin>   mainwin;

  420.     ScopedPointer<X_handler> handler;

  421.     X_handler_thread<Mainwin> handlerThread;

  422. 

  423.     float fParameters[kNumParameters];

  424. 

  425.     PluginClassEND(AT1Plugin)

  426.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(AT1Plugin)

  427. };

  428. 

  429. // -----------------------------------------------------------------------

  430. 

  431. static const NativePluginDescriptor at1Desc = {

  432.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  434.                                                   |NATIVE_PLUGIN_HAS_UI

  435.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS

  436.                                                   |NATIVE_PLUGIN_NEEDS_UI_MAIN_THREAD

  437.                                                   |NATIVE_PLUGIN_USES_PARENT_ID),

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

  439.     /* audioIns  */ 1,

  440.     /* audioOuts */ 1,

  441.     /* midiIns   */ 1,

  442.     /* midiOuts  */ 0,

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

  444.     /* paramOuts */ 0,

  445.     /* name      */ "AT1",

  446.     /* label     */ "at1",

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

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

  449.     PluginDescriptorFILL(AT1Plugin)

  450. };

  451. 

  452. // -----------------------------------------------------------------------

  453. 

  454. CARLA_EXPORT

  455. void carla_register_native_plugin_zita_at1();

  456. 

  457. CARLA_EXPORT

  458. void carla_register_native_plugin_zita_at1()

  459. {

  460.     carla_register_native_plugin(&at1Desc);

  461. }

  462. 

  463. // -----------------------------------------------------------------------