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

443 lines
13KB
Raw Blame History 

  1. /*

  2.  * Carla Native Plugins

  3.  * Copyright (C) 2012-2017 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 "CarlaNativeExtUI.hpp"

  19. #include "CarlaJuceUtils.hpp"

  20. 

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

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

  23. 

  24. #include "water/maths/MathsFunctions.h"

  25. 

  26. using water::roundToIntAccurate;

  27. 

  28. using namespace AT1;

  29. 

  30. // -----------------------------------------------------------------------

  31. // AT1 Plugin

  32. 

  33. class AT1Plugin : public NativePluginAndUiClass

  34. {

  35. public:

  36.     enum Parameters {

  37.         // rotary knobs

  38.         kParameterR_TUNE,

  39.         kParameterR_FILT,

  40.         kParameterR_BIAS,

  41.         kParameterR_CORR,

  42.         kParameterR_OFFS,

  43.         // knob count

  44.         kParameterNROTARY,

  45.         // midi channel

  46.         kParameterM_CHANNEL = kParameterNROTARY,

  47.         // final count

  48.         kNumParameters

  49.     };

  50. 

  51.     AT1Plugin(const NativeHostDescriptor* const host)

  52.         : NativePluginAndUiClass(host, "zita-at1-ui"),

  53.           fJackClient(),

  54.           jclient(nullptr),

  55.           notemask(0xfff)

  56.     {

  57.         CARLA_SAFE_ASSERT(host != nullptr);

  58. 

  59.         carla_zeroStruct(fJackClient);

  60. 

  61.         fJackClient.bufferSize = getBufferSize();

  62.         fJackClient.sampleRate = getSampleRate();

  63. 

  64.         // set initial values

  65.         fParameters[kParameterR_TUNE] = 440.0f;

  66.         fParameters[kParameterR_FILT] = 0.1f;

  67.         fParameters[kParameterR_BIAS] = 0.5f;

  68.         fParameters[kParameterR_CORR] = 1.0f;

  69.         fParameters[kParameterR_OFFS] = 0.0f;

  70.         fParameters[kParameterM_CHANNEL] = 0.0f;

  71. 

  72.         _recreateZitaClient();

  73.     }

  74. 

  75.     // -------------------------------------------------------------------

  76.     // Plugin parameter calls

  77. 

  78.     uint32_t getParameterCount() const override

  79.     {

  80.         return kNumParameters;

  81.     }

  82. 

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

  84.     {

  85.         CARLA_SAFE_ASSERT_RETURN(index < kNumParameters, nullptr);

  86. 

  87.         static NativeParameter param;

  88.         static NativeParameterScalePoint scalePoints[17];

  89. 

  90.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_AUTOMABLE;

  91. 

  92.         // reset

  93.         param.name = nullptr;

  94.         param.unit = nullptr;

  95.         param.ranges.def       = 0.0f;

  96.         param.ranges.min       = 0.0f;

  97.         param.ranges.max       = 1.0f;

  98.         param.ranges.step      = 1.0f;

  99.         param.ranges.stepSmall = 1.0f;

  100.         param.ranges.stepLarge = 1.0f;

  101.         param.scalePointCount  = 0;

  102.         param.scalePoints      = nullptr;

  103. 

  104.         switch (index)

  105.         {

  106.         case kParameterR_TUNE:

  107.             param.name = "Tuning";

  108.             param.ranges.def = 440.0f;

  109.             param.ranges.min = 400.0f;

  110.             param.ranges.max = 480.0f;

  111.             break;

  112.         case kParameterR_FILT:

  113.             hints |= NATIVE_PARAMETER_IS_LOGARITHMIC;

  114.             param.name = "Filter";

  115.             param.ranges.def = 0.1f;

  116.             param.ranges.min = 0.02f;

  117.             param.ranges.max = 0.5f;

  118.             break;

  119.         case kParameterR_BIAS:

  120.             param.name = "Bias";

  121.             param.ranges.def = 0.5f;

  122.             param.ranges.min = 0.0f;

  123.             param.ranges.max = 1.0f;

  124.             break;

  125.         case kParameterR_CORR:

  126.             param.name = "Correction";

  127.             param.ranges.def = 1.0f;

  128.             param.ranges.min = 0.0f;

  129.             param.ranges.max = 1.0f;

  130.             break;

  131.         case kParameterR_OFFS:

  132.             param.name = "Offset";

  133.             param.ranges.def = 0.0f;

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

  135.             param.ranges.max = 2.0f;

  136.             break;

  137.         case kParameterM_CHANNEL:

  138.             hints |= NATIVE_PARAMETER_USES_SCALEPOINTS;

  139.             param.name = "MIDI Channel";

  140.             param.ranges.def = 0.0f;

  141.             param.ranges.min = 0.0f;

  142.             param.ranges.max = 16.0f;

  143.             param.scalePointCount = 17;

  144.             param.scalePoints     = scalePoints;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  179.             break;

  180.         }

  181. 

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

  183. 

  184.         return &param;

  185.     }

  186. 

  187.     float getParameterValue(const uint32_t index) const override

  188.     {

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

  190. 

  191.         return fParameters[index];

  192.     }

  193. 

  194.     // -------------------------------------------------------------------

  195.     // Plugin state calls

  196. 

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

  198.     {

  199.         CARLA_SAFE_ASSERT_RETURN(index < kNumParameters,);

  200. 

  201.         fParameters[index] = value;

  202. 

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

  204. 

  205.         switch (index)

  206.         {

  207.         case kParameterR_TUNE:

  208.             retuner->set_refpitch(value);

  209.             break;

  210.         case kParameterR_FILT:

  211.             retuner->set_corrfilt(value);

  212.             break;

  213.         case kParameterR_BIAS:

  214.             retuner->set_notebias(value);

  215.             break;

  216.         case kParameterR_CORR:

  217.             retuner->set_corrgain(value);

  218.             break;

  219.         case kParameterR_OFFS:

  220.             retuner->set_corroffs(value);

  221.             break;

  222.         case kParameterM_CHANNEL:

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

  224.             break;

  225.         }

  226.     }

  227. 

  228.     // -------------------------------------------------------------------

  229.     // Plugin process calls

  230. 

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

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

  233.     {

  234.         if (! fJackClient.active)

  235.         {

  236.             carla_zeroFloats(outBuffer[0], frames);

  237.             return;

  238.         }

  239. 

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

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

  242. 

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

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

  245. 

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

  247.     }

  248. 

  249.     // -------------------------------------------------------------------

  250.     // Plugin UI calls

  251. 

  252.     void uiShow(const bool show) override

  253.     {

  254.         NativePluginAndUiClass::uiShow(show);

  255. 

  256.         if (show && isPipeRunning())

  257.         {

  258.             char tmpBuf[0xff+1];

  259.             tmpBuf[0xff] = '\0';

  260. 

  261.             const CarlaMutexLocker cml(getPipeLock());

  262. 

  263.             writeMessage("zita-mask\n", 10);

  264. 

  265.             std::snprintf(tmpBuf, 0xff, "%i\n", notemask);

  266.             writeMessage(tmpBuf);

  267. 

  268.             flushMessages();

  269.         }

  270.     }

  271. 

  272.     void uiIdle() override

  273.     {

  274.         NativePluginAndUiClass::uiIdle();

  275. 

  276.         if (! isPipeRunning())

  277.             return;

  278. 

  279.         char tmpBuf[0xff+1];

  280.         tmpBuf[0xff] = '\0';

  281. 

  282.         const CarlaMutexLocker cmlc(fClientMutex);

  283.         const CarlaMutexLocker cmlp(getPipeLock());

  284.         const ScopedLocale csl;

  285. 

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

  287. 

  288.         writeMessage("zita-data\n", 10);

  289. 

  290.         std::snprintf(tmpBuf, 0xff, "%f\n", retuner->get_error());

  291.         writeMessage(tmpBuf);

  292. 

  293.         std::snprintf(tmpBuf, 0xff, "%i\n", retuner->get_noteset());

  294.         writeMessage(tmpBuf);

  295. 

  296.         std::snprintf(tmpBuf, 0xff, "%i\n", jclient->get_midiset());

  297.         writeMessage(tmpBuf);

  298. 

  299.         flushMessages();

  300.     }

  301. 

  302.     // -------------------------------------------------------------------

  303.     // Plugin state calls

  304. 

  305.     char* getState() const override

  306.     {

  307.         char tmpBuf[0xff+1];

  308.         tmpBuf[0xff] = '\0';

  309.         std::snprintf(tmpBuf, 0xff, "%i", notemask);

  310. 

  311.         return strdup(tmpBuf);

  312.     }

  313. 

  314.     void setState(const char* const data) override

  315.     {

  316.         CARLA_SAFE_ASSERT_RETURN(data != nullptr && data[0] != '\0',);

  317. 

  318.         notemask = std::atoi(data);

  319. 

  320.         const CarlaMutexLocker cml(fClientMutex);

  321.         jclient->set_notemask(notemask);

  322.     }

  323. 

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

  325.     // Plugin dispatcher calls

  326. 

  327.     void bufferSizeChanged(const uint32_t bufferSize) override

  328.     {

  329.         fJackClient.bufferSize = bufferSize;

  330.         // _recreateZitaClient(); // FIXME

  331.     }

  332. 

  333.     void sampleRateChanged(const double sampleRate) override

  334.     {

  335.         fJackClient.sampleRate = sampleRate;

  336.         // _recreateZitaClient(); // FIXME

  337.     }

  338. 

  339.     // -------------------------------------------------------------------

  340.     // Pipe Server calls

  341. 

  342.     bool msgReceived(const char* const msg) noexcept override

  343.     {

  344.         if (NativePluginAndUiClass::msgReceived(msg))

  345.             return true;

  346. 

  347.         if (std::strcmp(msg, "zita-mask") == 0)

  348.         {

  349.             int mask;

  350. 

  351.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsInt(mask), true);

  352. 

  353.             const CarlaMutexLocker cml(fClientMutex);

  354. 

  355.             try {

  356.                 if (mask < 0)

  357.                 {

  358.                     jclient->clr_midimask();

  359.                 }

  360.                 else

  361.                 {

  362.                     notemask = static_cast<uint>(mask);

  363.                     jclient->set_notemask(mask);

  364.                 }

  365.             } CARLA_SAFE_EXCEPTION("msgReceived, zita-mask");

  366. 

  367.             return true;

  368.         }

  369. 

  370.         return false;

  371.     }

  372. 

  373.     // -------------------------------------------------------------------

  374. 

  375. private:

  376.     // Fake jack client

  377.     jack_client_t fJackClient;

  378. 

  379.     // Zita stuff (core)

  380.     ScopedPointer<Jclient> jclient;

  381.     uint notemask;

  382. 

  383.     // Parameters

  384.     float fParameters[kNumParameters];

  385. 

  386.     // mutex to make sure jclient is always valid

  387.     CarlaMutex fClientMutex;

  388. 

  389.     void _recreateZitaClient()

  390.     {

  391.         const CarlaMutexLocker cml(fClientMutex);

  392. 

  393.         jclient = new Jclient(&fJackClient);

  394.         jclient->set_notemask(notemask);

  395.         jclient->set_midichan(roundToIntAccurate(fParameters[kParameterM_CHANNEL])-1);

  396. 

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

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

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

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

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

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

  403.     }

  404. 

  405.     PluginClassEND(AT1Plugin)

  406.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(AT1Plugin)

  407. };

  408. 

  409. // -----------------------------------------------------------------------

  410. 

  411. static const NativePluginDescriptor at1Desc = {

  412.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  414.                                                   |NATIVE_PLUGIN_HAS_UI

  415.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS

  416.                                                   |NATIVE_PLUGIN_USES_STATE),

  417.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  418.     /* audioIns  */ 1,

  419.     /* audioOuts */ 1,

  420.     /* midiIns   */ 1,

  421.     /* midiOuts  */ 0,

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

  423.     /* paramOuts */ 0,

  424.     /* name      */ "AT1",

  425.     /* label     */ "at1",

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

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

  428.     PluginDescriptorFILL(AT1Plugin)

  429. };

  430. 

  431. // -----------------------------------------------------------------------

  432. 

  433. CARLA_EXPORT

  434. void carla_register_native_plugin_zita_at1();

  435. 

  436. CARLA_EXPORT

  437. void carla_register_native_plugin_zita_at1()

  438. {

  439.     carla_register_native_plugin(&at1Desc);

  440. }

  441. 

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