void multigrain_dsp_free(t_multigrain *x)
{
dsp_free((t_pxobject *)x);
t_freebytes(x->grains, MAXGRAINS * sizeof(t_grain));
t_freebytes(x->pitchscale, MAXSCALE * sizeof(float));
t_freebytes(x->changroup, x->output_channels * sizeof(long));
}
static void specBrightness_tilde_bang(t_specBrightness_tilde *x)
{
int i, j, window, window_half, bang_sample, bin_boundary;
float dividend, divisor, brightness;
t_sample *signal_R, *signal_I;
double current_time;
window = x->window;
window_half = window*0.5;
// create local memory
signal_R = (t_sample *)getbytes(0);
signal_I = (t_sample *)getbytes(0);
signal_R = (t_sample *)t_resizebytes(signal_R, 0, window*sizeof(t_sample));
signal_I = (t_sample *)t_resizebytes(signal_I, 0, window_half*sizeof(t_sample));
bin_boundary = specBrightness_tilde_nearest_bin_index(x->freq_boundary, x->bin_freqs); // hard-coded based on 1200, but can use nearest_bin_freq function later
current_time = clock_gettimesince(x->last_dsp_time);
bang_sample = (int)(((current_time/1000.0)*x->sr)+0.5); // round
if (bang_sample < 0)
bang_sample = 0;
else if ( bang_sample >= x->n )
bang_sample = x->n - 1;
// construct analysis window using bang_sample as the end of the window
for(i=0, j=bang_sample; i<window; i++, j++)
signal_R[i] = x->signal_R[j];
specBrightness_tilde_hann(window, signal_R, x->hann);
mayer_realfft(window, signal_R);
specBrightness_tilde_realfft_unpack(window, window_half, signal_R, signal_I);
specBrightness_tilde_abs(window_half, signal_R, signal_I);
// if(x->normalize)
// specBrightness_tilde_normal(window_half, signal_R);
dividend=0;
divisor=0;
brightness=0;
for(i=bin_boundary; i<window_half; i++)
dividend += signal_R[i];
for(i=0; i<window_half; i++)
divisor += signal_R[i];
if(divisor==0)
divisor=1;
brightness = dividend/divisor;
outlet_float(x->x_brightness, brightness);
// free local memory
t_freebytes(signal_R, window * sizeof(t_sample));
t_freebytes(signal_I, window_half * sizeof(t_sample));
}
void getonset_free(t_getonset *x) {
if (x->Buf1) t_freebytes(x->Buf1, x->BufSize * sizeof(float));
if (x->Buf2) t_freebytes(x->Buf2, x->BufSize * sizeof(float));
if (x->BufFFT) t_freebytes(x->BufFFT, x->FFTSize * sizeof(float));
if (x->memFFT) t_freebytes(x->memFFT, CMAX * x->FFTSize * sizeof(float));
freeobject((t_object *)x->g_clock);
dsp_free((t_pxobject *)x);
}
static void specCentroid_tilde_free(t_specCentroid_tilde *x)
{
// free the input buffer memory
t_freebytes(x->signal_R, (x->window+x->n)*sizeof(t_sample));
// free the hann window memory
t_freebytes(x->hann, x->window*sizeof(float));
}
static void pique_free(t_pique *x)
{
int n = x->x_n;
t_freebytes(x->x_freq, n * sizeof(*x->x_freq));
t_freebytes(x->x_amp, n * sizeof(*x->x_amp));
t_freebytes(x->x_ampre, n * sizeof(*x->x_ampre));
t_freebytes(x->x_ampim, n * sizeof(*x->x_ampim));
}
void oscil_dsp_free(t_oscil *x)
{
t_freebytes(x->wavetable, x->table_length * sizeof(float));
t_freebytes(x->old_wavetable, x->table_length * sizeof(float));
t_freebytes(x->harmonic_weights, OSCIL_MAXIMUM_HARMONICS * sizeof(float));
t_freebytes(x->harmonic_phases, OSCIL_MAXIMUM_HARMONICS * sizeof(float));
}
void resample_free(t_resample *x)
{
if (x->s_n) t_freebytes(x->s_vec, x->s_n*sizeof(*x->s_vec));
if (x->coefsize) t_freebytes(x->coeffs, x->coefsize*sizeof(*x->coeffs));
if (x->bufsize) t_freebytes(x->buffer, x->bufsize*sizeof(*x->buffer));
x->s_n = x->coefsize = x->bufsize = 0;
x->s_vec = x->coeffs = x->buffer = 0;
}
void centroid_free(t_centroid *x) {
if (x->Buf1) t_freebytes(x->Buf1, x->BufSize * sizeof(float));
if (x->Buf2) t_freebytes(x->Buf2, x->BufSize * sizeof(float));
if (x->BufFFT) t_freebytes(x->BufFFT, x->FFTSize * sizeof(float));
if (x->WindFFT) t_freebytes(x->WindFFT, x->FFTSize * sizeof(float));
if (x->memFFT) t_freebytes(x->memFFT, CMAX * x->FFTSize * sizeof(float));
freeobject((t_object *)x->c_clock);
dsp_free((t_pxobject *)x);
}
static void specCentroid_tilde_bang(t_specCentroid_tilde *x)
{
int i, j, window, window_half, bang_sample;
float dividend, divisor, centroid;
t_sample *signal_R, *signal_I;
double current_time;
window = x->window;
window_half = window*0.5;
// create local memory
signal_R = (t_sample *)getbytes(0);
signal_I = (t_sample *)getbytes(0);
signal_R = (t_sample *)t_resizebytes(signal_R, 0, window*sizeof(t_sample));
signal_I = (t_sample *)t_resizebytes(signal_I, 0, window_half*sizeof(t_sample));
current_time = clock_gettimesince(x->last_dsp_time);
bang_sample = (int)(((current_time/1000.0)*x->sr)+0.5); // round
if (bang_sample < 0)
bang_sample = 0;
else if ( bang_sample >= x->n )
bang_sample = x->n - 1;
// construct analysis window using bang_sample as the end of the window
for(i=0, j=bang_sample; i<window; i++, j++)
signal_R[i] = x->signal_R[j];
specCentroid_tilde_hann(window, signal_R, x->hann);
mayer_realfft(window, signal_R);
specCentroid_tilde_realfft_unpack(window, window_half, signal_R, signal_I);
specCentroid_tilde_abs(window_half, signal_R, signal_I);
// if(x->normalize)
// specCentroid_tilde_normal(window_half, signal_R);
dividend=0;
divisor=0;
centroid=0;
for(i=0; i<window_half; i++)
dividend += signal_R[i]*(i*(x->sr/window)); // weight by bin freq
for(i=0; i<window_half; i++)
divisor += 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_R, window * sizeof(t_sample));
t_freebytes(signal_I, window_half * sizeof(t_sample));
}
static void cepstrum_tilde_bang(t_cepstrum_tilde *x)
{
int i, j, window, window_half, bang_sample;
t_atom *listOut;
t_sample *signal_R, *signal_I;
double current_time;
window = x->window;
window_half = window*0.5;
signal_R = (t_sample *)getbytes(0);
signal_I = (t_sample *)getbytes(0);
listOut = (t_atom *)getbytes(0);
signal_R = (t_sample *)t_resizebytes(signal_R, 0, window*sizeof(t_sample));
signal_I = (t_sample *)t_resizebytes(signal_I, 0, window_half*sizeof(t_sample));
listOut = (t_atom *)t_resizebytes(listOut, 0, ((int)x->window*0.5)*sizeof(t_atom));
current_time = clock_gettimesince(x->last_dsp_time);
bang_sample = (int)(((current_time/1000.0)*x->sr)+0.5); // round
if (bang_sample < 0)
bang_sample = 0;
else if ( bang_sample >= x->n )
bang_sample = x->n - 1;
// construct analysis window using bang_sample as the end of the window
for(i=0, j=bang_sample; i<window; i++, j++)
signal_R[i] = x->signal_R[j];
cepstrum_tilde_hann(window, signal_R, x->hann);
mayer_realfft(window, signal_R);
cepstrum_tilde_realfft_unpack(window, window_half, signal_R, signal_I);
cepstrum_tilde_abs(window_half, signal_R, signal_I);
if(x->normalize)
cepstrum_tilde_normal(window_half, signal_R);
cepstrum_tilde_log(window_half, signal_R);
// fill out the negative frequencies
for(i=0; i<window_half; i++)
signal_I[i] = signal_R[i];
// signal_I[i] = 0.0; // or we could zero them out...
cepstrum_tilde_realifft(window, window_half, signal_R, signal_I);
for(i=0; i<window_half; i++)
SETFLOAT(listOut+i, signal_R[i]);
outlet_list(x->x_featureList, 0, window_half, listOut);
t_freebytes(signal_R, window * sizeof(t_sample));
t_freebytes(signal_I, window_half * sizeof(t_sample));
t_freebytes(listOut, window_half * sizeof(t_atom));
}
void pitcher_free(t_pitcher *x) {
if (x->ringBufSize != 0) {
t_freebytes(x->inputRingBuf, (long) (x->ringBufSize * sizeof(float)));
}
if (x->ringBufSize != 0) {
t_freebytes(x->outputRingBuf, (long) (x->ringBufSize * sizeof(float)));
}
dsp_free(&(x->x_obj));
}
void namelist_free(t_namelist *listwas)
{
t_namelist *nl, *nl2;
for (nl = listwas; nl; nl = nl2)
{
nl2 = nl->nl_next;
t_freebytes(nl->nl_string, strlen(nl->nl_string) + 1);
t_freebytes(nl, sizeof(*nl));
}
}
static void bfcc_tilde_free(t_bfcc_tilde *x)
{
int i;
// free the input buffer memory
t_freebytes(x->signal_R, (x->window+x->n)*sizeof(t_sample));
// free the blackman window memory
t_freebytes(x->blackman, x->window*sizeof(float));
// free the cosine window memory
t_freebytes(x->cosine, x->window*sizeof(float));
// free the hamming window memory
t_freebytes(x->hamming, x->window*sizeof(float));
// free the hann window memory
t_freebytes(x->hann, x->window*sizeof(float));
// free the bfcc memory
t_freebytes(x->bfcc, x->num_filters*sizeof(float));
// free the filterbank memory
for(i=0; i<x->num_filters; i++)
t_freebytes(x->x_filterbank[i].filter, x->x_filterbank_sizes[i]*sizeof(float));
t_freebytes(x->x_filterbank, x->num_filters*sizeof(t_filter));
// free the indices memory
t_freebytes(x->x_indices, x->num_filters*sizeof(t_indices));
}
static void specBrightness_tilde_free(t_specBrightness_tilde *x)
{
// free the input buffer memory
t_freebytes(x->signal_R, (x->window+x->n)*sizeof(t_sample));
// free the hann window memory
t_freebytes(x->hann, x->window*sizeof(float));
// free the bin freq memory
t_freebytes(x->bin_freqs, x->window*sizeof(float));
}
static void magSpec_tilde_free(t_magSpec_tilde *x)
{
// free the input buffer memory
t_freebytes(x->signal_R, (x->window+x->n)*sizeof(t_sample));
// free the window memory
t_freebytes(x->blackman, x->window*sizeof(t_float));
t_freebytes(x->cosine, x->window*sizeof(t_float));
t_freebytes(x->hamming, x->window*sizeof(t_float));
t_freebytes(x->hann, x->window*sizeof(t_float));
}
static void nearestPoint_free(t_nearestPoint *x)
{
int i;
for(i=0; i<x->numPoints; i++)
t_freebytes(x->x_coordinates[i].coordinate, x->dimensions*sizeof(t_float));
t_freebytes(x->x_coordinates, x->numPoints*sizeof(t_coordinate));
t_freebytes(x->x_input, x->dimensions*sizeof(t_float));
}
static void udpsend_tilde_free(t_udpsend_tilde* x)
{
udpsend_tilde_disconnect(x);
/* free the memory */
if (x->x_cbuf)t_freebytes(x->x_cbuf, x->x_cbufsize);
if (x->x_myvec)t_freebytes(x->x_myvec, sizeof(t_int) * (x->x_ninlets + 3));
clock_free(x->x_clock);
pthread_mutex_destroy(&x->x_mutex);
}
void fft_free(t_fft *x)
{
if (x->f_realin)
t_freebytes(x->f_realin,x->f_points * sizeof(float));
if (x->f_imagin)
t_freebytes(x->f_imagin,x->f_points * sizeof(float));
if (x->f_realout)
t_freebytes(x->f_realout,x->f_points * sizeof(float));
if (x->f_imagout)
t_freebytes(x->f_imagout,x->f_points * sizeof(float));
dsp_free((t_pxobject *)x);
if (fts_mode)
freeobject(x->f_clock);
}
void fft_free(t_fft *x)
{
if (x->x_realin)
t_freebytes(x->x_realin,x->x_fftsize * sizeof(float));
if (x->x_imagin)
t_freebytes(x->x_imagin,x->x_fftsize * sizeof(float));
if (x->x_realout)
t_freebytes(x->x_realout,x->x_fftsize * sizeof(float));
if (x->x_imagout)
t_freebytes(x->x_imagout,x->x_fftsize * sizeof(float));
if (x->x_window)
t_freebytes(x->x_window,x->x_fftsize * sizeof(float));
dsp_free((t_pxobject *)x);
}
void stft_free(t_stft *x)
{
if (x->x_in)
t_freebytes(x->x_in,x->x_fftsize * sizeof(float));
if (x->x_out)
t_freebytes(x->x_out,x->x_fftsize * sizeof(float));
if (x->x_window)
t_freebytes(x->x_window,x->x_fftsize * sizeof(float));
if (x->x_sdifbuf)
t_freebytes(x->x_sdifbuf,x->x_sdifbufsize * sizeof(t_complex));
//if (x->x_twiddle)
// t_freebytes(x->x_twiddle, CMAX * x->x_fftsize * sizeof(float));
dsp_free((t_pxobject *)x);
}
static void zeroCrossing_tilde_bang(t_zeroCrossing_tilde *x)
{
int i, j, window, bang_sample;
float crossings;
t_sample *signal_R;
double current_time;
window = x->window;
signal_R = (t_sample *)getbytes(0);
signal_R = (t_sample *)t_resizebytes(signal_R, 0, window * sizeof(t_sample));
current_time = clock_gettimesince(x->last_dsp_time);
bang_sample = (int)(((current_time/1000.0)*x->sr)+0.5); // round
if (bang_sample < 0)
bang_sample = 0;
else if ( bang_sample >= x->n )
bang_sample = x->n - 1;
// construct analysis window using bang_sample as the end of the window
for(i=0, j=bang_sample; i<window; i++, j++)
signal_R[i] = x->signal_R[j];
crossings=0;
crossings = zeroCrossing_tilde_zero_crossing_rate(window, signal_R);
outlet_float(x->x_crossings, crossings);
// free local memory
t_freebytes(signal_R, window*sizeof(t_sample));
}
static void gstub_dis(t_gstub *gs)
{
int refcount = --gs->gs_refcount;
if ((!refcount) && gs->gs_which == GP_NONE)
t_freebytes(gs, sizeof (*gs));
else if (refcount < 0) bug("gstub_dis");
}
static void pack_bang(t_pack *x)
{
int i, reentered = 0, size = x->x_n * sizeof (t_atom);
t_gpointer *gp;
t_atom *outvec;
for (i = x->x_nptr, gp = x->x_gpointer; i--; gp++)
if (!gpointer_check(gp, 1))
{
pd_error(x, "pack: stale pointer");
return;
}
/* reentrancy protection. The first time through use the pre-allocated
x_outvec; if we're reentered we have to allocate new memory. */
if (!x->x_outvec)
{
/* LATER figure out how to deal with reentrancy and pointers... */
if (x->x_nptr)
post("pack_bang: warning: reentry with pointers unprotected");
outvec = t_getbytes(size);
reentered = 1;
}
else
{
outvec = x->x_outvec;
x->x_outvec = 0;
}
memcpy(outvec, x->x_vec, size);
outlet_list(x->x_obj.ob_outlet, &s_list, x->x_n, outvec);
if (reentered)
t_freebytes(outvec, size);
else x->x_outvec = outvec;
}
static void vinlet_free(t_vinlet *x)
{
canvas_rminlet(x->x_canvas, x->x_inlet);
if (x->x_buf)
t_freebytes(x->x_buf, x->x_bufsize * sizeof(*x->x_buf));
resample_free(&x->x_updown);
}
void conv_tilde_free(t_conv_tilde *x)
{
#ifdef THREADS
int rc = pthread_join(x->childthread, NULL);
if (rc != 0 )
post("conv~: pthread_join() error %d.", rc);
#endif
/* Free channel variable arrays. */
//free(x->parameters);
free(x->input_rw_ptr);
free(x->ir_end_ptr);
free(x->ir_frames);
free(x->frames_stored);
free(x->irlength);
free(x->ircount);
free(x->ircount_prev);
/* Free fft plans and associated arrays. */
conv_tilde_free_fft_plans(x);
/* free the dsp vector */
if (x->x_myvec)
t_freebytes(x->x_myvec, sizeof(t_int) * (x->all_channels + 3));
}
static void vline_tilde_float(t_vline *x, t_float f)
{
t_time timenow = clock_gettimesince(x->x_referencetime);
t_sample inlet1 = (x->x_inlet1 < 0 ? 0 : (t_sample)x->x_inlet1);
t_sample inlet2 = (t_sample) x->x_inlet2;
t_time starttime = timenow + inlet2;
t_vseg *s1, *s2, *deletefrom = 0,
*snew = (t_vseg *)t_getbytes(sizeof(*snew));
if (PD_BADFLOAT(f))
f = 0;
/* negative delay input means stop and jump immediately to new value */
if (inlet2 < 0)
{
vline_tilde_stop(x);
x->x_value = ftofix(f);
return;
}
/* check if we supplant the first item in the list. We supplant
an item by having an earlier starttime, or an equal starttime unless
the equal one was instantaneous and the new one isn't (in which case
we'll do a jump-and-slide starting at that time.) */
if (!x->x_list || x->x_list->s_starttime > starttime ||
(x->x_list->s_starttime == starttime &&
(x->x_list->s_targettime > x->x_list->s_starttime || inlet1 <= 0)))
{
deletefrom = x->x_list;
x->x_list = snew;
}
else
{
for (s1 = x->x_list; (s2 = s1->s_next); s1 = s2)
{
if (s2->s_starttime > starttime ||
(s2->s_starttime == starttime &&
(s2->s_targettime > s2->s_starttime || inlet1 <= 0)))
{
deletefrom = s2;
s1->s_next = snew;
goto didit;
}
}
s1->s_next = snew;
deletefrom = 0;
didit: ;
}
while (deletefrom)
{
s1 = deletefrom->s_next;
t_freebytes(deletefrom, sizeof(*deletefrom));
deletefrom = s1;
}
snew->s_next = 0;
snew->s_target = f;
snew->s_starttime = starttime;
snew->s_targettime = starttime + inlet1;
x->x_inlet1 = x->x_inlet2 = 0;
}
static void vline_tilde_stop(t_vline *x)
{
t_vseg *s1, *s2;
for (s1 = x->x_list; s1; s1 = s2)
s2 = s1->s_next, t_freebytes(s1, sizeof(*s1));
x->x_list = 0;
x->x_inc = 0;
x->x_inlet1 = x->x_inlet2 = 0;
}
// clean up
static void freeverb_free(t_freeverb *x)
{
int i;
#ifndef PD
dsp_free((t_pxobject *)x); // Free the object
#endif
// free memory used by delay lines
for(i = 0; i < numcombs; i++)
{
t_freebytes(x->x_bufcombL[i], x->x_combtuningL[i]*sizeof(t_float));
t_freebytes(x->x_bufcombR[i], x->x_combtuningR[i]*sizeof(t_float));
}
for(i = 0; i < numallpasses; i++)
{
t_freebytes(x->x_bufallpassL[i], x->x_allpasstuningL[i]*sizeof(t_float));
t_freebytes(x->x_bufallpassR[i], x->x_allpasstuningR[i]*sizeof(t_float));
}
}
static void netsend_send(t_netsend *x, t_symbol *s, int argc, t_atom *argv)
{
#ifdef ROCKBOX
(void) x;
(void) s;
(void) argc;
(void) argv;
#else /* ROCKBOX */
if (x->x_fd >= 0)
{
t_binbuf *b = binbuf_new();
char *buf, *bp;
int length, sent;
t_atom at;
binbuf_add(b, argc, argv);
SETSEMI(&at);
binbuf_add(b, 1, &at);
binbuf_gettext(b, &buf, &length);
for (bp = buf, sent = 0; sent < length;)
{
static double lastwarntime;
static double pleasewarn;
double timebefore = sys_getrealtime();
int res = send(x->x_fd, buf, length-sent, 0);
double timeafter = sys_getrealtime();
int late = (timeafter - timebefore > 0.005);
if (late || pleasewarn)
{
if (timeafter > lastwarntime + 2)
{
post("netsend blocked %d msec",
(int)(1000 * ((timeafter - timebefore) + pleasewarn)));
pleasewarn = 0;
lastwarntime = timeafter;
}
else if (late) pleasewarn += timeafter - timebefore;
}
if (res <= 0)
{
sys_sockerror("netsend");
netsend_disconnect(x);
break;
}
else
{
sent += res;
bp += res;
}
}
t_freebytes(buf, length);
binbuf_free(b);
}
else error("netsend: not connected");
#endif /* ROCKBOX */
}
static t_int *vline_tilde_perform(t_int *w)
{
t_vline *x = (t_vline *)(w[1]);
t_sample *out = (t_sample *)(w[2]);
int n = (int)(w[3]), i;
t_sample f = x->x_value;
t_sample inc = x->x_inc;
t_time msecpersamp = x->x_msecpersamp;
#ifndef ROCKBOX
t_time samppermsec = x->x_samppermsec;
#endif
t_time timenow = clock_gettimesince(x->x_referencetime) - n * msecpersamp;
t_vseg *s = x->x_list;
for (i = 0; i < n; i++)
{
t_time timenext = timenow + msecpersamp;
checknext:
if (s)
{
/* has starttime elapsed? If so update value and increment */
if (s->s_starttime < timenext)
{
if (x->x_targettime <= timenext)
f = x->x_target, inc = 0;
/* if zero-length segment bash output value */
if (s->s_targettime <= s->s_starttime)
{
f = s->s_target;
inc = 0;
}
else
{
t_time incpermsec = idiv((s->s_target - f),
(s->s_targettime - s->s_starttime));
f = mult(f + incpermsec,(timenext - s->s_starttime));
inc = mult(incpermsec,msecpersamp);
}
x->x_inc = inc;
x->x_target = s->s_target;
x->x_targettime = s->s_targettime;
x->x_list = s->s_next;
t_freebytes(s, sizeof(*s));
s = x->x_list;
goto checknext;
}
}
if (x->x_targettime <= timenext)
f = x->x_target, inc = 0;
*out++ = f;
f = f + inc;
timenow = timenext;
}
x->x_value = f;
return (w+4);
}