void randomvals_dsp(t_randomvals *x, t_signal **sp, short *count)
{
dsp_add(randomvals_perform, 4, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n, x);
}
static void pdp_scope_dsp(t_pdp_scope *x, t_signal **sp)
{
dsp_add(pdp_scope_perform, 3, x, sp[0]->s_n, sp[0]->s_vec);
}
static void triangle_dsp(t_triangle *x, t_signal **sp)
{
dsp_add(triangle_perform, 5, x, sp[0]->s_n,
sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec);
}
static void fade_tilde_dsp(t_fade_tilde *x, t_signal **sp)
{
dsp_add(fade_tilde_perform, 4, sp[0]->s_vec, sp[1]->s_vec, x, sp[0]->s_n);
}
static void dcombsR_dsp(t_dcombsR *x, t_signal **sp)
{
dsp_add(dcombsR_perform, 4, x, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n);
}
static void foldback_tilde_dsp(t_foldback_tilde *x, t_signal **sp)
{
dsp_add(foldback_tilde_perform, 4, x, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n);
}
static void sigzero_dsp(t_sigzero *x, t_signal **sp)
{
dsp_add(sigzero_perform, 3, sp[0]->s_vec, x, sp[0]->s_n);
}
static void aubiotempo_tilde_dsp(t_aubiotempo_tilde *x, t_signal **sp)
{
dsp_add(aubiotempo_tilde_perform, 3, x, sp[0]->s_vec, sp[0]->s_n);
}
static void intg_dsp(t_intg *intg, t_signal **sp) {
dsp_add(intg_perform, 4,
&intg->intg, sp[0]->s_n, sp[1]->s_vec, sp[0]->s_vec);
}
static void median_dsp(t_median *x, t_signal **sp){
dsp_add(median_perform, 4, x, sp[0]->s_n, sp[0]->s_vec, sp[1]->s_vec);
}
// ../../../../Jamoma/Core/DSP/library/build/JamomaDSP.dylib Method
void decibels_dsp(t_decibels *x, t_signal **sp, short *count)
{
if (count[0] && count[1])
dsp_add(decibels_perform, 4, x, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n);
}
static void trapezoid_dsp(t_trapezoid *x, t_signal **sp)
{
dsp_add(trapezoid_perform, 6, x, sp[0]->s_n,
sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[3]->s_vec);
}
// ---------------------------------------------------
// DSP Function
// ---------------------------------------------------
static void rminus_dsp(t_rminus *x, t_signal **sp)
{
dsp_add(rminus_perform, 4, sp[0]->s_n,
sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec);
}
static void sigdelwrite_dsp(t_sigdelwrite *x, t_signal **sp)
{
dsp_add(sigdelwrite_perform, 3, sp[0]->s_vec, &x->x_cspace, sp[0]->s_n);
x->x_sortno = ugen_getsortno();
sigdelwrite_checkvecsize(x, sp[0]->s_n);
}
void distortion_dsp(t_distortion *x, t_signal **sp)
{
dsp_add(distortion2_perform, 6, x, sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[3]->s_vec,sp[0]->s_n);
}
void stringpitch_dsp(t_stringpitch *x, t_signal **sp, short *connect) {
int vs = sys_getblksize();
if (vs > x->BufSize) post(" You need to use a smaller signal vector size...",0);
else if (connect[0]) dsp_add(stringpitch_perform, 3, sp[0]->s_vec, x, sp[0]->s_n);
}
void gendyn_dsp(t_gendyn *x, t_signal **sp, short *count){
dsp_add(gendyn_perform, 4, x, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n);
}
static void log_dsp(t_log *x, t_signal **sp)
{
dsp_add(log_perform, 4, sp[0]->s_n, sp[0]->s_vec, sp[1]->s_vec,
&x->x_rcplogbase);
}
void channel_dsp(t_channel *x, t_signal **sp, short *count)
{
dsp_add(channel_perform, 4, x, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n);
}
/* set up prolog DSP code */
void vinlet_dspprolog(struct _vinlet *x, t_signal **parentsigs,
int myvecsize, int calcsize, int phase, int period, int frequency,
int downsample, int upsample, int reblock, int switched)
{
t_signal *insig;
/* no buffer means we're not a signal inlet */
if (!x->x_buf)
return;
x->x_updown.downsample = downsample;
x->x_updown.upsample = upsample;
/* if the "reblock" flag is set, arrange to copy data in from the
parent. */
if (reblock)
{
int parentvecsize, bufsize, oldbufsize, prologphase;
int re_parentvecsize; /* resampled parentvectorsize */
/* this should never happen: */
if (!x->x_buf) return;
/* the prolog code counts from 0 to period-1; the
phase is backed up by one so that AFTER the prolog code
runs, the "x_fill" phase is in sync with the "x_read" phase. */
prologphase = (phase - 1) & (period - 1);
if (parentsigs)
{
insig = parentsigs[inlet_getsignalindex(x->x_inlet)];
parentvecsize = insig->s_vecsize;
re_parentvecsize = parentvecsize * upsample / downsample;
}
else
{
insig = 0;
parentvecsize = 1;
re_parentvecsize = 1;
}
bufsize = re_parentvecsize;
if (bufsize < myvecsize) bufsize = myvecsize;
if (bufsize != (oldbufsize = x->x_bufsize))
{
t_float *buf = x->x_buf;
t_freebytes(buf, oldbufsize * sizeof(*buf));
buf = (t_float *)t_getbytes(bufsize * sizeof(*buf));
memset((char *)buf, 0, bufsize * sizeof(*buf));
x->x_bufsize = bufsize;
x->x_endbuf = buf + bufsize;
x->x_buf = buf;
}
if (parentsigs)
{
x->x_hop = period * re_parentvecsize;
x->x_fill = prologphase ?
x->x_endbuf - (x->x_hop - prologphase * re_parentvecsize) :
x->x_endbuf;
if (upsample * downsample == 1)
dsp_add(vinlet_doprolog, 3, x, insig->s_vec,
re_parentvecsize);
else {
int method = (x->x_updown.method == 3?
(pd_compatibilitylevel < 44 ? 0 : 1) : x->x_updown.method);
resamplefrom_dsp(&x->x_updown, insig->s_vec, parentvecsize,
re_parentvecsize, method);
dsp_add(vinlet_doprolog, 3, x, x->x_updown.s_vec,
re_parentvecsize);
}
/* if the input signal's reference count is zero, we have
to free it here because we didn't in ugen_doit(). */
if (!insig->s_refcount)
signal_makereusable(insig);
}
else memset((char *)(x->x_buf), 0, bufsize * sizeof(*x->x_buf));
x->x_directsignal = 0;
}
else
{
/* no reblocking; in this case our output signal is "borrowed"
and merely needs to be pointed to the real one. */
x->x_directsignal = parentsigs[inlet_getsignalindex(x->x_inlet)];
}
}
/* called to start DSP. Here we call Pd back to add our perform
routine to a linear callback list which Pd in turn calls to grind
out the samples. */
static void fileosc_dsp(t_fileosc *x, t_signal **sp)
{
dsp_add(fileosc_perform, 4, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n, x);
}
/* set up epilog DSP code. If we're reblocking, this is the
time to copy the samples out to the containing object's outlets.
If we aren't reblocking, there's nothing to do here. */
void voutlet_dspepilog(struct _voutlet *x, t_signal **parentsigs,
int myvecsize, int calcsize, int phase, int period, int frequency,
int downsample, int upsample, int reblock, int switched)
{
if (!x->x_buf) return; /* this shouldn't be necesssary... */
x->x_updown.downsample=downsample;
x->x_updown.upsample=upsample;
if (reblock)
{
t_signal *outsig;
int parentvecsize, bufsize, oldbufsize;
int re_parentvecsize;
int bigperiod, epilogphase, blockphase;
if (parentsigs)
{
outsig = parentsigs[outlet_getsignalindex(x->x_parentoutlet)];
parentvecsize = outsig->s_vecsize;
re_parentvecsize = parentvecsize * upsample / downsample;
}
else
{
outsig = 0;
parentvecsize = 1;
re_parentvecsize = 1;
}
bigperiod = myvecsize/re_parentvecsize;
if (!bigperiod) bigperiod = 1;
epilogphase = phase & (bigperiod - 1);
blockphase = (phase + period - 1) & (bigperiod - 1) & (- period);
bufsize = re_parentvecsize;
if (bufsize < myvecsize) bufsize = myvecsize;
if (bufsize != (oldbufsize = x->x_bufsize))
{
t_sample *buf = x->x_buf;
t_freebytes(buf, oldbufsize * sizeof(*buf));
buf = (t_sample *)t_getbytes(bufsize * sizeof(*buf));
memset((char *)buf, 0, bufsize * sizeof(*buf));
x->x_bufsize = bufsize;
x->x_endbuf = buf + bufsize;
x->x_buf = buf;
}
if (re_parentvecsize * period > bufsize) bug("voutlet_dspepilog");
x->x_write = x->x_buf + re_parentvecsize * blockphase;
if (x->x_write == x->x_endbuf) x->x_write = x->x_buf;
if (period == 1 && frequency > 1)
x->x_hop = re_parentvecsize / frequency;
else x->x_hop = period * re_parentvecsize;
/* post("phase %d, block %d, parent %d", phase & 63,
parentvecsize * blockphase, parentvecsize * epilogphase); */
if (parentsigs)
{
/* set epilog pointer and schedule it */
x->x_empty = x->x_buf + re_parentvecsize * epilogphase;
if (upsample * downsample == 1)
dsp_add(voutlet_doepilog, 3, x, outsig->s_vec,
re_parentvecsize);
else
{
int method = (x->x_updown.method == 3?
(pd_compatibilitylevel < 44 ? 0 : 1) : x->x_updown.method);
dsp_add(voutlet_doepilog_resampling, 2, x, re_parentvecsize);
resampleto_dsp(&x->x_updown, outsig->s_vec, re_parentvecsize,
parentvecsize, method);
}
}
}
/* if we aren't blocked but we are switched, the epilog code just
copies zeros to the output. In this case the blocking code actually
jumps over the epilog if the block is running. */
else if (switched)
{
if (parentsigs)
{
t_signal *outsig =
parentsigs[outlet_getsignalindex(x->x_parentoutlet)];
dsp_add_zero(outsig->s_vec, outsig->s_n);
}
}
}
static void lincong_dsp(t_lincong *x, t_signal **sp)
{
x->x_sr = sp[0]->s_sr;
dsp_add(lincong_perform, 4, x, sp[0]->s_n, sp[0]->s_vec, sp[1]->s_vec);
}
void random_dsp(t_random *x, t_signal **sp, short *count)
{
// add to the dsp chain -- i need my class, my input vector, my output vector, and my vector size...
dsp_add(random_perform, 4, x, sp[0]->s_vec-1, sp[0]->s_n+1);
}
void morph_tilde_dsp(t_morph_tilde *x, t_signal **sp){
dsp_add(morph_tilde_perform, 5, sp[0]->s_vec,
sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n, x);
}
static void random_dsp(t_random *x, t_signal **sp)
{
// add to the dsp chain -- i need my class, my input vector, my output vector, and my vector size...
dsp_add(random_perform, 3, x, sp[0]->s_vec, sp[0]->s_n);
}
static void overdrive_dsp(t_overdrive *x, t_signal **sp)
{
dsp_add(overdrive_perform, 5, x, sp[0]->s_n,
sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec);
}
static void connes_dsp(t_connes *x, t_signal **sp) {
dsp_add(connes_perform, 4, x, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n);
}
void ibufconcatenate_dsp(t_ibufconcatenate *x, t_signal **sp, short *count)
{
if (!x->max_mode)
dsp_add(ibufconcatenate_perform, 7, sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[3]->s_vec, sp[4]->s_vec, sp[0]->s_n, x);
}
static void envg_dsp(t_envg *envg, t_signal **sp) {
dsp_add(envg_perform, 10,
&envg->envg, sp[0]->s_n, sp[7]->s_vec, sp[0]->s_vec,
sp[1]->s_vec, sp[2]->s_vec, sp[3]->s_vec, sp[4]->s_vec,
sp[5]->s_vec, sp[6]->s_vec);
}
