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

800 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. 

  31. // -----------------------------------------------------------------------

  32. // Init

  33. 

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

  35. {

  36.     switch (index)

  37.     {

  38.     case paramAttack:

  39.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  40.         parameter.name       = "Attack";

  41.         parameter.symbol     = "att";

  42.         parameter.unit       = "ms";

  43.         parameter.ranges.def = 10.0f;

  44.         parameter.ranges.min = 0.1f;

  45.         parameter.ranges.max = 100.0f;

  46.         break;

  47.     case paramRelease:

  48.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  49.         parameter.name       = "Release";

  50.         parameter.symbol     = "rel";

  51.         parameter.unit       = "ms";

  52.         parameter.ranges.def = 80.0f;

  53.         parameter.ranges.min = 1.0f;

  54.         parameter.ranges.max = 500.0f;

  55.         break;

  56.     case paramKnee:

  57.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  58.         parameter.name       = "Knee";

  59.         parameter.symbol     = "kn";

  60.         parameter.unit       = "dB";

  61.         parameter.ranges.def = 0.0f;

  62.         parameter.ranges.min = 0.0f;

  63.         parameter.ranges.max = 9.0f;

  64.         break;

  65.     case paramRatio:

  66.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  67.         parameter.name       = "Ratio";

  68.         parameter.symbol     = "rat";

  69.         parameter.unit       = " ";

  70.         parameter.ranges.def = 4.0f;

  71.         parameter.ranges.min = 1.0f;

  72.         parameter.ranges.max = 20.0f;

  73.         break;

  74.     case paramThresh1:

  75.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  76.         parameter.name       = "Threshold 1";

  77.         parameter.symbol     = "thr1";

  78.         parameter.unit       = "dB";

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

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

  81.         parameter.ranges.max = 0.0f;

  82.         break;

  83.     case paramThresh2:

  84.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  85.         parameter.name       = "Threshold 2";

  86.         parameter.symbol     = "thr2";

  87.         parameter.unit       = "dB";

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

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

  90.         parameter.ranges.max = 0.0f;

  91.         break;

  92.     case paramThresh3:

  93.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  94.         parameter.name       = "Threshold 3";

  95.         parameter.symbol     = "thr3";

  96.         parameter.unit       = "dB";

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

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

  99.         parameter.ranges.max = 0.0f;

  100.         break;

  101.     case paramMakeup1:

  102.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  103.         parameter.name       = "Makeup 1";

  104.         parameter.symbol     = "mak1";

  105.         parameter.unit       = "dB";

  106.         parameter.ranges.def = 0.0f;

  107.         parameter.ranges.min = 0.0f;

  108.         parameter.ranges.max = 30.0f;

  109.         break;

  110.     case paramMakeup2:

  111.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  112.         parameter.name       = "Makeup 2";

  113.         parameter.symbol     = "mak2";

  114.         parameter.unit       = "dB";

  115.         parameter.ranges.def = 0.0f;

  116.         parameter.ranges.min = 0.0f;

  117.         parameter.ranges.max = 30.0f;

  118.         break;

  119.     case paramMakeup3:

  120.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  121.         parameter.name       = "Makeup 3";

  122.         parameter.symbol     = "mak3";

  123.         parameter.unit       = "dB";

  124.         parameter.ranges.def = 0.0f;

  125.         parameter.ranges.min = 0.0f;

  126.         parameter.ranges.max = 30.0f;

  127.         break;

  128.     case paramGainR1:

  129.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_OUTPUT;

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

  131.         parameter.symbol     = "gr1";

  132.         parameter.unit       = "dB";

  133.         parameter.ranges.def = 0.0f;

  134.         parameter.ranges.min = 0.0f;

  135.         parameter.ranges.max = 20.0f;

  136.         break;

  137.     case paramGainR2:

  138.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_OUTPUT;

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

  140.         parameter.symbol     = "gr2";

  141.         parameter.unit       = "dB";

  142.         parameter.ranges.def = 0.0f;

  143.         parameter.ranges.min = 0.0f;

  144.         parameter.ranges.max = 20.0f;

  145.         break;

  146.     case paramGainR3:

  147.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_OUTPUT;

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

  149.         parameter.symbol     = "gr3";

  150.         parameter.unit       = "dB";

  151.         parameter.ranges.def = 0.0f;

  152.         parameter.ranges.min = 0.0f;

  153.         parameter.ranges.max = 20.0f;

  154.         break;

  155.     case paramXover1:

  156.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_LOGARITHMIC;

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

  158.         parameter.symbol     = "xover1";

  159.         parameter.unit       = "Hz";

  160.         parameter.ranges.def = 500.0f;

  161.         parameter.ranges.min = 20.0f;

  162.         parameter.ranges.max = 20000.0f;

  163.         break;

  164.     case paramXover2:

  165.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_LOGARITHMIC;

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

  167.         parameter.symbol     = "xover2";

  168.         parameter.unit       = "Hz";

  169.         parameter.ranges.def = 3000.0f;

  170.         parameter.ranges.min = 20.0f;

  171.         parameter.ranges.max = 20000.0f;

  172.         break;

  173.     case paramToggle1:

  174.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_BOOLEAN;

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

  176.         parameter.symbol     = "toggle1";

  177.         parameter.unit       = " ";

  178.         parameter.ranges.def = 0.0f;

  179.         parameter.ranges.min = 0.0f;

  180.         parameter.ranges.max = 1.0f;

  181.         break;

  182.     case paramToggle2:

  183.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_BOOLEAN;

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

  185.         parameter.symbol     = "toggle2";

  186.         parameter.unit       = " ";

  187.         parameter.ranges.def = 0.0f;

  188.         parameter.ranges.min = 0.0f;

  189.         parameter.ranges.max = 1.0f;

  190.         break;

  191.     case paramToggle3:

  192.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_BOOLEAN;

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

  194.         parameter.symbol     = "toggle3";

  195.         parameter.unit       = " ";

  196.         parameter.ranges.def = 0.0f;

  197.         parameter.ranges.min = 0.0f;

  198.         parameter.ranges.max = 1.0f;

  199.         break;

  200.     case paramListen1:

  201.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_BOOLEAN;

  202.         parameter.name       = "Listen 1";

  203.         parameter.symbol     = "listen1";

  204.         parameter.unit       = " ";

  205.         parameter.ranges.def = 0.0f;

  206.         parameter.ranges.min = 0.0f;

  207.         parameter.ranges.max = 1.0f;

  208.         break;

  209.     case paramListen2:

  210.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_BOOLEAN;

  211.         parameter.name       = "Listen 2";

  212.         parameter.symbol     = "listen2";

  213.         parameter.unit       = " ";

  214.         parameter.ranges.def = 0.0f;

  215.         parameter.ranges.min = 0.0f;

  216.         parameter.ranges.max = 1.0f;

  217.         break;

  218.     case paramListen3:

  219.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_BOOLEAN;

  220.         parameter.name       = "Listen 3";

  221.         parameter.symbol     = "listen3";

  222.         parameter.unit       = " ";

  223.         parameter.ranges.def = 0.0f;

  224.         parameter.ranges.min = 0.0f;

  225.         parameter.ranges.max = 1.0f;

  226.         break;

  227.     case paramGlobalGain:

  228.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  229.         parameter.name       = "Master Trim";

  230.         parameter.symbol     = "globalgain";

  231.         parameter.unit       = "dB";

  232.         parameter.ranges.def = 0.0f;

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

  234.         parameter.ranges.max = 12.0f;

  235.         break;

  236.     case paramStereoDet:

  237.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_BOOLEAN;

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

  239.         parameter.symbol     = "stereodet";

  240.         parameter.unit       = " ";

  241.         parameter.ranges.def = 1.0f;

  242.         parameter.ranges.min = 0.0f;

  243.         parameter.ranges.max = 1.0f;

  244.         break;

  245.     case paramOutputLevelL:

  246.         parameter.hints      = PARAMETER_IS_OUTPUT;

  247.         parameter.name       = "Output Left";

  248.         parameter.symbol     = "outl";

  249.         parameter.unit       = "dB";

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

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

  252.         parameter.ranges.max = 20.0f;

  253.         break;

  254.     case paramOutputLevelR:

  255.         parameter.hints      = PARAMETER_IS_OUTPUT;

  256.         parameter.name       = "Output Right";

  257.         parameter.symbol     = "outr";

  258.         parameter.unit       = "dB";

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

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

  261.         parameter.ranges.max = 20.0f;

  262.         break;

  263.     }

  264. }

  265. 

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

  267. {

  268.     if (index != 0)

  269.         return;

  270. 

  271.     programName = "Default";

  272. }

  273. 

  274. // -----------------------------------------------------------------------

  275. // Internal data

  276. 

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

  278. {

  279.     switch (index)

  280.     {

  281.     case paramAttack:

  282.         return attack;

  283.         break;

  284.     case paramRelease:

  285.         return release;

  286.         break;

  287.     case paramKnee:

  288.         return knee;

  289.         break;

  290.     case paramRatio:

  291.         return ratio;

  292.         break;

  293.     case paramThresh1:

  294.         return thresdb[0];

  295.         break;

  296.     case paramThresh2:

  297.         return thresdb[1];

  298.         break;

  299.     case paramThresh3:

  300.         return thresdb[2];

  301.         break;

  302.     case paramMakeup1:

  303.         return makeup[0];

  304.         break;

  305.     case paramMakeup2:

  306.         return makeup[1];

  307.         break;

  308.     case paramMakeup3:

  309.         return makeup[2];

  310.         break;

  311.     case paramGainR1:

  312.         return gainr[0];

  313.         break;

  314.     case paramGainR2:

  315.         return gainr[1];

  316.         break;

  317.     case paramGainR3:

  318.         return gainr[2];

  319.         break;

  320.     case paramXover1:

  321.         return xover1;

  322.         break;

  323.     case paramXover2:

  324.         return xover2;

  325.         break;

  326.     case paramToggle1:

  327.         return toggle[0];

  328.         break;

  329.     case paramToggle2:

  330.         return toggle[1];

  331.         break;

  332.     case paramToggle3:

  333.         return toggle[2];

  334.         break;

  335.     case paramListen1:

  336.         return listen[0];

  337.         break;

  338.     case paramListen2:

  339.         return listen[1];

  340.         break;

  341.     case paramListen3:

  342.         return listen[2];

  343.         break;

  344.     case paramGlobalGain:

  345.         return globalgain;

  346.         break;

  347.     case paramStereoDet:

  348.         return stereodet;

  349.         break;

  350.     case paramOutputLevelL:

  351.         return outl;

  352.         break;

  353.     case paramOutputLevelR:

  354.         return outr;

  355.         break;

  356.     default:

  357.         return 0.0f;

  358.     }

  359. }

  360. 

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

  362. {

  363.     switch (index)

  364.     {

  365.     case paramAttack:

  366.         attack = value;

  367.         break;

  368.     case paramRelease:

  369.         release = value;

  370.         break;

  371.     case paramKnee:

  372.         knee = value;

  373.         break;

  374.     case paramRatio:

  375.         ratio = value;

  376.         break;

  377.     case paramThresh1:

  378.         thresdb[0] = value;

  379.         break;

  380.     case paramThresh2:

  381.         thresdb[1] = value;

  382.         break;

  383.     case paramThresh3:

  384.         thresdb[2] = value;

  385.         break;

  386.     case paramMakeup1:

  387.         makeup[0] = value;

  388.         break;

  389.     case paramMakeup2:

  390.         makeup[1] = value;

  391.         break;

  392.     case paramMakeup3:

  393.         makeup[2] = value;

  394.         break;

  395.     case paramGainR1:

  396.         gainr[0] = value;

  397.         break;

  398.     case paramGainR2:

  399.         gainr[1] = value;

  400.         break;

  401.     case paramGainR3:

  402.         gainr[2] = value;

  403.         break;

  404.     case paramXover1:

  405.         xover1 = value;

  406.         break;

  407.     case paramXover2:

  408.         xover2 = value;

  409.         break;

  410.     case paramToggle1:

  411.         toggle[0] = value;

  412.         if (value == 0.f)

  413. 	    gainr[0] = 0.f;

  414.         break;

  415.     case paramToggle2:

  416.         toggle[1] = value;

  417.         if (value == 0.f)

  418. 	    gainr[1] = 0.f;

  419.         break;

  420.     case paramToggle3:

  421.         toggle[2] = value;

  422.         if (value == 0.f)

  423. 	    gainr[2] = 0.f;

  424.         break;

  425.     case paramListen1:

  426.         listen[0] = value;

  427.         if (value == 0.f)

  428. 	    gainr[0] = 0.f;

  429.         break;

  430.     case paramListen2:

  431.         listen[1] = value;

  432.         if (value == 0.f)

  433. 	    gainr[1] = 0.f;

  434.         break;

  435.     case paramListen3:

  436.         listen[2] = value;

  437.         if (value == 0.f)

  438. 	    gainr[2] = 0.f;

  439.         break;

  440.     case paramGlobalGain:

  441.         globalgain = value;

  442.         break;

  443.     case paramStereoDet:

  444.         stereodet = value;

  445.         break;

  446.     case paramOutputLevelL:

  447.         outl = value;

  448.         break;

  449.     case paramOutputLevelR:

  450.         outr = value;

  451.         break;

  452.     }

  453. }

  454. 

  455. void ZaMultiCompX2Plugin::d_setProgram(uint32_t index)

  456. {

  457.     if (index != 0)

  458.         return;

  459. 

  460.     /* Default parameter values */

  461.     attack = 10.0f;

  462.     release = 80.0f;

  463.     knee = 0.0f;

  464.     ratio = 4.0f;

  465.     thresdb[0] = -20.0f;

  466.     thresdb[1] = -18.0f;

  467.     thresdb[2] = -16.0f;

  468.     makeup[0] = 0.0f;

  469.     makeup[1] = 0.0f;

  470.     makeup[2] = 0.0f;

  471.     gainr[0] = 0.0f;

  472.     gainr[1] = 0.0f;

  473.     gainr[2] = 0.0f;

  474.     xover1 = 500.0f;

  475.     xover2 = 3000.0f;

  476.     toggle[0] = 0.0f;

  477.     toggle[1] = 0.0f;

  478.     toggle[2] = 0.0f;

  479.     listen[0] = 0.0f;

  480.     listen[1] = 0.0f;

  481.     listen[2] = 0.0f;

  482.     globalgain = 0.0f;

  483.     stereodet = 1.0f;

  484.     outl = -45.f;

  485.     outr = -45.f;

  486.     maxL = 0.f;

  487.     maxR = 0.f;

  488. 

  489.     /* Default variable values */

  490. 

  491.     /* reset filter values */

  492.     d_activate();

  493. }

  494. 

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

  496. {

  497.     resetl = true;

  498.     resetr = true;

  499. }

  500. 

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

  502. {

  503. }

  504. 

  505. // -----------------------------------------------------------------------

  506. // Process

  507. 

  508. void ZaMultiCompX2Plugin::d_activate()

  509. {

  510.         int i,j;

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

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

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

  514. 

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

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

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

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

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

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

  521. 		}

  522.         }

  523. 	maxL = maxR = 0.f;

  524. }

  525. 

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

  527. {

  528.         in = sanitize_denormal(in);

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

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

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

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

  533. 

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

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

  536. 	out = sanitize_denormal(out);

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

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

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

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

  541.         return out;

  542. }

  543. 

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

  545. {

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

  547.         float sn=sin(omega);

  548.         float cs=cos(omega);

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

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

  551. 

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

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

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

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

  556. }

  557. 

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

  559. {

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

  561.         float sn=sin(omega);

  562.         float cs=cos(omega);

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

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

  565. 

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

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

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

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

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

  571. }

  572. 

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

  574. {

  575. 	float srate = d_getSampleRate();

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

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

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

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

  580. 

  581.         float cdb=0.f;

  582.         float Lgain = 1.f;

  583.         float Rgain = 1.f;

  584.         float Lxg, Lyg;

  585.         float Rxg, Ryg;

  586.         float Lxl, Lyl, Ly1;

  587.         float Rxl, Ryl, Ry1;

  588. 

  589.         Lyg = Ryg = 0.f;

  590. 	inL = sanitize_denormal(inL);

  591. 	inR = sanitize_denormal(inR);

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

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

  594.         Lxg = sanitize_denormal(Lxg);

  595.         Rxg = sanitize_denormal(Rxg);

  596. 

  597. 

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

  599.                 Lyg = Lxg;

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

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

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

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

  604.         }

  605. 

  606.         Lyg = sanitize_denormal(Lyg);

  607. 

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

  609.                 Ryg = Rxg;

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

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

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

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

  614.         }

  615. 

  616.         Ryg = sanitize_denormal(Ryg);

  617. 

  618.         if (stereolink == STEREOLINK_MAX) {

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

  620.         } else {

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

  622.         }

  623. 

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

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

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

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

  628. 

  629. 

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

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

  632.         Ly1 = sanitize_denormal(Ly1);

  633.         Lyl = sanitize_denormal(Lyl);

  634. 

  635.         cdb = -Lyl;

  636.         Lgain = from_dB(cdb);

  637. 

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

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

  640.         Ry1 = sanitize_denormal(Ry1);

  641.         Ryl = sanitize_denormal(Ryl);

  642. 

  643.         cdb = -Ryl;

  644.         Rgain = from_dB(cdb);

  645. 

  646.         if (stereolink == STEREOLINK_MAX)

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

  648. 	else

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

  650. 

  651. 	*outL = inL;

  652. 	*outL *= Lgain;

  653. 	*outR = inR;

  654. 	*outR *= Rgain;

  655. 

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

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

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

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

  660. }

  661. 

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

  663. {

  664. 	float srate = d_getSampleRate();

  665. 	float maxxL = maxL;

  666. 	float maxxR = maxR;

  667. 

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

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

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

  671. 

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

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

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

  675. 

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

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

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

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

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

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

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

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

  684. 

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

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

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

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

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

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

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

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

  693. 

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

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

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

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

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

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

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

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

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

  703. 

  704. 		int listenmode = 0;

  705. 

  706. 		// Interleaved channel processing

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

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

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

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

  711. 		if (tog1)

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

  713. 

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

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

  716. 

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

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

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

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

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

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

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

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

  725. 		if (tog2)

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

  727. 

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

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

  730. 

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

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

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

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

  735. 		if (tog3)

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

  737. 

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

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

  740. 

  741. 

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

  743. 		if (listen1) {

  744. 			listenmode = 1;

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

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

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

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

  749. 		}

  750. 		if (listen2) {

  751. 			listenmode = 1;

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

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

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

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

  756. 		}

  757. 		if (listen3) {

  758. 			listenmode = 1;

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

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

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

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

  763. 		}

  764. 		if (!listenmode) {

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

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

  767. 		}

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

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

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

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

  772. 

  773. 		if (resetl) {

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

  775. 			resetl = false;

  776. 		} else {

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

  778. 		}

  779. 		if (resetr) {

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

  781. 			resetr = false;

  782. 		} else {

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

  784. 		}

  785.         }

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

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

  788. }

  789. 

  790. // -----------------------------------------------------------------------

  791. 

  792. Plugin* createPlugin()

  793. {

  794.     return new ZaMultiCompX2Plugin();

  795. }

  796. 

  797. // -----------------------------------------------------------------------

  798. 

  799. END_NAMESPACE_DISTRHO