void FFTSubbandPower_Ctor(FFTSubbandPower *unit)
{
SETCALC(FFTSubbandPower_next);
ZOUT0(0) = unit->outval = 0.;
unit->m_square = ZIN0(2) > 0.f;
unit->m_normfactor = 0.f;
// ZIN0(1) tells us how many cutoffs we're looking for
int numcutoffs = (int)ZIN0(1);
int numbands = numcutoffs+1;
unit->m_scalemode = (int)ZIN0(3);
float * outvals = (float*)RTAlloc(unit->mWorld, numbands * sizeof(float));
for(int i=0; i<numbands; i++) {
outvals[i] = 0.f;
}
unit->m_outvals = outvals;
unit->m_cutoffs = (int*)RTAlloc(unit->mWorld, numcutoffs * sizeof(int));
unit->m_cutoff_inited = false;
unit->m_numbands = numbands;
}
void PlaneTree_Ctor(PlaneTree* unit)
{
// Infer the size of the "inputs" array which has been tagged on to the end of the arguments list.
int ndims = unit->mNumInputs - 2;
//Print("PlaneTree_Ctor: ndims is %i\n", ndims);
// Allocate a comfy bit of memory where we'll put the input data while we process it
unit->m_inputdata = (float*)RTAlloc(unit->mWorld, ndims * sizeof(float));
unit->m_workingdata = (float*)RTAlloc(unit->mWorld, ndims * sizeof(float));
// Try and ensure that the first ever input won't get accidentally skipped:
unit->m_inputdata[0] = -1e9f;
// Get the buffer reference, and check that the size and num channels matches what we expect.
unit->m_fbufnum = -1e9f;
GET_BUF
if((int)bufChannels != (ndims * 2 + 2)) {
Print("PlaneTree_Ctor: number of channels in buffer (%i) != number of input dimensions (%i) * 2 + 2\n",
bufChannels, ndims);
SETCALC(*ClearUnitOutputs);
return;
}
// initialize the unit generator state variables.
unit->m_ndims = ndims;
unit->m_result = -1e9f; // hopefully this will get filled in soon by a classification...
SETCALC(PlaneTree_next);
PlaneTree_next(unit, 1);
}
void IFFT_Ctor(IFFT* unit){
unit->m_wintype = (int)ZIN0(1); // wintype may be used by the base ctor
if(!FFTBase_Ctor(unit, 2)){
SETCALC(*ClearUnitOutputs);
// These zeroes are to prevent the dtor freeing things that don't exist:
unit->m_olabuf = 0;
unit->m_transformbuf = 0;
return;
}
// This will hold the transformed and progressively overlap-added data ready for outputting.
unit->m_olabuf = (float*)RTAlloc(unit->mWorld, unit->m_audiosize * sizeof(float));
memset(unit->m_olabuf, 0, unit->m_audiosize * sizeof(float));
unit->m_transformbuf = (float*)RTAlloc(unit->mWorld, scfft_trbufsize(unit->m_fullbufsize));
unit->m_scfft = (scfft*)RTAlloc(unit->mWorld, sizeof(scfft));
scfft_create(unit->m_scfft, unit->m_fullbufsize, unit->m_audiosize, unit->m_wintype, unit->m_fftsndbuf->data, unit->m_fftsndbuf->data, unit->m_transformbuf, false);
// "pos" will be reset to zero when each frame comes in. Until then, the following ensures silent output at first:
unit->m_pos = 0; //unit->m_audiosize;
if (unit->mCalcRate == calc_FullRate) {
unit->m_numSamples = unit->mWorld->mFullRate.mBufLength;
} else {
unit->m_numSamples = 1;
}
SETCALC(IFFT_next);
}
void MatchingP_Ctor(MatchingP* unit)
{
SETCALC(MatchingP_next);
// [trigger, residual, activ0, activ1,...] = MatchingP.ar(dict, in, dictsize, ntofind, hop=1, method=0)
CTOR_GET_BUF
// initialize the unit generator state variables.
unit->m_dictsize = IN0(2);
if(unit->m_dictsize != buf->channels){
printf("ERROR: (unit->m_dictsize != bufChannels)\n");
SETCALC(ClearUnitOutputs);
return;
}
unit->m_hopspls = static_cast<int>(sc_max(0.f, sc_min(1.f, IN0(4))) * buf->frames);
unit->m_shuntspls = buf->frames - unit->m_hopspls;
const int ntofind = (const int)IN0(3);
// UNUSED: unit->mMethod = IN0(5);
unit->m_audiowritepos = unit->m_hopspls;
unit->m_audioplaybackpos = 0;
// audiobuf size is bufFrames + hopspls -- playback happens in first bufFrames, input is written in last hopspls, analysis is in last bufFrames
unit->m_audiobuf = (float* )RTAlloc(unit->mWorld, sizeof(float) * (buf->frames + unit->m_hopspls));
Clear(buf->frames + unit->m_hopspls, unit->m_audiobuf);
// "activations" will contain [index0, activ0, index1, activ1, ... ]
unit->m_activations = (float* )RTAlloc(unit->mWorld, sizeof(float) * 2 * ntofind);
// calculate one sample of output.
unit->m_fbufnum = -9.9e9; // set it to something that will force the buffer info to be updated when _next runs
MatchingP_next(unit, 1);
}
void TextVU_Ctor(TextVU* unit)
{
SETCALC(TextVU_next_kk);
unit->m_trig = IN0(0);
unit->m_id = IN0(4); // number of chars in the id string
unit->m_id_string = (char*)RTAlloc(unit->mWorld, ((int)unit->m_id + 1) * sizeof(char));
Print("TextVU: string length %g\n", unit->m_id);
for(int i = 0; i < (int)unit->m_id; i++){
unit->m_id_string[i] = (char)IN0(5+i);
};
unit->m_id_string[(int)unit->m_id] = '\0';
size_t width = (size_t)std::max(IN0(2), 2.f);
unit->m_width = width;
// Now we want to initialise the set of cutoffs, where the first is -60dB and last is 0dB.
unit->m_cutoffs = (float*)RTAlloc(unit->mWorld, width * sizeof(float));
unit->m_vustring = (char*)RTAlloc(unit->mWorld, (width+1) * sizeof(char));
unit->m_vustring[width] = 0;
float cutstep = 60.f / (float)(width-1);
float db = -60.f;
for(size_t i=0; i<width; ++i){
// calc cutoffs in amplitude from the db vals
unit->m_cutoffs[i] = sc_dbamp(db);
//Print("cutoff %i: %g\n", i, unit->m_cutoffs[i]);
db += cutstep;
}
unit->m_maxinepoch = 0.f;
unit->m_maxever = 0;
unit->m_mayprint = unit->mWorld->mVerbosity >= 0;
TextVU_next_kk(unit, 1);
}
//buffer preparation
void PreparePartConv(World *world, struct SndBuf *buf, struct sc_msg_iter *msg)
{
// 'channels' not used- should just be mono, num frames= num samples
float *data1 = buf->data;
uint32 frombufnum = msg->geti();
int fftsize = msg->geti();
//output size must be frombuf->frames*2
if (frombufnum >= world->mNumSndBufs) frombufnum = 0;
SndBuf* frombuf = world->mSndBufs + frombufnum;
int frames2 = frombuf->frames;
float *data2 = frombuf->data;
//scfft
int nover2= fftsize>>1;
int numpartitions;
if(frames2 % nover2 == 0){
numpartitions= frames2/nover2;
}else{
numpartitions= (frames2/nover2)+1;
}
//printf("reality check numpartitions %d fftsize %d product %d numinputframes %d \n", numpartitions, fftsize, numpartitions*fftsize, frames2);
float * inputbuf= (float*)RTAlloc(world, fftsize * sizeof(float));
float * spectrum= (float*)RTAlloc(world, fftsize * sizeof(float));
SCWorld_Allocator alloc(ft, world);
scfft* m_scfft = scfft_create(fftsize, fftsize, kRectWindow, inputbuf, spectrum, kForward, alloc);
memset(inputbuf, 0, sizeof(float)*fftsize); // for zero padding
//run through input data buffer, taking nover2 chunks, zero padding each
for (int i=0; i<numpartitions; ++i) {
int indexnow= nover2*i;
int indexout= fftsize*i;
if(i<(numpartitions-1)){
memcpy(inputbuf, data2+indexnow, nover2 * sizeof(float));
}else{
int takenow = frames2 % nover2;
if(takenow == 0){
takenow = nover2;
}
memcpy(inputbuf, data2+indexnow, takenow * sizeof(float));
if(takenow<nover2){
memset(inputbuf+takenow, 0, (nover2-takenow)*sizeof(float));
}
}
scfft_dofft(m_scfft);
memcpy(data1+indexout, spectrum, fftsize * sizeof(float));
}
//clean up
RTFree(world, inputbuf);
RTFree(world, spectrum);
if(m_scfft) scfft_destroy(m_scfft, alloc);
}
void Demand_Ctor(Demand *unit)
{
//Print("Demand_Ctor\n");
if (INRATE(0) == calc_FullRate) {
if (INRATE(1) == calc_FullRate) {
SETCALC(Demand_next_aa);
} else {
SETCALC(Demand_next_ak);
}
} else {
if (INRATE(1) == calc_FullRate) {
SETCALC(Demand_next_ka);
} else {
SETCALC(Demand_next_aa);
}
}
unit->m_prevout = (float*) RTAlloc(unit->mWorld, unit->mNumOutputs * sizeof(float));
unit->m_out = (float**) RTAlloc(unit->mWorld, unit->mNumOutputs * sizeof(float*));
//Print("Demand_Ctor calc %08X\n", unit->mCalcFunc);
unit->m_prevtrig = 0.f;
unit->m_prevreset = 0.f;
for (int i=0; i<unit->mNumOutputs; ++i) {
unit->m_prevout[i] = 0.f;
OUT0(i) = 0.f;
}
}
void NearestN_Ctor(NearestN* unit) {
// Infer the size of the "inputs" array which has been tagged on to the end of the arguments list.
int ndims = unit->mNumInputs - 3;
int num = ZIN0(2);
// Allocate a comfy bit of memory where we'll put the input data while we process it
unit->m_inputdata = (float*)RTAlloc(unit->mWorld, ndims * sizeof(float));
unit->m_bestlist = (float*)RTAlloc(unit->mWorld, num * 3 * sizeof(float));
Clear(num * 3, unit->m_bestlist);
// Try and ensure that the first ever input won't get accidentally skipped:
unit->m_inputdata[0] = -1e9f;
// Get the buffer reference, and check that the size and num channels matches what we expect.
unit->m_fbufnum = -1e9f;
{
GET_BUF
// initialize the unit generator state variables.
unit->m_ndims = ndims;
unit->m_num = num;
SETCALC(NearestN_next);
}
NearestN_next(unit, 1);
}
g_fixeddelay *make_fixeddelay(GVerb *unit, int size, int maxsize){
g_fixeddelay *p;
p = (g_fixeddelay*)RTAlloc(unit->mWorld, sizeof(g_fixeddelay));
p->size = size;
p->idx = 0;
p->buf = (float*)RTAlloc(unit->mWorld, maxsize * sizeof(float));
Clear(maxsize, p->buf);
return(p);
}
void MedianSeparation_Ctor( MedianSeparation* unit ) {
//fft, fftharmonic, fftpercussive, fftsize, mediansize=17, hardorsoft=0, p=1
//IFFT needs to know what it is operating on
OUT0(0) = ZIN0(1); //-1;
OUT0(1) = ZIN0(2);
unit->fftsize_ = ZIN0(3); //so can set things up in constructor, rather than later on
unit->mediansize_ = ZIN0(4); //default 17, may cause trouble otherwise?
//printf("MedianSeparation starting %d %d \n",unit->fftsize_,unit->mediansize_);
if(unit->mediansize_<3)
unit->mediansize_ = 17;
unit->midpoint_ = unit->mediansize_/2;
unit->fftbins_ = (unit->fftsize_/2) +1; //actually /2 + 1 but polar form has separate packed dc and nyquist
unit->magnitudeposition_= 0;
unit->phaseposition_= 0;
//separate storage
unit->magnitudes_ = (float *) RTAlloc(unit->mWorld, sizeof(float)* unit->mediansize_ * unit->fftbins_);
unit->phases_ = (float *) RTAlloc(unit->mWorld, sizeof(float)* (unit->midpoint_+1) * unit->fftbins_); //only store half data since only need phases for midpoint about to output; this necessitates holding midpoint+1 values (to include just arrived)
//float * data_; //2D grid
//zero out all magnitudes and phases
int i;
for (i=0; i<unit->mediansize_ * unit->fftbins_; ++i)
unit->magnitudes_[i] = 0.0f;
for (i=0; i<(unit->midpoint_+1) * unit->fftbins_; ++i)
unit->phases_[i] = 0.0f;
unit->collection_ = (float *) RTAlloc(unit->mWorld, sizeof(float)* unit->mediansize_); //reusable array for sorting and finding median
unit->horizontalmedians_ = (float *) RTAlloc(unit->mWorld, sizeof(float)* unit->fftbins_);
unit->verticalmedians_ = (float *) RTAlloc(unit->mWorld, sizeof(float)* unit->fftbins_);
//need to go a step at a time over the vertical, horizontal sort and the eventual output (so takes four blocks to calculate, FFT must be at least 256)
unit->amortisationstep_=0;
SETCALC(MedianSeparation_next);
}
g_diffuser *make_diffuser(GVerb *unit, int size, float coef){
g_diffuser* p;
p = (g_diffuser*)RTAlloc(unit->mWorld, sizeof(g_diffuser));
p->size = size;
p->coef = coef;
p->idx = 0;
p->buf = (float*)RTAlloc(unit->mWorld, size * sizeof(float));
Clear(size, p->buf);
return(p);
}
LTIv(Unit* unit,int sizeB,int sizeA):cbuf(unit,sizeB),cbufout(unit,sizeA){
//Print("LTIv construct\n");
// for(int i=0;i<sizeB-1;i++){
// Print("KernelB %d %g\n",i,KernelB[i]);
// }
this->unit = unit;
kernel_sizeB = sizeB;
kernel_sizeA = sizeA;
KernelB = (float *)RTAlloc(unit->mWorld,sizeof(float)*sizeB);
KernelA = (float *)RTAlloc(unit->mWorld,sizeof(float)*sizeA);
};
void AnnBasic_Ctor(AnnBasic* unit)
{
unit->ann_i = -1;
unit->inputs = 0;
int ann_i = IN0( IN_ANN_NUM );
unsigned int inc = sigInCount(unit);
unsigned int outc = sigOutCount(unit);
// init ANN input buffer
fann_type* ann_ins = (fann_type*) RTAlloc( unit->mWorld, sizeof(fann_type) * inc);
for(int i=0; i < inc; ++i) ann_ins[i] = 0.f;
// set up the unit
unit->ann_i = ann_i;
unit->inputs = ann_ins;
SETCALC( AnnBasic_next);
// Calculate one sample of output
AnnBasic_next( unit, 1 );
//AnnBasic_idle( unit, 1 );
}
void differentiator(Filter *c)
{
c->x = (float *)RTAlloc(gWorld,sizeof(float[2]));//new float[2];//(float *)RTAlloc(gWorld,sizeof(float[2]));//
c->y = (float *)RTAlloc(gWorld,sizeof(float[2]));//new float[2];
c->a = (float *)RTAlloc(gWorld,sizeof(float[2]));//new float[2];
c->b = (float *)RTAlloc(gWorld,sizeof(float[2]));//new float[2];
memset(c->x,0,2*sizeof(float));
memset(c->y,0,2*sizeof(float));
c->a[0] = 1;
c->a[1] = 0;
c->b[0] = 1;
c->b[1] = -1;
c->n = 1;
}
g_damper *make_damper(GVerb *unit, float damping){
g_damper* p;
p = (g_damper*)RTAlloc(unit->mWorld, sizeof(g_damper));
p->damping = damping;
p->delay = 0.f;
return(p);
}
void init_delay(Delay *c, int di)
{
// turn size into a mask for quick modding
//c->size = 2*di;
/*
int p = 0;
while(c->size) {
c->size /= 2;
p++;
}
c->size = 1;
while(p) {
c->size *= 2;
p--;
}
c->mask = c->size - 1;
*/
c->size = NEXTPOWEROFTWO(2*di);
c->mask = c->size - 1;
c->x = (float *)RTAlloc(gWorld,sizeof(float) * c->size);//new float[c->size];
//c->y = new float[c->size];
memset(c->x,0,c->size*sizeof(float));
// memset(c->y,0,c->size*sizeof(float));
c->cursor = 0;
c->di = di;
c->d1 = (c->size-di)%c->size;
}
void* operator new(size_t sz, Unit* unit) {
//Print("TUBE new\n");
void * ptr = NULL;
ptr = RTAlloc(unit->mWorld,sz);
return ptr;
}
void cmdDemoFunc(World *inWorld, void* inUserData, struct sc_msg_iter *args, void *replyAddr)
{
Print("->cmdDemoFunc %p\n", inUserData);
// user data is the plug-in's user data.
MyPluginData* thePlugInData = (MyPluginData*)inUserData;
// allocate command data, free it in cmdCleanup.
MyCmdData* myCmdData = (MyCmdData*)RTAlloc(inWorld, sizeof(MyCmdData));
myCmdData->myPlugin = thePlugInData;
// ..get data from args..
myCmdData->x = 0.;
myCmdData->y = 0.;
myCmdData->name = 0;
// float arguments
myCmdData->x = args->getf();
myCmdData->y = args->getf();
// how to pass a string argument:
const char *name = args->gets(); // get the string argument
if (name) {
myCmdData->name = (char*)RTAlloc(inWorld, strlen(name)+1); // allocate space, free it in cmdCleanup.
strcpy(myCmdData->name, name); // copy the string
}
// how to pass a completion message
int msgSize = args->getbsize();
char* msgData = 0;
if (msgSize) {
// allocate space for completion message
// scsynth will delete the completion message for you.
msgData = (char*)RTAlloc(inWorld, msgSize);
args->getb(msgData, msgSize); // copy completion message.
}
DoAsynchronousCommand(inWorld, replyAddr, "cmdDemoFunc", (void*)myCmdData,
(AsyncStageFn)cmdStage2,
(AsyncStageFn)cmdStage3,
(AsyncStageFn)cmdStage4,
cmdCleanup,
msgSize, msgData);
Print("<-cmdDemoFunc\n");
}
void resonator(float f, float Fs, float tau, Filter *c) {
c->x = (float *)RTAlloc(gWorld,sizeof(float[3]));//new float[3];
c->y = (float *)RTAlloc(gWorld,sizeof(float[3]));//new float[3];
c->a = (float *)RTAlloc(gWorld,sizeof(float[3]));//new float[3];
c->b = (float *)RTAlloc(gWorld,sizeof(float[3]));//new float[3];
memset(c->x,0,3*sizeof(float));
memset(c->y,0,3*sizeof(float));
float rp = exp(-1/(tau*Fs));
float omega = 2*PI*f/Fs;
c->a[0] = 1;
c->a[1] = -2*rp*cos(omega);
c->a[2] = rp*rp;
c->b[0] = 0;
c->b[1] = sin(omega);
c->b[2] = 0;
c->n = 2;
}
void loss(float f0, float fs, float c1, float c3, Filter *c)
{
c->x = (float *)RTAlloc(gWorld,sizeof(float[2]));//new float[2];
c->y = (float *)RTAlloc(gWorld,sizeof(float[2]));//new float[2];
c->a = (float *)RTAlloc(gWorld,sizeof(float[2]));//new float[2];
c->b = (float *)RTAlloc(gWorld,sizeof(float[2]));//new float[2];
memset(c->x,0,2*sizeof(float));
memset(c->y,0,2*sizeof(float));
float g = 1.0 - c1/f0;
float b = 4.0*c3+f0;
float a1 = (-b+sqrt(b*b-16.0*c3*c3))/(4.0*c3);
c->b[0] = g*(1+a1);
c->b[1] = 0;
c->a[0] = 1;
c->a[1] = a1;
c->n = 1;
}
void FFT_Ctor(FFT *unit)
{
unit->m_wintype = (int)ZIN0(3); // wintype may be used by the base ctor
if(!FFTBase_Ctor(unit, 5)){
SETCALC(FFT_ClearUnitOutputs);
// These zeroes are to prevent the dtor freeing things that don't exist:
unit->m_inbuf = 0;
unit->m_transformbuf = 0;
unit->m_scfft = 0;
return;
}
int fullbufsize = unit->m_fullbufsize * sizeof(float);
int audiosize = unit->m_audiosize * sizeof(float);
int hopsize = (int)(sc_max(sc_min(ZIN0(2), 1.f), 0.f) * unit->m_audiosize);
if (((int)(hopsize / unit->mWorld->mFullRate.mBufLength)) * unit->mWorld->mFullRate.mBufLength
!= hopsize) {
Print("FFT_Ctor: hopsize (%i) not an exact multiple of SC's block size (%i) - automatically corrected.\n", hopsize, unit->mWorld->mFullRate.mBufLength);
hopsize = ((int)(hopsize / unit->mWorld->mFullRate.mBufLength)) * unit->mWorld->mFullRate.mBufLength;
}
unit->m_hopsize = hopsize;
unit->m_shuntsize = unit->m_audiosize - hopsize;
unit->m_inbuf = (float*)RTAlloc(unit->mWorld, audiosize);
unit->m_transformbuf = (float*)RTAlloc(unit->mWorld, scfft_trbufsize(unit->m_fullbufsize));
unit->m_scfft = (scfft*)RTAlloc(unit->mWorld, sizeof(scfft));
scfft_create(unit->m_scfft, unit->m_fullbufsize, unit->m_audiosize, unit->m_wintype, unit->m_inbuf, unit->m_fftsndbuf->data, unit->m_transformbuf, true);
memset(unit->m_inbuf, 0, audiosize);
//Print("FFT_Ctor: hopsize %i, shuntsize %i, bufsize %i, wintype %i, \n",
// unit->m_hopsize, unit->m_shuntsize, unit->m_bufsize, unit->m_wintype);
if (INRATE(1) == calc_FullRate) {
unit->m_numSamples = unit->mWorld->mFullRate.mBufLength;
} else {
unit->m_numSamples = 1;
}
SETCALC(FFT_next);
}
void Neuromodule_initInputs(Dneuromodule *unit, int size)
{
int memsize = size * sizeof(double);
int numWeights = size * size;
unit->m_theta = (double*)RTAlloc(unit->mWorld, memsize);
memset(unit->m_theta, 0, memsize);
unit->m_x = (double*)RTAlloc(unit->mWorld, memsize);
memset(unit->m_x, 0, memsize);
unit->m_weights = (double*)RTAlloc(unit->mWorld, numWeights);
memset(unit->m_weights, 0, numWeights);
unit->m_x_temp = (double*)RTAlloc(unit->mWorld, memsize);
memset(unit->m_x_temp, 0, memsize);
}
void* operator new(size_t sz, Unit* unit) {
//Print("KL_Junction new\n");
void * ptr = NULL;
ptr = RTAlloc(unit->mWorld,sz);
/*
if(ptr==NULL)
Print("Null pointer\n");
else
Print("not Null pointer\n");*/
return ptr;
}
void Onsets_Ctor(Onsets *unit)
{
if(ZIN0(8)>0)
SETCALC(Onsets_next_rawodf);
else
SETCALC(Onsets_next);
unit->m_needsinit = true;
unit->m_ods = (OnsetsDS*) RTAlloc(unit->mWorld, sizeof(OnsetsDS) );
ZOUT0(0) = unit->outval = 0.f;
}
void Dpoll_Ctor(Dpoll *unit)
{
SETCALC(Dpoll_next);
unit->m_id = IN0(3); // number of chars in the id string
unit->m_id_string = (char*)RTAlloc(unit->mWorld, ((int)unit->m_id + 1) * sizeof(char));
for(int i = 0; i < (int)unit->m_id; i++) {
unit->m_id_string[i] = (char)IN0(4+i);
}
unit->m_id_string[(int)unit->m_id] = '\0';
unit->m_mayprint = unit->mWorld->mVerbosity >= 0;
OUT0(0) = 0.f;
}
void Convolution_Ctor(Convolution *unit)
{
//require size N+M-1 to be a power of two
unit->m_insize=(int)ZIN0(2);
// printf("hello %i /n", unit->m_insize);
unit->m_fftsize=2*(unit->m_insize);
//just use memory for the input buffers and fft buffers
int insize = unit->m_insize * sizeof(float);
int fftsize = unit->m_fftsize * sizeof(float);
unit->m_inbuf1 = (float*)RTAlloc(unit->mWorld, insize);
unit->m_inbuf2 = (float*)RTAlloc(unit->mWorld, insize);
unit->m_fftbuf1 = (float*)RTAlloc(unit->mWorld, fftsize);
unit->m_fftbuf2 = (float*)RTAlloc(unit->mWorld, fftsize);
unit->m_outbuf = (float*)RTAlloc(unit->mWorld, fftsize);
unit->m_overlapbuf = (float*)RTAlloc(unit->mWorld, insize);
memset(unit->m_outbuf, 0, fftsize);
memset(unit->m_overlapbuf, 0, insize);
//unit->m_log2n = LOG2CEIL(unit->m_fftsize);
unit->m_pos = 0;
SCWorld_Allocator alloc(ft, unit->mWorld);
unit->m_scfft1 = scfft_create(unit->m_fftsize, unit->m_fftsize, kRectWindow, unit->m_fftbuf1, unit->m_fftbuf1, kForward, alloc);
unit->m_scfft2 = scfft_create(unit->m_fftsize, unit->m_fftsize, kRectWindow, unit->m_fftbuf2, unit->m_fftbuf2, kForward, alloc);
unit->m_scfftR = scfft_create(unit->m_fftsize, unit->m_fftsize, kRectWindow, unit->m_fftbuf1, unit->m_outbuf, kBackward, alloc);
SETCALC(Convolution_next);
}
/*
void complex_divide(float Hn[2], float Hd[2], float H[2])
{
float magn = sqrt(Hn[0]*Hn[0] + Hn[1]*Hn[1]);
float argn = atan2(Hn[1],Hn[0]);
float magd = sqrt(Hd[0]*Hd[0] + Hd[1]*Hd[1]);
float argd = atan2(Hd[1],Hd[0]);
float mag = magn/magd;
float arg = argn - argd;
H[0] = mag*cos(arg);
H[1] = mag*sin(arg);
}
*/
float groupdelay(Filter *c, float f, float Fs)
{
float df = 5;
float f2 = f + df;
float f1 = f - df;
float omega2 = 2*PI*f2/Fs;
float omega1 = 2*PI*f1/Fs;
return (omega2*phasedelay(c,f2,Fs) - omega1*phasedelay(c,f1,Fs))/(omega2-omega1);
}
float phasedelay(Filter *c, float f, float Fs)
{
float Hn[2];
float Hd[2];
float H[2];
Hn[0] = 0.0; Hn[1] = 0.0;
Hd[0] = 0.0; Hd[1] = 0.0;
float omega = 2*PI*f/Fs;
int N = c->n;
for(int k=0;k<=N;k++) {
Hn[0] += cos(k*omega)*c->b[k];
Hn[1] += sin(k*omega)*c->b[k];
}
for(int k=0;k<=N;k++) {
Hd[0] += cos(k*omega)*c->a[k];
Hd[1] += sin(k*omega)*c->a[k];
}
complex_divide(Hn,Hd,H);
float arg = atan2(H[1],H[0]);
if(arg<0) arg = arg + 2*PI;
return arg/omega;
}
void differentiator(Filter *c)
{
c->x = (float *)RTAlloc(gWorld,sizeof(float[2]));//new float[2];//(float *)RTAlloc(gWorld,sizeof(float[2]));//
c->y = (float *)RTAlloc(gWorld,sizeof(float[2]));//new float[2];
c->a = (float *)RTAlloc(gWorld,sizeof(float[2]));//new float[2];
c->b = (float *)RTAlloc(gWorld,sizeof(float[2]));//new float[2];
memset(c->x,0,2*sizeof(float));
memset(c->y,0,2*sizeof(float));
c->a[0] = 1;
c->a[1] = 0;
c->b[0] = 1;
c->b[1] = -1;
c->n = 1;
}
void resonator(float f, float Fs, float tau, Filter *c) {
c->x = (float *)RTAlloc(gWorld,sizeof(float[3]));//new float[3];
c->y = (float *)RTAlloc(gWorld,sizeof(float[3]));//new float[3];
c->a = (float *)RTAlloc(gWorld,sizeof(float[3]));//new float[3];
c->b = (float *)RTAlloc(gWorld,sizeof(float[3]));//new float[3];
memset(c->x,0,3*sizeof(float));
memset(c->y,0,3*sizeof(float));
float rp = exp(-1/(tau*Fs));
float omega = 2*PI*f/Fs;
c->a[0] = 1;
c->a[1] = -2*rp*cos(omega);
c->a[2] = rp*rp;
c->b[0] = 0;
c->b[1] = sin(omega);
c->b[2] = 0;
c->n = 2;
}
void loss(float f0, float fs, float c1, float c3, Filter *c)
{
c->x = (float *)RTAlloc(gWorld,sizeof(float[2]));//new float[2];
c->y = (float *)RTAlloc(gWorld,sizeof(float[2]));//new float[2];
c->a = (float *)RTAlloc(gWorld,sizeof(float[2]));//new float[2];
c->b = (float *)RTAlloc(gWorld,sizeof(float[2]));//new float[2];
memset(c->x,0,2*sizeof(float));
memset(c->y,0,2*sizeof(float));
float g = 1.0 - c1/f0;
float b = 4.0*c3+f0;
float a1 = (-b+sqrt(b*b-16.0*c3*c3))/(4.0*c3);
c->b[0] = g*(1+a1);
c->b[1] = 0;
c->a[0] = 1;
c->a[1] = a1;
c->n = 1;
}
/*/
void biquad(float f0, float fs, float Q, int type, Filter *c)
{
c->x = (float *)RTAlloc(gWorld,sizeof(float[3]));//new float[3];
c->y = (float *)RTAlloc(gWorld,sizeof(float[3]));//new float[3];
c->a = (float *)RTAlloc(gWorld,sizeof(float[3]));//new float[3];
c->b = (float *)RTAlloc(gWorld,sizeof(float[3]));//new float[3];
memset(c->x,0,3*sizeof(float));
memset(c->y,0,3*sizeof(float));
float a = 1/(2*tan(PI*f0/fs));
float a2 = a*a;
float aoQ = a/Q;
float d = (4*a2+2*aoQ+1);
c->a[0] = 1;
c->a[1] = -(8*a2-2) / d;
c->a[2] = (4*a2 - 2*aoQ + 1) / d;
switch(type) {
case pass:
c->b[0] = 2*aoQ/d;
c->b[1] = 0;
c->b[2] = -2*aoQ/d;
break;
case low:
c->b[0] = 1/d;
c->b[1] = 2/d;
c->b[2] = 1/d;
break;
case high:
c->b[0] = 4*a2/d;
c->b[1] = -8*a2/d;
c->b[2] = 4*a2/d;
break;
case notch:
c->b[0] = (1+4*a2)/d;
c->b[1] = (2-8*a2)/d;
c->b[2] = (1+4*a2)/d;
break;
}
c->n = 2;
}
*/
void thirian(float D, int N, Filter *c)
{
c->x =(float *)RTAlloc(gWorld, sizeof(float) * (N + 1));// new float[N+1];
c->y = (float *)RTAlloc(gWorld, sizeof(float) * (N + 1));//new float[N+1];
c->a = (float *)RTAlloc(gWorld, sizeof(float) * (N + 1));//new float[N+1];
c->b = (float *)RTAlloc(gWorld, sizeof(float) * (N + 1));//new float[N+1];
memset(c->x,0,(N+1)*sizeof(float));
memset(c->y,0,(N+1)*sizeof(float));
for(int k=0;k<=N;k++) {
double ak = (float)choose((long)N,(long)k);
if(k%2==1)
ak = -ak;
for(int n=0;n<=N;n++) {
ak *= ((double)D-(double)(N-n));
ak /= ((double)D-(double)(N-k-n));
}
c->a[k] = (float)ak;
c->b[N-k] = (float)ak;
}
c->n = N;
}
void Dtag_initInputs(Dtag *unit, int argOffset, int size)
{
unit->m_tape_size = (int32) IN0(dtag_tape_param);
// make sure axiom isn't longer than the tape.
if(unit->m_axiom_size > (int) unit->m_tape_size) {
unit->m_axiom_size = (int) unit->m_tape_size;
}
// allocate tape
int32 memtapesize = (int32) unit->m_tape_size * sizeof(int);
unit->m_tape = (float*)RTAlloc(unit->mWorld, memtapesize);
memset(unit->m_tape, 0, memtapesize);
// allocate offsets and lengths
int memsize = size * sizeof(int);
unit->m_rule_lengths = (int*)RTAlloc(unit->mWorld, memsize);
memset(unit->m_rule_lengths, 0, memsize);
unit->m_rule_offsets = (int*)RTAlloc(unit->mWorld, memsize);
memset(unit->m_rule_offsets, 0, memsize);
for(int i=0; i < size; i++) {
unit->m_rule_lengths[i] = (int) IN0(i + argOffset); // drop first n args
}
// calculate positions
int position = argOffset + size;
for(int i=0; i < size; i++) {
unit->m_rule_offsets[i] = position;
position += unit->m_rule_lengths[i];
// printf("m_rule_offsets[%ld]: %ld\n", i, unit->m_rule_offsets[i]);
}
}
void DbufTag_initInputs(DbufTag *unit, int argOffset, int size)
{
int memsize = size * sizeof(int);
unit->m_rule_lengths = (int*)RTAlloc(unit->mWorld, memsize);
memset(unit->m_rule_lengths, 0, memsize);
unit->m_rule_offsets = (int*)RTAlloc(unit->mWorld, memsize);
memset(unit->m_rule_offsets, 0, memsize);
for(int i=0; i < size; i++) {
unit->m_rule_lengths[i] = (int) IN0(i + argOffset); // drop first n args
}
// calculate positions
int position = argOffset + size;
for(int i=0; i < size; i++) {
unit->m_rule_offsets[i] = position;
position += unit->m_rule_lengths[i];
// printf("m_rule_offsets[%d]: %d\n", i, unit->m_rule_offsets[i]);
}
}
void AudioControl_Ctor(AudioControl* unit)
{
unit->prevVal = (float*)RTAlloc(unit->mWorld, unit->mNumOutputs * sizeof(float));
for(int i = 0; i < unit->mNumOutputs; i++){
unit->prevVal[i] = 0.0;
}
if (unit->mNumOutputs == 1) {
SETCALC(AudioControl_next_1);
AudioControl_next_1(unit, 1);
} else {
SETCALC(AudioControl_next_k);
AudioControl_next_k(unit, 1);
}
}