// DSP Method
void fade_dsp(t_fade *x, t_signal **sp, short *count)
{
short i, j, k, l=0;
void **audioVectors = NULL;
TTUInt8 numChannels = 0;
TTUInt16 vs = 0;
if(count[x->numChannels * 2]) // SIGNAL RATE CROSSFADE CONNECTED
audioVectors = (void**)sysmem_newptr(sizeof(void*) * ((x->numChannels * 3) + 2));
else // CONTROL RATE CROSSFADE
audioVectors = (void**)sysmem_newptr(sizeof(void*) * ((x->numChannels * 3) + 1));
audioVectors[l] = x;
l++;
// audioVectors[] passed to balance_perform() as {x, audioInL[0], audioInR[0], audioOut[0], audioInL[1], audioInR[1], audioOut[1],...}
for(i=0; i < x->numChannels; i++){
j = x->numChannels + i;
k = x->numChannels*2 + i + 1; // + 1 to account for the position input
if(count[i] && count[j] && count[k]){
numChannels++;
if(sp[i]->s_n > vs)
vs = sp[i]->s_n;
audioVectors[l] = sp[i]->s_vec;
l++;
audioVectors[l] = sp[j]->s_vec;
l++;
audioVectors[l] = sp[k]->s_vec;
l++;
}
}
if(count[x->numChannels * 2]){ // SIGNAL RATE CROSSFADE CONNECTED
audioVectors[l] = sp[x->numChannels*2]->s_vec;
l++;
}
x->audioIn1->setNumChannels(numChannels);
x->audioIn2->setNumChannels(numChannels);
x->audioOut->setNumChannels(numChannels);
x->audioIn1->setVectorSizeWithInt(vs);
x->audioIn2->setVectorSizeWithInt(vs);
x->audioOut->setVectorSizeWithInt(vs);
//audioIn will be set in the perform method
x->audioOut->alloc();
x->xfade->setAttributeValue(kTTSym_sampleRate, sp[0]->s_sr);
if(count[x->numChannels * 2]) // SIGNAL RATE CROSSFADE CONNECTED
dsp_addv(fade_perform2, l, audioVectors);
else
dsp_addv(fade_perform1, l, audioVectors);
sysmem_freeptr(audioVectors);
}
void HoaEncode_dsp(t_HoaEncode *x, t_signal **sp, short *count)
{
int i;
int pointer_count;
t_int **sigvec;
x->f_ambiEncoder->setVectorSize(sp[0]->s_n);
x->f_inputNumber = x->f_ambiEncoder->getNumberOfInputs();
x->f_outputNumber = x->f_ambiEncoder->getNumberOfOutputs();
if(x->f_ambiEncoder->getMode() == "split")
{
pointer_count = x->f_outputNumber + 2 + x->f_inputNumber;
sigvec = (t_int **)calloc(pointer_count, sizeof(t_int *));
for(i = 0; i < pointer_count; i++)
sigvec[i] = (t_int *)calloc(1, sizeof(t_int));
sigvec[0] = (t_int *)x;
sigvec[1] = (t_int *)sp[0]->s_n;
for(i = 2; i < pointer_count; i++)
sigvec[i] = (t_int *)sp[i - 2]->s_vec;
if(count[x->f_inputNumber-1])
dsp_addv(HoaEncode_performVec, pointer_count, (void **)sigvec);
else
dsp_addv(HoaEncode_performOffsetVec, pointer_count, (void **)sigvec);
free(sigvec);
}
else
{
pointer_count = x->f_outputNumber + 2 + x->f_inputNumber;
sigvec = (t_int **)calloc(pointer_count, sizeof(t_int *));
for(i = 0; i < pointer_count; i++)
sigvec[i] = (t_int *)calloc(1, sizeof(t_int));
sigvec[0] = (t_int *)x;
sigvec[1] = (t_int *)sp[0]->s_n;
for(i = 2; i < pointer_count; i++)
sigvec[i] = (t_int *)sp[i - 2]->s_vec;
if(count[x->f_inputNumber - 1])
dsp_addv(HoaEncode_perform, pointer_count, (void **)sigvec);
else
dsp_addv(HoaEncode_performOffset, pointer_count, (void **)sigvec);
free(sigvec);
}
}
void stereoWidth_dsp(t_stereoWidth *x, t_signal **sp, short *count)
{
x->f_stereoWidth->setVectorSize(sp[0]->s_n);
long numberOfinlets = 0;
for(int i = 0; i < 3; i++)
{
if (count[i])
numberOfinlets++;
}
int i;
int pointer_count;
t_int **sigvec;
pointer_count = 7;
sigvec = (t_int **)calloc(pointer_count, sizeof(t_int *));
for(i = 0; i < pointer_count; i++)
sigvec[i] = (t_int *)calloc(1, sizeof(t_int));
sigvec[0] = (t_int *)x;
sigvec[1] = (t_int *)numberOfinlets;
for(i = 2; i < pointer_count; i++)
sigvec[i] = (t_int *)sp[i - 2]->s_vec;
dsp_addv(stereoWidth_perform, pointer_count, (void **)sigvec);
free(sigvec);
}
static void udpsend_tilde_dsp(t_udpsend_tilde *x, t_signal **sp)
{
int i;
pthread_mutex_lock(&x->x_mutex);
x->x_myvec[0] = (t_int*)x;
x->x_myvec[1] = (t_int*)sp[0]->s_n;
x->x_samplerate = sp[0]->s_sr;
for (i = 0; i < x->x_ninlets; i++)
{
x->x_myvec[2 + i] = (t_int*)sp[i]->s_vec;
}
pthread_mutex_unlock(&x->x_mutex);
if (DEFAULT_AUDIO_BUFFER_SIZE % sp[0]->s_n)
{
error("udpsend~: signal vector size too large (needs to be even divisor of %d)", DEFAULT_AUDIO_BUFFER_SIZE);
}
else
{
dsp_addv(udpsend_tilde_perform, x->x_ninlets + 2, (t_int*)x->x_myvec);
}
}
// DSP Method
void in_dsp(TTPtr self, t_signal **sp, short *count)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTInputPtr anInput = (TTInputPtr)x->wrappedObject;
void** audioVectors = NULL;
TTUInt16 vectorSize = 0;
if (anInput) {
audioVectors = (void**)sysmem_newptr(sizeof(void*) * 3);
audioVectors[0] = x;
if (count[0] || count[1]) {
if (sp[0]->s_n > vectorSize)
vectorSize = sp[0]->s_n;
audioVectors[1] = sp[0]->s_vec;
audioVectors[2] = sp[1]->s_vec;
}
// set signal numChannels and vectorSize
anInput->mSignalIn->setAttributeValue(kTTSym_numChannels, 1);
anInput->mSignalOut->setAttributeValue(kTTSym_numChannels, 1);
anInput->mSignalIn->setAttributeValue(kTTSym_vectorSize, vectorSize);
anInput->mSignalOut->setAttributeValue(kTTSym_vectorSize, vectorSize);
// anInput->mSignalIn will be set in the perform method
anInput->mSignalOut->sendMessage(kTTSym_alloc);
dsp_addv(in_perform, 3, audioVectors);
sysmem_freeptr(audioVectors);
}
}
void Huygens_dsp(t_Huygens *x, t_signal **sp, short *count)
{
int i;
int pointer_count;
t_int **sigvec;
x->f_n = (int)sp[0]->s_n;
x->f_sr = (int)sp[0]->s_sr;
pointer_count = x->f_outputNumber + 5;
sigvec = (t_int **)calloc(pointer_count, sizeof(t_int *));
for(i = 0; i < pointer_count; i++)
sigvec[i] = (t_int *)calloc(1, sizeof(t_int));
sigvec[0] = (t_int *)x;
sigvec[1] = (t_int *)sp[0]->s_n;
for(i = 2; i < pointer_count; i++)
sigvec[i] = (t_int *)sp[i - 2]->s_vec;
x->f_count[0] = count[1];
x->f_count[1] = count[2];
dsp_addv(Huygens_perform, pointer_count, (void **)sigvec);
free(sigvec);
}
// DSP Method
void PackDsp(PackPtr self, t_signal** sp, short* count)
{
TTUInt16 i, k=0;
void **audioVectors = NULL;
TTUInt16 highestIndexForConnectedSignal = 0;
self->vectorSize = sp[0]->s_n;
// Setup the perform method
audioVectors = (void**)sysmem_newptr(sizeof(void*) * (self->maxNumChannels + 1));
audioVectors[k] = self;
k++;
self->numChannels = 0;
for (i=0; i < self->maxNumChannels; i++) {
self->numChannels++;
audioVectors[k] = sp[i]->s_vec;
k++;
if (count[i])
highestIndexForConnectedSignal = i;
}
self->audioGraphObject->setOutputNumChannels(0, highestIndexForConnectedSignal+1);
self->audioGraphObject->getUnitGenerator()->setAttributeValue(kTTSym_vectorSize, (uint)self->vectorSize);
self->audioGraphObject->getUnitGenerator()->setAttributeValue(kTTSym_maxNumChannels, (uint)self->maxNumChannels);
self->audioGraphObject->getUnitGenerator()->setAttributeValue(kTTSym_sampleRate, (uint)sp[0]->s_sr);
dsp_addv(PackPerform, k, audioVectors);
sysmem_freeptr(audioVectors);
}
static void plugin_tilde_dsp (Pd_Plugin_Tilde* x, t_signal** sp)
{
unsigned i = 0;
unsigned long num_samples;
num_samples = sp[0]->s_n;
/* Pack vector of parameters for DSP routine */
x->dsp_vec[0] = (t_int)x;
x->dsp_vec[1] = (t_int)num_samples;
/* Inputs are before outputs; ignore the first "null" input */
for (i = 2; i < x->dsp_vec_length; i++) {
x->dsp_vec[i] = (t_int)(sp[i - 1]->s_vec);
}
/* Connect audio ports with buffers (this is only done when DSP
processing begins) */
plugin_tilde_connect_audio (x,
(float**)(&x->dsp_vec[2]),
(float**)(&x->dsp_vec[2 + x->num_audio_inputs]),
num_samples);
/* add DSP routine to Pd's DSP chain */
dsp_addv (plugin_tilde_perform, x->dsp_vec_length, x->dsp_vec);
}
void epluribus_dsp(t_epluribus *x, t_signal **sp)
{
long i;
t_int **sigvec;
int pointer_count;
if( x->incount < 2 || x->incount > 256 ){
post("bad vector count");
return;
}
pointer_count = x->incount + 4; // all metros, plus 2 outlets, plus the object pointer, plus N
sigvec = (t_int **) calloc(pointer_count, sizeof(t_int *));
for(i = 0; i < pointer_count; i++){
sigvec[i] = (t_int *) calloc(sizeof(t_int),1);
}
sigvec[0] = (t_int *)x; // first pointer is to the object
sigvec[pointer_count - 1] = (t_int *)sp[0]->s_n; // last pointer is to vector size (N)
for(i = 1; i < pointer_count - 1; i++){ // now attach the inlet and all outlets
sigvec[i] = (t_int *)sp[i-1]->s_vec;
}
dsp_addv(epluribus_perform, pointer_count, (t_int *) sigvec);
free(sigvec);
}
// DSP Method
void out_dsp(t_out *x, t_signal **sp, short *count)
{
short i, j, k=0;
void** audioVectors = NULL;
TTUInt8 numChannels = 0;
TTUInt16 vs = sp[0]->s_n;
int sr = sp[0]->s_sr;
x->ramp_gain->setAttributeValue(TT("sr"), sr); // convert midi to db for tap_gain
x->ramp_xfade->setAttributeValue(TT("sr"), sr); // convert midi to db for tap_gain
audioVectors = (void**)sysmem_newptr(sizeof(void*) * ((x->numOutputs * 2) + 1));
audioVectors[k] = x;
k++;
for(i=0; i < x->numOutputs; i++){
j = x->numOutputs + i;
if(count[i] || count[j]){
numChannels++;
if(sp[i]->s_n > vs)
vs = sp[i]->s_n;
audioVectors[k] = sp[i]->s_vec;
k++;
audioVectors[k] = sp[j]->s_vec;
k++;
}
}
x->numChannels = numChannels;
x->audioIn->setAttributeValue(TT("numChannels"), numChannels);
x->audioOut->setAttributeValue(TT("numChannels"), numChannels);
x->audioTemp->setAttributeValue(TT("numChannels"), numChannels);
x->zeroSignal->setAttributeValue(TT("numChannels"), numChannels);
x->vectorSize = vs;
x->audioIn->setAttributeValue(TT("vectorSize"), vs);
x->audioOut->setAttributeValue(TT("vectorSize"), vs);
x->audioTemp->setAttributeValue(TT("vectorSize"), vs);
x->zeroSignal->setAttributeValue(TT("vectorSize"), vs);
//audioIn will be set in the perform method
x->audioOut->sendMessage(TT("alloc"));
x->audioTemp->sendMessage(TT("alloc"));
x->zeroSignal->sendMessage(TT("alloc"));
x->zeroSignal->sendMessage(TT("clear"));
dsp_addv(out_perform, k, audioVectors);
sysmem_freeptr(audioVectors);
// start the meters
if(x->num_meter_objects){
for(i=0; i<MAX_NUM_CHANNELS; i++)
x->peakamp[i] = 0;
clock_delay(x->clock, kPollIntervalDefault); // start the clock
}
}
void samm_dsp(t_samm *x, t_signal **sp, short *count)
{
long i;
t_int **sigvec;
int pointer_count;
pointer_count = x->metro_count + 3; // all metros, plus 1 inlet, plus the object pointer, plus N
if(x->vs != sp[0]->s_n){
x->vs = sp[0]->s_n;
samm_init(x,1);
}
if(x->sr != sp[0]->s_sr) {
x->sr = sp[0]->s_sr;
x->onebeat_samps = (60.0/x->tempo) * x->sr;
for(i = 0; i < x->metro_count; i++){
x->metro_samps[i] = x->metro_beatdurs[i] * x->onebeat_samps;
x->metro[i] = 0;
}
}
sigvec = (t_int **) calloc(pointer_count, sizeof(t_int *));
for(i = 0; i < pointer_count; i++){
sigvec[i] = (t_int *) calloc(sizeof(t_int),1);
}
sigvec[0] = (t_int *)x; // first pointer is to the object
sigvec[pointer_count - 1] = (t_int *)sp[0]->s_n; // last pointer is to vector size (N)
for(i = 1; i < pointer_count - 1; i++){ // now attach the inlet and all outlets
sigvec[i] = (t_int *)sp[i-1]->s_vec;
}
// post("attached %d pointers",pointer_count);
#if MSP
dsp_addv(samm_perform, pointer_count, (void **) sigvec);
#endif
#if PD
dsp_addv(samm_perform, pointer_count, (t_int *) sigvec);
#endif
free(sigvec);
}
void emd_dsp(t_emd *x, t_signal **sp, short *count) {
int i;
int before = x->emd.size;
int after = sp[0]->s_n;
if(before != after)
emdResize(&(x->emd), after);
x->addv[0] = x;
for(i = 0; i < 1 + x->emd.order; i++)
x->addv[i + 1] = sp[i]->s_vec;
dsp_addv(emd_perform, x->addvSize, x->addv);
//post("emd_dsp");
}
static void
shmsrc_tilde_dsp(t_shmsrc_tilde *x, t_signal **sp)
{
x->x_myvec[0] = (t_int*)x;
x->x_myvec[1] = (t_int*)sp[0]->s_n;
x->x_pd_samplerate = (long)sp[0]->s_sr;
int i;
for (i = 0; i < x->x_num_outlets; i++)
x->x_myvec[2 + i] = (t_int*)sp[i+1]->s_vec;
dsp_addv(shmsrc_tilde_perform, x->x_num_outlets + 2, (t_int *)x->x_myvec);
}
void grans_dsp(t_grans *x, t_signal **sp)
{
int num = x->numinlets + x->numoutlets;
t_int **w = x->w;
w[0] = (t_int *)x;
w[1] = (t_int *)sp[0]->s_n;
int i;
for (i = 0; i < num; i++) {
w[i+2] = (t_int *)sp[i]->s_vec;
}
dsp_addv(grans_perform, num+2, (t_int *)w);
}
// DSP Method
void gain_dsp(t_gain *x, t_signal **sp, short *count)
{
short i, j, k, l=0;
void** audioVectors = NULL;
TTUInt16 numChannels = 0;
TTUInt16 vs = 0;
audioVectors = (void**)sysmem_newptr(sizeof(void*) * ((x->numChannels * 3) + 1));
audioVectors[l] = x;
l++;
// audioVectors[] passed to gain_perform() as:
// {x, audioInL[0], audioInR[0], audioOut[0], audioInL[1], audioInR[1], audioOut[1],...}
for(i=0; i < x->numChannels; i++){
j = x->numChannels + i;
k = x->numChannels*2 + i;
if(count[i] && count[j] && count[k]){
numChannels++;
if(sp[i]->s_n > vs)
vs = sp[i]->s_n;
audioVectors[l] = sp[i]->s_vec;
l++;
audioVectors[l] = sp[j]->s_vec;
l++;
audioVectors[l] = sp[k]->s_vec;
l++;
}
}
x->signalIn->setNumChannels(TTUInt16(numChannels*2));
x->signalOut->setNumChannels(numChannels);
x->signalTemp->setNumChannels(numChannels);
x->signalIn->setVectorSizeWithInt(vs);
x->signalOut->setVectorSizeWithInt(vs);
x->signalTemp->setVectorSizeWithInt(vs);
//signalIn will be set in the perform method
x->signalOut->alloc();
x->signalTemp->alloc();
x->xfade->setAttributeValue(kTTSym_sampleRate, sp[0]->s_sr);
x->gain->setAttributeValue(kTTSym_sampleRate, sp[0]->s_sr);
x->gain->setAttributeValue(TT("interpolated"), true);
dsp_addv(gain_perform, l, audioVectors);
sysmem_freeptr(audioVectors);
}
static void streamout13_dsp(t_streamout13 *x, t_signal **sp)
{
/*
dsp_add(streamout13_perform, 3, x, sp[0]->s_vec, sp[0]->s_n);
*/
int i;
t_int** myvec = getbytes(sizeof(t_int)*(x->x_n + 3));
myvec[0] = (t_int*)x;
myvec[1] = (t_int*)sp[0]->s_n;
for (i=0;i < x->x_n/*+1*/;i++)
myvec[2 + i] = (t_int*)sp[i]->s_vec;
dsp_addv(streamout13_perform, x->x_n + 3, (t_int*)myvec);
freebytes(myvec,sizeof(t_int)*(x->x_n + 3));
}
void HoaStereo_dsp(t_HoaStereo *x, t_signal **sp, short *count)
{
x->f_AmbisonicStereo->setVectorSize(sp[0]->s_n);
int pointer_count = x->f_AmbisonicStereo->getNumberOfInputs() + x->f_AmbisonicStereo->getNumberOfOutputs() + 3;
t_int** sigvec = (t_int **)malloc(pointer_count * sizeof(t_int *));
for(int i = 0; i < pointer_count; i++)
sigvec[i] = (t_int *)malloc(sizeof(t_int));
sigvec[0] = (t_int *)x;
sigvec[1] = (t_int *)x->f_AmbisonicStereo->getNumberOfInputs();
sigvec[2] = (t_int *)x->f_AmbisonicStereo->getNumberOfOutputs();
for(int i = 3; i < pointer_count; i++)
sigvec[i] = (t_int *)sp[i - 3]->s_vec;
dsp_addv(HoaStereo_perform, pointer_count, (void **)sigvec);
free(sigvec);
}
void arsic_dsp(t_arsic *x, t_signal **sp, t_perfroutine perf, int complain)
{
t_int *ap = x->s_perfargs;
if (ap)
{
int i, nsigs = x->s_nperfargs - 2;
x->s_ksr = sp[0]->s_sr * 0.001;
arsic_validate(x, complain);
arsic_check(x);
/* LATER consider glist traversing, and, if we have no feeders,
choosing an optimized version of perform routine */
*ap++ = (t_int)x;
*ap++ = (t_int)sp[0]->s_n;
for (i = 0; i < nsigs; i++) *ap++ = (t_int)sp[i]->s_vec;
dsp_addv(perf, x->s_nperfargs, x->s_perfargs);
}
else loudbug_bug("arsic_dsp");
}
// DSP Method: Adds our perform method to the DSP call chain
void balance_dsp(t_balance *x, t_signal **sp, short *count)
{
short i, j, k, l=0;
void **audioVectors = NULL;
audioVectors = (void**)sysmem_newptr(sizeof(void*) * ((x->maxNumChannels * 3) + 1));
audioVectors[l] = x;
l++;
// audioVectors[] passed to balance_perform() as {x, audioInL[0], audioInR[0], audioOut[0], audioInL[1], audioInR[1], audioOut[1],...}
x->numChannels = 0;
x->vs = 0;
for(i=0; i < x->maxNumChannels; i++){
j = x->maxNumChannels + i;
k = x->maxNumChannels*2 + i;
if(count[i] && count[j] && count[k]){
x->numChannels++;
if(sp[i]->s_n > x->vs)
x->vs = sp[i]->s_n;
audioVectors[l] = sp[i]->s_vec;
l++;
audioVectors[l] = sp[j]->s_vec;
l++;
audioVectors[l] = sp[k]->s_vec;
l++;
}
}
x->audioOut->setAttributeValue(TT("NumChannels"), x->numChannels*2);
x->audioOut->setAttributeValue(TT("NumChannels"), x->numChannels);
x->audioIn->setAttributeValue(TT("VectorSize"), x->vs);
x->audioOut->setAttributeValue(TT("VectorSize"), x->vs);
//audioIn will be set in the perform method
x->audioOut->sendMessage(TT("alloc"));
x->balance->setAttributeValue(TT("SampleRate"), sp[0]->s_sr);
dsp_addv(balance_perform, l, audioVectors);
sysmem_freeptr(audioVectors);
}
// dsp setup
void firbank_dsp(t_firbank *x, t_signal **sp, short *connect) {
int i;
x->v = sp[0]->s_n;
if(x->v != x->framesize / 2) {
object_post((t_object *)x, "firbank~: vector size (%d) is not equal to framesize / 2 (%d)", x->v, x->framesize / 2);
}
// setup args
x->w[0] = (t_int*)x;
x->w[1] = (t_int*)(sp[0]->s_n);
for(i = 0; i < (x->n + x->m); i++) {
x->w[i+2] = (t_int*)(sp[i]->s_vec);
}
dsp_addv(firbank_perform, 2 + x->n + x->m, (void**)(x->w)); // not sure if this is right for number of inlets, outlets
}
void HoaConvolve_dsp(t_HoaConvolve *x, t_signal **sp, short *count)
{
int i;
int pointer_count;
t_int **sigvec;
x->f_ambiConvolve->setVectorSize(sp[0]->s_n);
pointer_count = x->f_ambiConvolve->getNumberOfInputs() + x->f_ambiConvolve->getNumberOfOutputs() + 2;
sigvec = (t_int **)calloc(pointer_count, sizeof(t_int *));
for(i = 0; i < pointer_count; i++)
sigvec[i] = (t_int *)calloc(1, sizeof(t_int));
sigvec[0] = (t_int *)x;
sigvec[1] = (t_int *)sp[0]->s_n;
for(i = 2; i < pointer_count; i++)
sigvec[i] = (t_int *)sp[i - 2]->s_vec;
dsp_addv(HoaConvolve_perform, pointer_count, (void **)sigvec);
free(sigvec);
}
void scope_dsp(t_scope *x, t_signal **sp, short *count)
{
int i;
int pointer_count;
t_int **sigvec;
pointer_count = (x->f_order * 2 + 1) + 2;
sigvec = (t_int **)calloc(pointer_count, sizeof(t_int *));
for(i = 0; i < pointer_count; i++)
sigvec[i] = (t_int *)calloc(1, sizeof(t_int));
sigvec[0] = (t_int *)x;
sigvec[1] = (t_int *)sp[0]->s_n;
for(i = 2; i < pointer_count; i++)
sigvec[i] = (t_int *)sp[i - 2]->s_vec;
dsp_addv(scope_perform, pointer_count, (void **)sigvec);
free(sigvec);
x->f_startclock = 1;
}
void leeloo_dsp(t_leeloo *x, t_signal **sp)
{
size_t i;
t_int* vec;
if(x->l_vsize && x->l_vtemp)
{
freebytes(x->l_vtemp, x->l_vsize);
x->l_vtemp = NULL;
x->l_vsize = 0;
}
x->l_vsize = sizeof(t_sample) * x->l_nios * (size_t)sp[0]->s_n;
x->l_vtemp = (t_sample *)getbytes(x->l_vsize);
if(x->l_vtemp)
{
vec = (t_int *)getbytes((x->l_nios * 2 + 3) * sizeof(t_int));
if(vec)
{
vec[0] = (t_int)x->l_nios;
vec[1] = (t_int)sp[0]->s_n;
vec[2] = (t_int)x->l_vtemp;
for(i = 0; i < x->l_nios * 2; ++i)
{
vec[i+3] = (t_int)sp[i]->s_vec;
}
dsp_addv(leeloo_perform, (x->l_nios * 2 + 3), vec);
freebytes(vec, (x->l_nios * 2 + 2) * sizeof(t_int));
}
else
{
pd_error(x, "can't allocate temporary vectors.");
}
}
else
{
pd_error(x, "can't allocate temporary vectors.");
}
}
void HoaBinaural_dsp(t_HoaBinaural *x, t_signal **sp, short *count)
{
int i;
int pointer_count;
t_int **sigvec;
x->f_ambiBinaural->setVectorSize(sp[0]->s_n);
x->f_ambiBinaural->setSamplingRate(sp[0]->s_sr);
pointer_count = x->f_ambiBinaural->getNumberOfOutputs() + x->f_ambiBinaural->getNumberOfInputs() + 2;
sigvec = (t_int **)malloc(pointer_count * sizeof(t_int *));
for(i = 0; i < pointer_count; i++)
sigvec[i] = (t_int *)malloc(sizeof(t_int));
sigvec[0] = (t_int *)x;
sigvec[1] = (t_int *)sp[0]->s_n;
for(i = 2; i < pointer_count; i++)
sigvec[i] = (t_int *)sp[i - 2]->s_vec;
dsp_addv(HoaBinaural_perform, pointer_count, (void **)sigvec);
free(sigvec);
}
void HoaFilter_dsp(t_HoaFilter *x, t_signal **sp, short *count)
{
int i;
int pointer_count;
t_int **sigvec;
x->f_ambiFilter->setVectorSize(sp[0]->s_n);
x->f_inputNumber = x->f_ambiFilter->getNumberOfInputs();
x->f_outputNumber = x->f_ambiFilter->getNumberOfOutputs();
pointer_count = x->f_outputNumber + 2 + x->f_inputNumber;
sigvec = (t_int **)calloc(pointer_count, sizeof(t_int *));
for(i = 0; i < pointer_count; i++)
sigvec[i] = (t_int *)calloc(1, sizeof(t_int));
sigvec[0] = (t_int *)x;
sigvec[1] = (t_int *)sp[0]->s_n;
for(i = 2; i < pointer_count; i++)
sigvec[i] = (t_int *)sp[i - 2]->s_vec;
if(count[x->f_inputNumber - 1])
dsp_addv(HoaFilter_perform, pointer_count, (void **)sigvec);
free(sigvec);
}
/* The “dsp”-method has two arguments, the pointer to the class-data space, and
a pointer to an array of signals. */
void conv_tilde_dsp(t_conv_tilde *x, t_signal **sp)
{
int i;
/* PD's system for passing the signal to the dsp method as int pointers is */
/* a bit unclear. Passing the frame length as an t_int pointer especially */
/* seems like chewing gum solution but hey, it works. */
/* Add struct pointer. */
x->x_myvec[0] = (t_int*)x;
/* Add the audio buffer length second. */
x->x_myvec[1] = (t_int*)(sp[0]->s_n);
/* Add each input and output channel */
for (i = 0; i < x->all_channels; i++)
{
x->x_myvec[2 + i] = (t_int*)sp[i]->s_vec;
}
/* Add the pointers to the DSP tree as a vector. */
dsp_addv(conv_tilde_perform, x->all_channels + 2, (t_int*)x->x_myvec);
}
// DSP Method
void op_dsp(t_op *x, t_signal **sp, short *count)
{
short i, j, k=0;
void **audioVectors = NULL;
audioVectors = (void**)sysmem_newptr(sizeof(void*) * ((x->maxNumChannels * 2) + 1));
audioVectors[k] = x;
k++;
x->numChannels = 0;
x->vs = 0;
for(i=0; i < x->maxNumChannels; i++){
j = x->maxNumChannels + i;
if(count[i] && count[j]){
x->numChannels++;
if(sp[i]->s_n > x->vs)
x->vs = sp[i]->s_n;
audioVectors[k] = sp[i]->s_vec;
k++;
audioVectors[k] = sp[j]->s_vec;
k++;
}
}
x->audioIn->setAttributeValue(kTTSym_numChannels, x->maxNumChannels);
x->audioOut->setAttributeValue(kTTSym_numChannels, x->maxNumChannels);
x->audioIn->setAttributeValue(kTTSym_vectorSize, x->vs);
x->audioOut->setAttributeValue(kTTSym_vectorSize, x->vs);
//audioIn will be set in the perform method
x->audioOut->sendMessage(TT("alloc"));
x->op->setAttributeValue(kTTSym_sampleRate, sp[0]->s_sr);
dsp_addv(op_perform, k, audioVectors);
sysmem_freeptr(audioVectors);
}
void vdb_dsp(t_vdb *x, t_signal **sp, short *count)
{
int i;
int vector_count;
t_int **sigvec;
vector_count = x->inlet_count+x->outlet_count + 2;
for(i = 0; i < vector_count - 2; i++){
x->connections[i] = count[i];
// post("connection %d: %d",i,count[i]);
}
// post("vector count %d",vector_count);
vdb_attach_buffer(x);
/*
post("delay inlet status: %d",count[x->delay_inlet]);
post("feedback inlet status: %d",count[x->feedback_inlet]); */
sigvec = (t_int **) calloc(vector_count, sizeof(t_int *));
for(i = 0; i < vector_count; i++)
sigvec[i] = (t_int *) calloc(sizeof(t_int),1);
sigvec[0] = (t_int *)x;
sigvec[vector_count - 1] = (t_int *)sp[0]->s_n;
for(i = 1; i < vector_count - 1; i++){
sigvec[i] = (t_int *)sp[i-1]->s_vec;
}
dsp_addv(vdb_perform, vector_count, (void **)sigvec);
free(sigvec);
}
void HoaSevenDotOne_dsp(t_HoaSevenDotOne *x, t_signal **sp, short *count)
{
int i;
int pointer_count;
t_int **sigvec;
x->f_ninputs = x->f_AmbisonicSixDotOne->getNumberOfInputs();
x->f_noutputs = x->f_AmbisonicSixDotOne->getNumberOfOutputs();
x->f_AmbisonicSixDotOne->setVectorSize(sp[0]->s_n);
pointer_count = x->f_AmbisonicSixDotOne->getNumberOfInputs() + x->f_AmbisonicSixDotOne->getNumberOfOutputs() + 2;
sigvec = (t_int **)malloc(pointer_count * sizeof(t_int *));
for(i = 0; i < pointer_count; i++)
sigvec[i] = (t_int *)malloc(sizeof(t_int));
sigvec[0] = (t_int *)x;
sigvec[1] = (t_int *)sp[0]->s_n;
for(i = 2; i < pointer_count; i++)
sigvec[i] = (t_int *)sp[i - 2]->s_vec;
dsp_addv(HoaSevenDotOne_perform, pointer_count, (void **)sigvec);
free(sigvec);
}
void eobj_dsp(void *x, t_signal **sp)
{
int i;
short* count;
t_int* temp;
t_float **tempout, *tempreal;
t_linetraverser t;
t_outconnect *oc;
t_eclass* c = eobj_getclass(x);
t_edsp* dsp = eobj_getdsp(x);
int nouts = obj_nsigoutlets((t_object *)x);
int nins = obj_nsiginlets((t_object *)x);
int samplesize;
if(c && c->c_widget.w_dsp && dsp && (nins || nouts) && sp && sp[0])
{
samplesize = sp[0]->s_n;
dsp->d_perform_method = NULL;
if(dsp->d_misc == E_NO_INPLACE)
{
if(dsp->d_sigs_out)
{
tempout = (t_float **)realloc(dsp->d_sigs_out, (size_t)nouts * sizeof(t_float *));
}
else
{
tempout = (t_float **)malloc((size_t)nouts * sizeof(t_float *));
}
if(!tempout)
{
if(dsp->d_sigs_out)
{
free(dsp->d_sigs_out);
dsp->d_sigs_out = NULL;
}
pd_error(dsp, "can't allocate memory for ni inpace processing.");
return;
}
dsp->d_sigs_out = tempout;
if(dsp->d_sigs_real)
{
tempreal = (t_float *)realloc(dsp->d_sigs_real, (size_t)(nouts * samplesize) * sizeof(t_float));
}
else
{
tempreal = (t_float *)malloc((size_t)(nouts * samplesize) * sizeof(t_float));
}
if(!tempreal)
{
if(dsp->d_sigs_real)
{
free(dsp->d_sigs_real);
dsp->d_sigs_real = NULL;
}
free(dsp->d_sigs_out);
dsp->d_sigs_out = NULL;
pd_error(dsp, "can't allocate memory for ni inpace processing.");
return;
}
dsp->d_sigs_real = tempreal;
for(i = 0; i < nouts; i++)
{
dsp->d_sigs_out[i] = dsp->d_sigs_real+i*samplesize;
}
}
if(dsp->d_vectors)
{
temp = (t_int *)realloc(dsp->d_vectors, (size_t)(nins + nouts + 7) * sizeof(t_int));
}
else
{
temp = (t_int *)malloc((size_t)(nins + nouts + 7) * sizeof(t_int));
}
if(!temp)
{
if(dsp->d_vectors)
{
free(dsp->d_vectors);
dsp->d_vectors = NULL;
}
free(dsp->d_sigs_real);
dsp->d_sigs_real = NULL;
free(dsp->d_sigs_out);
dsp->d_sigs_out = NULL;
dsp->d_size = 0;
pd_error(x, "can't allocate memory for dsp vector.");
return;
}
dsp->d_vectors = temp;
dsp->d_size = nins + nouts + 7;
count = (short*)malloc((size_t)(nins + nouts) * sizeof(short));
if(count)
{
for(i = 0; i < (nins + nouts); i++)
{
count[i] = 0;
}
linetraverser_start(&t, eobj_getcanvas(x));
while((oc = linetraverser_next(&t)))
{
if(t.tr_ob2 == x && obj_issignaloutlet(t.tr_ob, t.tr_outno))
{
count[t.tr_inno] = 1;
}
}
dsp->d_vectors[0] = (t_int)x;
dsp->d_vectors[1] = (t_int)dsp;
dsp->d_vectors[2] = (t_int)sp[0]->s_n;
dsp->d_vectors[3] = (t_int)dsp->d_flags;
dsp->d_vectors[4] = (t_int)dsp->d_user_param;
dsp->d_vectors[5] = (t_int)nins;
dsp->d_vectors[6] = (t_int)nouts;
for(i = 7; i < dsp->d_size; i++)
{
if(sp[i - 7] && sp[i - 7]->s_vec)
{
dsp->d_vectors[i] = (t_int)(sp[i - 7]->s_vec);
}
else
{
free(count);
free(dsp->d_vectors);
dsp->d_vectors = NULL;
free(dsp->d_sigs_real);
dsp->d_sigs_real = NULL;
free(dsp->d_sigs_out);
dsp->d_sigs_out = NULL;
dsp->d_size = 0;
pd_error(x, "one of the signal isn't allocated.");
return;
}
}
c->c_widget.w_dsp(x, x, count, sp[0]->s_sr, sp[0]->s_n, 0);
if(dsp->d_perform_method != NULL && dsp->d_misc == E_INPLACE)
{
dsp_addv(eobj_perform_inplace, (int)dsp->d_size, dsp->d_vectors);
}
else if(dsp->d_perform_method != NULL && dsp->d_misc == E_NO_INPLACE)
{
dsp_addv(eobj_perform_noinplace, (int)dsp->d_size, dsp->d_vectors);
}
free(count);
return;
}
else
{
free(dsp->d_vectors);
dsp->d_vectors = NULL;
free(dsp->d_sigs_real);
dsp->d_sigs_real = NULL;
free(dsp->d_sigs_out);
dsp->d_sigs_out = NULL;
dsp->d_size = 0;
pd_error(x, "can't allocate memory for dsp chain counter.");
}
}
}
