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.
1794 Commits
16 Branches
324MB
Tree: cdfc63fb6c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'cdfc63fb6c'
${ noResults }
Carla/source/modules/native-plugins/zamulticompx2/ZaMultiCompX2Plugin.cpp

813 lines
24KB
Raw Blame History 

  1. /*

  2.  * ZaMultiCompX2 Stereo multiband compressor

  3.  * Copyright (C) 2014  Damien Zammit <damien@zamaudio.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 "ZaMultiCompX2Plugin.hpp"

  19. 

  20. START_NAMESPACE_DISTRHO

  21. 

  22. // -----------------------------------------------------------------------

  23. 

  24. ZaMultiCompX2Plugin::ZaMultiCompX2Plugin()

  25.     : Plugin(paramCount, 1, 1) // 1 program, 1 state

  26. {

  27.     // set default values

  28.     d_setProgram(0);

  29. 

  30.     // reset

  31.     d_deactivate();

  32. }

  33. 

  34. ZaMultiCompX2Plugin::~ZaMultiCompX2Plugin()

  35. {

  36. }

  37. 

  38. // -----------------------------------------------------------------------

  39. // Init

  40. 

  41. void ZaMultiCompX2Plugin::d_initParameter(uint32_t index, Parameter& parameter)

  42. {

  43.     switch (index)

  44.     {

  45.     case paramAttack:

  46.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  47.         parameter.name       = "Attack";

  48.         parameter.symbol     = "att";

  49.         parameter.unit       = "ms";

  50.         parameter.ranges.def = 10.0f;

  51.         parameter.ranges.min = 0.1f;

  52.         parameter.ranges.max = 100.0f;

  53.         break;

  54.     case paramRelease:

  55.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  56.         parameter.name       = "Release";

  57.         parameter.symbol     = "rel";

  58.         parameter.unit       = "ms";

  59.         parameter.ranges.def = 80.0f;

  60.         parameter.ranges.min = 1.0f;

  61.         parameter.ranges.max = 500.0f;

  62.         break;

  63.     case paramKnee:

  64.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  65.         parameter.name       = "Knee";

  66.         parameter.symbol     = "kn";

  67.         parameter.unit       = "dB";

  68.         parameter.ranges.def = 0.0f;

  69.         parameter.ranges.min = 0.0f;

  70.         parameter.ranges.max = 9.0f;

  71.         break;

  72.     case paramRatio:

  73.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  74.         parameter.name       = "Ratio";

  75.         parameter.symbol     = "rat";

  76.         parameter.unit       = " ";

  77.         parameter.ranges.def = 4.0f;

  78.         parameter.ranges.min = 1.0f;

  79.         parameter.ranges.max = 20.0f;

  80.         break;

  81.     case paramThresh1:

  82.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  83.         parameter.name       = "Threshold 1";

  84.         parameter.symbol     = "thr1";

  85.         parameter.unit       = "dB";

  86.         parameter.ranges.def = -20.0f;

  87.         parameter.ranges.min = -60.0f;

  88.         parameter.ranges.max = 0.0f;

  89.         break;

  90.     case paramThresh2:

  91.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  92.         parameter.name       = "Threshold 2";

  93.         parameter.symbol     = "thr2";

  94.         parameter.unit       = "dB";

  95.         parameter.ranges.def = -18.0f;

  96.         parameter.ranges.min = -60.0f;

  97.         parameter.ranges.max = 0.0f;

  98.         break;

  99.     case paramThresh3:

  100.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  101.         parameter.name       = "Threshold 3";

  102.         parameter.symbol     = "thr3";

  103.         parameter.unit       = "dB";

  104.         parameter.ranges.def = -16.0f;

  105.         parameter.ranges.min = -60.0f;

  106.         parameter.ranges.max = 0.0f;

  107.         break;

  108.     case paramMakeup1:

  109.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  110.         parameter.name       = "Makeup 1";

  111.         parameter.symbol     = "mak1";

  112.         parameter.unit       = "dB";

  113.         parameter.ranges.def = 0.0f;

  114.         parameter.ranges.min = 0.0f;

  115.         parameter.ranges.max = 30.0f;

  116.         break;

  117.     case paramMakeup2:

  118.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  119.         parameter.name       = "Makeup 2";

  120.         parameter.symbol     = "mak2";

  121.         parameter.unit       = "dB";

  122.         parameter.ranges.def = 0.0f;

  123.         parameter.ranges.min = 0.0f;

  124.         parameter.ranges.max = 30.0f;

  125.         break;

  126.     case paramMakeup3:

  127.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  128.         parameter.name       = "Makeup 3";

  129.         parameter.symbol     = "mak3";

  130.         parameter.unit       = "dB";

  131.         parameter.ranges.def = 0.0f;

  132.         parameter.ranges.min = 0.0f;

  133.         parameter.ranges.max = 30.0f;

  134.         break;

  135.     case paramGainR1:

  136.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_OUTPUT;

  137.         parameter.name       = "Gain Reduction 1";

  138.         parameter.symbol     = "gr1";

  139.         parameter.unit       = "dB";

  140.         parameter.ranges.def = 0.0f;

  141.         parameter.ranges.min = 0.0f;

  142.         parameter.ranges.max = 20.0f;

  143.         break;

  144.     case paramGainR2:

  145.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_OUTPUT;

  146.         parameter.name       = "Gain Reduction 2";

  147.         parameter.symbol     = "gr2";

  148.         parameter.unit       = "dB";

  149.         parameter.ranges.def = 0.0f;

  150.         parameter.ranges.min = 0.0f;

  151.         parameter.ranges.max = 20.0f;

  152.         break;

  153.     case paramGainR3:

  154.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_OUTPUT;

  155.         parameter.name       = "Gain Reduction 3";

  156.         parameter.symbol     = "gr3";

  157.         parameter.unit       = "dB";

  158.         parameter.ranges.def = 0.0f;

  159.         parameter.ranges.min = 0.0f;

  160.         parameter.ranges.max = 20.0f;

  161.         break;

  162.     case paramXover1:

  163.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_LOGARITHMIC;

  164.         parameter.name       = "Crossover freq 1";

  165.         parameter.symbol     = "xover1";

  166.         parameter.unit       = "Hz";

  167.         parameter.ranges.def = 500.0f;

  168.         parameter.ranges.min = 20.0f;

  169.         parameter.ranges.max = 20000.0f;

  170.         break;

  171.     case paramXover2:

  172.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_LOGARITHMIC;

  173.         parameter.name       = "Crossover freq 2";

  174.         parameter.symbol     = "xover2";

  175.         parameter.unit       = "Hz";

  176.         parameter.ranges.def = 3000.0f;

  177.         parameter.ranges.min = 20.0f;

  178.         parameter.ranges.max = 20000.0f;

  179.         break;

  180.     case paramToggle1:

  181.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_BOOLEAN;

  182.         parameter.name       = "ZamComp 1 ON";

  183.         parameter.symbol     = "toggle1";

  184.         parameter.unit       = " ";

  185.         parameter.ranges.def = 0.0f;

  186.         parameter.ranges.min = 0.0f;

  187.         parameter.ranges.max = 1.0f;

  188.         break;

  189.     case paramToggle2:

  190.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_BOOLEAN;

  191.         parameter.name       = "ZamComp 2 ON";

  192.         parameter.symbol     = "toggle2";

  193.         parameter.unit       = " ";

  194.         parameter.ranges.def = 0.0f;

  195.         parameter.ranges.min = 0.0f;

  196.         parameter.ranges.max = 1.0f;

  197.         break;

  198.     case paramToggle3:

  199.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_BOOLEAN;

  200.         parameter.name       = "ZamComp 3 ON";

  201.         parameter.symbol     = "toggle3";

  202.         parameter.unit       = " ";

  203.         parameter.ranges.def = 0.0f;

  204.         parameter.ranges.min = 0.0f;

  205.         parameter.ranges.max = 1.0f;

  206.         break;

  207.     case paramListen1:

  208.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_BOOLEAN;

  209.         parameter.name       = "Listen 1";

  210.         parameter.symbol     = "listen1";

  211.         parameter.unit       = " ";

  212.         parameter.ranges.def = 0.0f;

  213.         parameter.ranges.min = 0.0f;

  214.         parameter.ranges.max = 1.0f;

  215.         break;

  216.     case paramListen2:

  217.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_BOOLEAN;

  218.         parameter.name       = "Listen 2";

  219.         parameter.symbol     = "listen2";

  220.         parameter.unit       = " ";

  221.         parameter.ranges.def = 0.0f;

  222.         parameter.ranges.min = 0.0f;

  223.         parameter.ranges.max = 1.0f;

  224.         break;

  225.     case paramListen3:

  226.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_BOOLEAN;

  227.         parameter.name       = "Listen 3";

  228.         parameter.symbol     = "listen3";

  229.         parameter.unit       = " ";

  230.         parameter.ranges.def = 0.0f;

  231.         parameter.ranges.min = 0.0f;

  232.         parameter.ranges.max = 1.0f;

  233.         break;

  234.     case paramGlobalGain:

  235.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  236.         parameter.name       = "Master Trim";

  237.         parameter.symbol     = "globalgain";

  238.         parameter.unit       = "dB";

  239.         parameter.ranges.def = 0.0f;

  240.         parameter.ranges.min = -12.0f;

  241.         parameter.ranges.max = 12.0f;

  242.         break;

  243.     case paramStereoDet:

  244.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_BOOLEAN;

  245.         parameter.name       = "Detection (MAX/avg)";

  246.         parameter.symbol     = "stereodet";

  247.         parameter.unit       = " ";

  248.         parameter.ranges.def = 1.0f;

  249.         parameter.ranges.min = 0.0f;

  250.         parameter.ranges.max = 1.0f;

  251.         break;

  252.     case paramOutputLevelL:

  253.         parameter.hints      = PARAMETER_IS_OUTPUT;

  254.         parameter.name       = "Output Left";

  255.         parameter.symbol     = "outl";

  256.         parameter.unit       = "dB";

  257.         parameter.ranges.def = -45.0f;

  258.         parameter.ranges.min = -45.0f;

  259.         parameter.ranges.max = 20.0f;

  260.         break;

  261.     case paramOutputLevelR:

  262.         parameter.hints      = PARAMETER_IS_OUTPUT;

  263.         parameter.name       = "Output Right";

  264.         parameter.symbol     = "outr";

  265.         parameter.unit       = "dB";

  266.         parameter.ranges.def = -45.0f;

  267.         parameter.ranges.min = -45.0f;

  268.         parameter.ranges.max = 20.0f;

  269.         break;

  270.     }

  271. }

  272. 

  273. void ZaMultiCompX2Plugin::d_initProgramName(uint32_t index, d_string& programName)

  274. {

  275.     if (index != 0)

  276.         return;

  277. 

  278.     programName = "Default";

  279. }

  280. 

  281. // -----------------------------------------------------------------------

  282. // Internal data

  283. 

  284. float ZaMultiCompX2Plugin::d_getParameterValue(uint32_t index) const

  285. {

  286.     switch (index)

  287.     {

  288.     case paramAttack:

  289.         return attack;

  290.         break;

  291.     case paramRelease:

  292.         return release;

  293.         break;

  294.     case paramKnee:

  295.         return knee;

  296.         break;

  297.     case paramRatio:

  298.         return ratio;

  299.         break;

  300.     case paramThresh1:

  301.         return thresdb[0];

  302.         break;

  303.     case paramThresh2:

  304.         return thresdb[1];

  305.         break;

  306.     case paramThresh3:

  307.         return thresdb[2];

  308.         break;

  309.     case paramMakeup1:

  310.         return makeup[0];

  311.         break;

  312.     case paramMakeup2:

  313.         return makeup[1];

  314.         break;

  315.     case paramMakeup3:

  316.         return makeup[2];

  317.         break;

  318.     case paramGainR1:

  319.         return gainr[0];

  320.         break;

  321.     case paramGainR2:

  322.         return gainr[1];

  323.         break;

  324.     case paramGainR3:

  325.         return gainr[2];

  326.         break;

  327.     case paramXover1:

  328.         return xover1;

  329.         break;

  330.     case paramXover2:

  331.         return xover2;

  332.         break;

  333.     case paramToggle1:

  334.         return toggle[0];

  335.         break;

  336.     case paramToggle2:

  337.         return toggle[1];

  338.         break;

  339.     case paramToggle3:

  340.         return toggle[2];

  341.         break;

  342.     case paramListen1:

  343.         return listen[0];

  344.         break;

  345.     case paramListen2:

  346.         return listen[1];

  347.         break;

  348.     case paramListen3:

  349.         return listen[2];

  350.         break;

  351.     case paramGlobalGain:

  352.         return globalgain;

  353.         break;

  354.     case paramStereoDet:

  355.         return stereodet;

  356.         break;

  357.     case paramOutputLevelL:

  358.         return outl;

  359.         break;

  360.     case paramOutputLevelR:

  361.         return outr;

  362.         break;

  363.     default:

  364.         return 0.0f;

  365.     }

  366. }

  367. 

  368. void ZaMultiCompX2Plugin::d_setParameterValue(uint32_t index, float value)

  369. {

  370.     switch (index)

  371.     {

  372.     case paramAttack:

  373.         attack = value;

  374.         break;

  375.     case paramRelease:

  376.         release = value;

  377.         break;

  378.     case paramKnee:

  379.         knee = value;

  380.         break;

  381.     case paramRatio:

  382.         ratio = value;

  383.         break;

  384.     case paramThresh1:

  385.         thresdb[0] = value;

  386.         break;

  387.     case paramThresh2:

  388.         thresdb[1] = value;

  389.         break;

  390.     case paramThresh3:

  391.         thresdb[2] = value;

  392.         break;

  393.     case paramMakeup1:

  394.         makeup[0] = value;

  395.         break;

  396.     case paramMakeup2:

  397.         makeup[1] = value;

  398.         break;

  399.     case paramMakeup3:

  400.         makeup[2] = value;

  401.         break;

  402.     case paramGainR1:

  403.         gainr[0] = value;

  404.         break;

  405.     case paramGainR2:

  406.         gainr[1] = value;

  407.         break;

  408.     case paramGainR3:

  409.         gainr[2] = value;

  410.         break;

  411.     case paramXover1:

  412.         xover1 = value;

  413.         break;

  414.     case paramXover2:

  415.         xover2 = value;

  416.         break;

  417.     case paramToggle1:

  418.         toggle[0] = value;

  419.         if (value == 0.f)

  420. 	    gainr[0] = 0.f;

  421.         break;

  422.     case paramToggle2:

  423.         toggle[1] = value;

  424.         if (value == 0.f)

  425. 	    gainr[1] = 0.f;

  426.         break;

  427.     case paramToggle3:

  428.         toggle[2] = value;

  429.         if (value == 0.f)

  430. 	    gainr[2] = 0.f;

  431.         break;

  432.     case paramListen1:

  433.         listen[0] = value;

  434.         if (value == 0.f)

  435. 	    gainr[0] = 0.f;

  436.         break;

  437.     case paramListen2:

  438.         listen[1] = value;

  439.         if (value == 0.f)

  440. 	    gainr[1] = 0.f;

  441.         break;

  442.     case paramListen3:

  443.         listen[2] = value;

  444.         if (value == 0.f)

  445. 	    gainr[2] = 0.f;

  446.         break;

  447.     case paramGlobalGain:

  448.         globalgain = value;

  449.         break;

  450.     case paramStereoDet:

  451.         stereodet = value;

  452.         break;

  453.     case paramOutputLevelL:

  454.         outl = value;

  455.         break;

  456.     case paramOutputLevelR:

  457.         outr = value;

  458.         break;

  459.     }

  460. }

  461. 

  462. void ZaMultiCompX2Plugin::d_setProgram(uint32_t index)

  463. {

  464.     if (index != 0)

  465.         return;

  466. 

  467.     /* Default parameter values */

  468.     attack = 10.0f;

  469.     release = 80.0f;

  470.     knee = 0.0f;

  471.     ratio = 4.0f;

  472.     thresdb[0] = -20.0f;

  473.     thresdb[1] = -18.0f;

  474.     thresdb[2] = -16.0f;

  475.     makeup[0] = 0.0f;

  476.     makeup[1] = 0.0f;

  477.     makeup[2] = 0.0f;

  478.     gainr[0] = 0.0f;

  479.     gainr[1] = 0.0f;

  480.     gainr[2] = 0.0f;

  481.     xover1 = 500.0f;

  482.     xover2 = 3000.0f;

  483.     toggle[0] = 0.0f;

  484.     toggle[1] = 0.0f;

  485.     toggle[2] = 0.0f;

  486.     listen[0] = 0.0f;

  487.     listen[1] = 0.0f;

  488.     listen[2] = 0.0f;

  489.     globalgain = 0.0f;

  490.     stereodet = 1.0f;

  491.     outl = -45.f;

  492.     outr = -45.f;

  493.     maxL = 0.f;

  494.     maxR = 0.f;

  495. 

  496.     /* Default variable values */

  497. 

  498.     /* reset filter values */

  499.     d_activate();

  500. }

  501. 

  502. void ZaMultiCompX2Plugin::d_setState(const char* key, const char* value)

  503. {

  504.     resetl = true;

  505.     resetr = true;

  506. }

  507. 

  508. void ZaMultiCompX2Plugin::d_initStateKey(unsigned int key, d_string& val)

  509. {

  510. }

  511. 

  512. // -----------------------------------------------------------------------

  513. // Process

  514. 

  515. void ZaMultiCompX2Plugin::d_activate()

  516. {

  517.         int i,j;

  518.         for (i = 0; i < MAX_COMP; i++)

  519.         	for (j = 0; j < 2; j++)

  520.                 	old_yl[j][i]=old_y1[j][i]=0.f;

  521. 

  522.         for (i = 0; i < MAX_FILT; i++) {

  523.         	for (j = 0; j < 2; j++) {

  524.                 	a0[j][i] = a1[j][i] = a2[j][i] = 0.f;

  525.                 	b1[j][i] = b2[j][i] = 0.f;

  526.                 	w1[j][i] = w2[j][i] = 0.f;

  527.                 	z1[j][i] = z2[j][i] = 0.f;

  528. 		}

  529.         }

  530. 	maxL = maxR = 0.f;

  531. }

  532. 

  533. void ZaMultiCompX2Plugin::d_deactivate()

  534. {

  535.     // all values to zero

  536.     d_activate();

  537. }

  538. 

  539. float ZaMultiCompX2Plugin::run_filter(int i, int ch, float in)

  540. {

  541.         in = sanitize_denormal(in);

  542.         w1[ch][i] = sanitize_denormal(w1[ch][i]);

  543.         w2[ch][i] = sanitize_denormal(w2[ch][i]);

  544. 	z1[ch][i] = sanitize_denormal(z1[ch][i]);

  545. 	z2[ch][i] = sanitize_denormal(z2[ch][i]);

  546. 

  547.         float out = in * a0[ch][i] 	+ w1[ch][i] * a1[ch][i] + w2[ch][i] * a2[ch][i]

  548. 					- z1[ch][i] * b1[ch][i] - z2[ch][i] * b2[ch][i];

  549. 	out = sanitize_denormal(out);

  550.         w2[ch][i] = w1[ch][i];

  551.         z2[ch][i] = z1[ch][i];

  552.         w1[ch][i] = in;

  553. 	z1[ch][i] = out;

  554.         return out;

  555. }

  556. 

  557. void ZaMultiCompX2Plugin::set_lp_coeffs(float fc, float q, float sr, int i, int ch, float gain=1.0)

  558. {

  559.         float omega=(float)(2.f*M_PI*fc/sr);

  560.         float sn=sin(omega);

  561.         float cs=cos(omega);

  562.         float alpha=(float)(sn/(2.f*q));

  563.         float inv=(float)(1.0/(1.0+alpha));

  564. 

  565.         a2[ch][i] = a0[ch][i] =  (float)(gain*inv*(1.f - cs)*0.5f);

  566.         a1[ch][i] = a0[ch][i] + a0[ch][i];

  567.         b1[ch][i] = (float)(-2.f*cs*inv);

  568.         b2[ch][i] = (float)((1.f - alpha)*inv);

  569. }

  570. 

  571. void ZaMultiCompX2Plugin::set_hp_coeffs(float fc, float q, float sr, int i, int ch, float gain=1.0) 

  572. {       

  573.         float omega=(float)(2.f*M_PI*fc/sr);

  574.         float sn=sin(omega);

  575.         float cs=cos(omega);

  576.         float alpha=(float)(sn/(2.f*q));

  577.         float inv=(float)(1.f/(1.f+alpha));

  578.         

  579.         a0[ch][i] =  (float)(gain*inv*(1.f + cs)/2.f);

  580.         a1[ch][i] =  -2.f * a0[ch][i];

  581.         a2[ch][i] =  a0[ch][i];

  582.         b1[ch][i] =  (float)(-2.f*cs*inv);

  583.         b2[ch][i] =  (float)((1.f - alpha)*inv);

  584. }

  585. 

  586. void ZaMultiCompX2Plugin::run_comp(int k, float inL, float inR, float *outL, float *outR)

  587. {

  588. 	float srate = d_getSampleRate();

  589.         float width=(knee-0.99f)*6.f;

  590.         float attack_coeff = exp(-1000.f/(attack * srate));

  591.         float release_coeff = exp(-1000.f/(release * srate));

  592. 	int stereolink = (stereodet > 0.5f) ? STEREOLINK_MAX : STEREOLINK_AVERAGE;

  593. 

  594.         float cdb=0.f;

  595.         float Lgain = 1.f;

  596.         float Rgain = 1.f;

  597.         float Lxg, Lyg;

  598.         float Rxg, Ryg;

  599.         float Lxl, Lyl, Ly1;

  600.         float Rxl, Ryl, Ry1;

  601. 

  602.         Lyg = Ryg = 0.f;

  603. 	inL = sanitize_denormal(inL);

  604. 	inR = sanitize_denormal(inR);

  605.         Lxg = (inL==0.f) ? -160.f : to_dB(fabs(inL));

  606.         Rxg = (inR==0.f) ? -160.f : to_dB(fabs(inR));

  607.         Lxg = sanitize_denormal(Lxg);

  608.         Rxg = sanitize_denormal(Rxg); 

  609.         

  610.         

  611.         if (2.f*(Lxg-thresdb[k])<-width) {

  612.                 Lyg = Lxg;

  613.         } else if (2.f*fabs(Lxg-thresdb[k])<=width) {

  614.                 Lyg = Lxg + (1.f/ratio-1.f)*(Lxg-thresdb[k]+width/2.f)*(Lxg-thresdb[k]+width/2.f)/(2.f*width);

  615.         } else if (2.f*(Lxg-thresdb[k])>width) {

  616.                 Lyg = thresdb[k] + (Lxg-thresdb[k])/ratio;

  617.         }

  618.         

  619.         Lyg = sanitize_denormal(Lyg); 

  620.         

  621.         if (2.f*(Rxg-thresdb[k])<-width) {

  622.                 Ryg = Rxg;

  623.         } else if (2.f*fabs(Rxg-thresdb[k])<=width) {

  624.                 Ryg = Rxg + (1.f/ratio-1.f)*(Rxg-thresdb[k]+width/2.f)*(Rxg-thresdb[k]+width/2.f)/(2.f*width);

  625.         } else if (2.f*(Rxg-thresdb[k])>width) {

  626.                 Ryg = thresdb[k] + (Rxg-thresdb[k])/ratio;

  627.         }

  628.         

  629.         Ryg = sanitize_denormal(Ryg); 

  630.         

  631.         if (stereolink == STEREOLINK_MAX) {

  632.                 Lxl = Rxl = fmaxf(Lxg - Lyg, Rxg - Ryg);

  633.         } else {

  634.                 Lxl = Rxl = (Lxg - Lyg + Rxg - Ryg) / 2.f;

  635.         }       

  636.         

  637.         old_y1[0][k] = sanitize_denormal(old_y1[0][k]); 

  638.         old_y1[1][k] = sanitize_denormal(old_y1[1][k]);

  639.         old_yl[0][k] = sanitize_denormal(old_yl[0][k]); 

  640.         old_yl[1][k] = sanitize_denormal(old_yl[1][k]);

  641.         

  642.         

  643.         Ly1 = fmaxf(Lxl, release_coeff * old_y1[0][k]+(1.f-release_coeff)*Lxl);     

  644.         Lyl = attack_coeff * old_yl[0][k]+(1.f-attack_coeff)*Ly1;

  645.         Ly1 = sanitize_denormal(Ly1);

  646.         Lyl = sanitize_denormal(Lyl);

  647.         

  648.         cdb = -Lyl;

  649.         Lgain = from_dB(cdb);

  650.         

  651.         Ry1 = fmaxf(Rxl, release_coeff * old_y1[1][k]+(1.f-release_coeff)*Rxl);

  652.         Ryl = attack_coeff * old_yl[1][k]+(1.f-attack_coeff)*Ry1;

  653.         Ry1 = sanitize_denormal(Ry1);

  654.         Ryl = sanitize_denormal(Ryl);

  655.         

  656.         cdb = -Ryl;

  657.         Rgain = from_dB(cdb);

  658.         

  659.         if (stereolink == STEREOLINK_MAX)

  660. 		gainr[k] = fmaxf(Lyl, Ryl);

  661. 	else

  662.         	gainr[k] = (Lyl + Ryl) / 2.f;

  663. 

  664. 	*outL = inL;

  665. 	*outL *= Lgain;

  666. 	*outR = inR;

  667. 	*outR *= Rgain;

  668.         

  669.         old_yl[0][k] = Lyl;

  670.         old_yl[1][k] = Ryl;

  671.         old_y1[0][k] = Ly1;

  672.         old_y1[1][k] = Ry1;	

  673. }

  674. 

  675. void ZaMultiCompX2Plugin::d_run(float** inputs, float** outputs, uint32_t frames)

  676. {

  677. 	float srate = d_getSampleRate();

  678. 	float maxxL = maxL;

  679. 	float maxxR = maxR;

  680. 

  681.         int tog1 = (toggle[0] > 0.5f) ? 1 : 0;

  682.         int tog2 = (toggle[1] > 0.5f) ? 1 : 0;

  683.         int tog3 = (toggle[2] > 0.5f) ? 1 : 0;

  684. 

  685.         int listen1 = (listen[0] > 0.5f) ? 1 : 0;

  686.         int listen2 = (listen[1] > 0.5f) ? 1 : 0;

  687.         int listen3 = (listen[2] > 0.5f) ? 1 : 0;

  688. 

  689.         set_lp_coeffs(xover1, ONEOVERROOT2, srate, 0, 0);

  690.         set_lp_coeffs(xover1, ONEOVERROOT2, srate, 1, 0);

  691.         set_hp_coeffs(xover1, ONEOVERROOT2, srate, 2, 0);

  692.         set_hp_coeffs(xover1, ONEOVERROOT2, srate, 3, 0);

  693.         set_lp_coeffs(xover2, ONEOVERROOT2, srate, 4, 0);

  694.         set_lp_coeffs(xover2, ONEOVERROOT2, srate, 5, 0);

  695.         set_hp_coeffs(xover2, ONEOVERROOT2, srate, 6, 0);

  696.         set_hp_coeffs(xover2, ONEOVERROOT2, srate, 7, 0);

  697. 

  698.         set_lp_coeffs(xover1, ONEOVERROOT2, srate, 0, 1);

  699.         set_lp_coeffs(xover1, ONEOVERROOT2, srate, 1, 1);

  700.         set_hp_coeffs(xover1, ONEOVERROOT2, srate, 2, 1);

  701.         set_hp_coeffs(xover1, ONEOVERROOT2, srate, 3, 1);

  702.         set_lp_coeffs(xover2, ONEOVERROOT2, srate, 4, 1);

  703.         set_lp_coeffs(xover2, ONEOVERROOT2, srate, 5, 1);

  704.         set_hp_coeffs(xover2, ONEOVERROOT2, srate, 6, 1);

  705.         set_hp_coeffs(xover2, ONEOVERROOT2, srate, 7, 1);

  706. 

  707.         for (uint32_t i = 0; i < frames; ++i) {

  708.                 float tmp1[2], tmp2[2], tmp3[2], tmp4[2], tmp5[2], tmp6[2];

  709. 		float fil1[2], fil2[2], fil3[2], fil4[2];

  710. 		float outL[MAX_COMP] = {0.f};

  711. 		float outR[MAX_COMP] = {0.f};

  712. 		float inl = sanitize_denormal(inputs[0][i]);

  713. 		float inr = sanitize_denormal(inputs[1][i]);

  714. 		inl = (fabs(inl) < DANGER) ? inl : 0.f;

  715. 		inr = (fabs(inr) < DANGER) ? inr : 0.f;

  716. 

  717. 		int listenmode = 0;

  718. 

  719. 		// Interleaved channel processing

  720.                 fil1[0] = run_filter(0, 0, inl);

  721.                 fil1[1] = run_filter(0, 1, inr);

  722.                 tmp1[0] = run_filter(1, 0, fil1[0]);

  723.                 tmp1[1] = run_filter(1, 1, fil1[1]);

  724. 		if (tog1)

  725. 			run_comp(0, tmp1[0], tmp1[1], &outL[0], &outR[0]);

  726. 

  727. 		tmp2[0] = tog1 ? outL[0] * from_dB(makeup[0]) : tmp1[0];

  728.                 tmp2[1] = tog1 ? outR[0] * from_dB(makeup[0]) : tmp1[1];

  729. 

  730.                 fil2[0] = run_filter(2, 0, inl);

  731.                 fil2[1] = run_filter(2, 1, inr);

  732.                 tmp3[0] = run_filter(3, 0, fil2[0]);

  733.                 tmp3[1] = run_filter(3, 1, fil2[1]);

  734.                 fil3[0] = run_filter(4, 0, tmp3[0]);

  735.                 fil3[1] = run_filter(4, 1, tmp3[1]);

  736.                 tmp4[0] = run_filter(5, 0, fil3[0]);

  737.                 tmp4[1] = run_filter(5, 1, fil3[1]);

  738. 		if (tog2)

  739. 			run_comp(1, tmp4[0], tmp4[1], &outL[1], &outR[1]);

  740. 

  741.                 tmp3[0] = tog2 ? outL[1] * from_dB(makeup[1]) : tmp4[0];

  742.                 tmp3[1] = tog2 ? outR[1] * from_dB(makeup[1]) : tmp4[1];

  743. 

  744.                 fil4[0] = run_filter(6, 0, inl);

  745.                 fil4[1] = run_filter(6, 1, inr);

  746.                 tmp5[0] = run_filter(7, 0, fil4[0]);

  747.                 tmp5[1] = run_filter(7, 1, fil4[1]);

  748. 		if (tog3) 

  749. 			run_comp(2, tmp5[0], tmp5[1], &outL[2], &outR[2]);

  750. 

  751.                 tmp6[0] = tog3 ? outL[2] * from_dB(makeup[2]) : tmp5[0];

  752.                 tmp6[1] = tog3 ? outR[2] * from_dB(makeup[2]) : tmp5[1];

  753. 

  754. 

  755. 		outputs[0][i] = outputs[1][i] = 0.f;	

  756. 		if (listen1) {

  757. 			listenmode = 1;

  758. 			outputs[0][i] += outL[0] * tog1*from_dB(makeup[0])

  759. 					+ (1.-tog1) * tmp1[0];

  760. 			outputs[1][i] += outR[0] * tog1*from_dB(makeup[0])

  761. 					+ (1.-tog1) * tmp1[1];

  762. 		}

  763. 		if (listen2) {

  764. 			listenmode = 1;

  765. 			outputs[0][i] += outL[1] * tog2*from_dB(makeup[1])

  766. 					+ (1.-tog2) * tmp4[0];

  767. 			outputs[1][i] += outR[1] * tog2*from_dB(makeup[1])

  768. 					+ (1.-tog2) * tmp4[1];

  769. 		}

  770. 		if (listen3) {

  771. 			listenmode = 1;

  772. 			outputs[0][i] += outL[2] * tog3*from_dB(makeup[2])

  773. 					+ (1.-tog3) * tmp5[0];

  774. 			outputs[1][i] += outR[2] * tog3*from_dB(makeup[2])

  775. 					+ (1.-tog3) * tmp5[1];

  776. 		}

  777. 		if (!listenmode) {

  778.                 	outputs[0][i] = tmp2[0] + tmp3[0] + tmp6[0];

  779.                 	outputs[1][i] = tmp2[1] + tmp3[1] + tmp6[1];

  780. 		}

  781.                 outputs[0][i] = sanitize_denormal(outputs[0][i]);

  782.                 outputs[1][i] = sanitize_denormal(outputs[1][i]);

  783.                 outputs[0][i] *= from_dB(globalgain);

  784.                 outputs[1][i] *= from_dB(globalgain);

  785. 

  786. 		if (resetl) {

  787. 			maxL = fabsf(outputs[0][i]);

  788. 			resetl = false;

  789. 		} else {

  790. 			maxxL = (fabsf(outputs[0][i]) > maxxL) ? fabsf(outputs[0][i]) : sanitize_denormal(maxxL);

  791. 		}

  792. 		if (resetr) {

  793. 			maxR = fabsf(outputs[1][i]);

  794. 			resetr = false;

  795. 		} else {

  796. 			maxxR = (fabsf(outputs[1][i]) > maxxR) ? fabsf(outputs[1][i]) : sanitize_denormal(maxxR);

  797. 		}

  798.         }

  799. 	outl = (maxxL <= 0.f) ? -160.f : to_dB(maxxL);

  800. 	outr = (maxxR <= 0.f) ? -160.f : to_dB(maxxR);

  801. }

  802. 

  803. // -----------------------------------------------------------------------

  804. 

  805. Plugin* createPlugin()

  806. {

  807.     return new ZaMultiCompX2Plugin();

  808. }

  809. 

  810. // -----------------------------------------------------------------------

  811. 

  812. END_NAMESPACE_DISTRHO