int main(void){
printf("program starts\n");
// this is just a random sudoku i inputed. to test the code
// uncomment out the user input if you want to solve your own sudoku
int sudoku[9][9] ={
{2,8,5,0,0,0,0,0,0}, //1
{0,7,0,0,2,5,0,0,9}, //2
{0,0,0,0,0,0,0,0,4}, //3
{1,9,0,0,0,0,0,0,0}, //4
{6,0,0,0,9,0,0,1,0}, //5
{0,0,0,7,0,4,0,8,0}, //6
{0,0,0,8,0,3,0,0,0}, //7
{0,0,3,6,0,0,0,4,0}, //8
{0,0,0,0,0,0,5,0,0} //9
};
int (*pointer)[9][9] = &sudoku;
// just creates a place to store value
// default value is that all the location is 1
// convert will change the values from 1 to 0 if the location is unknown
int values[9][9] = {
{1,1,1,1,1,1,1,1,1}, //1
{1,1,1,1,1,1,1,1,1}, //2
{1,1,1,1,1,1,1,1,1}, //3
{1,1,1,1,1,1,1,1,1}, //4
{1,1,1,1,1,1,1,1,1}, //5
{1,1,1,1,1,1,1,1,1}, //6
{1,1,1,1,1,1,1,1,1}, //7
{1,1,1,1,1,1,1,1,1}, //8
{1,1,1,1,1,1,1,1,1} //9
};
int (*valuepointer)[9][9] = &values;
// uncomment the next line you want to input your own sudoku
//input(pointer);
// converts the sudoku values to prime so it is easier to deal with
convert(pointer, valuepointer);
// use logic to solve sudoku
totallogic(pointer, valuepointer, 1);
// if the logic can not solve the sudoku
// then guess and checking with recurbrute will begin
if (issudokucomplete(valuepointer)==0){
recurbrute(pointer, valuepointer, 1);
}
// unconvert the values from primes to normal numbers
// so the user can understand
unconvert(pointer);
// prints the finished sudoku for the user to see
printraw(pointer);
// i don't have a system pause because i am not a pleb
// i run my programs from cmd prompt
return 0;
}
void do_thresher(t_thresher *x)
{
int i;
t_fftease *fft = x->fft;
t_float *channel = fft->channel;
t_float damping_factor = x->damping_factor;
int max_hold_frames = x->max_hold_frames;
int *frames_left = x->frames_left;
t_float *composite_frame = x->composite_frame;
int N = fft->N;
t_float move_threshold = x->move_threshold;
fold(fft);
rdft(fft,FFT_FORWARD);
convert(fft);
if( x->first_frame ){
for ( i = 0; i < N+2; i++ ){
composite_frame[i] = channel[i];
frames_left[i] = max_hold_frames;
}
x->first_frame = 0;
} else {
for( i = 0; i < N+2; i += 2 ){
if(fabs( composite_frame[i] - channel[i] ) > move_threshold || frames_left[i] <= 0 ){
composite_frame[i] = channel[i];
composite_frame[i+1] = channel[i+1];
frames_left[i] = max_hold_frames;
} else {
--(frames_left[i]);
composite_frame[i] *= damping_factor;
}
}
}
// try memcpy here
for ( i = 0; i < N+2; i++ ){
channel[i] = composite_frame[i];
}
if(fft->obank_flag){
oscbank(fft);
} else {
unconvert(fft);
rdft(fft,FFT_INVERSE);
overlapadd(fft);
}
}
void makeWaves(
struct FFTSound *fftsound,
struct RSynthData *rsd,
void(*waveconsumer)(struct FFTSound *fftsound,void *pointer,double **samples,int num_samples),
bool (*progressupdate)(int pr,void *pointer),
void *pointer,
int start,int end,
bool obank,
bool keep_formants
)
{
double a0=0.0;
long point=0, point2=0;
int ch;
int on=(-fftsound->Nw*fftsound->I)/fftsound->Dn, in=-fftsound->Nw;
int j,i;
double coef[fftsound->numcoef2+2];
int keepform=0;
if(obank){
fprintf(stderr,"\n\nWarning! The result of the additiv resynthesis might be buggy. Please listen to the result to check that its okey or use the IFFT type.\n\n");
}
// init_again();
// rsd=getRSynthData(fftsound);
memset(coef,0.0,sizeof(double)*(fftsound->numcoef2+2));
if (keep_formants && fftsound->numcoef2!=0)
keepform=1;
for (j=start; j<end; j++) {
on+=fftsound->I; in+=fftsound->Dn;
for (ch=0; ch<fftsound->samps_per_frame; ch++) {
point =
ch*fftsound->horiz_num*fftsound->numchannels
+ j*fftsound->numchannels;
point2=ch*lpc_horiz_num*(fftsound->numcoef2+2)+j*(fftsound->numcoef2+2);
if(fftsound->usemem==false) pthread_mutex_lock(&fftsound->mutex);
for (i=0; i<fftsound->numchannels; i++) {
rsd->channel[i+i]=MEGAMP_GET(point+i); //ch*fftsound->horiz_num + i,j
rsd->channel[i+i+1]=MEGFREQ_GET(point+i);
}
if(fftsound->usemem==false) pthread_mutex_unlock(&fftsound->mutex);
// printf("j2: %d\n",j);
if (obank==true) {
if (j==start){
for (i=0; i<fftsound->N2+1; i++) {
rsd->lastfreq[ch][i]=rsd->channel[i+i+1];
rsd->lastamp[ch][i]=rsd->channel[i+i];
rsd->indx[ch][i]=0.;
}
}
if (j>=lpc_horiz_num) keepform=0;
if (keepform) {
for (i=0; i<fftsound->numcoef2+2; i++) {
coef[i]=lpc_coef[point2]; point2++;
}
a0=coef[fftsound->numcoef2+1];
}
oscbank(
fftsound,
rsd,rsd->channel,
fftsound->N2, fftsound->R, fftsound->I,
rsd->output[ch], ch,
fftsound->Nw,coef,
fftsound->numcoef2*keepform,a0
);
} else {
unconvert(rsd, rsd->channel, rsd->buffer, fftsound->N2, fftsound->I, fftsound->R, ch);
rfft(rsd->buffer, fftsound->N2, INVERSE);
overlapadd(rsd->buffer, fftsound->N, fftsound->Wsyn, rsd->output[ch], fftsound->Nw, on);
}
} // end for(ch=0; ch<fftsound->samps_per_frame; ch++)
if (obank==true){
shiftout(
fftsound,
waveconsumer,
pointer,
rsd->output,
fftsound->Nw,
fftsound->I,
in+fftsound->Nw2+fftsound->Dn
);
}else{
shiftout(
fftsound,
waveconsumer,
pointer,
rsd->output,
fftsound->Nw,
fftsound->I,
on
);
}
if(progressupdate!=NULL){
if((*progressupdate)(j,pointer)==false)break;
}
} // end for(j=start; j<end; j++)
// returnRSynthData(rsd);
}
t_int *thresher_perform(t_int *w)
{
float sample, outsamp ;
int i,j;
t_thresher *x = (t_thresher *) (w[1]);
float *in = (t_float *)(w[2]);
float *inthresh = (t_float *)(w[3]);
float *damping = (t_float *)(w[4]);
float *out = (t_float *)(w[5]);
int n = (int)(w[6]);
float *input = x->input;
float *output = x->output;
float *buffer = x->buffer;
float *Wanal = x->Wanal;
float *Wsyn = x->Wsyn;
float *channel = x->channel;
float damping_factor = x->damping_factor;
int max_hold_frames = x->max_hold_frames;
int *frames_left = x->frames_left;
float *composite_frame = x->composite_frame;
float *c_lastphase_in = x->c_lastphase_in;
float *c_lastphase_out = x->c_lastphase_out;
float c_fundamental = x->c_fundamental;
float c_factor_in = x->c_factor_in;
float c_factor_out = x->c_factor_out;
int *bitshuffle = x->bitshuffle;
float *trigland = x->trigland;
float mult = x->mult;
int in_count = x->in_count;
int R = x->R;
int N = x->N;
int N2 = x->N2;
int D = x->D;
int Nw = x->Nw;
float move_threshold = x->move_threshold;
if( x->mute ) {
for( j = 0; j < D; j++) {
*out++ = 0.0 ;
}
return (w+7);
}
if ( x->bypass ) {
for( j = 0; j < D; j++) {
*out++ = *in++ ;
}
return (w+7);
}
if( x->thresh_connected ) {
move_threshold = *inthresh ;
}
if( x->damping_connected ) {
damping_factor = *damping ;
}
in_count += D;
for ( j = 0 ; j < Nw - D ; j++ )
input[j] = input[j+D];
for ( j = Nw - D; j < Nw; j++ ) {
input[j] = *in++;
}
fold( input, Wanal, Nw, buffer, N, in_count );
rdft( N, 1, buffer, bitshuffle, trigland );
convert( buffer, channel, N2, c_lastphase_in, c_fundamental, c_factor_in );
if( x->first_frame ){
for ( i = 0; i < N+2; i++ ){
composite_frame[i] = channel[i];
frames_left[i] = max_hold_frames;
}
x->first_frame = 0;
} else {
for( i = 0; i < N+2; i += 2 ){
if(fabs( composite_frame[i] - channel[i] ) > move_threshold ||
frames_left[i] <= 0 ){
composite_frame[i] = channel[i];
composite_frame[i+1] = channel[i+1];
frames_left[i] = max_hold_frames;
} else {
--(frames_left[i]);
composite_frame[i] *= damping_factor;
}
}
}
unconvert( composite_frame, buffer, N2, c_lastphase_out, c_fundamental, c_factor_out );
rdft( N, -1, buffer, bitshuffle, trigland );
overlapadd( buffer, N, Wsyn, output, Nw, in_count );
for ( j = 0; j < D; j++ )
*out++ = output[j] * mult;
for ( j = 0; j < Nw - D; j++ )
output[j] = output[j+D];
for ( j = Nw - D; j < Nw; j++ )
output[j] = 0.;
x->in_count = in_count;
x->damping_factor = damping_factor;
return (w+7);
}
/*********************************************************************** Vocoder: tratto da Ceres di ([email protected]) ***********************************************************************/ ULONG WavVocoder (PCSZ name, LONG argc, const RXSTRING * argv, PCSZ queuename, PRXSTRING retstr) { PSHORT pCh, pCh2, ptemp; APIRET rc; int i, frame, FDec, nCamp; int campioni, puntifft, Kn2, Koverlap; double soglia; if (argc != 4) { SendMsg (FUNC_VOCODER, ERR_NUMERO_PARAMETRI); return INVALID_ROUTINE; } if (!sscanf (argv[0].strptr, "%d", &pCh)) { SendMsg (FUNC_VOCODER, ERR_PUNTATORE_ERRATO); return INVALID_ROUTINE; } if (!sscanf (argv[1].strptr, "%d", &pCh2)) { SendMsg (FUNC_VOCODER, ERR_PUNTATORE_ERRATO); return INVALID_ROUTINE; } nCamp = atol (argv[2].strptr); if (nCamp < 1) { SendMsg (FUNC_VOCODER, ERR_VALORE_INVALIDO); return INVALID_ROUTINE; } pCh = (PSHORT) AllineaCh (pCh, (ULONG) nCamp, FUNC_VOCODER); if (!pCh) return INVALID_ROUTINE; pCh2 = (PSHORT) AllineaCh (pCh2, (ULONG) nCamp, FUNC_VOCODER); if (!pCh2) return INVALID_ROUTINE; soglia = atof (argv[3].strptr) / 1000000; if ((soglia < 0) | (soglia > 1)) { SendMsg (FUNC_VOCODER, ERR_VALORE_INVALIDO); return INVALID_ROUTINE; } fvec (inout, K_PUNTI); fvec (buffer, K_PUNTI); fvec (dativoc, K_PUNTI); fvec (WAnalisi, K_PUNTI); fvec (WSintesi, K_PUNTI); campioni = K_PUNTI; puntifft = K_PUNTI / 2; Kn2 = K_PUNTI / 2; Koverlap = 2; FDec = campioni / Koverlap; makewindows (WAnalisi, WSintesi, campioni, campioni, FDec); for (frame = 0; frame < (10 * nCamp / K_PUNTI); frame++) { for (i = 0; i < campioni; i++) inout[i] = (double) *pCh++ / (double) MAX_CAMPIONE; fold (inout, WAnalisi, campioni, buffer, campioni, frame * campioni); for (i = 0; i < campioni; i++) inout[i] = (double) 0; /* */ rfft (buffer, puntifft, FORWARD); convert (buffer, dativoc, Kn2, FDec, FreqCamp, 1); /* if(frame==100) for (i=0; i<Kn2; i++) { printf("freq %f, amp %f\n", dativoc[i+i+1], dativoc[i+i] * 1000); } */ for (i = 0; i < Kn2; i++) { if (dativoc[i + i] < soglia) dativoc[i + i] = 0; } unconvert (dativoc, buffer, Kn2, FDec, FreqCamp, 1); rfft (buffer, puntifft, INVERSE); overlapadd (buffer, campioni, WSintesi, inout, campioni, frame * campioni); for (i = 0; i < campioni; i++) *pCh2++ = *pCh2 + (SHORT) (inout[i] * MAX_CAMPIONE); pCh = pCh - (SHORT) (K_PUNTI * 0.9); pCh2 = pCh2 - (SHORT) (K_PUNTI * 0.9); } free (inout); free (buffer); free (dativoc); free (WAnalisi); free (WSintesi); sprintf (retstr->strptr, "%f", ERR_OK); retstr->strlength = strlen (retstr->strptr); return VALID_ROUTINE; }
int PVOC::run()
{
#ifdef debug
printf("PVOC::run\n\n");
#endif
// This runs the engine forward until the first buffer of output data is ready (see PVOC::shiftout()).
// This compensates for the group delay of the windowed output.
int outFramesNeeded = framesToRun();
if (_cachedOutFrames)
{
int toCopy = min(_cachedOutFrames, outFramesNeeded);
if (toCopy >= 0)
{
#ifdef debug
printf("\twriting %d of %d leftover frames from _outbuf at offset %d to rtbaddout\n",
toCopy, _cachedOutFrames, _outReadOffset);
#endif
rtbaddout(&_outbuf[_outReadOffset], toCopy);
increment(toCopy);
_outReadOffset += toCopy;
assert(_outReadOffset <= _outWriteOffset);
if (_outReadOffset == _outWriteOffset)
_outReadOffset = _outWriteOffset = 0;
#ifdef debug
printf("\t_outbuf read offset %d, write offset %d\n",
_outReadOffset, _outWriteOffset);
#endif
outFramesNeeded -= toCopy;
_cachedOutFrames -= toCopy;
}
}
while (outFramesNeeded > 0)
{
#ifdef debug
printf("\ttop of loop: needed=%d _in=%d _on=%d Nw=%d\n",
outFramesNeeded, _in, _on, Nw);
#endif
/*
* analysis: input D samples; window, fold and rotate input
* samples into FFT buffer; take FFT; and convert to
* amplitude-frequency (phase vocoder) form
*/
shiftin( _pvInput, Nw, D);
/*
* increment times
*/
_in += D;
_on += I;
if ( Np ) {
::vvmult( winput, Hwin, _pvInput, Nw );
lpcoef[0] = ::lpa( winput, Nw, lpcoef, Np );
/* printf("%.3g/", lpcoef[0] ); */
}
::fold( _pvInput, Wanal, Nw, _fftBuf, N, _in );
::rfft( _fftBuf, N2, FORWARD );
convert( _fftBuf, channel, N2, D, R );
// if ( I == 0 ) {
// if ( Np )
// fwrite( lpcoef, sizeof(float), Np+1, stdout );
// fwrite( channel, sizeof(float), N+2, stdout );
// fflush( stdout );
// /* printf("\n" );
// continue;
// }
/*
* at this point channel[2*i] contains amplitude data and
* channel[2*i+1] contains frequency data (in Hz) for phase
* vocoder channels i = 0, 1, ... N/2; the center frequency
* associated with each channel is i*f, where f is the
* fundamental frequency of analysis R/N; any desired spectral
* modifications can be made at this point: pitch modifications
* are generally well suited to oscillator bank resynthesis,
* while time modifications are generally well (and more
* efficiently) suited to overlap-add resynthesis
*/
if (_pvFilter) {
_pvFilter->run(channel, N2);
}
if ( obank ) {
/*
* oscillator bank resynthesis
*/
oscbank( channel, N2, lpcoef, Np, R, Nw, I, P, _pvOutput );
#if defined(debug) && 0
printf("osc output (first 16):\n");
for (int x=0; x<16; ++x) printf("%g ",_pvOutput[x]);
printf("\n");
#endif
shiftout( _pvOutput, Nw, I, _on+Nw-I);
}
else {
/*
* overlap-add resynthesis
*/
unconvert( channel, _fftBuf, N2, I, R );
::rfft( _fftBuf, N2, INVERSE );
::overlapadd( _fftBuf, N, Wsyn, _pvOutput, Nw, _on );
// I samples written into _outbuf
shiftout( _pvOutput, Nw, I, _on);
}
// Handle case where last synthesized block extended beyond outFramesNeeded
int framesToOutput = ::min(outFramesNeeded, I);
#ifdef debug
printf("\tbottom of loop. framesToOutput: %d\n", framesToOutput);
#endif
int framesAvailable = _outWriteOffset - _outReadOffset;
framesToOutput = ::min(framesToOutput, framesAvailable);
if (framesToOutput > 0) {
#ifdef debug
printf("\twriting %d frames from offset %d to rtbaddout\n",
framesToOutput, _outReadOffset);
#endif
rtbaddout(&_outbuf[_outReadOffset], framesToOutput);
increment(framesToOutput);
_outReadOffset += framesToOutput;
if (_outReadOffset == _outWriteOffset)
_outReadOffset = _outWriteOffset = 0;
}
_cachedOutFrames = _outWriteOffset - _outReadOffset;
#ifdef debug
if (_cachedOutFrames > 0) {
printf("\tsaving %d samples left over\n", _cachedOutFrames);
}
printf("\toutbuf read offset %d, write offset %d\n\n",
_outReadOffset, _outWriteOffset);
#endif
outFramesNeeded -= framesToOutput;
} /* while (outFramesNeeded > 0) */
return framesToRun();
}
t_int *bthresher_perform(t_int *w)
{
float sample, outsamp ;
int i, j, on;
t_bthresher *x = (t_bthresher *) (w[1]);
float *in = (t_float *)(w[2]);
float *inthresh = (t_float *)(w[3]);
float *damping = (t_float *)(w[4]);
float *out = (t_float *)(w[5]);
t_int n = w[6];
int *bitshuffle = x->bitshuffle;
float *trigland = x->trigland;
float mult = x->mult;
int in_count = x->in_count;
int R = x->R;
int N = x->N;
int N2 = x->N2;
int D = x->D;
int Nw = x->Nw;
float *Wanal = x->Wanal;
float *Wsyn = x->Wsyn;
float *damping_factor = x->damping_factor;
float *move_threshold = x->move_threshold;
float *input = x->input;
float *output = x->output;
float *buffer = x->buffer;
float *channel = x->channel;
float *composite_frame = x->composite_frame;
int max_hold_frames = x->max_hold_frames;
int *frames_left = x->frames_left;
float thresh_scalar = x->thresh_scalar;
float damp_scalar = x->damp_scalar;
short inf_hold = x->inf_hold;
if( x->mute ) {
for( j = 0; j < D; j++) {
*out++ = 0.0 ;
}
} else if ( x->bypass ) {
for( j = 0; j < D; j++) {
*out++ = *in++ * 0.5;
}
} else {
#if MSP
if( x->thresh_connected ) {
thresh_scalar = *inthresh++;
}
if( x->damping_connected ) {
damp_scalar = *damping++;
}
#endif
#if PD
thresh_scalar = *inthresh++;
damp_scalar = *damping++;
#endif
in_count += D;
for ( j = 0 ; j < Nw - D ; j++ )
input[j] = input[j+D];
for ( j = Nw-D; j < Nw; j++ ) {
input[j] = *in++;
}
fold( input, Wanal, Nw, buffer, N, in_count );
rdft( N, 1, buffer, bitshuffle, trigland );
convert( buffer, channel, N2, x->c_lastphase_in, x->c_fundamental, x->c_factor_in );
if( x->first_frame ){
for ( i = 0; i < N+2; i++ ){
composite_frame[i] = channel[i];
x->frames_left[i] = max_hold_frames;
}
x->first_frame = 0;
} else {
if( thresh_scalar < .999 || thresh_scalar > 1.001 || damp_scalar < .999 || damp_scalar > 1.001 ) {
for(i = 0, j = 0; i < N+2; i += 2, j++ ){
if( fabs( composite_frame[i] - channel[i] ) > move_threshold[j] * thresh_scalar|| frames_left[j] <= 0 ){
composite_frame[i] = channel[i];
composite_frame[i+1] = channel[i+1];
frames_left[j] = max_hold_frames;
} else {
if(!inf_hold){
--(frames_left[j]);
}
composite_frame[i] *= damping_factor[j] * damp_scalar;
}
}
} else {
for( i = 0, j = 0; i < N+2; i += 2, j++ ){
if( fabs( composite_frame[i] - channel[i] ) > move_threshold[j] || frames_left[j] <= 0 ){
composite_frame[i] = channel[i];
composite_frame[i+1] = channel[i+1];
frames_left[j] = max_hold_frames;
} else {
if(!inf_hold){
--(frames_left[j]);
}
composite_frame[i] *= damping_factor[j];
}
}
}
}
unconvert(x->composite_frame, buffer, N2, x->c_lastphase_out, x->c_fundamental, x->c_factor_out);
rdft(N, -1, buffer, bitshuffle, trigland);
overlapadd(buffer, N, Wsyn, output, Nw, in_count);
for ( j = 0; j < D; j++ )
*out++ = output[j] * mult;
for ( j = 0; j < Nw - D; j++ )
output[j] = output[j+D];
for ( j = Nw - D; j < Nw; j++ )
output[j] = 0.;
}
x->in_count = in_count % Nw;
x->thresh_scalar = thresh_scalar;
x->damp_scalar = damp_scalar;
return (w+7);
}
t_int *cavoc_perform(t_int *w)
{
int i,j;
float oldfrac,newfrac;
t_cavoc *x = (t_cavoc *)(w[1]);
float *trigger_vec = (t_float *)(w[2]);
float *out = (t_float *)(w[3]);
t_int n = w[4];
int frames_left = x->frames_left;
float *input = x->input;
float *buffer = x->buffer;
int in_count = x->in_count;
int R = x->R;
int N = x->N;
int N2 = x->N2;
int D = x->D;
int Nw = x->Nw;
float *Wanal = x->Wanal;
float *Wsyn = x->Wsyn;
float *output = x->output;
float *channel = x->channel;
float mult = x->mult ;
int *bitshuffle = x->bitshuffle;
float *trigland = x->trigland ;
int hold_frames = x->hold_frames;
short *rule = x->rule;
short left = x->left;
short right = x->right;
short center = x->center;
float *last_frame = x->last_frame;
float *c_lastphase_out = x->c_lastphase_out;
float c_fundamental = x->c_fundamental;
float c_factor_out = x->c_factor_out;
short external_trigger = x->external_trigger;
short new_event = 0;
in_count += D;
if( x->mute ){
while( n-- ){
*out++ = 0.0;
}
return (w+5);
}
if(external_trigger){// only accurate to within a vector because of FFT
for(i=0;i<n;i++){
if(trigger_vec[i]){
new_event = 1;
break;
}
}
} else if(!--frames_left){
frames_left = hold_frames;
new_event = 1;
}
if(new_event){
for( i = 2; i < N; i+=2 ){
left = last_frame[ i - 2];
center = last_frame[i] ;
right = last_frame[i+2];
channel[i] = cavoc_apply_rule(left, right, center, rule );
}
/* boundary cases */
center = last_frame[0];
right = last_frame[2];
left = last_frame[N];
channel[0] = cavoc_apply_rule(left, right, center, rule );
center = last_frame[N];
right = last_frame[0];
left = last_frame[N - 2];
channel[N] = cavoc_apply_rule(left, right, center, rule );
/* save composite frame for next time */
for( i = 0; i < N+1; i++ ){
last_frame[i] = channel[i];
}
}
unconvert( channel, buffer, N2, c_lastphase_out, c_fundamental, c_factor_out );
rdft( N, -1, buffer, bitshuffle, trigland );
overlapadd( buffer, N, Wsyn, output, Nw, in_count);
for ( j = 0; j < D; j++ )
*out++ = output[j] * mult;
for ( j = 0; j < Nw - D; j++ )
output[j] = output[j+D];
for ( j = Nw - D; j < Nw; j++ )
output[j] = 0.;
/* restore state variables */
x->in_count = in_count % Nw;
x->frames_left = frames_left;
return (w+5);
}
t_int *resent_perform(t_int *w)
{
int iphase, amp, freq, i, j;
float fincr;
float fpos;
//////////////////////////////////////////////
t_resent *x = (t_resent *) (w[1]);
float *frame_incr = x->frame_incr ;
float *frame_phase = x->frame_phase ;
float *composite_frame = x->composite_frame ;
float in_sample;
t_float *in = (t_float *)(w[2]);
t_float *out = (t_float *)(w[3]);
t_float *sync_vec = (t_float *)(w[4]);
t_int n = w[5];
/* dereference structure */
int inCount = x->inCount;
int R = x->R;
int N = x->N;
int N2 = x->N2;
int D = x->D;
int Nw = x->Nw;
float *Wanal = x->Wanal;
float *Wsyn = x->Wsyn;
float *input = x->input;
float *output = x->output;
float *buffer = x->buffer;
float *channel = x->channel;
float fframe = x->current_frame ;
float last_fpos = x->last_fpos ;
int framecount = x->framecount;
float mult = x->mult ;
int *bitshuffle = x->bitshuffle;
float *trigland = x->trigland ;
float *c_lastphase_in = x->c_lastphase_in;
float *c_lastphase_out = x->c_lastphase_out;
float c_fundamental = x->c_fundamental;
float c_factor_in = x->c_factor_in;
float c_factor_out = x->c_factor_out;
float sync = x->sync;
sync = (float)x->frames_read / (float)x->framecount;
if(x->mute || x->lock){
while(n--){
*out++ = 0.0;
*sync_vec++ = sync;
}
return (w+6);
}
inCount += D;
if(x->read_me){
for ( j = 0 ; j < Nw - D ; j++ ){
input[j] = input[j+D];
}
if(x->playthrough){
for (j = Nw - D; j < Nw; j++) {
in_sample = input[j] = *in++;
*out++ = in_sample * 0.5; // scale down
*sync_vec++ = sync;
}
} else{
for (j = Nw - D; j < Nw; j++) {
input[j] = *in++;
*out++ = 0.0;
*sync_vec++ = sync;
}
}
fold( input, Wanal, Nw, buffer, N, inCount );
rdft( N, 1, buffer, bitshuffle, trigland );
convert( buffer, x->loveboat[(x->frames_read)++], N2, c_lastphase_in, c_fundamental, c_factor_in );
if(x->frames_read >= x->framecount){
x->read_me = 0;
}
}
else {
for( i = 0 ; i < N2; i++ ){
amp = i<<1;
freq = amp + 1 ;
iphase = frame_phase[i] ;
if( iphase < 0 )
iphase = 0;
if( iphase > framecount - 1 )
iphase = framecount - 1;
composite_frame[amp] = x->loveboat[iphase][amp];
composite_frame[freq] = x->loveboat[iphase][freq];
frame_phase[i] += frame_incr[i] ;
while( frame_phase[i] > framecount - 1)
frame_phase[i] -= framecount ;
while( frame_phase[i] < 0. )
frame_phase[i] += framecount ;
}
unconvert(composite_frame, buffer, N2, c_lastphase_out, c_fundamental, c_factor_out);
rdft( N, -1, buffer, bitshuffle, trigland );
overlapadd( buffer, N, Wsyn, output, Nw, inCount );
for (j = 0; j < D; j++){
*out++ = output[j] * mult;
*sync_vec++ = sync;
}
for (j = 0; j < Nw - D; j++){
output[j] = output[j+D];
}
for (j = Nw - D; j < Nw; j++){
output[j] = 0.;
}
}
/* restore state variables */
x->inCount = inCount %Nw;
x->current_frame = fframe;
x->last_fpos = last_fpos;
x->sync = sync;
return (w+6);
}
