static void magSpec_tilde_window(t_magSpec_tilde *x, t_floatarg w)
{
int i, window, isPow2;
window = w;
isPow2 = window && !( (window-1) & window );
if( !isPow2 )
error("requested window size is not a power of 2");
else
{
x->signal_R = (t_sample *)t_resizebytes(x->signal_R, (x->window+x->n) * sizeof(t_sample), (window+x->n) * sizeof(t_sample));
x->blackman = (t_float *)t_resizebytes(x->blackman, x->window*sizeof(t_float), window*sizeof(t_float));
x->cosine = (t_float *)t_resizebytes(x->cosine, x->window*sizeof(t_float), window*sizeof(t_float));
x->hamming = (t_float *)t_resizebytes(x->hamming, x->window*sizeof(t_float), window*sizeof(t_float));
x->hann = (t_float *)t_resizebytes(x->hann, x->window*sizeof(t_float), window*sizeof(t_float));
x->window = (t_float)window;
// re-init window functions
tIDLib_blackmanWindow(x->blackman, x->window);
tIDLib_cosineWindow(x->cosine, x->window);
tIDLib_hammingWindow(x->hamming, x->window);
tIDLib_hannWindow(x->hann, x->window);
// init signal buffer
for(i=0; i<(x->window+x->n); i++)
x->signal_R[i] = 0.0;
post("window size: %i", (int)x->window);
}
}
static void *specCentroid_new(t_symbol *s)
{
t_specCentroid *x = (t_specCentroid *)pd_new(specCentroid_class);
int i;
t_garray *a;
x->x_centroid = outlet_new(&x->x_obj, &s_float);
if(s)
{
x->x_arrayname = s;
if(!(a = (t_garray *)pd_findbyclass(x->x_arrayname, garray_class)))
;
else if(!garray_getfloatwords(a, &x->x_arrayPoints, &x->x_vec))
pd_error(x, "%s: bad template for specCentroid", x->x_arrayname->s_name);
}
else
error("specCentroid: no array specified.");
x->sr = 44100.0;
x->window = 1; // should be a bogus size initially to force the proper resizes when a real _analyze request comes through
x->windowFuncSize = 1;
x->windowFunction = 4; // 4 is hann window
x->powerSpectrum = 0; // choose mag (0) or power (1) spec in the specCentroid computation
x->maxWindowSize = MAXWINDOWSIZE; // this seems to be the maximum size allowable by mayer_realfft();
x->powersOfTwo = (int *)t_getbytes(sizeof(int));
x->powersOfTwo[0] = 64; // must have at least this large of a window
i=1;
while(x->powersOfTwo[i-1] < x->maxWindowSize)
{
x->powersOfTwo = (int *)t_resizebytes(x->powersOfTwo, i*sizeof(int), (i+1)*sizeof(int));
x->powersOfTwo[i] = pow(2, i+6); // +6 because we're starting at 2**6
i++;
}
x->powTwoArrSize = i;
x->signal_R = (t_sample *)t_getbytes(x->window*sizeof(t_sample));
for(i=0; i<x->window; i++)
x->signal_R[i] = 0.0;
x->blackman = (t_float *)t_getbytes(x->windowFuncSize*sizeof(t_float));
x->cosine = (t_float *)t_getbytes(x->windowFuncSize*sizeof(t_float));
x->hamming = (t_float *)t_getbytes(x->windowFuncSize*sizeof(t_float));
x->hann = (t_float *)t_getbytes(x->windowFuncSize*sizeof(t_float));
// initialize signal windowing functions
tIDLib_blackmanWindow(x->blackman, x->windowFuncSize);
tIDLib_cosineWindow(x->cosine, x->windowFuncSize);
tIDLib_hammingWindow(x->hamming, x->windowFuncSize);
tIDLib_hannWindow(x->hann, x->windowFuncSize);
return (x);
}
static void *specSkewness_tilde_new(t_symbol *s, int argc, t_atom *argv)
{
t_specSkewness_tilde *x = (t_specSkewness_tilde *)pd_new(specSkewness_tilde_class);
int i, isPow2;
s=s;
x->x_skewness = outlet_new(&x->x_obj, &s_float);
if(argc > 0)
{
x->window = atom_getfloat(argv);
isPow2 = (int)x->window && !( ((int)x->window-1) & (int)x->window );
if(!isPow2)
{
error("requested window size is not a power of 2. default value of 1024 used instead");
x->window = 1024;
};
}
else
x->window = 1024;
x->sr = 44100.0;
x->n = 64.0;
x->overlap = 1;
x->windowFunction = 4; // 4 is hann window
x->powerSpectrum = 0;
x->lastDspTime = clock_getlogicaltime();
x->signal_R = (t_sample *)t_getbytes((x->window+x->n) * sizeof(t_sample));
for(i=0; i<(x->window+x->n); i++)
x->signal_R[i] = 0.0;
x->blackman = (t_float *)t_getbytes(x->window*sizeof(t_float));
x->cosine = (t_float *)t_getbytes(x->window*sizeof(t_float));
x->hamming = (t_float *)t_getbytes(x->window*sizeof(t_float));
x->hann = (t_float *)t_getbytes(x->window*sizeof(t_float));
// initialize signal windowing functions
tIDLib_blackmanWindow(x->blackman, x->window);
tIDLib_cosineWindow(x->cosine, x->window);
tIDLib_hammingWindow(x->hamming, x->window);
tIDLib_hannWindow(x->hann, x->window);
x->binFreqs = (t_float *)t_getbytes(x->window*sizeof(t_float));
// freqs for each bin based on current window size and sample rate
for(i=0; i<x->window; i++)
x->binFreqs[i] = (x->sr/x->window)*i;
post("specSkewness~: window size: %i", (int)x->window);
return (x);
}
static void *magSpec_tilde_new(t_symbol *s, int argc, t_atom *argv)
{
t_magSpec_tilde *x = (t_magSpec_tilde *)pd_new(magSpec_tilde_class);
int i, isPow2;
s=s;
x->x_mag = outlet_new(&x->x_obj, gensym("list"));
if(argc > 0)
{
x->window = atom_getfloat(argv);
isPow2 = (int)x->window && !( ((int)x->window-1) & (int)x->window );
if(!isPow2)
{
error("requested window size is not a power of 2. default value of 1024 used instead");
x->window = 1024;
};
}
else
x->window = 1024;
x->sr = 44100.0;
x->n = 64.0;
x->overlap = 1;
x->windowFunction = 4; // 4 is hann window
x->normalize = 1;
x->powerSpectrum = 0;
x->lastDspTime = clock_getlogicaltime();
x->signal_R = (t_sample *)t_getbytes((x->window+x->n) * sizeof(t_sample));
for(i=0; i<(x->window+x->n); i++)
x->signal_R[i] = 0.0;
x->blackman = (t_float *)t_getbytes(x->window*sizeof(t_float));
x->cosine = (t_float *)t_getbytes(x->window*sizeof(t_float));
x->hamming = (t_float *)t_getbytes(x->window*sizeof(t_float));
x->hann = (t_float *)t_getbytes(x->window*sizeof(t_float));
// initialize signal windowing functions
tIDLib_blackmanWindow(x->blackman, x->window);
tIDLib_cosineWindow(x->cosine, x->window);
tIDLib_hammingWindow(x->hamming, x->window);
tIDLib_hannWindow(x->hann, x->window);
post("magSpec~: window size: %i", (int)x->window);
return (x);
}
static void barkSpec_tilde_window(t_barkSpec *x, int w)
{
int i, window, isPow2, oldNumFilters;
window = w;
isPow2 = window && !( (window-1) & window );
if( !isPow2 )
error("requested window size is not a power of 2");
else
{
x->signal_R = (t_sample *)t_resizebytes_(x->signal_R, (x->window+x->n) * sizeof(t_sample), (window+x->n) * sizeof(t_sample));
x->blackman = (t_float *)t_resizebytes_(x->blackman, x->window*sizeof(t_float), window*sizeof(t_float));
x->cosine = (t_float *)t_resizebytes_(x->cosine, x->window*sizeof(t_float), window*sizeof(t_float));
x->hamming = (t_float *)t_resizebytes_(x->hamming, x->window*sizeof(t_float), window*sizeof(t_float));
x->hann = (t_float *)t_resizebytes_(x->hann, x->window*sizeof(t_float), window*sizeof(t_float));
x->window = (t_float)window;
// re-init window functions
tIDLib_blackmanWindow(x->blackman, x->window);
tIDLib_cosineWindow(x->cosine, x->window);
tIDLib_hammingWindow(x->hamming, x->window);
tIDLib_hannWindow(x->hann, x->window);
// init signal buffer
for(i=0; i<(x->window+x->n); i++)
x->signal_R[i] = 0.0;
oldNumFilters = x->numFilters;
x->numFilters = tIDLib_getBarkFilterSpacing(&x->x_filterFreqs, x->sizeFilterFreqs, x->barkSpacing, x->sr);
x->sizeFilterFreqs = x->numFilters+2;
tIDLib_createFilterbank(x->x_filterFreqs, &x->x_filterbank, oldNumFilters, x->numFilters, x->window, x->sr);
post("window size: %i", (int)x->window);
}
}
static void specRolloff_tilde_window(t_specRolloff_tilde *x, t_floatarg w)
{
int i, window, isPow2;
window = w;
isPow2 = window && !( (window-1) & window );
if( !isPow2 )
error("requested window size is not a power of 2");
else
{
x->signal_R = (t_sample *)t_resizebytes(x->signal_R, (x->window+x->n) * sizeof(t_sample), (window+x->n) * sizeof(t_sample));
x->blackman = (t_float *)t_resizebytes(x->blackman, x->window*sizeof(t_float), window*sizeof(t_float));
x->cosine = (t_float *)t_resizebytes(x->cosine, x->window*sizeof(t_float), window*sizeof(t_float));
x->hamming = (t_float *)t_resizebytes(x->hamming, x->window*sizeof(t_float), window*sizeof(t_float));
x->hann = (t_float *)t_resizebytes(x->hann, x->window*sizeof(t_float), window*sizeof(t_float));
x->binFreqs = (t_float *)t_resizebytes(x->binFreqs, x->window*sizeof(t_float), window*sizeof(t_float));
x->window = (t_float)window;
// re-init window functions
tIDLib_blackmanWindow(x->blackman, x->window);
tIDLib_cosineWindow(x->cosine, x->window);
tIDLib_hammingWindow(x->hamming, x->window);
tIDLib_hannWindow(x->hann, x->window);
// init signal buffer
for(i=0; i<(x->window+x->n); i++)
x->signal_R[i] = 0.0;
// freqs for each bin based on current window size and sample rate
for(i=0; i<x->window; i++)
x->binFreqs[i] = (x->sr/x->window)*i;
post("window size: %i", (int)x->window);
}
}
static void specCentroid_analyze(t_specCentroid *x, t_floatarg start, t_floatarg n)
{
int i, j, oldWindow, window, windowHalf, startSamp, endSamp, lengthSamp;
t_float dividend, divisor, centroid, *windowFuncPtr;
t_sample *signal_I;
t_garray *a;
if(!(a = (t_garray *)pd_findbyclass(x->x_arrayname, garray_class)))
pd_error(x, "%s: no such array", x->x_arrayname->s_name);
else if(!garray_getfloatwords(a, &x->x_arrayPoints, &x->x_vec))
pd_error(x, "%s: bad template for specCentroid", x->x_arrayname->s_name);
else
{
startSamp = start;
startSamp = (startSamp<0)?0:startSamp;
if(n)
endSamp = startSamp + n-1;
else
endSamp = startSamp + x->window-1;
if(endSamp > x->x_arrayPoints)
endSamp = x->x_arrayPoints-1;
lengthSamp = endSamp-startSamp+1;
if(endSamp <= startSamp)
{
error("bad range of samples.");
return;
}
if(lengthSamp > x->powersOfTwo[x->powTwoArrSize-1])
{
post("WARNING: specCentroid: window truncated because requested size is larger than the current max_window setting. Use the max_window method to allow larger windows.");
lengthSamp = x->powersOfTwo[x->powTwoArrSize-1];
window = lengthSamp;
endSamp = startSamp + window - 1;
}
else
{
i=0;
while(lengthSamp > x->powersOfTwo[i])
i++;
window = x->powersOfTwo[i];
}
windowHalf = window * 0.5;
if(x->window != window)
{
oldWindow = x->window;
x->window = window;
x->signal_R = (t_sample *)t_resizebytes(x->signal_R, oldWindow*sizeof(t_sample), x->window*sizeof(t_sample));
}
if(x->windowFuncSize != lengthSamp)
{
x->blackman = (t_float *)t_resizebytes(x->blackman, x->windowFuncSize*sizeof(t_float), lengthSamp*sizeof(t_float));
x->cosine = (t_float *)t_resizebytes(x->cosine, x->windowFuncSize*sizeof(t_float), lengthSamp*sizeof(t_float));
x->hamming = (t_float *)t_resizebytes(x->hamming, x->windowFuncSize*sizeof(t_float), lengthSamp*sizeof(t_float));
x->hann = (t_float *)t_resizebytes(x->hann, x->windowFuncSize*sizeof(t_float), lengthSamp*sizeof(t_float));
x->windowFuncSize = lengthSamp;
tIDLib_blackmanWindow(x->blackman, x->windowFuncSize);
tIDLib_cosineWindow(x->cosine, x->windowFuncSize);
tIDLib_hammingWindow(x->hamming, x->windowFuncSize);
tIDLib_hannWindow(x->hann, x->windowFuncSize);
}
// create local memory
signal_I = (t_sample *)t_getbytes((windowHalf+1)*sizeof(t_sample));
// construct analysis window
for(i=0, j=startSamp; j<=endSamp; i++, j++)
x->signal_R[i] = x->x_vec[j].w_float;
// set window function
windowFuncPtr = x->hann; //default case to get rid of compile warning
switch(x->windowFunction)
{
case 0:
break;
case 1:
windowFuncPtr = x->blackman;
break;
case 2:
windowFuncPtr = x->cosine;
break;
case 3:
windowFuncPtr = x->hamming;
break;
case 4:
windowFuncPtr = x->hann;
break;
default:
break;
};
// if windowFunction == 0, skip the windowing (rectangular)
if(x->windowFunction>0)
for(i=0; i<lengthSamp; i++, windowFuncPtr++)
x->signal_R[i] *= *windowFuncPtr;
// then zero pad the end
for(; i<window; i++)
x->signal_R[i] = 0.0;
mayer_realfft(window, x->signal_R);
tIDLib_realfftUnpack(window, windowHalf, x->signal_R, signal_I);
tIDLib_power(windowHalf+1, x->signal_R, signal_I);
// power spectrum sometimes generates lower scores than magnitude. make it optional.
if(!x->powerSpectrum)
tIDLib_mag(windowHalf+1, x->signal_R);
dividend=0;
divisor=0;
centroid=0;
for(i=0; i<=windowHalf; i++)
dividend += x->signal_R[i]*(i*(x->sr/window)); // weight by bin freq
for(i=0; i<=windowHalf; i++)
divisor += x->signal_R[i];
if(divisor==0) divisor = 1; // don't divide by zero
centroid = dividend/divisor;
outlet_float(x->x_centroid, centroid);
// free local memory
t_freebytes(signal_I, (windowHalf+1)*sizeof(t_sample));
}
}
void *specFlatness_new(t_symbol *s, long argc, t_atom *argv)
{
t_specFlatness *x = (t_specFlatness *)object_alloc(specFlatness_class);
int i, isPow2;
double timef = 0.0;
//s=s;
if (x) {
dsp_setup((t_pxobject *)x, 1); // MSP inlets: arg is # of inlets and is REQUIRED!
// use 0 if you don't need inlets
//outlet_new(x, "signal"); // signal outlet (note "signal" rather than NULL)
//x->offset = 0.0;
x->x_flatness = floatout(x);
//x->x_flatness = outlet_new(&x->x_obj, &s_float);
if(argc > 1)
{
x->window = atom_getfloat(argv);
isPow2 = (int)x->window && !( ((int)x->window-1) & (int)x->window );
if(!isPow2)
{
error("requested window size is not a power of 2. default value of 1024 used instead");
x->window = 1024;
};
}
else if(argc > 0)
{
x->window = atom_getfloat(argv);
isPow2 = (int)x->window && !( ((int)x->window-1) & (int)x->window );
if(!isPow2)
{
error("requested window size is not a power of 2. default value of 1024 used instead");
x->window = 1024;
};
}
else
{
x->window = 1024;
};
x->sr = 44100.0;
x->n = 64.0;
x->overlap = 1;
x->windowFunction = 4; // 4 is hann window
x->powerSpectrum = 0;
//x->lastDspTime = clock_getlogicaltime();
clock_getftime(&timef);
x->lastDspTime = timef;
x->signal_R = (t_sample *)t_getbytes_((x->window+x->n) * sizeof(t_sample));
x->nthRoots = (t_float *)t_getbytes((x->window*0.5+1)*sizeof(t_float));
for(i=0; i<(x->window+x->n); i++)
x->signal_R[i] = 0.0;
x->blackman = (t_float *)t_getbytes_(x->window*sizeof(t_float));
x->cosine = (t_float *)t_getbytes_(x->window*sizeof(t_float));
x->hamming = (t_float *)t_getbytes_(x->window*sizeof(t_float));
x->hann = (t_float *)t_getbytes_(x->window*sizeof(t_float));
// initialize signal windowing functions
tIDLib_blackmanWindow(x->blackman, x->window);
tIDLib_cosineWindow(x->cosine, x->window);
tIDLib_hammingWindow(x->hamming, x->window);
tIDLib_hannWindow(x->hann, x->window);
post("specFlatness~: window size: %i", (int)x->window);
}
return (x);
}
void *barkSpec_new(t_symbol *s, long argc, t_atom *argv)
{
t_barkSpec *x = (t_barkSpec *)object_alloc(barkSpec_class);
int i, isPow2;
double timef = 0.0;
//s=s;
if (x) {
dsp_setup((t_pxobject *)x, 1); // MSP inlets: arg is # of inlets and is REQUIRED!
// use 0 if you don't need inlets
//outlet_new(x, "signal"); // signal outlet (note "signal" rather than NULL)
//x->offset = 0.0;
x->x_featureList = listout(x);
//x->x_featureList = outlet_new(&x->x_obj, &s_float);
if(argc > 1)
{
x->window = atom_getlong(argv); // should perform a check for >64 && power of two
isPow2 = (int)x->window && !( ((int)x->window-1) & (int)x->window );
if(!isPow2)
{
error("requested window size is not a power of 2. default value of 1024 used instead.");
x->window = 1024;
};
x->barkSpacing = atom_getfloat(argv+1);
}
else if(argc > 0)
{
x->window = atom_getlong(argv);
isPow2 = (int)x->window && !( ((int)x->window-1) & (int)x->window );
if(!isPow2)
{
error("requested window size is not a power of 2. default value of 1024 used instead.");
x->window = 1024;
};
x->barkSpacing = 0.5;
}
else
{
x->window = 1024;
x->barkSpacing = 0.5;
}
x->sr = 44100.0;
x->n = 64.0;
x->overlap = 1;
x->windowFunction = 4; // 4 is hann window
x->powerSpectrum = 0; // choose mag (0) or power (1) spec
x->normalize = 1; // this is generally a good thing, but should be off for concatenative synth
x->filterAvg = 0;
//x->lastDspTime = clock_getlogicaltime();
clock_getftime(&timef);
x->lastDspTime = timef;
x->sizeFilterFreqs = 0;
x->numFilters = 0; // this is just an init size that will be updated in createFilterbank anyway.
x->signal_R = (t_sample *)t_getbytes_((x->window+x->n)*sizeof(t_sample));
// initialize signal buffer
for(i=0; i<x->window+x->n; i++)
x->signal_R[i] = 0.0;
x->blackman = (t_float *)t_getbytes_(x->window*sizeof(t_float));
x->cosine = (t_float *)t_getbytes_(x->window*sizeof(t_float));
x->hamming = (t_float *)t_getbytes_(x->window*sizeof(t_float));
x->hann = (t_float *)t_getbytes_(x->window*sizeof(t_float));
// initialize signal windowing functions
tIDLib_blackmanWindow(x->blackman, x->window);
tIDLib_cosineWindow(x->cosine, x->window);
tIDLib_hammingWindow(x->hamming, x->window);
tIDLib_hannWindow(x->hann, x->window);
// grab memory
x->x_filterbank = (t_filter *)t_getbytes_(0);
x->x_filterFreqs = (t_float *)t_getbytes_(0);
x->numFilters = tIDLib_getBarkFilterSpacing(&x->x_filterFreqs, x->sizeFilterFreqs, x->barkSpacing, x->sr);
x->sizeFilterFreqs = x->numFilters+2;
tIDLib_createFilterbank(x->x_filterFreqs, &x->x_filterbank, 0, x->numFilters, x->window, x->sr);
}
return (x);
}
static void *bark_new(t_symbol *s, t_floatarg w, t_floatarg h, t_floatarg bs)
{
t_bark *x = (t_bark *)pd_new(bark_class);
int i, isPow2;
t_garray *a;
x->x_timeOut = outlet_new(&x->x_obj, &s_float);
x->x_growthOut = outlet_new(&x->x_obj, &s_float);
x->x_outputList = outlet_new(&x->x_obj, gensym("list"));
if(bs)
{
x->x_arrayname = s;
if(!(a = (t_garray *)pd_findbyclass(x->x_arrayname, garray_class)))
;
else if(!garray_getfloatwords(a, &x->x_array_points, &x->x_vec))
pd_error(x, "%s: bad template for bark", x->x_arrayname->s_name);
isPow2 = (int)w && !( ((int)w-1) & (int)w );
if( !isPow2 )
{
error("requested window size is not a power of 2. using default value of 2048 instead.");
x->window = 2048;
}
else
x->window = w;
if(h<0)
{
error("hop value must be > 0. default value of 128 samples used instead.");
x->hop = 128;
}
else
x->hop = h;
x->barkSpacing = bs;
}
else if(h)
{
x->x_arrayname = s;
if(!(a = (t_garray *)pd_findbyclass(x->x_arrayname, garray_class)))
;
else if(!garray_getfloatwords(a, &x->x_array_points, &x->x_vec))
pd_error(x, "%s: bad template for bark", x->x_arrayname->s_name);
isPow2 = (int)w && !( ((int)w-1) & (int)w );
if( !isPow2 )
{
error("requested window size is not a power of 2. using default value of 2048 instead.");
x->window = 2048;
}
else
x->window = w;
if(h<0)
{
error("hop value must be > 0. default value of 128 samples used instead.");
x->hop = 128;
}
else
x->hop = h;
x->barkSpacing = 0.5;
}
else if(w)
{
x->x_arrayname = s;
if(!(a = (t_garray *)pd_findbyclass(x->x_arrayname, garray_class)))
;
else if(!garray_getfloatwords(a, &x->x_array_points, &x->x_vec))
pd_error(x, "%s: bad template for bark", x->x_arrayname->s_name);
isPow2 = (int)w && !( ((int)w-1) & (int)w );
if( !isPow2 )
{
error("requested window size is not a power of 2. using default value of 2048 instead.");
x->window = 2048;
}
else
x->window = w;
x->hop = 128;
x->barkSpacing = 0.5;
}
else if(s)
{
x->x_arrayname = s;
if(!(a = (t_garray *)pd_findbyclass(x->x_arrayname, garray_class)))
;
else if(!garray_getfloatwords(a, &x->x_array_points, &x->x_vec))
pd_error(x, "%s: bad template for bark", x->x_arrayname->s_name);
x->window = 2048;
x->hop = 128;
x->barkSpacing = 0.5;
}
else
{
error("bark: no array specified.");
x->window = 2048;
x->hop = 128;
x->barkSpacing = 0.5;
}
x->debug = 0;
x->sr = 44100.0;
x->n = BLOCKSIZE;
x->windowFunction = 4; // 4 is hann window
x->powerSpectrum = 1; // choose mag (0) or power (1) spec
x->normalize = 0;
x->filterAvg = 0;
x->loThresh = 3;
x->hiThresh = 7;
x->minvel = 1.0;
x->haveHit = 0;
x->debounceTime = 20;
x->debounceSamp = x->debounceTime*0.001*x->sr;
x->debounceActive = -1;
x->maskDecay = 0.7;
x->maskPeriods = 4;
x->numFilters = 0;
x->prevTotalGrowth = 0.0;
x->useWeights = 0;
x->spew = 0;
x->signalBuf = (t_sample *)t_getbytes(x->window * sizeof(t_sample));
x->analysisBuf = (t_float *)t_getbytes(x->window * sizeof(t_float));
for(i=0; i<x->window; i++)
{
x->signalBuf[i] = 0.0;
x->analysisBuf[i] = 0.0;
}
x->blackman = (t_float *)t_getbytes(x->window*sizeof(t_float));
x->cosine = (t_float *)t_getbytes(x->window*sizeof(t_float));
x->hamming = (t_float *)t_getbytes(x->window*sizeof(t_float));
x->hann = (t_float *)t_getbytes(x->window*sizeof(t_float));
// initialize signal windowing functions
tIDLib_blackmanWindow(x->blackman, x->window);
tIDLib_cosineWindow(x->cosine, x->window);
tIDLib_hammingWindow(x->hamming, x->window);
tIDLib_hannWindow(x->hann, x->window);
// grab memory
x->x_filterbank = (t_filter *)t_getbytes(0);
x->x_filterFreqs = (t_float *)t_getbytes(0);
x->numFilters = tIDLib_getBarkFilterSpacing(&x->x_filterFreqs, x->sizeFilterFreqs, x->barkSpacing, x->sr);
x->sizeFilterFreqs = x->numFilters+2;
tIDLib_createFilterbank(x->x_filterFreqs, &x->x_filterbank, 0, x->numFilters, x->window, x->sr);
x->loBin = 0;
x->hiBin = x->numFilters-1;
x->mask = (t_float *)t_getbytes(x->numFilters*sizeof(t_float));
x->growth = (t_float *)t_getbytes(x->numFilters*sizeof(t_float));
x->numPeriods = (int *)t_getbytes(x->numFilters*sizeof(int));
x->growthList = (t_atom *)t_getbytes(x->numFilters*sizeof(t_atom));
x->loudWeights = (t_float *)t_getbytes(x->numFilters*sizeof(t_float));
for(i=0; i<x->numFilters; i++)
{
x->mask[i] = 0.0;
x->growth[i] = 0.0;
x->numPeriods[i] = 0.0;
SETFLOAT(x->growthList+i, 0.0);
x->loudWeights[i] = 0.0;
}
bark_create_loudness_weighting(x);
post("bark 0.0.6: window size: %i, hop: %i", (int)x->window, x->hop);
return (x);
}
static void *barkSpec_tilde_new(t_symbol *s, int argc, t_atom *argv)
{
t_barkSpec_tilde *x = (t_barkSpec_tilde *)pd_new(barkSpec_tilde_class);
int i, isPow2;
s=s;
x->x_featureList = outlet_new(&x->x_obj, gensym("list"));
if(argc > 1)
{
x->window = atom_getfloat(argv); // should perform a check for >64 && power of two
isPow2 = (int)x->window && !( ((int)x->window-1) & (int)x->window );
if(!isPow2)
{
error("requested window size is not a power of 2. default value of 1024 used instead.");
x->window = 1024;
};
x->barkSpacing = atom_getfloat(argv+1);
}
else if(argc > 0)
{
x->window = atom_getfloat(argv);
isPow2 = (int)x->window && !( ((int)x->window-1) & (int)x->window );
if(!isPow2)
{
error("requested window size is not a power of 2. default value of 1024 used instead.");
x->window = 1024;
};
x->barkSpacing = 0.5;
}
else
{
x->window = 1024;
x->barkSpacing = 0.5;
}
x->sr = 44100.0;
x->n = 64.0;
x->overlap = 1;
x->windowFunction = 4; // 4 is hann window
x->powerSpectrum = 0; // choose mag (0) or power (1) spec
x->normalize = 1; // this is generally a good thing, but should be off for concatenative synth
x->filterAvg = 0;
x->lastDspTime = clock_getlogicaltime();
x->sizeFilterFreqs = 0;
x->numFilters = 0; // this is just an init size that will be updated in createFilterbank anyway.
x->signal_R = (t_sample *)t_getbytes((x->window+x->n)*sizeof(t_sample));
// initialize signal buffer
for(i=0; i<x->window+x->n; i++)
x->signal_R[i] = 0.0;
x->blackman = (t_float *)t_getbytes(x->window*sizeof(t_float));
x->cosine = (t_float *)t_getbytes(x->window*sizeof(t_float));
x->hamming = (t_float *)t_getbytes(x->window*sizeof(t_float));
x->hann = (t_float *)t_getbytes(x->window*sizeof(t_float));
// initialize signal windowing functions
tIDLib_blackmanWindow(x->blackman, x->window);
tIDLib_cosineWindow(x->cosine, x->window);
tIDLib_hammingWindow(x->hamming, x->window);
tIDLib_hannWindow(x->hann, x->window);
// grab memory
x->x_filterbank = (t_filter *)t_getbytes(0);
x->x_filterFreqs = (t_float *)t_getbytes(0);
x->numFilters = tIDLib_getBarkFilterSpacing(&x->x_filterFreqs, x->sizeFilterFreqs, x->barkSpacing, x->sr);
x->sizeFilterFreqs = x->numFilters+2;
tIDLib_createFilterbank(x->x_filterFreqs, &x->x_filterbank, 0, x->numFilters, x->window, x->sr);
return (x);
}