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

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

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

  32. // Init

  33. 

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

  75.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  76.         parameter.name       = "Threshold";

  77.         parameter.symbol     = "thr";

  78.         parameter.unit       = "dB";

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

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

  81.         parameter.ranges.max = 0.0f;

  82.         break;

  83.     case paramMakeup1:

  84.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  85.         parameter.name       = "Makeup 1";

  86.         parameter.symbol     = "mak1";

  87.         parameter.unit       = "dB";

  88.         parameter.ranges.def = 0.0f;

  89.         parameter.ranges.min = 0.0f;

  90.         parameter.ranges.max = 30.0f;

  91.         break;

  92.     case paramMakeup2:

  93.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  94.         parameter.name       = "Makeup 2";

  95.         parameter.symbol     = "mak2";

  96.         parameter.unit       = "dB";

  97.         parameter.ranges.def = 0.0f;

  98.         parameter.ranges.min = 0.0f;

  99.         parameter.ranges.max = 30.0f;

  100.         break;

  101.     case paramMakeup3:

  102.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  103.         parameter.name       = "Makeup 3";

  104.         parameter.symbol     = "mak3";

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

  111.         parameter.hints      = PARAMETER_IS_OUTPUT;

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

  113.         parameter.symbol     = "gr1";

  114.         parameter.unit       = "dB";

  115.         parameter.ranges.def = 0.0f;

  116.         parameter.ranges.min = 0.0f;

  117.         parameter.ranges.max = 20.0f;

  118.         break;

  119.     case paramGainR2:

  120.         parameter.hints      = PARAMETER_IS_OUTPUT;

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

  122.         parameter.symbol     = "gr2";

  123.         parameter.unit       = "dB";

  124.         parameter.ranges.def = 0.0f;

  125.         parameter.ranges.min = 0.0f;

  126.         parameter.ranges.max = 20.0f;

  127.         break;

  128.     case paramGainR3:

  129.         parameter.hints      = PARAMETER_IS_OUTPUT;

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

  131.         parameter.symbol     = "gr3";

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

  138.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_LOGARITHMIC;

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

  140.         parameter.symbol     = "xover1";

  141.         parameter.unit       = "Hz";

  142.         parameter.ranges.def = 250.0f;

  143.         parameter.ranges.min = 20.0f;

  144.         parameter.ranges.max = 1400.0f;

  145.         break;

  146.     case paramXover2:

  147.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_LOGARITHMIC;

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

  149.         parameter.symbol     = "xover2";

  150.         parameter.unit       = "Hz";

  151.         parameter.ranges.def = 1400.0f;

  152.         parameter.ranges.min = 1400.0f;

  153.         parameter.ranges.max = 14000.0f;

  154.         break;

  155.     case paramToggle1:

  156.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_BOOLEAN;

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

  158.         parameter.symbol     = "toggle1";

  159.         parameter.unit       = " ";

  160.         parameter.ranges.def = 0.0f;

  161.         parameter.ranges.min = 0.0f;

  162.         parameter.ranges.max = 1.0f;

  163.         break;

  164.     case paramToggle2:

  165.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_BOOLEAN;

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

  167.         parameter.symbol     = "toggle2";

  168.         parameter.unit       = " ";

  169.         parameter.ranges.def = 0.0f;

  170.         parameter.ranges.min = 0.0f;

  171.         parameter.ranges.max = 1.0f;

  172.         break;

  173.     case paramToggle3:

  174.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_BOOLEAN;

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

  176.         parameter.symbol     = "toggle3";

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

  183.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_BOOLEAN;

  184.         parameter.name       = "Listen 1";

  185.         parameter.symbol     = "listen1";

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

  192.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_BOOLEAN;

  193.         parameter.name       = "Listen 2";

  194.         parameter.symbol     = "listen2";

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

  201.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_BOOLEAN;

  202.         parameter.name       = "Listen 3";

  203.         parameter.symbol     = "listen3";

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

  210.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  211.         parameter.name       = "Master Trim";

  212.         parameter.symbol     = "globalgain";

  213.         parameter.unit       = "dB";

  214.         parameter.ranges.def = 0.0f;

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

  216.         parameter.ranges.max = 12.0f;

  217.         break;

  218.     case paramOutputLevel:

  219.         parameter.hints      = PARAMETER_IS_OUTPUT;

  220.         parameter.name       = "Output Level";

  221.         parameter.symbol     = "outlevel";

  222.         parameter.unit       = "dB";

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

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

  225.         parameter.ranges.max = 20.0f;

  226.         break;

  227.     }

  228. }

  229. 

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

  231. {

  232.     if (index != 0)

  233.         return;

  234. 

  235.     programName = "Default";

  236. }

  237. 

  238. // -----------------------------------------------------------------------

  239. // Internal data

  240. 

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

  242. {

  243.     switch (index)

  244.     {

  245.     case paramAttack:

  246.         return attack;

  247.         break;

  248.     case paramRelease:

  249.         return release;

  250.         break;

  251.     case paramKnee:

  252.         return knee;

  253.         break;

  254.     case paramRatio:

  255.         return ratio;

  256.         break;

  257.     case paramThresh:

  258.         return thresdb;

  259.         break;

  260.     case paramMakeup1:

  261.         return makeup[0];

  262.         break;

  263.     case paramMakeup2:

  264.         return makeup[1];

  265.         break;

  266.     case paramMakeup3:

  267.         return makeup[2];

  268.         break;

  269.     case paramGainR1:

  270.         return gainr[0];

  271.         break;

  272.     case paramGainR2:

  273.         return gainr[1];

  274.         break;

  275.     case paramGainR3:

  276.         return gainr[2];

  277.         break;

  278.     case paramXover1:

  279.         return xover1;

  280.         break;

  281.     case paramXover2:

  282.         return xover2;

  283.         break;

  284.     case paramToggle1:

  285.         return toggle[0];

  286.         break;

  287.     case paramToggle2:

  288.         return toggle[1];

  289.         break;

  290.     case paramToggle3:

  291.         return toggle[2];

  292.         break;

  293.     case paramListen1:

  294.         return listen[0];

  295.         break;

  296.     case paramListen2:

  297.         return listen[1];

  298.         break;

  299.     case paramListen3:

  300.         return listen[2];

  301.         break;

  302.     case paramGlobalGain:

  303.         return globalgain;

  304.         break;

  305.     case paramOutputLevel:

  306.         return outlevel;

  307.         break;

  308.     default:

  309.         return 0.0f;

  310.     }

  311. }

  312. 

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

  314. {

  315.     switch (index)

  316.     {

  317.     case paramAttack:

  318.         attack = value;

  319.         break;

  320.     case paramRelease:

  321.         release = value;

  322.         break;

  323.     case paramKnee:

  324.         knee = value;

  325.         break;

  326.     case paramRatio:

  327.         ratio = value;

  328.         break;

  329.     case paramThresh:

  330.         thresdb = value;

  331.         break;

  332.     case paramMakeup1:

  333.         makeup[0] = value;

  334.         break;

  335.     case paramMakeup2:

  336.         makeup[1] = value;

  337.         break;

  338.     case paramMakeup3:

  339.         makeup[2] = value;

  340.         break;

  341.     case paramGainR1:

  342.         gainr[0] = value;

  343.         break;

  344.     case paramGainR2:

  345.         gainr[1] = value;

  346.         break;

  347.     case paramGainR3:

  348.         gainr[2] = value;

  349.         break;

  350.     case paramXover1:

  351.         xover1 = value;

  352.         break;

  353.     case paramXover2:

  354.         xover2 = value;

  355.         break;

  356.     case paramToggle1:

  357.         toggle[0] = value;

  358. 	if (value == 0.f)

  359. 	    gainr[0] = 0.f;

  360.         break;

  361.     case paramToggle2:

  362.         toggle[1] = value;

  363. 	if (value == 0.f)

  364. 	    gainr[1] = 0.f;

  365.         break;

  366.     case paramToggle3:

  367.         toggle[2] = value;

  368. 	if (value == 0.f)

  369. 	    gainr[2] = 0.f;

  370.         break;

  371.     case paramListen1:

  372.         listen[0] = value;

  373. 	if (value == 0.f)

  374. 	    gainr[0] = 0.f;

  375.         break;

  376.     case paramListen2:

  377.         listen[1] = value;

  378. 	if (value == 0.f)

  379. 	    gainr[1] = 0.f;

  380.         break;

  381.     case paramListen3:

  382.         listen[2] = value;

  383. 	if (value == 0.f)

  384. 	    gainr[2] = 0.f;

  385.         break;

  386.     case paramGlobalGain:

  387.         globalgain = value;

  388.         break;

  389.     case paramOutputLevel:

  390.         outlevel = value;

  391.         break;

  392.     }

  393. }

  394. 

  395. void ZaMultiCompPlugin::d_setProgram(uint32_t index)

  396. {

  397.     if (index != 0)

  398.         return;

  399. 

  400.     /* Default parameter values */

  401.     attack = 10.0f;

  402.     release = 80.0f;

  403.     knee = 0.0f;

  404.     ratio = 4.0f;

  405.     thresdb = -16.0f;

  406.     makeup[0] = 0.0f;

  407.     makeup[1] = 0.0f;

  408.     makeup[2] = 0.0f;

  409.     gainr[0] = 0.0f;

  410.     gainr[1] = 0.0f;

  411.     gainr[2] = 0.0f;

  412.     xover1 = 250.0f;

  413.     xover2 = 1400.0f;

  414.     toggle[0] = 0.0f;

  415.     toggle[1] = 0.0f;

  416.     toggle[2] = 0.0f;

  417.     listen[0] = 0.0f;

  418.     listen[1] = 0.0f;

  419.     listen[2] = 0.0f;

  420.     globalgain = 0.0f;

  421.     outlevel = -45.0f;

  422. 

  423.     /* Default variable values */

  424. 

  425.     /* reset filter values */

  426.     d_activate();

  427. }

  428. 

  429. // -----------------------------------------------------------------------

  430. // Process

  431. 

  432. void ZaMultiCompPlugin::d_activate()

  433. {

  434.         int i;

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

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

  437.         }

  438. 

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

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

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

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

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

  444.         }

  445. }

  446. 

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

  448. {

  449.         in = sanitize_denormal(in);

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

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

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

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

  454. 

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

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

  457. 	out = sanitize_denormal(out);

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

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

  460. 	w1[i] = in;

  461.         z1[i] = out;

  462.         return out;

  463. }

  464. 

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

  466. {

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

  468.         float sn=sin(omega);

  469.         float cs=cos(omega);

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

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

  472. 

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

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

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

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

  477. }

  478. 

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

  480. {

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

  482.         float sn=sin(omega);

  483.         float cs=cos(omega);

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

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

  486. 

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

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

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

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

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

  492. }

  493. 

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

  495. {

  496. 	float srate = d_getSampleRate();

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

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

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

  500. 

  501.         float cdb=0.f;

  502.         float gain = 1.f;

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

  504.         float out;

  505. 

  506.         yg=0.f;

  507. 	in = sanitize_denormal(in);

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

  509. 	xg = sanitize_denormal(xg);

  510. 

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

  512.                 yg = xg;

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

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

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

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

  517.         }

  518. 

  519.         yg = sanitize_denormal(yg);

  520. 

  521.         xl = xg - yg;

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

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

  524. 

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

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

  527.         y1 = sanitize_denormal(y1);

  528.         yl = sanitize_denormal(yl);

  529. 

  530.         cdb = -yl;

  531.         gain = from_dB(cdb);

  532.         gainr[k] = yl;

  533. 

  534.         out = in;

  535.         out *= gain;

  536. 

  537.         old_yl[k] = yl;

  538.         old_y1[k] = y1;

  539.         return sanitize_denormal(out);

  540. }

  541. 

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

  543. {

  544. 	float srate = d_getSampleRate();

  545. 	float max = 0.f;

  546. 

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

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

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

  550. 

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

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

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

  554. 

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

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

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

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

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

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

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

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

  563. 

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

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

  566. 		float cmp1, cmp2, cmp3, in;

  567. 		int listenmode = 0;

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

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

  570.                 fil1 = run_filter(0, in);

  571.                 tmp1 = run_filter(1, fil1);

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

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

  574.                 fil2 = run_filter(2, in);

  575.                 tmp3 = run_filter(3, fil2);

  576.                 fil3 = run_filter(4, tmp3);

  577.                 tmp4 = run_filter(5, fil3);

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

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

  580.                 fil4 = run_filter(6, in);

  581.                 tmp5 = run_filter(7, fil4);

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

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

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

  585. 		if (listen1) {

  586. 			listenmode = 1;

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

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

  589. 		}

  590. 		if (listen2) {

  591. 			listenmode = 1;

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

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

  594. 		}

  595. 		if (listen3) {

  596. 			listenmode = 1;

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

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

  599. 		}

  600. 		if (!listenmode) {

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

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

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

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

  605. 		}

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

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

  608. 

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

  610.         }

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

  612. }

  613. 

  614. // -----------------------------------------------------------------------

  615. 

  616. Plugin* createPlugin()

  617. {

  618.     return new ZaMultiCompPlugin();

  619. }

  620. 

  621. // -----------------------------------------------------------------------

  622. 

  623. END_NAMESPACE_DISTRHO