ty_gverb *gverb_new(int srate, float maxroomsize, float roomsize,
float revtime,
float damping, float spread,
float inputbandwidth, float earlylevel,
float taillevel)
{
ty_gverb *p;
float ga,gb,gt;
int i,n;
float r;
float diffscale;
int a,b,c,cc,d,dd,e;
float spread1,spread2;
p = (ty_gverb *)malloc(sizeof(ty_gverb));
p->rate = srate;
p->fdndamping = damping;
p->maxroomsize = maxroomsize;
p->roomsize = roomsize;
p->revtime = revtime;
p->earlylevel = earlylevel;
p->taillevel = taillevel;
p->maxdelay = p->rate*p->maxroomsize/340.0;
p->largestdelay = p->rate*p->roomsize/340.0;
/* Input damper */
p->inputbandwidth = inputbandwidth;
p->inputdamper = damper_make(1.0 - p->inputbandwidth);
/* FDN section */
p->fdndels = (ty_fixeddelay **)calloc(FDNORDER, sizeof(ty_fixeddelay *));
for(i = 0; i < FDNORDER; i++) {
p->fdndels[i] = fixeddelay_make((int)p->maxdelay+1000);
}
p->fdngains = (float *)calloc(FDNORDER, sizeof(float));
p->fdnlens = (int *)calloc(FDNORDER, sizeof(int));
p->fdndamps = (ty_damper **)calloc(FDNORDER, sizeof(ty_damper *));
for(i = 0; i < FDNORDER; i++) {
p->fdndamps[i] = damper_make(p->fdndamping);
}
ga = 60.0;
gt = p->revtime;
ga = powf(10.0f,-ga/20.0f);
n = p->rate*gt;
p->alpha = pow((double)ga, 1.0/(double)n);
gb = 0.0;
for(i = 0; i < FDNORDER; i++) {
if (i == 0) gb = 1.000000*p->largestdelay;
if (i == 1) gb = 0.816490*p->largestdelay;
if (i == 2) gb = 0.707100*p->largestdelay;
if (i == 3) gb = 0.632450*p->largestdelay;
#if 0
p->fdnlens[i] = nearest_prime((int)gb, 0.5);
#else
p->fdnlens[i] = f_round(gb);
#endif
p->fdngains[i] = -powf((float)p->alpha,p->fdnlens[i]);
}
p->d = (float *)calloc(FDNORDER, sizeof(float));
p->u = (float *)calloc(FDNORDER, sizeof(float));
p->f = (float *)calloc(FDNORDER, sizeof(float));
/* Diffuser section */
diffscale = (float)p->fdnlens[3]/(210+159+562+410);
spread1 = spread;
spread2 = 3.0*spread;
b = 210;
r = 0.125541;
a = spread1*r;
c = 210+159+a;
cc = c-b;
r = 0.854046;
a = spread2*r;
d = 210+159+562+a;
dd = d-c;
e = 1341-d;
p->ldifs = (ty_diffuser **)calloc(4, sizeof(ty_diffuser *));
p->ldifs[0] = diffuser_make((int)(diffscale*b),0.75);
p->ldifs[1] = diffuser_make((int)(diffscale*cc),0.75);
p->ldifs[2] = diffuser_make((int)(diffscale*dd),0.625);
p->ldifs[3] = diffuser_make((int)(diffscale*e),0.625);
b = 210;
r = -0.568366;
a = spread1*r;
c = 210+159+a;
cc = c-b;
r = -0.126815;
a = spread2*r;
d = 210+159+562+a;
dd = d-c;
e = 1341-d;
p->rdifs = (ty_diffuser **)calloc(4, sizeof(ty_diffuser *));
p->rdifs[0] = diffuser_make((int)(diffscale*b),0.75);
p->rdifs[1] = diffuser_make((int)(diffscale*cc),0.75);
p->rdifs[2] = diffuser_make((int)(diffscale*dd),0.625);
p->rdifs[3] = diffuser_make((int)(diffscale*e),0.625);
/* Tapped delay section */
p->tapdelay = fixeddelay_make(44000);
p->taps = (int *)calloc(FDNORDER, sizeof(int));
p->tapgains = (float *)calloc(FDNORDER, sizeof(float));
p->taps[0] = 5+0.410*p->largestdelay;
p->taps[1] = 5+0.300*p->largestdelay;
p->taps[2] = 5+0.155*p->largestdelay;
p->taps[3] = 5+0.000*p->largestdelay;
for(i = 0; i < FDNORDER; i++) {
p->tapgains[i] = pow(p->alpha,(double)p->taps[i]);
}
return(p);
}
int GVERB::init(double pfs[], int n_args)
{
if (rtsetoutput(pfs[0], pfs[2]+pfs[11], this) == -1)
return DONT_SCHEDULE;
if (outputChannels() != 2)
return die("GVERB", "stereo output required");
if (rtsetinput(pfs[1], this) == -1)
return DONT_SCHEDULE; // no input
inputframes = pfs[2] * SR;
inputchan = pfs[12];
amp = pfs[3];
float maxroomsize = 300.0f;
float roomsize = 50.0f;
float revtime = 7.0f;
float damping = 0.5f;
float spread = 15.0f;
float inputbandwidth = 0.5f;
float drylevel = 0.0f; //-1.9832f;
float earlylevel = 0.0f; //-1.9832f;
float taillevel = 0.0f;
float ga,gb,gt;
unsigned int i;
int n;
float r;
float diffscale;
int a,b,c,cc,d,dd,e;
float spread1,spread2;
// BGG max/msp heritage, params/etc. stored in this "p" struct (ty_gverb)
p = &realp;
// zero out the struct, to be careful
bzero((void *)p, sizeof (ty_gverb));
p->rate = SR;
p->fdndamping = damping;
p->maxroomsize = maxroomsize;
p->roomsize = CLIP(roomsize, 0.1f, maxroomsize);
p->revtime = revtime;
p->drylevel = drylevel;
p->earlylevel = earlylevel;
p->taillevel = taillevel;
p->maxdelay = p->rate*p->maxroomsize/340.0;
p->largestdelay = p->rate*p->roomsize/340.0;
/* Input damper */
p->inputbandwidth = inputbandwidth;
p->inputdamper = damper_make(1.0 - p->inputbandwidth);
/* FDN section */
p->fdndels = (ty_fixeddelay **)malloc(FDNORDER*sizeof(ty_fixeddelay *));
if(!p->fdndels)
return die("GVERB", "out of memory for fixeddelay ptrs");
for(i = 0; i < FDNORDER; i++)
{
p->fdndels[i] = fixeddelay_make((int)p->maxdelay+1000);
if(!p->fdndels[i])
return die("GVERB", "out of memory for fixeddelays");
}
p->fdngains = (float *)malloc(FDNORDER*sizeof(float));
p->fdnlens = (int *)malloc(FDNORDER*sizeof(int));
if(!p->fdngains || !p->fdnlens)
return die("GVERB", "out of memory for delay gains and lengths");
p->fdndamps = (ty_damper **)malloc(FDNORDER*sizeof(ty_damper *));
if(!p->fdndamps)
return die("GVERB", "out of memory for delay amps");
for(i = 0; i < FDNORDER; i++)
{
p->fdndamps[i] = damper_make(p->fdndamping);
if(!p->fdndamps[i])
return die("GVERB", "out of memory for delay amps 2");
}
ga = 60.0;
gt = p->revtime;
ga = pow(10.0,-ga/20.0);
n = (int)(p->rate*gt);
p->alpha = pow((double)ga,(double)1.0/(double)n);
gb = 0.0;
for(i = 0; i < FDNORDER; i++)
{
if (i == 0) gb = 1.000000*p->largestdelay;
if (i == 1) gb = 0.816490*p->largestdelay;
if (i == 2) gb = 0.707100*p->largestdelay;
if (i == 3) gb = 0.632450*p->largestdelay;
#if 0
p->fdnlens[i] = nearest_prime((int)gb, 0.5);
#else
p->fdnlens[i] = (int)gb;
#endif
// p->fdngains[i] = -pow(p->alpha,(double)p->fdnlens[i]);
p->fdngains[i] = -powf((float)p->alpha,p->fdnlens[i]);
}
p->d = (float *)malloc(FDNORDER*sizeof(float));
p->u = (float *)malloc(FDNORDER*sizeof(float));
p->f = (float *)malloc(FDNORDER*sizeof(float));
if(!p->d || !p->u || !p->f)
return die("GVERB", "out of memory for other delay stuff");
/* Diffuser section */
diffscale = (float)p->fdnlens[3]/(210+159+562+410);
spread1 = spread;
spread2 = 3.0*spread;
b = 210;
r = 0.125541f;
a = (int)(spread1*r);
c = 210+159+a;
cc = c-b;
r = 0.854046f;
a = (int)(spread2*r);
d = 210+159+562+a;
dd = d-c;
e = 1341-d;
p->ldifs = (ty_diffuser **)malloc(4*sizeof(ty_diffuser *));
if(!p->ldifs)
return die("GVERB", "out of memory for diffuser left structs");
p->ldifs[0] = diffuser_make((int)(diffscale*b),0.75);
p->ldifs[1] = diffuser_make((int)(diffscale*cc),0.75);
p->ldifs[2] = diffuser_make((int)(diffscale*dd),0.625);
p->ldifs[3] = diffuser_make((int)(diffscale*e),0.625);
if(!p->ldifs[0] || !p->ldifs[1] || !p->ldifs[2] || !p->ldifs[3])
return die("GVERB", "out of memory for diffuser left makes");
b = 210;
r = -0.568366f;
a = (int)(spread1*r);
c = 210+159+a;
cc = c-b;
r = -0.126815f;
a = (int)(spread2*r);
d = 210+159+562+a;
dd = d-c;
e = 1341-d;
p->rdifs = (ty_diffuser **)malloc(4*sizeof(ty_diffuser *));
if(!p->rdifs)
return die("GVERB", "out of memory for diffuser right structs");
p->rdifs[0] = diffuser_make((int)(diffscale*b),0.75);
p->rdifs[1] = diffuser_make((int)(diffscale*cc),0.75);
p->rdifs[2] = diffuser_make((int)(diffscale*dd),0.625);
p->rdifs[3] = diffuser_make((int)(diffscale*e),0.625);
if(!p->rdifs[0] || !p->rdifs[1] || !p->rdifs[2] || !p->rdifs[3])
return die("GVERB", "out of memory for diffuser right makes");
/* Tapped delay section */
p->tapdelay = fixeddelay_make(44000);
p->taps = (int *)malloc(FDNORDER*sizeof(int));
p->tapgains = (float *)malloc(FDNORDER*sizeof(float));
if(!p->tapdelay || !p->taps || !p->tapgains)
return die("GVERB", "out of memory for taps");
p->taps[0] = (int)(5+0.410*p->largestdelay);
p->taps[1] = (int)(5+0.300*p->largestdelay);
p->taps[2] = (int)(5+0.155*p->largestdelay);
p->taps[3] = (int)(5+0.000*p->largestdelay);
for(i = 0; i < FDNORDER; i++)
{
p->tapgains[i] = pow(p->alpha,(double)p->taps[i]);
}
// these values get set after all the init stuff
if (pfs[4] < 1.0 || pfs[4] > maxroomsize)
return die("GVERB", "bogus roomsize: %f\n", pfs[4]);
gverb_set_roomsize(p, pfs[4]); // sets p->roomsize
if (pfs[5] < 0.1 || pfs[5] > 360.0)
return die("GVERB", "bad revtime: %f\n", pfs[5]);
gverb_set_revtime(p, pfs[5]);
if (pfs[6] < 0.0 || pfs[6] > 1.0)
return die("GVERB", "incorrect damping: %f\n", pfs[6]);
gverb_set_damping(p, pfs[6]);
if (pfs[7] < 0.0 || pfs[7] > 1.0)
return die("GVERB", "input bandwith problem: %f\n", pfs[7]);
gverb_set_inputbandwidth(p, pfs[7]);
if (pfs[8] < -90.0 || pfs[8] > 0.0)
return die("GVERB", "dry level wrong: %f\n", pfs[8]);
gverb_set_drylevel(p, pfs[8]);
if (pfs[9] < -90.0 || pfs[9] > 0.0)
return die("GVERB", "problem with early reflection level: %f\n", pfs[9]);
gverb_set_earlylevel(p, pfs[9]);
if (pfs[10] < -90.0 || pfs[10] > 0.0)
return die("GVERB", "bogus tail level: %f\n", pfs[10]);
gverb_set_taillevel(p, pfs[10]);
branch = 0;
return nSamps();
}
// constructor
GVerb( t_CKFLOAT fs)
{
const float maxroomsize = 300.0f;
float roomsize = 30.0f;
float revtime = 5.0f;
float damping = 0.8f;
float spread = 15.0f;
float inputbandwidth = 0.5f;
float drylevel = 0.6f; //-1.9832f;
float earlylevel = 0.4f; //-1.9832f;
float taillevel = 0.5f;
float ga,gb,gt;
unsigned int i;
int n;
float r;
float diffscale;
int a,b,c,cc,d,dd,e;
float spread1,spread2;
p = &realp;
memset((void *)p, 0, sizeof (ty_gverb));
p->rate = fs;
p->fdndamping = damping;
p->maxroomsize = maxroomsize;
p->roomsize = CLIP(roomsize, 0.1f, maxroomsize);
p->revtime = revtime;
p->drylevel = drylevel;
p->earlylevel = earlylevel;
p->taillevel = taillevel;
p->maxdelay = p->rate*p->maxroomsize/340.0;
p->largestdelay = p->rate*p->roomsize/340.0;
/* Input damper */
p->inputbandwidth = inputbandwidth;
p->inputdamper = damper_make(1.0 - p->inputbandwidth);
/* FDN section */
p->fdndels = (ty_fixeddelay **)malloc(FDNORDER*sizeof(ty_fixeddelay *));
for(i = 0; i < FDNORDER; i++)
{
p->fdndels[i] = fixeddelay_make((int)p->maxdelay+1000);
}
p->fdngains = (float *)malloc(FDNORDER*sizeof(float));
p->fdnlens = (int *)malloc(FDNORDER*sizeof(int));
p->fdndamps = (ty_damper **)malloc(FDNORDER*sizeof(ty_damper *));
for(i = 0; i < FDNORDER; i++)
{
p->fdndamps[i] = damper_make(p->fdndamping);
}
ga = 60.0;
gt = p->revtime;
ga = pow(10.0,-ga/20.0);
n = (int)(p->rate*gt);
p->alpha = pow((double)ga,(double)1.0/(double)n);
gb = 0.0;
for(i = 0; i < FDNORDER; i++)
{
if (i == 0) gb = 1.000000*p->largestdelay;
if (i == 1) gb = 0.816490*p->largestdelay;
if (i == 2) gb = 0.707100*p->largestdelay;
if (i == 3) gb = 0.632450*p->largestdelay;
#if 0
p->fdnlens[i] = nearest_prime((int)gb, 0.5);
#else
p->fdnlens[i] = (int)gb;
#endif
// p->fdngains[i] = -pow(p->alpha,(double)p->fdnlens[i]);
p->fdngains[i] = -powf((float)p->alpha,p->fdnlens[i]);
}
p->d = (float *)malloc(FDNORDER*sizeof(float));
p->u = (float *)malloc(FDNORDER*sizeof(float));
p->f = (float *)malloc(FDNORDER*sizeof(float));
/* Diffuser section */
diffscale = (float)p->fdnlens[3]/(210+159+562+410);
spread1 = spread;
spread2 = 3.0*spread;
b = 210;
r = 0.125541f;
a = (int)(spread1*r);
c = 210+159+a;
cc = c-b;
r = 0.854046f;
a = (int)(spread2*r);
d = 210+159+562+a;
dd = d-c;
e = 1341-d;
p->ldifs = (ty_diffuser **)malloc(4*sizeof(ty_diffuser *));
p->ldifs[0] = diffuser_make((int)(diffscale*b),0.75);
p->ldifs[1] = diffuser_make((int)(diffscale*cc),0.75);
p->ldifs[2] = diffuser_make((int)(diffscale*dd),0.625);
p->ldifs[3] = diffuser_make((int)(diffscale*e),0.625);
b = 210;
r = -0.568366f;
a = (int)(spread1*r);
c = 210+159+a;
cc = c-b;
r = -0.126815f;
a = (int)(spread2*r);
d = 210+159+562+a;
dd = d-c;
e = 1341-d;
p->rdifs = (ty_diffuser **)malloc(4*sizeof(ty_diffuser *));
p->rdifs[0] = diffuser_make((int)(diffscale*b),0.75);
p->rdifs[1] = diffuser_make((int)(diffscale*cc),0.75);
p->rdifs[2] = diffuser_make((int)(diffscale*dd),0.625);
p->rdifs[3] = diffuser_make((int)(diffscale*e),0.625);
/* Tapped delay section */
p->tapdelay = fixeddelay_make(44000);
p->taps = (int *)malloc(FDNORDER*sizeof(int));
p->tapgains = (float *)malloc(FDNORDER*sizeof(float));
p->taps[0] = (int)(5+0.410*p->largestdelay);
p->taps[1] = (int)(5+0.300*p->largestdelay);
p->taps[2] = (int)(5+0.155*p->largestdelay);
p->taps[3] = (int)(5+0.000*p->largestdelay);
for(i = 0; i < FDNORDER; i++)
{
p->tapgains[i] = pow(p->alpha,(double)p->taps[i]);
}
}
