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

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

  44.                    private Mainwin::ValueChangedCallback

  45. {

  46. public:

  47.     enum Parameters {

  48.         kParameterDELAY,

  49.         kParameterXOVER,

  50.         kParameterRTLOW,

  51.         kParameterRTMID,

  52.         kParameterFDAMP,

  53.         kParameterEQ1FR,

  54.         kParameterEQ1GN,

  55.         kParameterEQ2FR,

  56.         kParameterEQ2GN,

  57.         kParameterOPMIXorRGXYZ,

  58.         kParameterNROTARY

  59.     };

  60. 

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

  62.         : NativePluginClass(host),

  63.           kIsAmbisonic(isAmbisonic),

  64.           kNumInputs(2),

  65.           kNumOutputs(isAmbisonic ? 4 : 2),

  66.           fJackClient(),

  67.           xresman(),

  68.           jclient(nullptr),

  69.           display(nullptr),

  70.           rootwin(nullptr),

  71.           mainwin(nullptr),

  72.           handler(nullptr),

  73.           handlerThread(this),

  74.           leakDetector_REV1Plugin()

  75.     {

  76.         CARLA_SAFE_ASSERT(host != nullptr);

  77. 

  78.         carla_zeroStruct(fJackClient);

  79. 

  80.         fJackClient.clientName = "rev1";

  81.         fJackClient.bufferSize = getBufferSize();

  82.         fJackClient.sampleRate = getSampleRate();

  83. 

  84.         int   argc   = 1;

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

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

  87. 

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

  89. 

  90.         // set initial values

  91.         fParameters[kParameterDELAY] = 0.04f;

  92.         fParameters[kParameterXOVER] = 200.0f;

  93.         fParameters[kParameterRTLOW] = 3.0f;

  94.         fParameters[kParameterRTMID] = 2.0f;

  95.         fParameters[kParameterFDAMP] = 6.0e3;

  96.         fParameters[kParameterEQ1FR] = 160.0f;

  97.         fParameters[kParameterEQ1GN] = 0.0f;

  98.         fParameters[kParameterEQ2FR] = 2.5e3;

  99.         fParameters[kParameterEQ2GN] = 0.0f;

  100. 

  101.         if (isAmbisonic)

  102.             fParameters[kParameterOPMIXorRGXYZ] = 0.0f;

  103.         else

  104.             fParameters[kParameterOPMIXorRGXYZ] = 0.5f;

  105. 

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

  107. 

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

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

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

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

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

  113. 

  114.         if (isAmbisonic)

  115.         {

  116.             reverb->set_opmix(0.5);

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

  118.         }

  119.         else

  120.         {

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

  122.             reverb->set_rgxyz(0.0);

  123.         }

  124. 

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

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

  127.     }

  128. 

  129.     // -------------------------------------------------------------------

  130.     // Plugin parameter calls

  131. 

  132.     uint32_t getParameterCount() const override

  133.     {

  134.         return kParameterNROTARY;

  135.     }

  136. 

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

  138.     {

  139.         CARLA_SAFE_ASSERT_RETURN(index < kParameterNROTARY, nullptr);

  140. 

  141.         static NativeParameter param;

  142. 

  143.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_AUTOMABLE;

  144. 

  145.         // reset

  146.         param.name = nullptr;

  147.         param.unit = nullptr;

  148.         param.ranges.def       = 0.0f;

  149.         param.ranges.min       = 0.0f;

  150.         param.ranges.max       = 1.0f;

  151.         param.ranges.step      = 1.0f;

  152.         param.ranges.stepSmall = 1.0f;

  153.         param.ranges.stepLarge = 1.0f;

  154.         param.scalePointCount  = 0;

  155.         param.scalePoints      = nullptr;

  156. 

  157.         switch (index)

  158.         {

  159.         case kParameterDELAY:

  160.             param.name = "Delay";

  161.             param.ranges.def = 0.04f;

  162.             param.ranges.min = 0.02f;

  163.             param.ranges.max = 0.100f;

  164.             break;

  165.         case kParameterXOVER:

  166.             hints |= NATIVE_PARAMETER_IS_LOGARITHMIC;

  167.             param.name = "Crossover";

  168.             param.ranges.def = 200.0f;

  169.             param.ranges.min = 50.0f;

  170.             param.ranges.max = 1000.0f;

  171.             break;

  172.         case kParameterRTLOW:

  173.             hints |= NATIVE_PARAMETER_IS_LOGARITHMIC;

  174.             param.name = "RT60 Low";

  175.             param.ranges.def = 3.0f;

  176.             param.ranges.min = 1.0f;

  177.             param.ranges.max = 8.0f;

  178.             break;

  179.         case kParameterRTMID:

  180.             hints |= NATIVE_PARAMETER_IS_LOGARITHMIC;

  181.             param.name = "RT60 Mid";

  182.             param.ranges.def = 2.0f;

  183.             param.ranges.min = 1.0f;

  184.             param.ranges.max = 8.0f;

  185.             break;

  186.         case kParameterFDAMP:

  187.             hints |= NATIVE_PARAMETER_IS_LOGARITHMIC;

  188.             param.name = "HF Damping";

  189.             param.ranges.def = 6.0e3;

  190.             param.ranges.min = 1.5e3;

  191.             param.ranges.max = 24.0e3;

  192.             break;

  193.         case kParameterEQ1FR:

  194.             hints |= NATIVE_PARAMETER_IS_LOGARITHMIC;

  195.             param.name = "Eq1 Frequency";

  196.             param.ranges.def = 160.0f;

  197.             param.ranges.min = 40.0f;

  198.             param.ranges.max = 2.5e3;

  199.             break;

  200.         case kParameterEQ1GN:

  201.             param.name = "Eq1 Gain";

  202.             param.ranges.def = 0.0f;

  203.             param.ranges.min = -15.0;

  204.             param.ranges.max = 15.0f;

  205.             break;

  206.         case kParameterEQ2FR:

  207.             hints |= NATIVE_PARAMETER_IS_LOGARITHMIC;

  208.             param.name = "Eq2 Frequency";

  209.             param.ranges.def = 2.5e3;

  210.             param.ranges.min = 160.0;

  211.             param.ranges.max = 10e3;

  212.             break;

  213.         case kParameterEQ2GN:

  214.             param.name = "Eq2 Gain";

  215.             param.ranges.def = 0.0f;

  216.             param.ranges.min = -15.0;

  217.             param.ranges.max = 15.0f;

  218.             break;

  219.         case kParameterOPMIXorRGXYZ:

  220.             if (kIsAmbisonic)

  221.             {

  222.                 param.name = "XYZ gain";

  223.                 param.ranges.def = 0.0f;

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

  225.                 param.ranges.max = 9.0f;

  226.             }

  227.             else

  228.             {

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

  230.                 param.ranges.def = 0.5f;

  231.                 param.ranges.min = 0.0f;

  232.                 param.ranges.max = 1.0f;

  233.             }

  234.             break;

  235.         }

  236. 

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

  238. 

  239.         return &param;

  240.     }

  241. 

  242.     float getParameterValue(const uint32_t index) const override

  243.     {

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

  245. 

  246.         return fParameters[index];

  247.     }

  248. 

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

  250.     // Plugin state calls

  251. 

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

  253.     {

  254.         CARLA_SAFE_ASSERT_RETURN(index < kParameterNROTARY,);

  255. 

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

  257. 

  258.         fParameters[index] = value;

  259. 

  260.         switch (index)

  261.         {

  262.         case kParameterDELAY:

  263.             reverb->set_delay(value);

  264.             break;

  265.         case kParameterXOVER:

  266.             reverb->set_xover(value);

  267.             break;

  268.         case kParameterRTLOW:

  269.             reverb->set_rtlow(value);

  270.             break;

  271.         case kParameterRTMID:

  272.             reverb->set_rtmid(value);

  273.             break;

  274.         case kParameterFDAMP:

  275.             reverb->set_fdamp(value);

  276.             break;

  277.         case kParameterEQ1FR:

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

  279.             break;

  280.         case kParameterEQ1GN:

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

  282.             break;

  283.         case kParameterEQ2FR:

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

  285.             break;

  286.         case kParameterEQ2GN:

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

  288.             break;

  289.         case kParameterOPMIXorRGXYZ:

  290.             if (kIsAmbisonic)

  291.                 reverb->set_rgxyz(value);

  292.             else

  293.                 reverb->set_opmix(value);

  294.             break;

  295.         }

  296.     }

  297. 

  298.     // -------------------------------------------------------------------

  299.     // Plugin process calls

  300. 

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

  302.     {

  303.         if (! fJackClient.active)

  304.         {

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

  306. 

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

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

  309. 

  310.             return;

  311.         }

  312. 

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

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

  315. 

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

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

  318. 

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

  320.     }

  321. 

  322.     // -------------------------------------------------------------------

  323.     // Plugin UI calls

  324. 

  325.     void uiShow(const bool show) override

  326.     {

  327.         if (show)

  328.         {

  329.             if (display != nullptr)

  330.                 return;

  331. 

  332.             display = new X_display(nullptr);

  333. 

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

  335.                 return hostUiUnavailable();

  336. 

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

  338. 

  339.             rootwin = new X_rootwin(display);

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

  341.             rootwin->handle_event();

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

  343. 

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

  345. 

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

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

  348. 

  349.             handler->next_event();

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

  351. 

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

  353.         }

  354.         else

  355.         {

  356.             if (handlerThread.isThreadRunning())

  357.                 handlerThread.stopThread();

  358. 

  359.             handler = nullptr;

  360.             mainwin = nullptr;

  361.             rootwin = nullptr;

  362.             display = nullptr;

  363.         }

  364.     }

  365. 

  366.     void uiIdle() override

  367.     {

  368.         if (mainwin == nullptr)

  369.             return;

  370. 

  371.         if (handlerThread.wasClosed())

  372.         {

  373.             {

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

  375.                 handler = nullptr;

  376.                 mainwin = nullptr;

  377.                 rootwin = nullptr;

  378.                 display = nullptr;

  379.             }

  380.             uiClosed();

  381.         }

  382.     }

  383. 

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

  385.     {

  386.         CARLA_SAFE_ASSERT_RETURN(index < kParameterNROTARY,);

  387. 

  388.         if (mainwin == nullptr)

  389.             return;

  390. 

  391.         handlerThread.setParameterValueLater(index, value);

  392.     }

  393. 

  394.     // -------------------------------------------------------------------

  395.     // Plugin dispatcher calls

  396. 

  397.     void bufferSizeChanged(const uint32_t bufferSize) override

  398.     {

  399.         fJackClient.bufferSize = bufferSize;

  400.     }

  401. 

  402.     void sampleRateChanged(const double sampleRate) override

  403.     {

  404.         fJackClient.sampleRate = sampleRate;

  405.     }

  406. 

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

  408.     {

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

  410. 

  411.         if (mainwin == nullptr)

  412.             return;

  413. 

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

  415. 

  416.         mainwin->x_set_title(uiName);

  417.     }

  418. 

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

  420.     // Mainwin callbacks

  421. 

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

  423.     {

  424.         uint32_t index = rindex;

  425. 

  426.         if (kIsAmbisonic && rindex == kParameterNROTARY)

  427.             index = kParameterOPMIXorRGXYZ;

  428. 

  429.         fParameters[index] = value;

  430.         uiParameterChanged(index, value);

  431.     }

  432. 

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

  434.     // X_handler_thread callbacks

  435. 

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

  437.     {

  438.         CARLA_SAFE_ASSERT_RETURN(mainwin != nullptr,);

  439. 

  440.         uint32_t rindex = index;

  441. 

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

  443.             rindex += 1;

  444. 

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

  446.     }

  447. 

  448.     // -------------------------------------------------------------------

  449. 

  450. private:

  451.     const bool     kIsAmbisonic;

  452.     const uint32_t kNumInputs;

  453.     const uint32_t kNumOutputs;

  454. 

  455.     // Fake jack client

  456.     jack_client_t fJackClient;

  457. 

  458.     // Zita stuff (core)

  459.     X_resman xresman;

  460.     ScopedPointer<Jclient>   jclient;

  461.     ScopedPointer<X_display> display;

  462.     ScopedPointer<X_rootwin> rootwin;

  463.     ScopedPointer<Mainwin>   mainwin;

  464.     ScopedPointer<X_handler> handler;

  465.     X_handler_thread<Mainwin> handlerThread;

  466. 

  467.     float fParameters[kParameterNROTARY];

  468. 

  469. public:

  470.     static NativePluginHandle _instantiateAmbisonic(const NativeHostDescriptor* host)

  471.     {

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

  473.     }

  474. 

  475.     static NativePluginHandle _instantiateStereo(const NativeHostDescriptor* host)

  476.     {

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

  478.     }

  479. 

  480.     static void _cleanup(NativePluginHandle handle)

  481.     {

  482.         delete (REV1Plugin*)handle;

  483.     }

  484. 

  485.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(REV1Plugin)

  486. };

  487. 

  488. // -----------------------------------------------------------------------

  489. 

  490. static const NativePluginDescriptor rev1AmbisonicDesc = {

  491.     /* category  */ NATIVE_PLUGIN_CATEGORY_DELAY,

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

  493.                                                   |NATIVE_PLUGIN_HAS_UI

  494.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS

  495.                                                   |NATIVE_PLUGIN_NEEDS_UI_MAIN_THREAD

  496.                                                   |NATIVE_PLUGIN_USES_PARENT_ID),

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

  498.     /* audioIns  */ 2,

  499.     /* audioOuts */ 4,

  500.     /* midiIns   */ 0,

  501.     /* midiOuts  */ 0,

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

  503.     /* paramOuts */ 0,

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

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

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

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

  508.     REV1Plugin::_instantiateAmbisonic,

  509.     REV1Plugin::_cleanup,

  510.     REV1Plugin::_get_parameter_count,

  511.     REV1Plugin::_get_parameter_info,

  512.     REV1Plugin::_get_parameter_value,

  513.     REV1Plugin::_get_parameter_text,

  514.     REV1Plugin::_get_midi_program_count,

  515.     REV1Plugin::_get_midi_program_info,

  516.     REV1Plugin::_set_parameter_value,

  517.     REV1Plugin::_set_midi_program,

  518.     REV1Plugin::_set_custom_data,

  519.     REV1Plugin::_ui_show,

  520.     REV1Plugin::_ui_idle,

  521.     REV1Plugin::_ui_set_parameter_value,

  522.     REV1Plugin::_ui_set_midi_program,

  523.     REV1Plugin::_ui_set_custom_data,

  524.     REV1Plugin::_activate,

  525.     REV1Plugin::_deactivate,

  526.     REV1Plugin::_process,

  527.     REV1Plugin::_get_state,

  528.     REV1Plugin::_set_state,

  529.     REV1Plugin::_dispatcher

  530. };

  531. 

  532. static const NativePluginDescriptor rev1StereoDesc = {

  533.     /* category  */ NATIVE_PLUGIN_CATEGORY_DELAY,

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

  535.                                                   |NATIVE_PLUGIN_HAS_UI

  536.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS

  537.                                                   |NATIVE_PLUGIN_NEEDS_UI_MAIN_THREAD

  538.                                                   |NATIVE_PLUGIN_USES_PARENT_ID),

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

  540.     /* audioIns  */ 2,

  541.     /* audioOuts */ 2,

  542.     /* midiIns   */ 0,

  543.     /* midiOuts  */ 0,

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

  545.     /* paramOuts */ 0,

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

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

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

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

  550.     REV1Plugin::_instantiateStereo,

  551.     REV1Plugin::_cleanup,

  552.     REV1Plugin::_get_parameter_count,

  553.     REV1Plugin::_get_parameter_info,

  554.     REV1Plugin::_get_parameter_value,

  555.     REV1Plugin::_get_parameter_text,

  556.     REV1Plugin::_get_midi_program_count,

  557.     REV1Plugin::_get_midi_program_info,

  558.     REV1Plugin::_set_parameter_value,

  559.     REV1Plugin::_set_midi_program,

  560.     REV1Plugin::_set_custom_data,

  561.     REV1Plugin::_ui_show,

  562.     REV1Plugin::_ui_idle,

  563.     REV1Plugin::_ui_set_parameter_value,

  564.     REV1Plugin::_ui_set_midi_program,

  565.     REV1Plugin::_ui_set_custom_data,

  566.     REV1Plugin::_activate,

  567.     REV1Plugin::_deactivate,

  568.     REV1Plugin::_process,

  569.     REV1Plugin::_get_state,

  570.     REV1Plugin::_set_state,

  571.     REV1Plugin::_dispatcher

  572. };

  573. 

  574. // -----------------------------------------------------------------------

  575. 

  576. CARLA_EXPORT

  577. void carla_register_native_plugin_zita_rev1();

  578. 

  579. CARLA_EXPORT

  580. void carla_register_native_plugin_zita_rev1()

  581. {

  582.     carla_register_native_plugin(&rev1AmbisonicDesc);

  583.     carla_register_native_plugin(&rev1StereoDesc);

  584. }

  585. 

  586. // -----------------------------------------------------------------------