void IFFT_next(IFFT *unit, int wrongNumSamples){
float *out = OUT(0); // NB not ZOUT0
// Load state from struct into local scope
int pos = unit->m_pos;
int fullbufsize = unit->m_fullbufsize;
int audiosize = unit->m_audiosize;
// int numSamples = unit->mWorld->mFullRate.mBufLength;
int numSamples = unit->m_numSamples;
float *olabuf = unit->m_olabuf;
float fbufnum = ZIN0(0);
// Only run the IFFT if we're receiving a new block of input data - otherwise just output data already received
if (fbufnum >= 0.f){
// Ensure it's in cartesian format, not polar
ToComplexApx(unit->m_fftsndbuf);
float* fftbuf = unit->m_fftsndbuf->data;
scfft_doifft(unit->m_scfft);
// Then shunt the "old" time-domain output down by one hop
int hopsamps = pos;
int shuntsamps = audiosize - hopsamps;
if(hopsamps != audiosize){ // There's only copying to be done if the position isn't all the way to the end of the buffer
memcpy(olabuf, olabuf+hopsamps, shuntsamps * sizeof(float));
}
// Then mix the "new" time-domain data in - adding at first, then just setting (copying) where the "old" is supposed to be zero.
#if SC_DARWIN
vDSP_vadd(olabuf, 1, fftbuf, 1, olabuf, 1, shuntsamps);
#else
// NB we re-use the "pos" variable temporarily here for write rather than read
for(pos = 0; pos < shuntsamps; ++pos){
olabuf[pos] += fftbuf[pos];
}
#endif
memcpy(olabuf + shuntsamps, fftbuf + shuntsamps, (hopsamps) * sizeof(float));
// Move the pointer back to zero, which is where playback will next begin
pos = 0;
} // End of has-the-chain-fired
// Now we can output some stuff, as long as there is still data waiting to be output.
// If there is NOT data waiting to be output, we output zero. (Either irregular/negative-overlap
// FFT firing, or FFT has given up, or at very start of execution.)
if(pos >= audiosize){
ClearUnitOutputs(unit, numSamples);
}else{
memcpy(out, olabuf + pos, numSamples * sizeof(float));
pos += numSamples;
}
unit->m_pos = pos;
}
void Convolution2_next(Convolution2 *unit, int wrongNumSamples)
{
float *in1 = IN(0);
//float *in2 = IN(1);
float curtrig = ZIN0(2);
float *out1 = unit->m_inbuf1 + unit->m_pos;
// float *out2 = unit->m_inbuf2 + unit->m_pos;
int numSamples = unit->mWorld->mFullRate.mBufLength;
uint32 insize=unit->m_insize * sizeof(float);
// copy input
Copy(numSamples, out1, in1);
unit->m_pos += numSamples;
if (unit->m_prevtrig <= 0.f && curtrig > 0.f){
//float fbufnum = ZIN0(1);
//int log2n2 = unit->m_log2n;
//uint32 bufnum = (int)fbufnum;
//printf("bufnum %i \n", bufnum);
//World *world = unit->mWorld;
//if (bufnum >= world->mNumSndBufs) bufnum = 0;
//SndBuf *buf = world->mSndBufs + bufnum;
SndBuf *buf = ConvGetBuffer(unit,(uint32)ZIN0(1), "Convolution2", numSamples);
if (!buf)
return;
LOCK_SNDBUF_SHARED(buf);
memcpy(unit->m_fftbuf2, buf->data, insize);
memset(unit->m_fftbuf2+unit->m_insize, 0, insize);
//rffts(unit->m_fftbuf2, log2n2, 1, cosTable[log2n2]);
scfft_dofft(unit->m_scfft2);
}
if (unit->m_pos & unit->m_insize) {
//have collected enough samples to transform next frame
unit->m_pos = 0; //reset collection counter
// copy to fftbuf
//int log2n = unit->m_log2n;
memcpy(unit->m_fftbuf1, unit->m_inbuf1, insize);
//zero pad second part of buffer to allow for convolution
memset(unit->m_fftbuf1+unit->m_insize, 0, insize);
//if (unit->m_prevtrig <= 0.f && curtrig > 0.f)
scfft_dofft(unit->m_scfft1);
//in place transform for now
// rffts(unit->m_fftbuf1, log2n, 1, cosTable[log2n]);
//complex multiply time
int numbins = unit->m_fftsize >> 1; //unit->m_fftsize - 2 >> 1;
float * p1= unit->m_fftbuf1;
float * p2= unit->m_fftbuf2;
p1[0] *= p2[0];
p1[1] *= p2[1];
//complex multiply
for (int i=1; i<numbins; ++i) {
float real,imag;
int realind,imagind;
realind= 2*i; imagind= realind+1;
real= p1[realind]*p2[realind]- p1[imagind]*p2[imagind];
imag= p1[realind]*p2[imagind]+ p1[imagind]*p2[realind];
p1[realind] = real; //p2->bin[i];
p1[imagind]= imag;
}
//copy second part from before to overlap
memcpy(unit->m_overlapbuf, unit->m_outbuf+unit->m_insize, insize);
//inverse fft into outbuf
memcpy(unit->m_outbuf, unit->m_fftbuf1, unit->m_fftsize * sizeof(float));
//in place
//riffts(unit->m_outbuf, log2n, 1, cosTable[log2n]);
scfft_doifft(unit->m_scfftR);
// DoWindowing(log2n, unit->m_outbuf, unit->m_fftsize);
}
void Convolution_next(Convolution *unit, int numSamples)
{
float *in1 = IN(0);
float *in2 = IN(1);
float *out1 = unit->m_inbuf1 + unit->m_pos;
float *out2 = unit->m_inbuf2 + unit->m_pos;
//int numSamples = unit->mWorld->mFullRate.mBufLength;
// copy input
Copy(numSamples, out1, in1);
Copy(numSamples, out2, in2);
unit->m_pos += numSamples;
int insize= unit->m_insize;
if (unit->m_pos & insize) {
//have collected enough samples to transform next frame
unit->m_pos = 0; //reset collection counter
int memsize= insize*sizeof(float);
// copy to fftbuf
memcpy(unit->m_fftbuf1, unit->m_inbuf1, memsize);
memcpy(unit->m_fftbuf2, unit->m_inbuf2, memsize);
//zero pad second part of buffer to allow for convolution
memset(unit->m_fftbuf1+unit->m_insize, 0, memsize);
memset(unit->m_fftbuf2+unit->m_insize, 0, memsize);
// do fft
//in place transform for now
//old Green fft code, now replaced by scfft
// int log2n = unit->m_log2n;
// rffts(unit->m_fftbuf1, log2n, 1, cosTable[log2n]);
// rffts(unit->m_fftbuf2, log2n, 1, cosTable[log2n]);
scfft_dofft(unit->m_scfft1);
scfft_dofft(unit->m_scfft2);
//complex multiply time
float * p1= unit->m_fftbuf1;
float * p2= unit->m_fftbuf2;
p1[0] *= p2[0];
p1[1] *= p2[1];
//complex multiply
for (int i=1; i<insize; ++i) {
float real,imag;
int realind,imagind;
realind= 2*i; imagind= realind+1;
real= p1[realind]*p2[realind]- p1[imagind]*p2[imagind];
imag= p1[realind]*p2[imagind]+ p1[imagind]*p2[realind];
p1[realind] = real;
p1[imagind]= imag;
}
//copy second part from before to overlap
memcpy(unit->m_overlapbuf, unit->m_outbuf+unit->m_insize, memsize);
//inverse fft into outbuf
memcpy(unit->m_outbuf, unit->m_fftbuf1, unit->m_fftsize * sizeof(float));
//in place
//riffts(unit->m_outbuf, log2n, 1, cosTable[log2n]);
scfft_doifft(unit->m_scfftR);
}
//write out samples copied from outbuf, with overlap added in
float *output = ZOUT(0);
float *out= unit->m_outbuf+unit->m_pos;
float *overlap= unit->m_overlapbuf+unit->m_pos;
for (int i=0; i<numSamples; ++i)
ZXP(output) = out[i] + overlap[i];
}
void PartConv_next( PartConv *unit, int inNumSamples )
{
float *in = IN(0);
float *out = OUT(0);
int pos = unit->m_pos;
//safety check
if (!(unit->mWorld->mSndBufs + unit->m_specbufnumcheck)->data) {
printf("PartConv Error: Spectral data buffer not allocated \n");
ClearUnitOutputs(unit, inNumSamples);
SETCALC(*ClearUnitOutputs);
unit->mDone = true;
return;
}
float * input= unit->m_inputbuf;
float * output= unit->m_output;
int outputpos= unit->m_outputpos;
//into input buffer
memcpy(input+pos, in, inNumSamples * sizeof(float));
pos += inNumSamples;
//if ready for new FFT
int nover2 = unit->m_nover2;
//assumes that blocksize perfectly divides windowsize
if (pos == nover2) {
//FFT this input, second half of input always zero
//memset(input+unit->m_nover2, 0, sizeof(float)*unit->m_nover2);
scfft_dofft(unit->m_scfft);
//reset pos into input buffer
pos=0;
//reset outputpos
outputpos= 0;
float * spectrum = unit->m_spectrum;
float * spectrum2 = unit->m_spectrum2;
//multiply spectra and accumulate for all ir spectra across storage buffer
int fftsize = unit->m_fftsize;
int accumpos = unit->m_fd_accum_pos;
float * accumbuffer = unit->m_fd_accumulate;
float * irspectrum = unit->m_irspectra;
int fullsize = unit->m_fullsize;
//JUST DO FIRST ONE FOR NOW, AMORTISED FOR OTHERS
//frames
for (int i=0; i<1; ++i) {
int irpos= (i*fftsize);
int posnow= (accumpos+irpos)%fullsize;
float * target= accumbuffer+posnow;
float * ir= irspectrum+irpos;
//real multiply for dc and nyquist
target[0] += ir[0]*spectrum[0];
target[1] += ir[1]*spectrum[1];
//complex multiply for frequency bins
for (int j=1; j<nover2; ++j) {
int binposr= 2*j;
int binposi= binposr+1;
target[binposr] += (ir[binposr]*spectrum[binposr]) - (ir[binposi]*spectrum[binposi]);
target[binposi] += (ir[binposi]*spectrum[binposr]) + (ir[binposr]*spectrum[binposi]);
}
}
//IFFT this partition
float * input2 = unit->m_inputbuf2;
memcpy(input2, accumbuffer+accumpos, fftsize * sizeof(float));
scfft_doifft(unit->m_scifft);
//shunt output data down and zero top bit
memcpy(output, output+nover2, nover2 * sizeof(float));
memset(output+nover2, 0, nover2 * sizeof(float));
//sum into output
for (int j=0; j<fftsize; ++j)
output[j] += spectrum2[j];
//zero this partition
memset(accumbuffer+accumpos, 0, fftsize * sizeof(float));
//ONLY DO AT END OF AMORTISATION???? no, amort code has extra -1 in indexing to cope
//update partition counter
accumpos= (accumpos+fftsize)%fullsize;
unit->m_fd_accum_pos= accumpos;
//set up for amortisation (calculate output for other partitions of impulse response)
unit->m_amortcount=0;
unit->m_partitionsdone=1;
} else {
//amortisation steps:
//complex multiply of this new fft spectrum against existing irspectrums and sum to accumbuffer
if (unit->m_amortcount>=0) {
float * spectrum= unit->m_spectrum;
//multiply spectra and accumulate for all ir spectra across storage buffer
int fftsize= unit->m_fftsize;
int nover2= unit->m_nover2;
//int frames= unit->m_partitions;
int accumpos= unit->m_fd_accum_pos;
float * accumbuffer= unit->m_fd_accumulate;
float * irspectrum= unit->m_irspectra;
int fullsize= unit->m_fullsize;
int starti, stopi;
int number;
if(unit->m_amortcount==(unit->m_spareblocks-1)) {
number= unit->m_lastamort;
}else{
number= unit->m_numamort;
}
starti= unit->m_partitionsdone-1;
stopi= starti+number-1;
//printf("amort check count %d starti %d stopi %d number %d framesdone %d \n",unit->m_amortcount, starti, stopi, number, unit->m_partitionsdone);
unit->m_partitionsdone += number;
++unit->m_amortcount;
for (int i=starti; i<=stopi; ++i) {
int posnow= (accumpos+(i*fftsize))%fullsize;
float * target= accumbuffer+posnow;
int irpos= (i*fftsize);
float * ir= irspectrum+irpos;
//real multiply for dc and nyquist
target[0]+= ir[0]*spectrum[0];
target[1]+= ir[1]*spectrum[1];
//complex multiply for frequency bins
for (int j=1; j<nover2; ++j) {
int binposr= 2*j;
int binposi= binposr+1;
target[binposr]+= (ir[binposr]*spectrum[binposr]) - (ir[binposi]*spectrum[binposi]);
target[binposi]+= (ir[binposi]*spectrum[binposr]) + (ir[binposr]*spectrum[binposi]);
}
}
}
}
//do this second!
memcpy(out, output+outputpos, inNumSamples * sizeof(float));
//debugging tests: output values tend to be fftsize too big, probably due to complex multiply and also summation over all partitions
// RGen& rgen = *unit->mParent->mRGen;
// int testindex= rgen.irand(inNumSamples-1);
// printf("inNumSamples %d testindex %d out %f output %f \n",inNumSamples, testindex, out[testindex], *(output+outputpos+testindex));
outputpos+=inNumSamples;
unit->m_outputpos= outputpos;
unit->m_pos= pos;
}
void Convolution2_next(Convolution2 *unit, int wrongNumSamples)
{
float *in1 = IN(0);
float curtrig = ZIN0(2);
float *inbuf1writepos = unit->m_inbuf1 + unit->m_pos;
int numSamples = unit->mWorld->mFullRate.mBufLength;
uint32 framesize = unit->m_framesize;
uint32 framesize_f = framesize * sizeof(float);
// copy input
Copy(numSamples, inbuf1writepos, in1);
unit->m_pos += numSamples;
if (unit->m_prevtrig <= 0.f && curtrig > 0.f){
SndBuf *kernelbuf = ConvGetBuffer(unit,(uint32)ZIN0(1), "Convolution2", numSamples);
if (!kernelbuf)
return;
LOCK_SNDBUF_SHARED(kernelbuf);
// we cannot use a kernel larger than the fft size, so truncate if needed. the kernel may be smaller though.
size_t kernelcopysize = sc_min(kernelbuf->frames, framesize);
memcpy(unit->m_fftbuf2, kernelbuf->data, kernelcopysize * sizeof(float));
memset(unit->m_fftbuf2 + kernelcopysize, 0, (2 * framesize - kernelcopysize) * sizeof(float));
scfft_dofft(unit->m_scfft2);
}
if (unit->m_pos >= framesize) {
//have collected enough samples to transform next frame
unit->m_pos = 0; //reset collection counter
// copy to fftbuf
memcpy(unit->m_fftbuf1, unit->m_inbuf1, framesize_f);
//zero pad second part of buffer to allow for convolution
memset(unit->m_fftbuf1+unit->m_framesize, 0, framesize_f);
scfft_dofft(unit->m_scfft1);
//complex multiply time
int numbins = unit->m_fftsize >> 1;
float * p1= unit->m_fftbuf1;
float * p2= unit->m_fftbuf2;
p1[0] *= p2[0];
p1[1] *= p2[1];
//complex multiply
for (int i=1; i<numbins; ++i) {
float real,imag;
int realind,imagind;
realind= 2*i;
imagind= realind+1;
real= p1[realind]*p2[realind]- p1[imagind]*p2[imagind];
imag= p1[realind]*p2[imagind]+ p1[imagind]*p2[realind];
p1[realind] = real;
p1[imagind]= imag;
}
//copy second part from before to overlap
memcpy(unit->m_overlapbuf, unit->m_outbuf+unit->m_framesize, framesize_f);
//inverse fft into outbuf
scfft_doifft(unit->m_scfftR);
}
