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); }