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.
3059 Commits
16 Branches
14GB
Tree: 41a0cfaf8e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '41a0cfaf8e'
${ noResults }
Carla/source/native-plugins/zita-at1.cpp

445 lines
13KB
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 "CarlaNativeExtUI.hpp"

  19. #include "CarlaJuceUtils.hpp"

  20. 

  21. #include "juce_audio_basics.h"

  22. 

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

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

  25. 

  26. using juce::roundToIntAccurate;

  27. using juce::FloatVectorOperations;

  28. using juce::ScopedPointer;

  29. 

  30. using namespace AT1;

  31. 

  32. // -----------------------------------------------------------------------

  33. // AT1 Plugin

  34. 

  35. class AT1Plugin : public NativePluginAndUiClass

  36. {

  37. public:

  38.     enum Parameters {

  39.         // rotary knobs

  40.         kParameterR_TUNE,

  41.         kParameterR_FILT,

  42.         kParameterR_BIAS,

  43.         kParameterR_CORR,

  44.         kParameterR_OFFS,

  45.         // knob count

  46.         kParameterNROTARY,

  47.         // midi channel

  48.         kParameterM_CHANNEL = kParameterNROTARY,

  49.         // final count

  50.         kNumParameters

  51.     };

  52. 

  53.     AT1Plugin(const NativeHostDescriptor* const host)

  54.         : NativePluginAndUiClass(host, "at1-ui"),

  55.           fJackClient(),

  56.           jclient(nullptr),

  57.           notemask(0xfff)

  58.     {

  59.         CARLA_SAFE_ASSERT(host != nullptr);

  60. 

  61.         carla_zeroStruct(fJackClient);

  62. 

  63.         fJackClient.bufferSize = getBufferSize();

  64.         fJackClient.sampleRate = getSampleRate();

  65. 

  66.         // set initial values

  67.         fParameters[kParameterR_TUNE] = 440.0f;

  68.         fParameters[kParameterR_FILT] = 0.1f;

  69.         fParameters[kParameterR_BIAS] = 0.5f;

  70.         fParameters[kParameterR_CORR] = 1.0f;

  71.         fParameters[kParameterR_OFFS] = 0.0f;

  72.         fParameters[kParameterM_CHANNEL] = 0.0f;

  73. 

  74.         _recreateZitaClient();

  75.     }

  76. 

  77.     // -------------------------------------------------------------------

  78.     // Plugin parameter calls

  79. 

  80.     uint32_t getParameterCount() const override

  81.     {

  82.         return kNumParameters;

  83.     }

  84. 

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

  86.     {

  87.         CARLA_SAFE_ASSERT_RETURN(index < kNumParameters, nullptr);

  88. 

  89.         static NativeParameter param;

  90.         static NativeParameterScalePoint scalePoints[17];

  91. 

  92.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_AUTOMABLE;

  93. 

  94.         // reset

  95.         param.name = nullptr;

  96.         param.unit = nullptr;

  97.         param.ranges.def       = 0.0f;

  98.         param.ranges.min       = 0.0f;

  99.         param.ranges.max       = 1.0f;

  100.         param.ranges.step      = 1.0f;

  101.         param.ranges.stepSmall = 1.0f;

  102.         param.ranges.stepLarge = 1.0f;

  103.         param.scalePointCount  = 0;

  104.         param.scalePoints      = nullptr;

  105. 

  106.         switch (index)

  107.         {

  108.         case kParameterR_TUNE:

  109.             param.name = "Tuning";

  110.             param.ranges.def = 440.0f;

  111.             param.ranges.min = 400.0f;

  112.             param.ranges.max = 480.0f;

  113.             break;

  114.         case kParameterR_FILT:

  115.             hints |= NATIVE_PARAMETER_IS_LOGARITHMIC;

  116.             param.name = "Filter";

  117.             param.ranges.def = 0.1f;

  118.             param.ranges.min = 0.02f;

  119.             param.ranges.max = 0.5f;

  120.             break;

  121.         case kParameterR_BIAS:

  122.             param.name = "Bias";

  123.             param.ranges.def = 0.5f;

  124.             param.ranges.min = 0.0f;

  125.             param.ranges.max = 1.0f;

  126.             break;

  127.         case kParameterR_CORR:

  128.             param.name = "Correction";

  129.             param.ranges.def = 1.0f;

  130.             param.ranges.min = 0.0f;

  131.             param.ranges.max = 1.0f;

  132.             break;

  133.         case kParameterR_OFFS:

  134.             param.name = "Offset";

  135.             param.ranges.def = 0.0f;

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

  137.             param.ranges.max = 2.0f;

  138.             break;

  139.         case kParameterM_CHANNEL:

  140.             hints |= NATIVE_PARAMETER_USES_SCALEPOINTS;

  141.             param.name = "MIDI Channel";

  142.             param.ranges.def = 0.0f;

  143.             param.ranges.min = 0.0f;

  144.             param.ranges.max = 16.0f;

  145.             param.scalePointCount = 17;

  146.             param.scalePoints     = scalePoints;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  181.             break;

  182.         }

  183. 

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

  185. 

  186.         return &param;

  187.     }

  188. 

  189.     float getParameterValue(const uint32_t index) const override

  190.     {

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

  192. 

  193.         return fParameters[index];

  194.     }

  195. 

  196.     // -------------------------------------------------------------------

  197.     // Plugin state calls

  198. 

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

  200.     {

  201.         CARLA_SAFE_ASSERT_RETURN(index < kNumParameters,);

  202. 

  203.         fParameters[index] = value;

  204. 

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

  206. 

  207.         switch (index)

  208.         {

  209.         case kParameterR_TUNE:

  210.             retuner->set_refpitch(value);

  211.             break;

  212.         case kParameterR_FILT:

  213.             retuner->set_corrfilt(value);

  214.             break;

  215.         case kParameterR_BIAS:

  216.             retuner->set_notebias(value);

  217.             break;

  218.         case kParameterR_CORR:

  219.             retuner->set_corrgain(value);

  220.             break;

  221.         case kParameterR_OFFS:

  222.             retuner->set_corroffs(value);

  223.             break;

  224.         case kParameterM_CHANNEL:

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

  226.             break;

  227.         }

  228.     }

  229. 

  230.     // -------------------------------------------------------------------

  231.     // Plugin process calls

  232. 

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

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

  235.     {

  236.         if (! fJackClient.active)

  237.         {

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

  239.             return;

  240.         }

  241. 

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

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

  244. 

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

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

  247. 

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

  249.     }

  250. 

  251.     // -------------------------------------------------------------------

  252.     // Plugin UI calls

  253. 

  254.     void uiShow(const bool show) override

  255.     {

  256.         NativePluginAndUiClass::uiShow(show);

  257. 

  258.         if (show && isPipeRunning())

  259.         {

  260.             char tmpBuf[0xff+1];

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

  262. 

  263.             const CarlaMutexLocker cml(getPipeLock());

  264. 

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

  266. 

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

  268.             writeMessage(tmpBuf);

  269. 

  270.             flushMessages();

  271.         }

  272.     }

  273. 

  274.     void uiIdle() override

  275.     {

  276.         NativePluginAndUiClass::uiIdle();

  277. 

  278.         if (! isPipeRunning())

  279.             return;

  280. 

  281.         char tmpBuf[0xff+1];

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

  283. 

  284.         const CarlaMutexLocker cmlc(fClientMutex);

  285.         const CarlaMutexLocker cmlp(getPipeLock());

  286.         const ScopedLocale csl;

  287. 

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

  289. 

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

  291. 

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

  293.         writeMessage(tmpBuf);

  294. 

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

  296.         writeMessage(tmpBuf);

  297. 

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

  299.         writeMessage(tmpBuf);

  300. 

  301.         flushMessages();

  302.     }

  303. 

  304.     // -------------------------------------------------------------------

  305.     // Plugin state calls

  306. 

  307.     char* getState() const override

  308.     {

  309.         char tmpBuf[0xff+1];

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

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

  312. 

  313.         return strdup(tmpBuf);

  314.     }

  315. 

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

  317.     {

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

  319. 

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

  321. 

  322.         const CarlaMutexLocker cml(fClientMutex);

  323.         jclient->set_notemask(notemask);

  324.     }

  325. 

  326.     // -------------------------------------------------------------------

  327.     // Plugin dispatcher calls

  328. 

  329.     void bufferSizeChanged(const uint32_t bufferSize) override

  330.     {

  331.         fJackClient.bufferSize = bufferSize;

  332.         // _recreateZitaClient(); // FIXME

  333.     }

  334. 

  335.     void sampleRateChanged(const double sampleRate) override

  336.     {

  337.         fJackClient.sampleRate = sampleRate;

  338.         // _recreateZitaClient(); // FIXME

  339.     }

  340. 

  341.     // -------------------------------------------------------------------

  342.     // Pipe Server calls

  343. 

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

  345.     {

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

  347.             return true;

  348. 

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

  350.         {

  351.             int mask;

  352. 

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

  354. 

  355.             const CarlaMutexLocker cml(fClientMutex);

  356. 

  357.             try {

  358.                 if (mask < 0)

  359.                 {

  360.                     jclient->clr_midimask();

  361.                 }

  362.                 else

  363.                 {

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

  365.                     jclient->set_notemask(mask);

  366.                 }

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

  368. 

  369.             return true;

  370.         }

  371. 

  372.         return false;

  373.     }

  374. 

  375.     // -------------------------------------------------------------------

  376. 

  377. private:

  378.     // Fake jack client

  379.     jack_client_t fJackClient;

  380. 

  381.     // Zita stuff (core)

  382.     ScopedPointer<Jclient> jclient;

  383.     uint notemask;

  384. 

  385.     // Parameters

  386.     float fParameters[kNumParameters];

  387. 

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

  389.     CarlaMutex fClientMutex;

  390. 

  391.     void _recreateZitaClient()

  392.     {

  393.         const CarlaMutexLocker cml(fClientMutex);

  394. 

  395.         jclient = new Jclient(&fJackClient);

  396.         jclient->set_notemask(notemask);

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

  398. 

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

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

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

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

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

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

  405.     }

  406. 

  407.     PluginClassEND(AT1Plugin)

  408.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(AT1Plugin)

  409. };

  410. 

  411. // -----------------------------------------------------------------------

  412. 

  413. static const NativePluginDescriptor at1Desc = {

  414.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  416.                                                   |NATIVE_PLUGIN_HAS_UI

  417.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS

  418.                                                   |NATIVE_PLUGIN_USES_STATE),

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

  420.     /* audioIns  */ 1,

  421.     /* audioOuts */ 1,

  422.     /* midiIns   */ 1,

  423.     /* midiOuts  */ 0,

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

  425.     /* paramOuts */ 0,

  426.     /* name      */ "AT1",

  427.     /* label     */ "at1",

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

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

  430.     PluginDescriptorFILL(AT1Plugin)

  431. };

  432. 

  433. // -----------------------------------------------------------------------

  434. 

  435. CARLA_EXPORT

  436. void carla_register_native_plugin_zita_at1();

  437. 

  438. CARLA_EXPORT

  439. void carla_register_native_plugin_zita_at1()

  440. {

  441.     carla_register_native_plugin(&at1Desc);

  442. }

  443. 

  444. // -----------------------------------------------------------------------