void ZamEQ2Plugin::d_run(const float** inputs, float** outputs, uint32_t frames) { float srate = d_getSampleRate(); lowshelf(0, 0, srate, freql, gainl); peq(1, 0, srate, freq1, gain1, q1); peq(2, 0, srate, freq2, gain2, q2); highshelf(3, 0, srate, freqh, gainh); for (uint32_t i = 0; i < frames; i++) { double tmp,tmpl, tmph; double in = inputs[0][i]; in = sanitize_denormal(in); //lowshelf tmpl = (gainl == 0.f) ? in : run_filter(0, 0, in); //highshelf tmph = (gainh == 0.f) ? tmpl : run_filter(3, 0, tmpl); //parametric1 tmp = (gain1 == 0.f) ? tmph : run_filter(1, 0, tmph); //parametric2 tmpl = (gain2 == 0.f) ? tmp : run_filter(2, 0, tmp); outputs[0][i] = inputs[0][i]; outputs[0][i] = (float) tmpl; outputs[0][i] *= from_dB(master); } }
float ZamEQ2Plugin::run_filter(int i, int ch, double in) { double out; in = sanitize_denormal(in); out = in * b0[ch][i] + x1[ch][i] * b1[ch][i] + x2[ch][i] * b2[ch][i] - y1[ch][i] * a1[ch][i] - y2[ch][i] * a2[ch][i] + 1e-20f; out = sanitize_denormal(out); x2[ch][i] = sanitize_denormal(x1[ch][i]); y2[ch][i] = sanitize_denormal(y1[ch][i]); x1[ch][i] = in; y1[ch][i] = out; return (float) out; }
static float runfilter(LV2_Handle instance, float in) { ADelay* a = (ADelay*)instance; float out; in = sanitize_denormal(in); out = a->B0/a->A0*in + a->B1/a->A0*a->state[0] + a->B2/a->A0*a->state[1] -a->A1/a->A0*a->state[2] - a->A2/a->A0*a->state[3] + 1e-20; a->state[1] = a->state[0]; a->state[0] = in; a->state[3] = a->state[2]; a->state[2] = out; return out; }
float ZaMultiCompX2Plugin::run_filter(int i, int ch, float in) { in = sanitize_denormal(in); w1[ch][i] = sanitize_denormal(w1[ch][i]); w2[ch][i] = sanitize_denormal(w2[ch][i]); z1[ch][i] = sanitize_denormal(z1[ch][i]); z2[ch][i] = sanitize_denormal(z2[ch][i]); float out = in * a0[ch][i] + w1[ch][i] * a1[ch][i] + w2[ch][i] * a2[ch][i] - z1[ch][i] * b1[ch][i] - z2[ch][i] * b2[ch][i]; out = sanitize_denormal(out); w2[ch][i] = w1[ch][i]; z2[ch][i] = z1[ch][i]; w1[ch][i] = in; z1[ch][i] = out; return out; }
void ZamPianoPlugin::run(const float** inputs, float** outputs, uint32_t frames, const MidiEvent* midievent, uint32_t midicount) { uint32_t i, j; bool signal; int gate = 1; for (i = 0; i < 88; i++) { N[i].pbright = pbright; N[i].phammer = phammer; N[i].pstiff = pstiff; N[i].pdetune = pdetune; N[i].prevgain = prevgain; N[i].prevroom = prevroom; N[i].ppanangle = ppanangle; N[i].pspatialwidth = pspatialwidth; for (j = 0; j < frames; j++) { intermed[i][0][j] = 0.f; intermed[i][1][j] = 0.f; } } for (i = 0; i < midicount; i++) { int type = midievent[i].data[0] & 0xF0; int chan = midievent[i].data[0] & 0x0F; int n = midievent[i].data[1]; int v = midievent[i].data[2]; if (type == 0x90 && chan == 0x0) { // NOTE ON note[n].state = STRIKE; note[n].vel = v / 127.f; gate = 0; } else if (type == 0x80 && chan == 0x0) { // NOTE OFF gate = 1; if (note[n].state != SILENT) { note[n].state = RELEASE; } } } for (i = 0; i < frames; i++) { outputs[0][i] = 0.f; outputs[1][i] = 0.f; } signal = false; int k; for (k = 0; k < 88; k++) { if (note[k].state == SILENT) { N[k].pgate = 1.; continue; } signal = true; if (note[k].state == STRIKE) { //printf("STRIKE: %d\n", k); N[k].pfreq = 220. * powf(2., (k-69)/12.); N[k].pgain = note[k].vel; N[k].pgate = 0.; N[k].compute(1, inputs, intermed[k]); N[k].pgate = 1.; note[k].state++; } else if (note[k].state < RELEASE) { //printf("SUSTAIN: %d %d\n", k, note[k].state); note[k].state++; } else if (note[k].state < DECAY) { //printf("RELEASE: %d %d\n", k, note[k].state); //N[k].pfreq = 440. * powf(2., (k-69)/12.); N[k].pgain = 0.; //N[k].pgate = 0.; //N[k].compute(1, inputs, intermed[k]); N[k].pgate = 1.; note[k].state++; } else if (note[k].state < SILENT) { //printf("DECAY: %d %d\n", k, note[k].state); note[k].state++; } N[k].compute(frames, inputs, intermed[k]); } for (i = 0; i < 88; i++) { for (j = 0; j < frames; j++) { outputs[0][j] += intermed[i][0][j] * 0.1; outputs[1][j] += intermed[i][1][j] * 0.1; } } for (i = 0; i < frames; i++) { if (signal) { sanitize_denormal(outputs[0][i]); sanitize_denormal(outputs[1][i]); } else { outputs[0][i] = 0.f; outputs[1][i] = 0.f; } } }
void ZaMaximX2Plugin::run(const float** inputs, float** outputs, uint32_t frames) { uint32_t i; float N = (float)MAX_SAMPLES; float M = (float)MAX_SAMPLES; float absx[2]; float c[2]; float xmax[2]; float emax[2]; float eavg[2]; float g[2]; float srate = getSampleRate(); float alpha = 1.01; float a = 1. - exp(log((alpha - 1.) / (alpha)) / (N + 1.)); float beta = 0.f; for (i = 0; i < M; i++) { beta += powf(1. - a, N + 1. - i); } beta /= M; float maxx; float inL, inR; for (i = 0; i < frames; i++) { inL = inputs[0][i]; inR = inputs[1][i]; absx[0] = fabsf(inL); c[0] = MAX(absx[0], (absx[0]-beta*emaxn[0][pose[0]]) / (1. - beta)); pushsample(&cn[0][0], sanitize_denormal(c[0]), &posc[0]); xmax[0] = maxsample(&cn[0][0]); if (xmax[0] < emaxn[0][pose[0]]) { a = 1000 / (release * srate); } emax[0] = a*xmax[0] + (1. - a)*emaxn[0][pose[0]]; eavg[0] = avgall(&emaxn[0][0]); if (eavg[0] == 0.f) { g[0] = 1.; } else { g[0] = MIN(1., from_dB(thresdb) / eavg[0]); } absx[1] = fabsf(inR); c[1] = MAX(absx[1], (absx[1]-beta*emaxn[1][pose[1]]) / (1. - beta)); pushsample(&cn[1][0], sanitize_denormal(c[1]), &posc[1]); xmax[1] = maxsample(&cn[1][0]); if (xmax[1] < emaxn[1][pose[1]]) { a = 1000 / (release * srate); } else { a = 1. - exp(log((alpha-1.) / (alpha)) / (N + 1.)); } emax[1] = a*xmax[1] + (1. - a)*emaxn[1][pose[1]]; eavg[1] = avgall(&emaxn[1][0]); if (eavg[1] == 0.f) { g[1] = 1.; } else { g[1] = MIN(1., from_dB(thresdb) / eavg[1]); } maxx = MAX(xmax[0], xmax[1]); gainred = MAX(-to_dB(g[0]), -to_dB(g[1])); outlevel = sanitize_denormal(to_dB(maxx)) + (ceiling - thresdb); outputs[0][i] = inL; outputs[1][i] = inR; outputs[0][i] = clip(normalise(z[0][posz[0]] * g[0], 0.)); outputs[1][i] = clip(normalise(z[1][posz[1]] * g[1], 0.)); pushsample(&z[0][0], sanitize_denormal(inL), &posz[0]); pushsample(&emaxn[0][0], sanitize_denormal(emax[0]), &pose[0]); pushsample(&z[1][0], sanitize_denormal(inR), &posz[1]); pushsample(&emaxn[1][0], sanitize_denormal(emax[1]), &pose[1]); emax_old[0] = sanitize_denormal(emax[0]); eavg_old[0] = sanitize_denormal(eavg[0]); emax_old[1] = sanitize_denormal(emax[1]); eavg_old[1] = sanitize_denormal(eavg[1]); } }
void ZaMultiCompX2Plugin::d_run(const float** inputs, float** outputs, uint32_t frames) { float srate = d_getSampleRate(); float maxxL = maxL; float maxxR = maxR; int tog1 = (toggle[0] > 0.5f) ? 1 : 0; int tog2 = (toggle[1] > 0.5f) ? 1 : 0; int tog3 = (toggle[2] > 0.5f) ? 1 : 0; int listen1 = (listen[0] > 0.5f) ? 1 : 0; int listen2 = (listen[1] > 0.5f) ? 1 : 0; int listen3 = (listen[2] > 0.5f) ? 1 : 0; set_lp_coeffs(xover1, ONEOVERROOT2, srate, 0, 0); set_lp_coeffs(xover1, ONEOVERROOT2, srate, 1, 0); set_hp_coeffs(xover1, ONEOVERROOT2, srate, 2, 0); set_hp_coeffs(xover1, ONEOVERROOT2, srate, 3, 0); set_lp_coeffs(xover2, ONEOVERROOT2, srate, 4, 0); set_lp_coeffs(xover2, ONEOVERROOT2, srate, 5, 0); set_hp_coeffs(xover2, ONEOVERROOT2, srate, 6, 0); set_hp_coeffs(xover2, ONEOVERROOT2, srate, 7, 0); set_lp_coeffs(xover1, ONEOVERROOT2, srate, 0, 1); set_lp_coeffs(xover1, ONEOVERROOT2, srate, 1, 1); set_hp_coeffs(xover1, ONEOVERROOT2, srate, 2, 1); set_hp_coeffs(xover1, ONEOVERROOT2, srate, 3, 1); set_lp_coeffs(xover2, ONEOVERROOT2, srate, 4, 1); set_lp_coeffs(xover2, ONEOVERROOT2, srate, 5, 1); set_hp_coeffs(xover2, ONEOVERROOT2, srate, 6, 1); set_hp_coeffs(xover2, ONEOVERROOT2, srate, 7, 1); for (uint32_t i = 0; i < frames; ++i) { float tmp1[2], tmp2[2], tmp3[2], tmp4[2], tmp5[2], tmp6[2]; float fil1[2], fil2[2], fil3[2], fil4[2]; float outL[MAX_COMP+1] = {0.f}; float outR[MAX_COMP+1] = {0.f}; float inl = sanitize_denormal(inputs[0][i]); float inr = sanitize_denormal(inputs[1][i]); inl = (fabs(inl) < DANGER) ? inl : 0.f; inr = (fabs(inr) < DANGER) ? inr : 0.f; int listenmode = 0; // Interleaved channel processing fil1[0] = run_filter(0, 0, inl); fil1[1] = run_filter(0, 1, inr); tmp1[0] = run_filter(1, 0, fil1[0]); tmp1[1] = run_filter(1, 1, fil1[1]); if (tog1) run_comp(0, tmp1[0], tmp1[1], &outL[0], &outR[0]); tmp2[0] = tog1 ? outL[0] * from_dB(makeup[0]) : tmp1[0]; tmp2[1] = tog1 ? outR[0] * from_dB(makeup[0]) : tmp1[1]; fil2[0] = run_filter(2, 0, inl); fil2[1] = run_filter(2, 1, inr); tmp3[0] = run_filter(3, 0, fil2[0]); tmp3[1] = run_filter(3, 1, fil2[1]); fil3[0] = run_filter(4, 0, tmp3[0]); fil3[1] = run_filter(4, 1, tmp3[1]); tmp4[0] = run_filter(5, 0, fil3[0]); tmp4[1] = run_filter(5, 1, fil3[1]); if (tog2) run_comp(1, tmp4[0], tmp4[1], &outL[1], &outR[1]); tmp3[0] = tog2 ? outL[1] * from_dB(makeup[1]) : tmp4[0]; tmp3[1] = tog2 ? outR[1] * from_dB(makeup[1]) : tmp4[1]; fil4[0] = run_filter(6, 0, inl); fil4[1] = run_filter(6, 1, inr); tmp5[0] = run_filter(7, 0, fil4[0]); tmp5[1] = run_filter(7, 1, fil4[1]); if (tog3) run_comp(2, tmp5[0], tmp5[1], &outL[2], &outR[2]); tmp6[0] = tog3 ? outL[2] * from_dB(makeup[2]) : tmp5[0]; tmp6[1] = tog3 ? outR[2] * from_dB(makeup[2]) : tmp5[1]; outputs[0][i] = outputs[1][i] = 0.f; if (listen1) { listenmode = 1; outputs[0][i] += outL[0] * tog1*from_dB(makeup[0]) + (1.-tog1) * tmp1[0]; outputs[1][i] += outR[0] * tog1*from_dB(makeup[0]) + (1.-tog1) * tmp1[1]; } if (listen2) { listenmode = 1; outputs[0][i] += outL[1] * tog2*from_dB(makeup[1]) + (1.-tog2) * tmp4[0]; outputs[1][i] += outR[1] * tog2*from_dB(makeup[1]) + (1.-tog2) * tmp4[1]; } if (listen3) { listenmode = 1; outputs[0][i] += outL[2] * tog3*from_dB(makeup[2]) + (1.-tog3) * tmp5[0]; outputs[1][i] += outR[2] * tog3*from_dB(makeup[2]) + (1.-tog3) * tmp5[1]; } if (!listenmode) { outputs[0][i] = tmp2[0] + tmp3[0] + tmp6[0]; outputs[1][i] = tmp2[1] + tmp3[1] + tmp6[1]; } outputs[0][i] = sanitize_denormal(outputs[0][i]); outputs[1][i] = sanitize_denormal(outputs[1][i]); outputs[0][i] *= from_dB(globalgain); outputs[1][i] *= from_dB(globalgain); tmp1[0] = outputs[0][i]; tmp1[1] = outputs[1][i]; run_limit(tmp1[0], tmp1[1], &outL[3], &outR[3]); outputs[0][i] = outL[3]; outputs[1][i] = outR[3]; if (resetl) { maxL = fabsf(outputs[0][i]); resetl = false; } else { maxxL = (fabsf(outputs[0][i]) > maxxL) ? fabsf(outputs[0][i]) : sanitize_denormal(maxxL); } if (resetr) { maxR = fabsf(outputs[1][i]); resetr = false; } else { maxxR = (fabsf(outputs[1][i]) > maxxR) ? fabsf(outputs[1][i]) : sanitize_denormal(maxxR); } } outl = (maxxL <= 0.f) ? -160.f : to_dB(maxxL+limit); outr = (maxxR <= 0.f) ? -160.f : to_dB(maxxR+limit); }
void ZaMultiCompX2Plugin::run_comp(int k, float inL, float inR, float *outL, float *outR) { float srate = d_getSampleRate(); float width=(knee-0.99f)*6.f; float attack_coeff = exp(-1000.f/(attack * srate)); float release_coeff = exp(-1000.f/(release * srate)); int stereolink = (stereodet > 0.5f) ? STEREOLINK_MAX : STEREOLINK_AVERAGE; float slewfactor = 80.0;//1.f + knee/2.f; float cdb=0.f; float Lgain = 1.f; float Rgain = 1.f; float Lxg, Lyg; float Rxg, Ryg; float Lxl, Lyl, Ly1; float Rxl, Ryl, Ry1; Lyg = Ryg = 0.f; inL = sanitize_denormal(inL); inR = sanitize_denormal(inR); Lxg = (inL==0.f) ? -160.f : to_dB(fabs(inL)); Rxg = (inR==0.f) ? -160.f : to_dB(fabs(inR)); Lxg = sanitize_denormal(Lxg); Rxg = sanitize_denormal(Rxg); Lyg = Lxg + (1.f/ratio-1.f)*(Lxg-thresdb[k]+width/2.f)*(Lxg-thresdb[k]+width/2.f)/(2.f*width); Lyg = sanitize_denormal(Lyg); Ryg = Rxg + (1.f/ratio-1.f)*(Rxg-thresdb[k]+width/2.f)*(Rxg-thresdb[k]+width/2.f)/(2.f*width); Ryg = sanitize_denormal(Ryg); if (2.f*(Lxg-thresdb[k])<-width) { Lyg = Lxg; } else if (2.f*fabs(Lxg-thresdb[k])<=width && Lyg >= old_yg[0][k]) { attack_coeff = exp(-1000.f/(attack*slewfactor * srate)); } else if (2.f*fabs(Lxg-thresdb[k])<=width && Lyg < old_yg[0][k]) { Lyg = thresdb[k] + (Lxg-thresdb[k])/ratio; Lyg = sanitize_denormal(Lyg); } else if (2.f*(Lxg-thresdb[k])>width) { Lyg = thresdb[k] + (Lxg-thresdb[k])/ratio; Lyg = sanitize_denormal(Lyg); } if (2.f*(Rxg-thresdb[k])<-width) { Ryg = Rxg; } else if (2.f*fabs(Rxg-thresdb[k])<=width && Ryg >= old_yg[1][k]) { attack_coeff = exp(-1000.f/(attack*slewfactor * srate)); } else if (2.f*fabs(Rxg-thresdb[k])<=width && Ryg < old_yg[1][k]) { Ryg = thresdb[k] + (Rxg-thresdb[k])/ratio; Ryg = sanitize_denormal(Ryg); } else if (2.f*(Rxg-thresdb[k])>width) { Ryg = thresdb[k] + (Rxg-thresdb[k])/ratio; Ryg = sanitize_denormal(Ryg); } if (stereolink == STEREOLINK_MAX) { Lxl = Rxl = fmaxf(Lxg - Lyg, Rxg - Ryg); } else { Lxl = Rxl = (Lxg - Lyg + Rxg - Ryg) / 2.f; } old_y1[0][k] = sanitize_denormal(old_y1[0][k]); old_y1[1][k] = sanitize_denormal(old_y1[1][k]); old_yl[0][k] = sanitize_denormal(old_yl[0][k]); old_yl[1][k] = sanitize_denormal(old_yl[1][k]); Ly1 = fmaxf(Lxl, release_coeff * old_y1[0][k]+(1.f-release_coeff)*Lxl); Lyl = attack_coeff * old_yl[0][k]+(1.f-attack_coeff)*Ly1; Ly1 = sanitize_denormal(Ly1); Lyl = sanitize_denormal(Lyl); cdb = -Lyl; Lgain = from_dB(cdb); Ry1 = fmaxf(Rxl, release_coeff * old_y1[1][k]+(1.f-release_coeff)*Rxl); Ryl = attack_coeff * old_yl[1][k]+(1.f-attack_coeff)*Ry1; Ry1 = sanitize_denormal(Ry1); Ryl = sanitize_denormal(Ryl); cdb = -Ryl; Rgain = from_dB(cdb); if (stereolink == STEREOLINK_MAX) gainr[k] = fmaxf(Lyl, Ryl); else gainr[k] = (Lyl + Ryl) / 2.f; *outL = inL; *outL *= Lgain; *outR = inR; *outR *= Rgain; old_yl[0][k] = Lyl; old_yl[1][k] = Ryl; old_y1[0][k] = Ly1; old_y1[1][k] = Ry1; old_yg[0][k] = Lyg; old_yg[1][k] = Ryg; }
void ZaMultiCompX2Plugin::run_limit(float inL, float inR, float *outL, float *outR) { float srate = d_getSampleRate(); float width=0.01; float threshdb = -0.5; float attack_coeff = exp(-1000.f/(0.001 * srate)); float release_coeff = exp(-1000.f/(50.0 * srate)); float cdb=0.f; float Lgain = 1.f; float Rgain = 1.f; float Lxg, Lyg; float Rxg, Ryg; float Lxl, Lyl, Ly1; float Rxl, Ryl, Ry1; Lyg = Ryg = 0.f; inL = sanitize_denormal(inL); inR = sanitize_denormal(inR); Lxg = (inL==0.f) ? -160.f : to_dB(fabs(inL)); Rxg = (inR==0.f) ? -160.f : to_dB(fabs(inR)); Lxg = sanitize_denormal(Lxg); Rxg = sanitize_denormal(Rxg); Lyg = Lxg + (1.f/100.0-1.f)*(Lxg-threshdb+width/2.f)*(Lxg-threshdb+width/2.f)/(2.f*width); Lyg = sanitize_denormal(Lyg); Ryg = Rxg + (1.f/100.0-1.f)*(Rxg-threshdb+width/2.f)*(Rxg-threshdb+width/2.f)/(2.f*width); Ryg = sanitize_denormal(Ryg); if (2.f*(Lxg-threshdb) < -width) { Lyg = Lxg; } else { Lyg = threshdb + (Lxg-threshdb)/100.0; Lyg = sanitize_denormal(Lyg); } if (2.f*(Rxg-threshdb) < -width) { Ryg = Rxg; } else { Ryg = threshdb + (Rxg-threshdb)/100.0; Ryg = sanitize_denormal(Ryg); } Lxl = Rxl = fmaxf(Lxg - Lyg, Rxg - Ryg); old_l1[0] = sanitize_denormal(old_l1[0]); old_l1[1] = sanitize_denormal(old_l1[1]); old_ll[0] = sanitize_denormal(old_ll[0]); old_ll[1] = sanitize_denormal(old_ll[1]); Ly1 = fmaxf(Lxl, release_coeff * old_l1[0]+(1.f-release_coeff)*Lxl); Lyl = attack_coeff * old_ll[0]+(1.f-attack_coeff)*Ly1; Ly1 = sanitize_denormal(Ly1); Lyl = sanitize_denormal(Lyl); cdb = -Lyl; Lgain = from_dB(cdb); Ry1 = fmaxf(Rxl, release_coeff * old_l1[1]+(1.f-release_coeff)*Rxl); Ryl = attack_coeff * old_ll[1]+(1.f-attack_coeff)*Ry1; Ry1 = sanitize_denormal(Ry1); Ryl = sanitize_denormal(Ryl); cdb = -Ryl; Rgain = from_dB(cdb); *outL = inL; *outL *= Lgain; *outR = inR; *outR *= Rgain; limit = fmaxf(Lyl, Ryl); old_ll[0] = Lyl; old_ll[1] = Ryl; old_l1[0] = Ly1; old_l1[1] = Ry1; }
static void run(LV2_Handle instance, uint32_t n_samples) { ZamEXCITE* zamexcite = (ZamEXCITE*)instance; const float* const input_l = zamexcite->input_l; const float* const input_r = zamexcite->input_r; float* const output_l = zamexcite->output_l; float* const output_r = zamexcite->output_r; float attack = *(zamexcite->attack); float release = *(zamexcite->release); float knee = *(zamexcite->knee); float ratio = *(zamexcite->ratio); float threshold = from_dB(*(zamexcite->threshold)); float makeup = from_dB(*(zamexcite->makeup)); float* const gainr_l = zamexcite->gainr_l; float* const gainr_r = zamexcite->gainr_r; int stereolink = (*(zamexcite->stereolink) > 1.f) ? STEREOLINK_MAX : (*(zamexcite->stereolink) > 0.f) ? STEREOLINK_AVERAGE : STEREOLINK_UNCOUPLED; float width=(knee-0.99f)*6.f; float cdb=0.f; float attack_coeff = exp(-1000.f/(attack * zamexcite->srate)); float release_coeff = exp(-1000.f/(release * zamexcite->srate)); float thresdb = to_dB(threshold); float drygain = from_dB(*(zamexcite->drygain)); int delaysamples = min(MAXDELAYSAMPLES, (int) (*(zamexcite->finedelay) * zamexcite->srate / 1000000)); float togglelisten = (*(zamexcite->listen) > 0.1) ? 0.f : 1.f; zamexcite->delaysamples = delaysamples; /*if (zamexcite->delaychanged != delaysamples) { for (int i = 0; i < delaysamples; ++i) { zamexcite->delaybuf_l[i] = 0.f; zamexcite->delaybuf_r[i] = 0.f; } zamexcite->delaychanged = delaysamples; } */ double fConst0 = 3.141592653589793 / zamexcite->srate; double fSlow0 = tan((fConst0 * *(zamexcite->hpfreq))); double fSlow1 = (1.0 / pow(fSlow0,2)); double fSlow2 = (2 * (1 - fSlow1)); double fSlow3 = (1.0 / fSlow0); double fSlow4 = (1 + ((fSlow3 - 1.414213562373095) / fSlow0)); double fSlow5 = (1.0 / (1 + ((1.414213562373095 + fSlow3) / fSlow0))); double fSlow6 = (2 * (0 - fSlow1)); float Lgain = 1.f; float Rgain = 1.f; float Lxg, Lyg; float Rxg, Ryg; float Lxl, Lyl, Ly1; float Rxl, Ryl, Ry1; float tmpl, tmpr, intl, intr, tmpinl, tmpinr; float *posl = &zamexcite->delaybuf_l[zamexcite->pos]; float *posr = &zamexcite->delaybuf_r[zamexcite->pos]; for (uint32_t i = 0; i < n_samples; ++i) { *posl = input_l[i]; *posr = input_r[i]; posl++; posr++; zamexcite->pos++; if (zamexcite->pos > delaysamples) { zamexcite->pos = 0; posl = &zamexcite->delaybuf_l[0]; posr = &zamexcite->delaybuf_r[0]; } tmpinl=*posl; tmpinr=*posr; sanitize_denormal(tmpinl); sanitize_denormal(tmpinr); zamexcite->fRec0l[0] = ((double)tmpinl - (fSlow5 * ((fSlow4 * zamexcite->fRec0l[2]) + (fSlow2 * zamexcite->fRec0l[1])))); intl = (float)(fSlow5 * (((fSlow1 * zamexcite->fRec0l[0]) + (fSlow6 * zamexcite->fRec0l[1])) + (fSlow1 * zamexcite->fRec0l[2]))); zamexcite->fRec0r[0] = ((double)tmpinr - (fSlow5 * ((fSlow4 * zamexcite->fRec0r[2]) + (fSlow2 * zamexcite->fRec0r[1])))); intr = (float)(fSlow5 * (((fSlow1 * zamexcite->fRec0r[0]) + (fSlow6 * zamexcite->fRec0r[1])) + (fSlow1 * zamexcite->fRec0r[2]))); sanitize_denormal(intl); sanitize_denormal(intr); Lyg = Ryg = 0.f; Lxg = (intl==0.f) ? -160.f : to_dB(fabs(intl)); Rxg = (intr==0.f) ? -160.f : to_dB(fabs(intr)); sanitize_denormal(Lxg); sanitize_denormal(Rxg); if (2.f*(Lxg-thresdb)<-width) { Lyg = Lxg; } else if (2.f*fabs(Lxg-thresdb)<=width) { Lyg = Lxg + (1.f/ratio-1.f)*(Lxg-thresdb+width/2.f)*(Lxg-thresdb+width/2.f)/(2.f*width); } else if (2.f*(Lxg-thresdb)>width) { Lyg = thresdb + (Lxg-thresdb)/ratio; } sanitize_denormal(Lyg); if (2.f*(Rxg-thresdb)<-width) { Ryg = Rxg; } else if (2.f*fabs(Rxg-thresdb)<=width) { Ryg = Rxg + (1.f/ratio-1.f)*(Rxg-thresdb+width/2.f)*(Rxg-thresdb+width/2.f)/(2.f*width); } else if (2.f*(Rxg-thresdb)>width) { Ryg = thresdb + (Rxg-thresdb)/ratio; } sanitize_denormal(Ryg); if (stereolink == STEREOLINK_UNCOUPLED) { Lxl = Lxg - Lyg; Rxl = Rxg - Ryg; } else if (stereolink == STEREOLINK_MAX) { Lxl = Rxl = fmaxf(Lxg - Lyg, Rxg - Ryg); } else { Lxl = Rxl = (Lxg - Lyg + Rxg - Ryg) / 2.f; } sanitize_denormal(zamexcite->oldL_y1); sanitize_denormal(zamexcite->oldR_y1); sanitize_denormal(zamexcite->oldL_yl); sanitize_denormal(zamexcite->oldR_yl); Ly1 = fmaxf(Lxl, release_coeff * zamexcite->oldL_y1+(1.f-release_coeff)*Lxl); Lyl = attack_coeff * zamexcite->oldL_yl+(1.f-attack_coeff)*Ly1; sanitize_denormal(Ly1); sanitize_denormal(Lyl); cdb = -Lyl; Lgain = from_dB(cdb); *gainr_l = Lyl; Ry1 = fmaxf(Rxl, release_coeff * zamexcite->oldR_y1+(1.f-release_coeff)*Rxl); Ryl = attack_coeff * zamexcite->oldR_yl+(1.f-attack_coeff)*Ry1; sanitize_denormal(Ry1); sanitize_denormal(Ryl); cdb = -Ryl; Rgain = from_dB(cdb); *gainr_r = Ryl; tmpl = (intl * Lgain * makeup); tmpr = (intr * Rgain * makeup); sanitize_denormal(tmpl); sanitize_denormal(tmpr); sanitize_denormal(drygain); float outl = tmpl + (input_l[i] * drygain)*togglelisten; float outr = tmpr + (input_r[i] * drygain)*togglelisten; output_l[i] = outl; output_r[i] = outr; //post zamexcite->oldL_yl = Lyl; zamexcite->oldR_yl = Ryl; zamexcite->oldL_y1 = Ly1; zamexcite->oldR_y1 = Ry1; zamexcite->fRec0l[2] = zamexcite->fRec0l[1]; zamexcite->fRec0l[1] = zamexcite->fRec0l[0]; //zamexcite->fRec1l[2] = zamexcite->fRec1l[1]; //zamexcite->fRec1l[1] = zamexcite->fRec1l[0]; zamexcite->fRec0r[2] = zamexcite->fRec0r[1]; zamexcite->fRec0r[1] = zamexcite->fRec0r[0]; //zamexcite->fRec1r[2] = zamexcite->fRec1r[1]; //zamexcite->fRec1r[1] = zamexcite->fRec1r[0]; } }
void ZamCompPlugin::run(const float** inputs, float** outputs, uint32_t frames) { float srate = getSampleRate(); float width = (6.f * knee) + 0.01; float slewwidth = 1.8f; float cdb=0.f; float attack_coeff = exp(-1000.f/(attack * srate)); float release_coeff = exp(-1000.f/(release * srate)); int attslew = 0; int relslew = 0; float max = 0.f; float lgaininp = 0.f; float rgaininp = 0.f; float Lgain = 1.f; float Rgain = 1.f; float Lxg, Lxl, Lyg, Lyl, Ly1; float checkwidth = 0.f; uint32_t i; for (i = 0; i < frames; i++) { relslew = 0; attslew = 0; Lyg = 0.f; Lxg = (inputs[0][i]==0.f) ? -160.f : to_dB(fabs(inputs[0][i])); Lxg = sanitize_denormal(Lxg); Lyg = Lxg + (1.f/ratio-1.f)*(Lxg-thresdb+width/2.f)*(Lxg-thresdb+width/2.f)/(2.f*width); checkwidth = 2.f*fabs(Lxg-thresdb); if (2.f*(Lxg-thresdb) < -width) { Lyg = Lxg; } else if (checkwidth <= width) { Lyg = thresdb + (Lxg-thresdb)/ratio; Lyg = sanitize_denormal(Lyg); if (checkwidth <= slewwidth) { if (Lyg >= oldL_yg) { attslew = 1; } else { relslew = 1; } } } else if (2.f*(Lxg-thresdb) > width) { Lyg = thresdb + (Lxg-thresdb)/ratio; Lyg = sanitize_denormal(Lyg); } attack_coeff = attslew ? exp(-1000.f/((attack + 2.0*(slewfactor - 1)) * srate)) : attack_coeff; // Don't slew on release //release_coeff = relslew ? exp(-1000.f/((release + 2.0*(slewfactor - 1)) * srate)) : release_coeff; Lxl = Lxg - Lyg; oldL_y1 = sanitize_denormal(oldL_y1); oldL_yl = sanitize_denormal(oldL_yl); Ly1 = fmaxf(Lxl, release_coeff * oldL_y1+(1.f-release_coeff)*Lxl); Lyl = attack_coeff * oldL_yl+(1.f-attack_coeff)*Ly1; Ly1 = sanitize_denormal(Ly1); Lyl = sanitize_denormal(Lyl); cdb = -Lyl; Lgain = from_dB(cdb); gainred = Lyl; lgaininp = inputs[0][i] * Lgain; outputs[0][i] = lgaininp * from_dB(makeup); max = (fabsf(lgaininp) > max) ? fabsf(lgaininp) : sanitize_denormal(max); oldL_yl = Lyl; oldL_y1 = Ly1; oldL_yg = Lyg; } outlevel = (max == 0.f) ? -45.f : to_dB(max) - thresdb; }
static void run(LV2_Handle instance, uint32_t n_samples) { AComp* acomp = (AComp*)instance; const float* const input0 = acomp->input0; const float* const input1 = acomp->input1; float* const output = acomp->output; float srate = acomp->srate; float width = (6.f * *(acomp->knee)) + 0.01; float cdb=0.f; float attack_coeff = exp(-1000.f/(*(acomp->attack) * srate)); float release_coeff = exp(-1000.f/(*(acomp->release) * srate)); float max = 0.f; float lgaininp = 0.f; float Lgain = 1.f; float Lxg, Lxl, Lyg, Lyl, Ly1; int usesidechain = (*(acomp->sidechain) < 0.5) ? 0 : 1; uint32_t i; float ingain; float in0; float in1; float ratio = *(acomp->ratio); float thresdb = *(acomp->thresdb); for (i = 0; i < n_samples; i++) { in0 = input0[i]; in1 = input1[i]; ingain = usesidechain ? in1 : in0; Lyg = 0.f; Lxg = (ingain==0.f) ? -160.f : to_dB(fabs(ingain)); Lxg = sanitize_denormal(Lxg); Lyg = Lxg + (1.f/ratio-1.f)*(Lxg-thresdb+width/2.f)*(Lxg-thresdb+width/2.f)/(2.f*width); if (2.f*(Lxg-thresdb) < -width) { Lyg = Lxg; } else { Lyg = thresdb + (Lxg-thresdb)/ratio; Lyg = sanitize_denormal(Lyg); } Lxl = Lxg - Lyg; acomp->old_y1 = sanitize_denormal(acomp->old_y1); acomp->old_yl = sanitize_denormal(acomp->old_yl); Ly1 = fmaxf(Lxl, release_coeff * acomp->old_y1+(1.f-release_coeff)*Lxl); Lyl = attack_coeff * acomp->old_yl+(1.f-attack_coeff)*Ly1; Ly1 = sanitize_denormal(Ly1); Lyl = sanitize_denormal(Lyl); cdb = -Lyl; Lgain = from_dB(cdb); *(acomp->gainr) = Lyl; lgaininp = in0 * Lgain; output[i] = lgaininp * from_dB(*(acomp->makeup)); max = (fabsf(output[i]) > max) ? fabsf(output[i]) : sanitize_denormal(max); acomp->old_yl = Lyl; acomp->old_y1 = Ly1; acomp->old_yg = Lyg; } *(acomp->outlevel) = (max == 0.f) ? -45.f : to_dB(max); }