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.
1786 Commits
16 Branches
218MB
Tree: b71f933a2a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b71f933a2a'
${ noResults }
Carla/source/modules/native-plugins/zamulticomp/ZaMultiCompPlugin.cpp

636 lines
18KB
Raw Blame History 

  1. /*

  2.  * ZaMultiComp mono 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 "ZaMultiCompPlugin.hpp"

  19. 

  20. START_NAMESPACE_DISTRHO

  21. 

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

  23. 

  24. ZaMultiCompPlugin::ZaMultiCompPlugin()

  25.     : Plugin(paramCount, 1, 0) // 1 program, 0 states

  26. {

  27.     // set default values

  28.     d_setProgram(0);

  29. 

  30.     // reset

  31.     d_deactivate();

  32. }

  33. 

  34. ZaMultiCompPlugin::~ZaMultiCompPlugin()

  35. {

  36. }

  37. 

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

  39. // Init

  40. 

  41. void ZaMultiCompPlugin::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 paramThresh:

  82.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  83.         parameter.name       = "Threshold";

  84.         parameter.symbol     = "thr";

  85.         parameter.unit       = "dB";

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

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

  88.         parameter.ranges.max = 0.0f;

  89.         break;

  90.     case paramMakeup1:

  91.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  92.         parameter.name       = "Makeup 1";

  93.         parameter.symbol     = "mak1";

  94.         parameter.unit       = "dB";

  95.         parameter.ranges.def = 0.0f;

  96.         parameter.ranges.min = 0.0f;

  97.         parameter.ranges.max = 30.0f;

  98.         break;

  99.     case paramMakeup2:

  100.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  101.         parameter.name       = "Makeup 2";

  102.         parameter.symbol     = "mak2";

  103.         parameter.unit       = "dB";

  104.         parameter.ranges.def = 0.0f;

  105.         parameter.ranges.min = 0.0f;

  106.         parameter.ranges.max = 30.0f;

  107.         break;

  108.     case paramMakeup3:

  109.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  110.         parameter.name       = "Makeup 3";

  111.         parameter.symbol     = "mak3";

  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 paramGainR1:

  118.         parameter.hints      = PARAMETER_IS_OUTPUT;

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

  120.         parameter.symbol     = "gr1";

  121.         parameter.unit       = "dB";

  122.         parameter.ranges.def = 0.0f;

  123.         parameter.ranges.min = 0.0f;

  124.         parameter.ranges.max = 20.0f;

  125.         break;

  126.     case paramGainR2:

  127.         parameter.hints      = PARAMETER_IS_OUTPUT;

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

  129.         parameter.symbol     = "gr2";

  130.         parameter.unit       = "dB";

  131.         parameter.ranges.def = 0.0f;

  132.         parameter.ranges.min = 0.0f;

  133.         parameter.ranges.max = 20.0f;

  134.         break;

  135.     case paramGainR3:

  136.         parameter.hints      = PARAMETER_IS_OUTPUT;

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

  138.         parameter.symbol     = "gr3";

  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 paramXover1:

  145.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_LOGARITHMIC;

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

  147.         parameter.symbol     = "xover1";

  148.         parameter.unit       = "Hz";

  149.         parameter.ranges.def = 250.0f;

  150.         parameter.ranges.min = 20.0f;

  151.         parameter.ranges.max = 1400.0f;

  152.         break;

  153.     case paramXover2:

  154.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_LOGARITHMIC;

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

  156.         parameter.symbol     = "xover2";

  157.         parameter.unit       = "Hz";

  158.         parameter.ranges.def = 1400.0f;

  159.         parameter.ranges.min = 1400.0f;

  160.         parameter.ranges.max = 14000.0f;

  161.         break;

  162.     case paramToggle1:

  163.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_BOOLEAN;

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

  165.         parameter.symbol     = "toggle1";

  166.         parameter.unit       = " ";

  167.         parameter.ranges.def = 0.0f;

  168.         parameter.ranges.min = 0.0f;

  169.         parameter.ranges.max = 1.0f;

  170.         break;

  171.     case paramToggle2:

  172.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_BOOLEAN;

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

  174.         parameter.symbol     = "toggle2";

  175.         parameter.unit       = " ";

  176.         parameter.ranges.def = 0.0f;

  177.         parameter.ranges.min = 0.0f;

  178.         parameter.ranges.max = 1.0f;

  179.         break;

  180.     case paramToggle3:

  181.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_BOOLEAN;

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

  183.         parameter.symbol     = "toggle3";

  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 paramListen1:

  190.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_BOOLEAN;

  191.         parameter.name       = "Listen 1";

  192.         parameter.symbol     = "listen1";

  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 paramListen2:

  199.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_BOOLEAN;

  200.         parameter.name       = "Listen 2";

  201.         parameter.symbol     = "listen2";

  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 paramListen3:

  208.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_BOOLEAN;

  209.         parameter.name       = "Listen 3";

  210.         parameter.symbol     = "listen3";

  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 paramGlobalGain:

  217.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  218.         parameter.name       = "Master Trim";

  219.         parameter.symbol     = "globalgain";

  220.         parameter.unit       = "dB";

  221.         parameter.ranges.def = 0.0f;

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

  223.         parameter.ranges.max = 12.0f;

  224.         break;

  225.     case paramOutputLevel:

  226.         parameter.hints      = PARAMETER_IS_OUTPUT;

  227.         parameter.name       = "Output Level";

  228.         parameter.symbol     = "outlevel";

  229.         parameter.unit       = "dB";

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

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

  232.         parameter.ranges.max = 20.0f;

  233.         break;

  234.     }

  235. }

  236. 

  237. void ZaMultiCompPlugin::d_initProgramName(uint32_t index, d_string& programName)

  238. {

  239.     if (index != 0)

  240.         return;

  241. 

  242.     programName = "Default";

  243. }

  244. 

  245. // -----------------------------------------------------------------------

  246. // Internal data

  247. 

  248. float ZaMultiCompPlugin::d_getParameterValue(uint32_t index) const

  249. {

  250.     switch (index)

  251.     {

  252.     case paramAttack:

  253.         return attack;

  254.         break;

  255.     case paramRelease:

  256.         return release;

  257.         break;

  258.     case paramKnee:

  259.         return knee;

  260.         break;

  261.     case paramRatio:

  262.         return ratio;

  263.         break;

  264.     case paramThresh:

  265.         return thresdb;

  266.         break;

  267.     case paramMakeup1:

  268.         return makeup[0];

  269.         break;

  270.     case paramMakeup2:

  271.         return makeup[1];

  272.         break;

  273.     case paramMakeup3:

  274.         return makeup[2];

  275.         break;

  276.     case paramGainR1:

  277.         return gainr[0];

  278.         break;

  279.     case paramGainR2:

  280.         return gainr[1];

  281.         break;

  282.     case paramGainR3:

  283.         return gainr[2];

  284.         break;

  285.     case paramXover1:

  286.         return xover1;

  287.         break;

  288.     case paramXover2:

  289.         return xover2;

  290.         break;

  291.     case paramToggle1:

  292.         return toggle[0];

  293.         break;

  294.     case paramToggle2:

  295.         return toggle[1];

  296.         break;

  297.     case paramToggle3:

  298.         return toggle[2];

  299.         break;

  300.     case paramListen1:

  301.         return listen[0];

  302.         break;

  303.     case paramListen2:

  304.         return listen[1];

  305.         break;

  306.     case paramListen3:

  307.         return listen[2];

  308.         break;

  309.     case paramGlobalGain:

  310.         return globalgain;

  311.         break;

  312.     case paramOutputLevel:

  313.         return outlevel;

  314.         break;

  315.     default:

  316.         return 0.0f;

  317.     }

  318. }

  319. 

  320. void ZaMultiCompPlugin::d_setParameterValue(uint32_t index, float value)

  321. {

  322.     switch (index)

  323.     {

  324.     case paramAttack:

  325.         attack = value;

  326.         break;

  327.     case paramRelease:

  328.         release = value;

  329.         break;

  330.     case paramKnee:

  331.         knee = value;

  332.         break;

  333.     case paramRatio:

  334.         ratio = value;

  335.         break;

  336.     case paramThresh:

  337.         thresdb = value;

  338.         break;

  339.     case paramMakeup1:

  340.         makeup[0] = value;

  341.         break;

  342.     case paramMakeup2:

  343.         makeup[1] = value;

  344.         break;

  345.     case paramMakeup3:

  346.         makeup[2] = value;

  347.         break;

  348.     case paramGainR1:

  349.         gainr[0] = value;

  350.         break;

  351.     case paramGainR2:

  352.         gainr[1] = value;

  353.         break;

  354.     case paramGainR3:

  355.         gainr[2] = value;

  356.         break;

  357.     case paramXover1:

  358.         xover1 = value;

  359.         break;

  360.     case paramXover2:

  361.         xover2 = value;

  362.         break;

  363.     case paramToggle1:

  364.         toggle[0] = value;

  365. 	if (value == 0.f)

  366. 	    gainr[0] = 0.f;

  367.         break;

  368.     case paramToggle2:

  369.         toggle[1] = value;

  370. 	if (value == 0.f)

  371. 	    gainr[1] = 0.f;

  372.         break;

  373.     case paramToggle3:

  374.         toggle[2] = value;

  375. 	if (value == 0.f)

  376. 	    gainr[2] = 0.f;

  377.         break;

  378.     case paramListen1:

  379.         listen[0] = value;

  380. 	if (value == 0.f)

  381. 	    gainr[0] = 0.f;

  382.         break;

  383.     case paramListen2:

  384.         listen[1] = value;

  385. 	if (value == 0.f)

  386. 	    gainr[1] = 0.f;

  387.         break;

  388.     case paramListen3:

  389.         listen[2] = value;

  390. 	if (value == 0.f)

  391. 	    gainr[2] = 0.f;

  392.         break;

  393.     case paramGlobalGain:

  394.         globalgain = value;

  395.         break;

  396.     case paramOutputLevel:

  397.         outlevel = value;

  398.         break;

  399.     }

  400. }

  401. 

  402. void ZaMultiCompPlugin::d_setProgram(uint32_t index)

  403. {

  404.     if (index != 0)

  405.         return;

  406. 

  407.     /* Default parameter values */

  408.     attack = 10.0f;

  409.     release = 80.0f;

  410.     knee = 0.0f;

  411.     ratio = 4.0f;

  412.     thresdb = -16.0f;

  413.     makeup[0] = 0.0f;

  414.     makeup[1] = 0.0f;

  415.     makeup[2] = 0.0f;

  416.     gainr[0] = 0.0f;

  417.     gainr[1] = 0.0f;

  418.     gainr[2] = 0.0f;

  419.     xover1 = 250.0f;

  420.     xover2 = 1400.0f;

  421.     toggle[0] = 0.0f;

  422.     toggle[1] = 0.0f;

  423.     toggle[2] = 0.0f;

  424.     listen[0] = 0.0f;

  425.     listen[1] = 0.0f;

  426.     listen[2] = 0.0f;

  427.     globalgain = 0.0f;

  428.     outlevel = -45.0f;

  429. 

  430.     /* Default variable values */

  431. 

  432.     /* reset filter values */

  433.     d_activate();

  434. }

  435. 

  436. // -----------------------------------------------------------------------

  437. // Process

  438. 

  439. void ZaMultiCompPlugin::d_activate()

  440. {

  441.         int i;

  442.         for (i = 0; i < MAX_COMP; i++) {

  443.                 old_yl[i]=old_y1[i]=0.f;

  444.         }

  445. 

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

  447.                 a0[i] = a1[i] = a2[i] = 0.f;

  448.                 b1[i] = b2[i] = 0.f;

  449.                 w1[i] = w2[i] = 0.f;

  450.                 z1[i] = z2[i] = 0.f;

  451.         }

  452. }

  453. 

  454. void ZaMultiCompPlugin::d_deactivate()

  455. {

  456.     // all values to zero

  457. }

  458. 

  459. float ZaMultiCompPlugin::run_filter(int i, float in)

  460. {

  461.         in = sanitize_denormal(in);

  462. 	w1[i] = sanitize_denormal(w1[i]);

  463. 	w2[i] = sanitize_denormal(w2[i]);

  464. 	z1[i] = sanitize_denormal(z1[i]);

  465. 	z2[i] = sanitize_denormal(z2[i]);

  466. 

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

  468. 			- z1[i] * b1[i] - z2[i] * b2[i];

  469. 	out = sanitize_denormal(out);

  470.         w2[i] = w1[i];

  471.         z2[i] = z1[i];

  472. 	w1[i] = in;

  473.         z1[i] = out;

  474.         return out;

  475. }

  476. 

  477. void ZaMultiCompPlugin::set_lp_coeffs(float fc, float q, float sr, int i, float gain=1.0)

  478. {

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

  480.         float sn=sin(omega);

  481.         float cs=cos(omega);

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

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

  484. 

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

  486.         a1[i] = a0[i] + a0[i];

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

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

  489. }

  490. 

  491. void ZaMultiCompPlugin::set_hp_coeffs(float fc, float q, float sr, int i, float gain=1.0) 

  492. {       

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

  494.         float sn=sin(omega);

  495.         float cs=cos(omega);

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

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

  498.         

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

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

  501.         a2[i] =  a0[i];

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

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

  504. }

  505. 

  506. float ZaMultiCompPlugin::run_comp(int k, float in)

  507. {

  508. 	float srate = d_getSampleRate();

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

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

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

  512. 

  513.         float cdb=0.f;

  514.         float gain = 1.f;

  515.         float xg, xl, yg, yl, y1;

  516.         float out;

  517. 

  518.         yg=0.f;

  519. 	in = sanitize_denormal(in);

  520.         xg = (in==0.f) ? -160.f : to_dB(fabs(in));

  521. 	xg = sanitize_denormal(xg);

  522. 

  523.         if (2.f*(xg-thresdb)<-width) {

  524.                 yg = xg;

  525.         } else if (2.f*fabs(xg-thresdb)<=width) {

  526.                 yg = xg + (1.f/ratio-1.f)*(xg-thresdb+width/2.f)*(xg-thresdb+width/2.f)/(2.f*width);

  527.         } else if (2.f*(xg-thresdb)>width) {

  528.                 yg = thresdb + (xg-thresdb)/ratio;

  529.         }

  530. 

  531.         yg = sanitize_denormal(yg);

  532. 

  533.         xl = xg - yg;

  534.         old_y1[k] = sanitize_denormal(old_y1[k]);

  535.         old_yl[k] = sanitize_denormal(old_yl[k]);

  536. 

  537.         y1 = fmaxf(xl, release_coeff * old_y1[k]+(1.f-release_coeff)*xl);

  538.         yl = attack_coeff * old_yl[k]+(1.f-attack_coeff)*y1;

  539.         y1 = sanitize_denormal(y1);

  540.         yl = sanitize_denormal(yl);

  541. 

  542.         cdb = -yl;

  543.         gain = from_dB(cdb);

  544.         gainr[k] = yl;

  545. 

  546.         out = in;

  547.         out *= gain;

  548. 

  549.         old_yl[k] = yl;

  550.         old_y1[k] = y1;

  551.         return sanitize_denormal(out);

  552. }

  553. 

  554. void ZaMultiCompPlugin::d_run(float** inputs, float** outputs, uint32_t frames)

  555. {

  556. 	float srate = d_getSampleRate();

  557. 	float max = 0.f;

  558. 

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

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

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

  562. 

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

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

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

  566. 

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

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

  569.         set_hp_coeffs(xover1, ONEOVERROOT2, srate, 2);

  570.         set_hp_coeffs(xover1, ONEOVERROOT2, srate, 3);

  571.         set_lp_coeffs(xover2, ONEOVERROOT2, srate, 4);

  572.         set_lp_coeffs(xover2, ONEOVERROOT2, srate, 5);

  573.         set_hp_coeffs(xover2, ONEOVERROOT2, srate, 6);

  574.         set_hp_coeffs(xover2, ONEOVERROOT2, srate, 7);

  575. 

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

  577.                 float tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, fil1, fil2, fil3, fil4;

  578. 		float cmp1, cmp2, cmp3, in;

  579. 		int listenmode = 0;

  580. 		in = sanitize_denormal(inputs[0][i]);

  581. 		in = (fabs(in) < DANGER) ? in : 0.f;

  582.                 fil1 = run_filter(0, in);

  583.                 tmp1 = run_filter(1, fil1);

  584. 		cmp1 = (!tog1 && !listen1) ? 0.f : run_comp(0, tmp1);

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

  586.                 fil2 = run_filter(2, in);

  587.                 tmp3 = run_filter(3, fil2);

  588.                 fil3 = run_filter(4, tmp3);

  589.                 tmp4 = run_filter(5, fil3);

  590. 		cmp2 = (!tog2 && !listen2) ? 0.f : run_comp(1, tmp4);

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

  592.                 fil4 = run_filter(6, in);

  593.                 tmp5 = run_filter(7, fil4);

  594. 		cmp3 = (!tog3 && !listen3) ? 0.f : run_comp(2, tmp5);

  595.                 tmp6 = (tog3) ? cmp3 * from_dB(makeup[2]) : tmp5;

  596.         	outputs[0][i] = 0.f;

  597. 		if (listen1) {

  598. 			listenmode = 1;

  599. 			outputs[0][i] += cmp1 * tog1*from_dB(makeup[0])

  600. 					+ (1.-tog1) * tmp1;

  601. 		}

  602. 		if (listen2) {

  603. 			listenmode = 1;

  604. 			outputs[0][i] += cmp2 * tog2*from_dB(makeup[1])

  605. 					+ (1.-tog2) * tmp4;

  606. 		}

  607. 		if (listen3) {

  608. 			listenmode = 1;

  609. 			outputs[0][i] += cmp3 * tog3*from_dB(makeup[2])

  610. 					+ (1.-tog3) * tmp5;

  611. 		}

  612. 		if (!listenmode) {

  613. 			outputs[0][i] = 0.f;

  614. 			outputs[0][i] += tmp2;

  615. 			outputs[0][i] += tmp3;

  616. 			outputs[0][i] += tmp6;

  617. 		}

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

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

  620. 

  621. 		max = (fabsf(outputs[0][i]) > max) ? fabsf(outputs[0][i]) : sanitize_denormal(max);

  622.         }

  623. 	outlevel = (max == 0.f) ? -45.f : to_dB(max);

  624. }

  625. 

  626. // -----------------------------------------------------------------------

  627. 

  628. Plugin* createPlugin()

  629. {

  630.     return new ZaMultiCompPlugin();

  631. }

  632. 

  633. // -----------------------------------------------------------------------

  634. 

  635. END_NAMESPACE_DISTRHO