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-rev1.cpp

578 lines
18KB
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-rev1/guiclass.cc"

  26. #include "zita-rev1/jclient.cc"

  27. #include "zita-rev1/mainwin.cc"

  28. #include "zita-rev1/pareq.cc"

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

  30. #include "zita-rev1/reverb.cc"

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

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

  33. 

  34. using juce::FloatVectorOperations;

  35. using juce::ScopedPointer;

  36. 

  37. using namespace REV1;

  38. 

  39. // -----------------------------------------------------------------------

  40. // REV1 Plugin

  41. 

  42. class REV1Plugin : public NativePluginClass,

  43.                    private Mainwin::ValueChangedCallback

  44. {

  45. public:

  46.     enum Parameters {

  47.         kParameterDELAY,

  48.         kParameterXOVER,

  49.         kParameterRTLOW,

  50.         kParameterRTMID,

  51.         kParameterFDAMP,

  52.         kParameterEQ1FR,

  53.         kParameterEQ1GN,

  54.         kParameterEQ2FR,

  55.         kParameterEQ2GN,

  56.         kParameterOPMIXorRGXYZ,

  57.         kParameterNROTARY

  58.     };

  59. 

  60.     REV1Plugin(const NativeHostDescriptor* const host, const bool isAmbisonic)

  61.         : NativePluginClass(host),

  62.           kIsAmbisonic(isAmbisonic),

  63.           kNumInputs(2),

  64.           kNumOutputs(isAmbisonic ? 4 : 2),

  65.           fJackClient(),

  66.           xresman(),

  67.           jclient(nullptr),

  68.           display(nullptr),

  69.           rootwin(nullptr),

  70.           mainwin(nullptr),

  71.           handler(nullptr),

  72.           handlerThread(),

  73.           leakDetector_REV1Plugin()

  74.     {

  75.         CARLA_SAFE_ASSERT(host != nullptr);

  76. 

  77.         carla_zeroStruct(fJackClient);

  78. 

  79.         fJackClient.clientName = "rev1";

  80.         fJackClient.bufferSize = getBufferSize();

  81.         fJackClient.sampleRate = getSampleRate();

  82. 

  83.         int   argc   = 1;

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

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

  86. 

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

  88. 

  89.         // set initial values

  90.         fParameters[kParameterDELAY] = 0.04f;

  91.         fParameters[kParameterXOVER] = 200.0f;

  92.         fParameters[kParameterRTLOW] = 3.0f;

  93.         fParameters[kParameterRTMID] = 2.0f;

  94.         fParameters[kParameterFDAMP] = 6.0e3;

  95.         fParameters[kParameterEQ1FR] = 160.0f;

  96.         fParameters[kParameterEQ1GN] = 0.0f;

  97.         fParameters[kParameterEQ2FR] = 2.5e3;

  98.         fParameters[kParameterEQ2GN] = 0.0f;

  99. 

  100.         if (isAmbisonic)

  101.             fParameters[kParameterOPMIXorRGXYZ] = 0.0f;

  102.         else

  103.             fParameters[kParameterOPMIXorRGXYZ] = 0.5f;

  104. 

  105.         Reverb* const reverb(jclient->reverb());

  106. 

  107.         reverb->set_delay(fParameters[kParameterDELAY]);

  108.         reverb->set_xover(fParameters[kParameterXOVER]);

  109.         reverb->set_rtlow(fParameters[kParameterRTLOW]);

  110.         reverb->set_rtmid(fParameters[kParameterRTMID]);

  111.         reverb->set_fdamp(fParameters[kParameterFDAMP]);

  112. 

  113.         if (isAmbisonic)

  114.         {

  115.             reverb->set_opmix(0.5);

  116.             reverb->set_rgxyz(fParameters[kParameterOPMIXorRGXYZ]);

  117.         }

  118.         else

  119.         {

  120.             reverb->set_opmix(fParameters[kParameterOPMIXorRGXYZ]);

  121.             reverb->set_rgxyz(0.0);

  122.         }

  123. 

  124.         reverb->set_eq1(fParameters[kParameterEQ1FR], fParameters[kParameterEQ1GN]);

  125.         reverb->set_eq2(fParameters[kParameterEQ2FR], fParameters[kParameterEQ2GN]);

  126.     }

  127. 

  128.     // -------------------------------------------------------------------

  129.     // Plugin parameter calls

  130. 

  131.     uint32_t getParameterCount() const override

  132.     {

  133.         return kParameterNROTARY;

  134.     }

  135. 

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

  137.     {

  138.         CARLA_SAFE_ASSERT_RETURN(index < kParameterNROTARY, nullptr);

  139. 

  140.         static NativeParameter param;

  141. 

  142.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_AUTOMABLE;

  143. 

  144.         // reset

  145.         param.name = nullptr;

  146.         param.unit = nullptr;

  147.         param.ranges.def       = 0.0f;

  148.         param.ranges.min       = 0.0f;

  149.         param.ranges.max       = 1.0f;

  150.         param.ranges.step      = 1.0f;

  151.         param.ranges.stepSmall = 1.0f;

  152.         param.ranges.stepLarge = 1.0f;

  153.         param.scalePointCount  = 0;

  154.         param.scalePoints      = nullptr;

  155. 

  156.         switch (index)

  157.         {

  158.         case kParameterDELAY:

  159.             param.name = "Delay";

  160.             param.ranges.def = 0.04f;

  161.             param.ranges.min = 0.02f;

  162.             param.ranges.max = 0.100f;

  163.             break;

  164.         case kParameterXOVER:

  165.             hints |= NATIVE_PARAMETER_IS_LOGARITHMIC;

  166.             param.name = "Crossover";

  167.             param.ranges.def = 200.0f;

  168.             param.ranges.min = 50.0f;

  169.             param.ranges.max = 1000.0f;

  170.             break;

  171.         case kParameterRTLOW:

  172.             hints |= NATIVE_PARAMETER_IS_LOGARITHMIC;

  173.             param.name = "RT60 Low";

  174.             param.ranges.def = 3.0f;

  175.             param.ranges.min = 1.0f;

  176.             param.ranges.max = 8.0f;

  177.             break;

  178.         case kParameterRTMID:

  179.             hints |= NATIVE_PARAMETER_IS_LOGARITHMIC;

  180.             param.name = "RT60 Mid";

  181.             param.ranges.def = 2.0f;

  182.             param.ranges.min = 1.0f;

  183.             param.ranges.max = 8.0f;

  184.             break;

  185.         case kParameterFDAMP:

  186.             hints |= NATIVE_PARAMETER_IS_LOGARITHMIC;

  187.             param.name = "HF Damping";

  188.             param.ranges.def = 6.0e3;

  189.             param.ranges.min = 1.5e3;

  190.             param.ranges.max = 24.0e3;

  191.             break;

  192.         case kParameterEQ1FR:

  193.             hints |= NATIVE_PARAMETER_IS_LOGARITHMIC;

  194.             param.name = "Eq1 Frequency";

  195.             param.ranges.def = 160.0f;

  196.             param.ranges.min = 40.0f;

  197.             param.ranges.max = 2.5e3;

  198.             break;

  199.         case kParameterEQ1GN:

  200.             param.name = "Eq1 Gain";

  201.             param.ranges.def = 0.0f;

  202.             param.ranges.min = -15.0;

  203.             param.ranges.max = 15.0f;

  204.             break;

  205.         case kParameterEQ2FR:

  206.             hints |= NATIVE_PARAMETER_IS_LOGARITHMIC;

  207.             param.name = "Eq2 Frequency";

  208.             param.ranges.def = 2.5e3;

  209.             param.ranges.min = 160.0;

  210.             param.ranges.max = 10e3;

  211.             break;

  212.         case kParameterEQ2GN:

  213.             param.name = "Eq2 Gain";

  214.             param.ranges.def = 0.0f;

  215.             param.ranges.min = -15.0;

  216.             param.ranges.max = 15.0f;

  217.             break;

  218.         case kParameterOPMIXorRGXYZ:

  219.             if (kIsAmbisonic)

  220.             {

  221.                 param.name = "XYZ gain";

  222.                 param.ranges.def = 0.0f;

  223.                 param.ranges.min = -9.0f;

  224.                 param.ranges.max = 9.0f;

  225.             }

  226.             else

  227.             {

  228.                 param.name = "Dry/wet mix";

  229.                 param.ranges.def = 0.5f;

  230.                 param.ranges.min = 0.0f;

  231.                 param.ranges.max = 1.0f;

  232.             }

  233.             break;

  234.         }

  235. 

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

  237. 

  238.         return &param;

  239.     }

  240. 

  241.     float getParameterValue(const uint32_t index) const override

  242.     {

  243.         CARLA_SAFE_ASSERT_RETURN(index < kParameterNROTARY, 0.0f);

  244. 

  245.         return fParameters[index];

  246.     }

  247. 

  248.     // -------------------------------------------------------------------

  249.     // Plugin state calls

  250. 

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

  252.     {

  253.         CARLA_SAFE_ASSERT_RETURN(index < kParameterNROTARY,);

  254. 

  255.         Reverb* const reverb(jclient->reverb());

  256. 

  257.         fParameters[index] = value;

  258. 

  259.         switch (index)

  260.         {

  261.         case kParameterDELAY:

  262.             reverb->set_delay(value);

  263.             break;

  264.         case kParameterXOVER:

  265.             reverb->set_xover(value);

  266.             break;

  267.         case kParameterRTLOW:

  268.             reverb->set_rtlow(value);

  269.             break;

  270.         case kParameterRTMID:

  271.             reverb->set_rtmid(value);

  272.             break;

  273.         case kParameterFDAMP:

  274.             reverb->set_fdamp(value);

  275.             break;

  276.         case kParameterEQ1FR:

  277.             reverb->set_eq1(value, fParameters[kParameterEQ1GN]);

  278.             break;

  279.         case kParameterEQ1GN:

  280.             reverb->set_eq1(fParameters[kParameterEQ1FR], value);

  281.             break;

  282.         case kParameterEQ2FR:

  283.             reverb->set_eq2(value, fParameters[kParameterEQ2GN]);

  284.             break;

  285.         case kParameterEQ2GN:

  286.             reverb->set_eq2(fParameters[kParameterEQ2FR], value);

  287.             break;

  288.         case kParameterOPMIXorRGXYZ:

  289.             if (kIsAmbisonic)

  290.                 reverb->set_rgxyz(value);

  291.             else

  292.                 reverb->set_opmix(value);

  293.             break;

  294.         }

  295.     }

  296. 

  297.     // -------------------------------------------------------------------

  298.     // Plugin process calls

  299. 

  300.     void process(float** const inBuffer, float** const outBuffer, const uint32_t frames, const NativeMidiEvent* const, const uint32_t) override

  301.     {

  302.         if (! fJackClient.active)

  303.         {

  304.             const int iframes(static_cast<int>(frames));

  305. 

  306.             for (uint32_t i=0; i<kNumInputs; ++i)

  307.                 FloatVectorOperations::clear(outBuffer[i], iframes);

  308. 

  309.             return;

  310.         }

  311. 

  312.         for (uint32_t i=0; i<kNumInputs; ++i)

  313.             fJackClient.portsAudioIn[i].buffer.audio = inBuffer[i];

  314. 

  315.         for (uint32_t i=0; i<kNumOutputs; ++i)

  316.             fJackClient.portsAudioOut[i].buffer.audio = outBuffer[i];

  317. 

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

  319.     }

  320. 

  321.     // -------------------------------------------------------------------

  322.     // Plugin UI calls

  323. 

  324.     void uiShow(const bool show) override

  325.     {

  326.         if (show)

  327.         {

  328.             if (display != nullptr)

  329.                 return;

  330. 

  331.             display = new X_display(nullptr);

  332. 

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

  334.                 return hostUiUnavailable();

  335. 

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

  337. 

  338.             rootwin = new X_rootwin(display);

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

  340.             rootwin->handle_event();

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

  342. 

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

  344. 

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

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

  347. 

  348.             handler->next_event();

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

  350. 

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

  352.         }

  353.         else

  354.         {

  355.             if (handlerThread.isThreadRunning())

  356.                 handlerThread.stopThread();

  357. 

  358.             handler = nullptr;

  359.             mainwin = nullptr;

  360.             rootwin = nullptr;

  361.             display = nullptr;

  362.         }

  363.     }

  364. 

  365.     void uiIdle() override

  366.     {

  367.         if (mainwin == nullptr)

  368.             return;

  369. 

  370.         if (handlerThread.wasClosed())

  371.         {

  372.             {

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

  374.                 handler = nullptr;

  375.                 mainwin = nullptr;

  376.                 rootwin = nullptr;

  377.                 display = nullptr;

  378.             }

  379.             uiClosed();

  380.         }

  381.     }

  382. 

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

  384.     {

  385.         CARLA_SAFE_ASSERT_RETURN(index < kParameterNROTARY,);

  386. 

  387.         if (mainwin == nullptr)

  388.             return;

  389. 

  390.         uint32_t rindex = index;

  391. 

  392.         if (kIsAmbisonic && index == kParameterOPMIXorRGXYZ)

  393.             rindex += 1;

  394. 

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

  396. 

  397.         mainwin->_rotary[rindex]->set_value(value);

  398.     }

  399. 

  400.     // -------------------------------------------------------------------

  401.     // Plugin dispatcher calls

  402. 

  403.     void bufferSizeChanged(const uint32_t bufferSize) override

  404.     {

  405.         fJackClient.bufferSize = bufferSize;

  406.     }

  407. 

  408.     void sampleRateChanged(const double sampleRate) override

  409.     {

  410.         fJackClient.sampleRate = sampleRate;

  411.     }

  412. 

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

  414.     {

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

  416. 

  417.         if (mainwin == nullptr)

  418.             return;

  419. 

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

  421. 

  422.         mainwin->x_set_title(uiName);

  423.     }

  424. 

  425.     // -------------------------------------------------------------------

  426.     // Mainwin callbacks

  427. 

  428.     void valueChangedCallback(uint rindex, double value) override

  429.     {

  430.         uint32_t index = rindex;

  431. 

  432.         if (kIsAmbisonic && rindex == Mainwin::NROTARY)

  433.             index = kParameterOPMIXorRGXYZ;

  434. 

  435.         fParameters[index] = value;

  436.         uiParameterChanged(index, value);

  437.     }

  438. 

  439.     // -------------------------------------------------------------------

  440. 

  441. private:

  442.     const bool     kIsAmbisonic;

  443.     const uint32_t kNumInputs;

  444.     const uint32_t kNumOutputs;

  445. 

  446.     // Fake jack client

  447.     jack_client_t fJackClient;

  448. 

  449.     // Zita stuff (core)

  450.     X_resman xresman;

  451.     ScopedPointer<Jclient>   jclient;

  452.     ScopedPointer<X_display> display;

  453.     ScopedPointer<X_rootwin> rootwin;

  454.     ScopedPointer<Mainwin>   mainwin;

  455.     ScopedPointer<X_handler> handler;

  456.     X_handler_thread<Mainwin> handlerThread;

  457. 

  458.     float fParameters[kParameterNROTARY];

  459. 

  460. public:

  461.     static NativePluginHandle _instantiateAmbisonic(const NativeHostDescriptor* host)

  462.     {

  463.         return (host != nullptr) ? new REV1Plugin(host, true) : nullptr;

  464.     }

  465. 

  466.     static NativePluginHandle _instantiateStereo(const NativeHostDescriptor* host)

  467.     {

  468.         return (host != nullptr) ? new REV1Plugin(host, false) : nullptr;

  469.     }

  470. 

  471.     static void _cleanup(NativePluginHandle handle)

  472.     {

  473.         delete (REV1Plugin*)handle;

  474.     }

  475. 

  476.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(REV1Plugin)

  477. };

  478. 

  479. // -----------------------------------------------------------------------

  480. 

  481. static const NativePluginDescriptor rev1AmbisonicDesc = {

  482.     /* category  */ NATIVE_PLUGIN_CATEGORY_DELAY,

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

  484.                                                   |NATIVE_PLUGIN_HAS_UI

  485.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS

  486.                                                   |NATIVE_PLUGIN_NEEDS_UI_MAIN_THREAD

  487.                                                   |NATIVE_PLUGIN_USES_PARENT_ID),

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

  489.     /* audioIns  */ 2,

  490.     /* audioOuts */ 4,

  491.     /* midiIns   */ 0,

  492.     /* midiOuts  */ 0,

  493.     /* paramIns  */ REV1Plugin::kParameterNROTARY,

  494.     /* paramOuts */ 0,

  495.     /* name      */ "REV1 (Ambisonic)",

  496.     /* label     */ "rev1-ambisonic",

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

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

  499.     REV1Plugin::_instantiateAmbisonic,

  500.     REV1Plugin::_cleanup,

  501.     REV1Plugin::_get_parameter_count,

  502.     REV1Plugin::_get_parameter_info,

  503.     REV1Plugin::_get_parameter_value,

  504.     REV1Plugin::_get_parameter_text,

  505.     REV1Plugin::_get_midi_program_count,

  506.     REV1Plugin::_get_midi_program_info,

  507.     REV1Plugin::_set_parameter_value,

  508.     REV1Plugin::_set_midi_program,

  509.     REV1Plugin::_set_custom_data,

  510.     REV1Plugin::_ui_show,

  511.     REV1Plugin::_ui_idle,

  512.     REV1Plugin::_ui_set_parameter_value,

  513.     REV1Plugin::_ui_set_midi_program,

  514.     REV1Plugin::_ui_set_custom_data,

  515.     REV1Plugin::_activate,

  516.     REV1Plugin::_deactivate,

  517.     REV1Plugin::_process,

  518.     REV1Plugin::_get_state,

  519.     REV1Plugin::_set_state,

  520.     REV1Plugin::_dispatcher

  521. };

  522. 

  523. static const NativePluginDescriptor rev1StereoDesc = {

  524.     /* category  */ NATIVE_PLUGIN_CATEGORY_DELAY,

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

  526.                                                   |NATIVE_PLUGIN_HAS_UI

  527.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS

  528.                                                   |NATIVE_PLUGIN_NEEDS_UI_MAIN_THREAD

  529.                                                   |NATIVE_PLUGIN_USES_PARENT_ID),

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

  531.     /* audioIns  */ 2,

  532.     /* audioOuts */ 2,

  533.     /* midiIns   */ 0,

  534.     /* midiOuts  */ 0,

  535.     /* paramIns  */ REV1Plugin::kParameterNROTARY,

  536.     /* paramOuts */ 0,

  537.     /* name      */ "REV1 (Stereo)",

  538.     /* label     */ "rev1-stereo",

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

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

  541.     REV1Plugin::_instantiateStereo,

  542.     REV1Plugin::_cleanup,

  543.     REV1Plugin::_get_parameter_count,

  544.     REV1Plugin::_get_parameter_info,

  545.     REV1Plugin::_get_parameter_value,

  546.     REV1Plugin::_get_parameter_text,

  547.     REV1Plugin::_get_midi_program_count,

  548.     REV1Plugin::_get_midi_program_info,

  549.     REV1Plugin::_set_parameter_value,

  550.     REV1Plugin::_set_midi_program,

  551.     REV1Plugin::_set_custom_data,

  552.     REV1Plugin::_ui_show,

  553.     REV1Plugin::_ui_idle,

  554.     REV1Plugin::_ui_set_parameter_value,

  555.     REV1Plugin::_ui_set_midi_program,

  556.     REV1Plugin::_ui_set_custom_data,

  557.     REV1Plugin::_activate,

  558.     REV1Plugin::_deactivate,

  559.     REV1Plugin::_process,

  560.     REV1Plugin::_get_state,

  561.     REV1Plugin::_set_state,

  562.     REV1Plugin::_dispatcher

  563. };

  564. 

  565. // -----------------------------------------------------------------------

  566. 

  567. CARLA_EXPORT

  568. void carla_register_native_plugin_zita_rev1();

  569. 

  570. CARLA_EXPORT

  571. void carla_register_native_plugin_zita_rev1()

  572. {

  573.     carla_register_native_plugin(&rev1AmbisonicDesc);

  574.     carla_register_native_plugin(&rev1StereoDesc);

  575. }

  576. 

  577. // -----------------------------------------------------------------------