Chorus::Chorus (Parameters *param, float * efxoutl_, float * efxoutr_) :lfo(param), Effect(WetDry) { this->param = param; efxoutl = efxoutl_; efxoutr = efxoutr_; dlk = 0; drk = 0; maxdelay = lrintf (MAX_CHORUS_DELAY / 1000.0 * SAMPLE_RATE); delayl = new float[maxdelay+1]; delayr = new float[maxdelay+1]; float tmp = 0.08f; ldelay = new delayline(param,tmp, 2); rdelay = new delayline(param,tmp, 2); ldelay -> set_averaging(0.005f); rdelay -> set_averaging(0.005f); ldelay->set_mix( 0.5f ); rdelay->set_mix( 0.5f ); oldr = 0.0f; oldl = 0.0f; awesome_mode = 0; lfo.effectlfoout (&lfol, &lfor); dl2 = getdelay (lfol); dr2 = getdelay (lfor); Ppreset = 0; setpreset (0,Ppreset); cleanup (); };
Chorus::Chorus (float * efxoutl_, float * efxoutr_) { efxoutl = efxoutl_; efxoutr = efxoutr_; dlk = 0; drk = 0; maxdelay = lrintf (MAX_CHORUS_DELAY / 1000.0 * SAMPLE_RATE); delayl = new float[maxdelay]; delayr = new float[maxdelay]; Ppreset = 0; setpreset (0,Ppreset); float tmp = 0.08f; ldelay = new delayline(tmp, 2); rdelay = new delayline(tmp, 2); ldelay -> set_averaging(0.005f); rdelay -> set_averaging(0.005f); ldelay->set_mix( 0.5f ); rdelay->set_mix( 0.5f ); oldr = 0.0f; oldl = 0.0f; awesome_mode = 0; lfo.effectlfoout (&lfol, &lfor); dl2 = getdelay (lfol); dr2 = getdelay (lfor); cleanup (); };
extern double critical_delay(lofig_list* lofig) { losig_list* losig; char* signame; losig=critical_output(lofig); if (!losig->NAMECHAIN) { fprintf(stderr,"critical_delay: no losig name\n"); autexit(1); } signame=losig->NAMECHAIN->DATA; if (losig->TYPE==EXTERNAL) return getdelay(output_name(signame)); return getdelay(signame); }
Chorus::Chorus (float * efxoutl_, float * efxoutr_) { efxoutl = efxoutl_; efxoutr = efxoutr_; dlk = 0; drk = 0; maxdelay = lrintf (MAX_CHORUS_DELAY / 1000.0 * SAMPLE_RATE); delayl = new float[maxdelay]; delayr = new float[maxdelay]; Ppreset = 0; setpreset (0,Ppreset); lfo.effectlfoout (&lfol, &lfor); dl2 = getdelay (lfol); dr2 = getdelay (lfor); cleanup (); };
extern losig_list* critical_output(lofig_list* lofig) { double delay, max_delay=-1; losig_list* output=NULL, *losig; char* signame; for (losig=lofig->LOSIG; losig; losig=losig->NEXT) { if (!losig->NAMECHAIN) { fprintf(stderr,"critical_output: no losig name\n"); autexit(1); } signame=losig->NAMECHAIN->DATA; if (losig->TYPE==EXTERNAL) delay=getdelay(output_name(signame)); else delay=getdelay(signame); if (delay>max_delay) { max_delay=delay; output=losig; } } return output; }
int main (int argv, char **argc) { #pragma omp parallel { #pragma omp master { nthreads = omp_get_num_threads(); } } printf("Running OpenMP benchmark on %d thread(s)\n", nthreads); /* TUNE LENGTH OF LOOP BODY */ getdelay(); itersperthr = 1204; /*change from 128 to 256 for more test on guided,Liao*/ innerreps = 1000; /* GENERATE REFERENCE TIME */ refer(); /* TEST STATIC */ teststatic(); /* TEST STATIC,n */ cksz = 1; while (cksz <= itersperthr){ teststaticn(); cksz *= 2; } /* TEST DYNAMIC,n */ cksz = 1; while (cksz <= itersperthr){ testdynamicn(); cksz *= 2; } /* TEST GUIDED,n */ cksz = 1; while (cksz <= itersperthr*2/nthreads){ /*increase cksz*/ testguidedn(); cksz *= 2; } }
extern void save_xsch(FILE* xsch_stream, lofig_list* lofig, ptype_list* long_path, int color_mode) { long color; ptype_list* ptype, *ptype2=NULL; float delay=0, delay_out=0; char mes[1024]; char* signame = NULL; locon_list* locon; losig_list* losig; float gradient=1; int count; loins_list* loins; char *source, *dest=NULL, *last_sig; chain_list* chain, *loinschain=NULL; chain_list* lofigchain; losig_list* losig_aux; /*build gradient*/ if (long_path && color_mode==XSCH_GRADIENT) { /*get time of last entry*/ count=1; for (ptype=long_path; ptype->NEXT; ptype=ptype->NEXT) count++; if (!ptype->DATA) { fprintf(stderr,"save_xsch: compute error\n"); exit(1); } delay=ptype->TYPE; gradient=delay/((float)XSCH_COLOR_MAX); } /*color for signals*/ for (losig=lofig->LOSIG; losig; losig=losig->NEXT) { if (!losig->NAMECHAIN || !losig->NAMECHAIN->DATA) { fprintf(stderr,"save_xsch: no name for signal\n"); exit(1); } signame=losig->NAMECHAIN->DATA; if (isvdd(signame) || isvss(signame)) continue; if (losig->TYPE==EXTERNAL) { /*search external output*/ ptype=getptype(losig->USER,LOFIGCHAIN); for (lofigchain=ptype->DATA; lofigchain; lofigchain=lofigchain->NEXT) { locon=lofigchain->DATA; if (locon->TYPE==EXTERNAL && locon->DIRECTION!=IN) break; } if (lofigchain) delay=getdelay(output_name(signame)); else delay=getdelay(signame); } else delay=getdelay(signame); switch (color_mode) { case XSCH_GRADIENT: color=gradient_color(delay,gradient); break; case XSCH_CRITICAL_PATH: default: color=XSCH_NEUTRAL_COLOR; break; } flush_losig(xsch_stream, signame, color, delay, losig->TYPE); } /*color for instances*/ for (loins=lofig->LOINS; loins; loins=loins->NEXT) { /*search signal output*/ for (locon=loins->LOCON; locon; locon=locon->NEXT) { if (locon->DIRECTION==UNKNOWN) { fprintf(stderr,"BEH: 'linkage %s' in figure '%s' isn't accepted\n", locon->NAME,loins->INSNAME); exit(1); } if (locon->DIRECTION==OUT || locon->DIRECTION==INOUT || locon->DIRECTION==TRISTATE || locon->DIRECTION==TRANSCV) break; } if (!locon) { fprintf(stderr,"save_xsch: no output found for '%s'\n",loins->INSNAME); exit(1); } losig=locon->SIG; signame=losig->NAMECHAIN->DATA; delay=getdelay(loins->INSNAME); switch (color_mode) { case XSCH_GRADIENT: color=gradient_color(delay,gradient); break; case XSCH_CRITICAL_PATH: default: /*is instance in critical path?*/ for (ptype=long_path; ptype; ptype=ptype->NEXT) { if ((char*)ptype->DATA!=signame) continue; /*if output and input signals belong to critical path, then instance belongs*/ for (locon=loins->LOCON; locon; locon=locon->NEXT) { if (locon->DIRECTION==OUT || locon->DIRECTION==TRISTATE) continue; losig_aux=locon->SIG; /*is signal in critical path?*/ for (ptype2=long_path; ptype2; ptype2=ptype2->NEXT) { if ((char*)ptype2->DATA==losig_aux->NAMECHAIN->DATA) break; } if (ptype2) break; } ptype=ptype2; /*found?*/ break; } /*build critical path list*/ if (ptype) loinschain=addchain(loinschain,loins); if (ptype) color=XSCH_RED_COLOR; else color=XSCH_NEUTRAL_COLOR; } flush_loins(xsch_stream, loins->INSNAME, color, delay); } /*color for connectors*/ for (locon=lofig->LOCON; locon; locon=locon->NEXT) { if (isvdd(locon->NAME) || isvss(locon->NAME)) continue; switch (locon->DIRECTION) { case IN: delay_out=getdelay(locon->NAME); sprintf(mes, "%d ps",(int)delay_out); break; case OUT: case TRISTATE: delay_out=getdelay(output_name(locon->NAME)); sprintf(mes, "%d ps",(int)delay_out); break; case INOUT: case TRANSCV: delay=getdelay(locon->NAME); delay_out=getdelay(output_name(locon->NAME)); sprintf(mes, "%d ps on input; %d ps on output",(int)delay,(int)delay_out); break; } switch (color_mode) { case XSCH_GRADIENT: color=gradient_color(delay_out,gradient); break; case XSCH_CRITICAL_PATH: default: /* seek if signal is in a long path*/ for (ptype=long_path; ptype; ptype=ptype->NEXT) { if ((char*)ptype->DATA==locon->NAME) break; } if (ptype) color=XSCH_RED_COLOR; else color=XSCH_NEUTRAL_COLOR; } flush_stream_special(xsch_stream, locon->NAME, color, mes); } /*critical path*/ if (loinschain && long_path && color_mode==XSCH_CRITICAL_PATH) { source=NULL; last_sig=NULL; for (ptype=long_path; ptype; ptype=ptype->NEXT) { signame=ptype->DATA; for (chain=loinschain; chain; chain=chain->NEXT) { loins=chain->DATA; /*search signal output*/ for (locon=loins->LOCON; locon; locon=locon->NEXT) { if (locon->DIRECTION==OUT || locon->DIRECTION==INOUT || locon->DIRECTION==TRISTATE || locon->DIRECTION==TRANSCV) { losig=locon->SIG; if (losig->NAMECHAIN->DATA==signame) { dest=loins->INSNAME; break; } } } if (locon) break; } /*if no instance found it is external connector. it has the same name than signal*/ if (!locon) dest=signame; if (source) flush_path(xsch_stream, source, last_sig, dest, XSCH_RED_COLOR, delay, INTERNAL); source=dest; last_sig=signame; } /*for last signal search output*/ if (losig) { ptype=getptype(losig->USER,LOFIGCHAIN); for (chain=ptype->DATA; chain; chain=chain->NEXT) { locon=chain->DATA; /*port of circuit*/ if (locon->TYPE==EXTERNAL) {dest=locon->NAME; break;} loins=locon->ROOT; /*register input if no error*/ if (locon->DIRECTION==IN || locon->DIRECTION==INOUT || locon->DIRECTION==TRANSCV) {dest=loins->INSNAME; break;} } flush_path(xsch_stream, source, signame, dest, XSCH_RED_COLOR, delay, losig->TYPE); } } freechain(loinschain); }
static ptype_list* search_long_path(loins_list* loins, befig_list* befig) { loins_list* loins_aux, *best_loins=NULL; locon_list* locon; losig_list* losig, *best_losig=NULL; char* signame; chain_list* loconchain; ptype_list* ptype, *ret; float max_delay=-1, delay; bereg_list* bereg; biabl_list* biabl; if (!loins) { fprintf(stderr,"search_long_path: NULL pointer\n"); exit(1); } /*seek the latest input in cell*/ for (locon=loins->LOCON; locon; locon=locon->NEXT) { /*only inputs*/ if (locon->DIRECTION==OUT || locon->DIRECTION==TRISTATE || isvss(locon->NAME) || isvdd(locon->NAME)) continue; losig=locon->SIG; if (!losig->NAMECHAIN) { fprintf(stderr,"search_long_path: NULL pointer\n"); exit(1); } signame=(char*) losig->NAMECHAIN->DATA; delay=getdelay(signame); if (delay>max_delay) { best_losig=losig; max_delay=delay; } } /*no input found -> constant*/ if (!best_losig) return NULL; losig=best_losig; ptype=getptype(losig->USER,LOFIGCHAIN); if (!ptype || !ptype->DATA) { fprintf(stderr,"search_long_path: NULL pointer\n"); exit(1); } signame=(char*) losig->NAMECHAIN->DATA; ret=addptype(NULL, (int) max_delay, signame); /*stop at leaves or flip-flop */ if (losig->TYPE==EXTERNAL) return ret; for (bereg=befig->BEREG; bereg; bereg=bereg->NEXT) { if (bereg->NAME!=signame) continue; /*is it a flip-flop?*/ for (biabl=bereg->BIABL; biabl; biabl=biabl->NEXT) { if (getptype(biabl->USER,ABL_STABLE)) return ret; } } /*search driver of signal (latest if bus)*/ max_delay=-1; for (loconchain=(chain_list*) ptype->DATA; loconchain; loconchain=loconchain->NEXT) { locon=(locon_list*) loconchain->DATA; /*only outputs*/ if (locon->DIRECTION==IN || isvss(locon->NAME) || isvdd(locon->NAME) || locon->TYPE==EXTERNAL) continue; loins_aux=locon->ROOT; if (loins_aux==loins) continue; delay=getdelay(loins_aux->INSNAME); if (delay>max_delay) { best_loins=loins_aux; max_delay=delay; } } if (!best_loins) { fprintf(stderr,"search_long_path: no loins found for driving losig '%s'\n",signame); exit(1); } ret->NEXT=search_long_path(best_loins, befig); return ret; }
static ptype_list* search_long_path(losig_list* losig, int ck_include) { loins_list* best_loins=NULL; locon_list* locon; losig_list *best_losig=NULL; loins_list* loins; befig_list* befig; char* signame, *ck=NULL; int reg=0; /*flag for flip-flop*/ chain_list* lofigchain; ptype_list* ptype, *ret; double max_delay=-1, delay; cell_list* cell; biabl_list* biabl; if (!losig) { fprintf(stderr,"search_long_path: NULL pointer\n"); autexit(1); } if (!losig->NAMECHAIN) { fprintf(stderr,"search_long_path: no losig name\n"); autexit(1); } signame=(char*) losig->NAMECHAIN->DATA; /*control combinational loop, not to recurse infinitively*/ if ( searchauthelem( ControlLoop, (char*) losig ) ) { fprintf(stderr,"Warning: combinational loop on signal %s\n", signame ); return ret; } addauthelem( ControlLoop, (char*) losig, 1 ); /*search drivers*/ ptype=getptype(losig->USER,LOFIGCHAIN); if (!ptype || !ptype->DATA) { fprintf(stderr,"search_long_path: no lofigchain found\n"); autexit(1); } for (lofigchain=(chain_list*) ptype->DATA; lofigchain; lofigchain=lofigchain->NEXT) { locon=(locon_list*) lofigchain->DATA; if (locon->DIRECTION==UNKNOWN) { fprintf(stderr,"BEH: 'linkage %s' isn't accepted\n", locon->NAME); autexit(1); } /*only outputs*/ if (isvss(locon->NAME) || isvdd(locon->NAME) || locon->DIRECTION==IN || locon->TYPE==EXTERNAL) continue; loins=locon->ROOT; delay=loins_delay(loins,signame); if (delay>max_delay) { best_loins=loins; max_delay=delay; } } loins=best_loins; ret=addptype(NULL, (long) max_delay>=0?max_delay:getdelay(signame), losig); if (!loins) return ret; /*stop at flip-flop*/ cell=getCell(loins->FIGNAME); if (!cell) { fprintf(stderr,"library error: no cell '%s.vbe' found\n", loins->FIGNAME); autexit(1); } befig=cell->BEFIG; if (befig->BEREG) { for ( biabl = cell->BEFIG->BEREG->BIABL; biabl; biabl = biabl->NEXT ) { ptype=getptype(biabl->USER,ABL_STABLE); if (ptype) { /*do not include clock in path*/ if (!ck_include) return ret; reg=1; ck=ptype->DATA; break; } } } max_delay=-1; /*seek the latest input in cell*/ for (locon=loins->LOCON; locon; locon=locon->NEXT) { if (locon->DIRECTION==UNKNOWN) { fprintf(stderr,"BEH: 'linkage %s' in figure '%s' isn't accepted\n", locon->NAME,loins->FIGNAME); autexit(1); } /*only inputs*/ if (locon->DIRECTION==OUT || locon->DIRECTION==TRISTATE || isvss(locon->NAME) || isvdd(locon->NAME)) continue; /* if flip-flop, accept only clock */ if (reg && ck!=locon->NAME) continue; losig=locon->SIG; if (!losig->NAMECHAIN) { fprintf(stderr,"search_long_path: no name on signal\n"); autexit(1); } signame=(char*) losig->NAMECHAIN->DATA; delay=getdelay(signame); if (delay>max_delay) { best_losig=losig; max_delay=delay; } } losig=best_losig; /*no input found -> constant*/ if (!losig) return ret; ret->NEXT=search_long_path(losig,ck_include); return ret; }
//***************************************************************************** //receiving loop: grab 48KHz baseband samples from Line, //demodulate, decrypt, decode, play 8KHz voice over Speaker int rx(int typing) { //input: -1 for no typing chars, 1 - exist some chars in input buffer //output: 0 - no any jobs doing, 1 - some jobs were doing int i; float f; int job=0; //flag of any job were doing char lag_flag=0; //block lag is locked (modems synchronization complete) //char lock_flag=0; //phase of carrier (1333Hz, 6 samples per period) is locked //char sync_flag=0; //the difference of frequency transmitter-to-receiver sampling rate is locked //char current_lag=0; //block lag (0-90, aligned to last bit position, the 6 samples for bit) char info[8]={0}; //call info //regularly play Speaker's buffer job=playjit(); //the first try to play a tail of samples in buffer //check for we have enough samples for demodulation if(cnt<180*6) //check we haven't enough of unprocessed samples { //move tail to start of receiving buffer if(samples>speech) //check for tail { for(i=0; i<cnt; i++) speech[i]=samples[i]; //move tail to start of buffer samples=speech; //set pointer to start of buffer } //record i=_soundgrab((char*)(samples+cnt), 180*6); //try to grab new 48KHZ samples from Line if((i>0)&&(i<=(180*6))) //some samples grabbed { cnt+=i; //add grabbed samples to account job+=4; //set job } } else //we have enough samples for processing { i=Demodulate(samples, buf); //process samples: 36*6 (35-37)*6 samples samples+=i; //move pointer to next samples (with frequency adjusting) cnt-=i; //decrease the number of unprocessed samples if(0x80&buf[11]) //checks flag for output data block is ready { //check for synck and averages BER lag_flag=!(!(buf[11]&0x40)); //block lag is locked (synchronization compleet) //lock_flag=!(!(buf[11]&0x20)); //phaze of carrier (1333Hz, 6 samples per period) is locked //sync_flag=!(!(buf[11]&0x10)); //the differency of frequency transmitter-to-receiver sampling rate is locked //current_lag=buf[10]>>1; //block lag (0-90, aligned to last bit position, the 6 samples for bit) if(lag_flag) //check modem sync { //averages BER i=(0x0F&buf[11]); //count symbols errors (only 1 error per 9-bit symbol can be detected) fber*=0.99; //fber in range 0-900 fber+=i; //in range 0-9 errored bits per 90 bits treceived } //output statistics if(typing<0) //output call's info if no characters were typed by user { f=Mute(0); //get packets counter value i=State(0); //get current connection step * vad flag //notification of state and voice output if(!i) strcpy(info, (char*)"IDLE"); else if(abs(i)<8) strcpy(info, (char*)"CALL"); else if(f<=0) strcpy(info, (char*)"MUTE"); else if(i<0) strcpy(info, (char*)"PAUS"); else strcpy(info, (char*)"TALK"); if(f<0) f=-f; //absolute value i=f*0.0675; //computes total time of the call in sec: each packet 67,5 ms f=fau/4-100; //computes authentification level in % if(f<0) f=0; //only positive results have reason //current state notification if(lag_flag) printf("%s %dmin %dsec BER:%0.02f AU:%d%%\r", info, i/60, i%60, fber/90, (int)f); else printf("%s %dmin %dsec BER:---- AU:%d%%\r", info, i/60, i%60, (int)f); //lost of sync in modem } //process received packet detects voice/silence type buf[11]=0xFE; //set flag default as for silence descriptor if(lag_flag) //check modem sync { i=ProcessPkt(buf); //decode received packet if(i>=0) //received packet is a control type { fau*=0.99; //fau in range 0-800 (400 for random data) fau+=i; //averages authentication level } else if(i==-3) { buf[11]=0xFF; //set flag for voice data received } } //end of sync ok, packets processing } //end of data block received } //end of a portion of sampless processing //check we have received data and output buffer is empty for decoding if((0x0E&buf[11])&&(l_jit_buf<=180)) { //decode voice data or set silency job+=16; //set job if(1&buf[11]) //this is a voice frame, decode it { melpe_s(sp, buf); //decode 81 bits in 11 bytes to 540 8KHz samples } else memset(sp, 0, 1080); //or output 67.5 mS of silence buf[11]=0; //clears flag: data buffer is processed //computes average playing delay i=getdelay()+l_jit_buf; //total number of unplayed samples in buffers fdelay*=0.9; //averages fdelay+=i; //computes optimal resapling ratio for the optimum delay f=fabs(fdelay/10-720)/10000000; //correction rate due inconsistency if(i<360) qff-=f; //adjust current ratio else if(i>1080) qff+=f; if(qff<0.888) qff=0.888; //restrictions else if(qff>1.142) qff=1.142; //resample and play to Headset if(l_jit_buf>180) l_jit_buf=0; //prevent overflow l_jit_buf+=resample(sp, jit_buf+l_jit_buf, qff); //resample buffer for playing playjit(); //immediately try to play buffer } return job; }
static int insert_buffer(losig_list* losig, lofig_list* lofig, int optim_level, long index) { double capa, init_capa; cell_list* buffer; chain_list* namechain, *sigchain=NULL; char* signame; lofig_list* model; losig_list* losig_buf; loins_list* loins_buf; locon_list* locon; losig_list* losig_vdd=NULL, *losig_vss=NULL, *losig_aux; ptype_list* ptype, *buffer_ptype; double delay, best_delay, init_delay; loins_list* loins; chain_list* lofigchain,*newlofigchain=NULL; int buffer_is_better=0, change=1; /*flags*/ chain_list* pred; chain_list* temp; buffer=getCellbuffer(); /*no buffer in library*/ if (!buffer) return 0; if (!losig->NAMECHAIN) { fprintf(stderr,"insert_buffer: no name on signal\n"); autexit(1); } best_delay=critical_delay(lofig); init_capa=getcapacitance(losig->NAMECHAIN->DATA); /*add buffer to netlist*/ signame=getautoname(losig->NAMECHAIN->DATA); namechain=addchain(NULL,signame); losig_buf=addlosig(lofig,index,namechain,INTERNAL); putcapacitance(signame,0); putdelay(signame,0); model=getlofig(buffer->BEFIG->NAME,'A'); /*search vdd and vss*/ for (locon=lofig->LOCON; locon; locon=locon->NEXT) { if (isvdd(locon->NAME)) losig_vdd=locon->SIG; if (isvss(locon->NAME)) losig_vss=locon->SIG; } /*build list of signal*/ for (locon=model->LOCON;locon; locon=locon->NEXT) { if (locon->DIRECTION==UNKNOWN) { fprintf(stderr,"BEH: 'linkage %s' in figure '%s' isn't accepted\n", locon->NAME,model->NAME); autexit(1); } if (isvdd(locon->NAME)) losig_aux=losig_vdd; else if (isvss(locon->NAME)) losig_aux=losig_vss; else if (locon->DIRECTION==OUT) losig_aux=losig_buf; else if (locon->DIRECTION==IN) losig_aux=losig; else { fprintf(stderr,"insert_buffer: buffer port '%s' unknown\n",locon->NAME); autexit(1); } sigchain=addchain(sigchain,losig_aux); } sigchain=reverse(sigchain); loins_buf=addloins(lofig,signame,model,sigchain); freechain(sigchain); /*to check changes*/ init_delay=getdelay(losig->NAMECHAIN->DATA); init_capa=getcapacitance(losig->NAMECHAIN->DATA); loins_capacitance(loins_buf,1/*add capa*/); /*lofigchain*/ for (locon=loins_buf->LOCON;locon; locon=locon->NEXT) { if (locon->DIRECTION==UNKNOWN) { fprintf(stderr,"BEH: 'linkage %s' in figure '%s' isn't accepted\n", locon->NAME,loins_buf->INSNAME); autexit(1); } if (isvdd(locon->NAME)) losig_aux=losig_vdd; else if (isvss(locon->NAME)) losig_aux=losig_vss; else if (locon->DIRECTION==OUT) losig_aux=losig_buf; else if (locon->DIRECTION==IN) losig_aux=losig; else { fprintf(stderr,"insert_buffer: buffer port '%s' unknown\n",locon->NAME); autexit(1); } ptype=getptype(losig_aux->USER,LOFIGCHAIN); if (!ptype) losig_aux->USER=addptype(losig_aux->USER,LOFIGCHAIN,addchain(NULL,locon)); else ptype->DATA=addchain(ptype->DATA,locon); } /*move all instance after buffer*/ ptype=getptype(losig->USER,LOFIGCHAIN); buffer_ptype=getptype(losig_buf->USER,LOFIGCHAIN); if (!ptype || !buffer_ptype) { fprintf(stderr,"insert_buffer: LOFIGCHAIN not found\n"); autexit(1); } for (lofigchain=((chain_list*)ptype->DATA)->NEXT/*first is entry of buffer*/; lofigchain; lofigchain=lofigchain->NEXT) { locon=(locon_list*) lofigchain->DATA; if (locon->DIRECTION==UNKNOWN) { fprintf(stderr,"BEH: 'linkage %s' isn't accepted\n", locon->NAME); autexit(1); } /*do not move drivers and port of circuit*/ if (locon->TYPE==EXTERNAL || locon->DIRECTION!=IN) { newlofigchain=addchain(newlofigchain,locon); continue; } loins=locon->ROOT; /*change capacitance*/ loins_capacitance(loins,0/*remove capa*/); /*change netlist*/ locon->SIG=losig_buf; buffer_ptype->DATA=addchain(buffer_ptype->DATA,locon); loins_capacitance(loins,1/*add capa*/); } /*put back drivers*/ freechain(((chain_list*)ptype->DATA)->NEXT/*first is entry of buffer*/); ((chain_list*)ptype->DATA)->NEXT=newlofigchain; /*eval all changes*/ propagate_loins_delay(loins_buf); /*relaxation algorithm*/ while (change) { change=0; pred=NULL; buffer_ptype=getptype(losig_buf->USER,LOFIGCHAIN); ptype=getptype(losig->USER,LOFIGCHAIN); if (!buffer_ptype || !buffer_ptype->DATA) { fprintf(stderr,"insert_buffer: LOFIGCHAIN is empty\n"); autexit(1); } /*put critical path before buffer*/ for (lofigchain=buffer_ptype->DATA; lofigchain->NEXT/*last is buffer output*/; lofigchain=lofigchain->NEXT) { locon=lofigchain->DATA; loins=locon->ROOT; /*change capacitance*/ loins_capacitance(loins,0/*remove capa*/); /*change netlist*/ locon->SIG=losig; ptype->DATA=addchain(ptype->DATA,locon); loins_capacitance(loins,1/*add capa*/); /*put over*/ if (pred) pred->NEXT=lofigchain->NEXT; else buffer_ptype->DATA=lofigchain->NEXT; /*eval all changes*/ propagate_loins_delay(loins); propagate_loins_delay(loins_buf); delay=critical_delay(lofig); if (delay<best_delay) { /*finish change*/ best_delay=delay; change=1; /*flag of change*/ buffer_is_better=1; lofigchain->NEXT=NULL; freechain(lofigchain); break; } else { /*remove change*/ if (pred) pred->NEXT=lofigchain; else buffer_ptype->DATA=lofigchain; /*unchange capacitance*/ loins_capacitance(loins,0/*remove capa*/); /*unchange netlist*/ locon->SIG=losig_buf; temp=ptype->DATA; ptype->DATA=temp->NEXT; temp->NEXT=NULL; freechain(temp); loins_capacitance(loins,1/*add capa*/); /*avoid change*/ propagate_loins_delay(loins_buf); propagate_loins_delay(loins); /*for next loop*/ pred=lofigchain; } } }/*end of while*/ if (buffer_is_better) { /*chose the best buffer*/ change_instance(loins_buf, losig_buf, lofig, optim_level); } else { /*if insert buffer is worst than before, remove it*/ /*remove all references of buffer in lofigchain*/ for (locon=loins_buf->LOCON; locon; locon=locon->NEXT) { losig_aux=locon->SIG; ptype=getptype(losig_aux->USER,LOFIGCHAIN); if (!ptype) break; pred=NULL; for (lofigchain=ptype->DATA; lofigchain; lofigchain=lofigchain->NEXT) { if (lofigchain->DATA==locon) { if (pred) pred->NEXT=lofigchain->NEXT; else ptype->DATA=lofigchain->NEXT; lofigchain->NEXT=NULL; freechain(lofigchain); break; } pred=lofigchain; } } buffer_ptype=getptype(losig_buf->USER,LOFIGCHAIN); ptype=getptype(losig->USER,LOFIGCHAIN); if (buffer_ptype) { for (lofigchain=buffer_ptype->DATA; lofigchain; lofigchain=lofigchain->NEXT) { locon=lofigchain->DATA; loins=locon->ROOT; /*change capacitance*/ loins_capacitance(loins,0/*remove capa*/); /*change netlist*/ locon->SIG=losig; ptype->DATA=addchain(ptype->DATA,locon); loins_capacitance(loins,1/*add capa*/); propagate_loins_delay(loins); } freechain(buffer_ptype->DATA); buffer_ptype->DATA=NULL; } loins_capacitance(loins_buf,0/*remove capa*/); dellosig(lofig,index); delloins(lofig,loins_buf->INSNAME); propagate_losig_delay(losig); /*verify no change on timing*/ delay=critical_delay(lofig); capa=getcapacitance(losig->NAMECHAIN->DATA); //01/09/2004 xtof's modification: rounding problem if ((int)(capa + 0.5)!=(int)(init_capa + 0.5) || (int)(delay + 0.5)!=(int)(best_delay + 0.5) || (int)(init_delay + 0.5)!=(int)(getdelay(losig->NAMECHAIN->DATA) + 0.5)) { fprintf(stderr, "insert_buffer: compute error %e!=%e fF %f!=%f ps %f!=%f ps\n", capa,init_capa,delay,best_delay, init_delay, getdelay(losig->NAMECHAIN->DATA)); autexit(1); } } return buffer_is_better; }
/* * Apply the effect */ void Chorus::out (float * smpsl, float * smpsr) { int i; float tmp; dl1 = dl2; dr1 = dr2; lfo.effectlfoout (&lfol, &lfor); if(awesome_mode) { //use interpolated delay line for better sound float tmpsub; dl2 = delay + lfol * depth; dr2 = delay + lfor * depth; if (Poutsub != 0) tmpsub = -1.0f; else tmpsub = 1.0f; for (i = 0; i < param->PERIOD; i++) { //Left mdel = (dl1 * (float)(param->PERIOD - i) + dl2 * (float)i) / param->fPERIOD; tmp = smpsl[i] + oldl*fb; efxoutl[i] = tmpsub*ldelay->delay(tmp, mdel, 0, 1, 0); oldl = efxoutl[i]; //Right mdel = (dr1 * (float)(param->PERIOD - i) + dr2 * (float)i) / param->fPERIOD; tmp = smpsr[i] + oldr*fb; efxoutr[i] = tmpsub*rdelay->delay(tmp, mdel, 0, 1, 0); oldr = efxoutr[i]; } } else { dl2 = getdelay (lfol); dr2 = getdelay (lfor); for (i = 0; i < param->PERIOD; i++) { float inl = smpsl[i]; float inr = smpsr[i]; //LRcross float l = inl; float r = inr; inl = l * (1.0f - lrcross) + r * lrcross; inr = r * (1.0f - lrcross) + l * lrcross; //Left channel //compute the delay in samples using linear interpolation between the lfo delays mdel = (dl1 * (float)(param->PERIOD - i) + dl2 * (float)i) / param->fPERIOD; if (++dlk >= maxdelay) dlk = 0; float tmp = (float) dlk - mdel + (float)maxdelay * 2.0f; //where should I get the sample from ((dlhi)=((tmp>0) ? ( (int)(tmp) ) :( (int)(tmp-1.0f) ))); dlhi %= maxdelay; dlhi2 = (dlhi - 1 + maxdelay) % maxdelay; dllo = 1.0f - fmodf (tmp, 1.0f); efxoutl[i] = delayl[dlhi2] * dllo + delayl[dlhi] * (1.0f - dllo); delayl[dlk] = inl + efxoutl[i] * fb; //Right channel //compute the delay in samples using linear interpolation between the lfo delays mdel = (dr1 * (float)(param->PERIOD - i) + dr2 * (float)i) / param->fPERIOD; if (++drk >= maxdelay) drk = 0; tmp = (float)drk - mdel + (float)maxdelay * 2.0f; //where should I get the sample from ((dlhi)=((tmp>0) ? ( (int)(tmp) ) :( (int)(tmp-1.0f) ))); dlhi %= maxdelay; dlhi2 = (dlhi - 1 + maxdelay) % maxdelay; dllo = 1.0f - fmodf (tmp, 1.0f); efxoutr[i] = delayr[dlhi2] * dllo + delayr[dlhi] * (1.0f - dllo); delayr[dlk] = inr + efxoutr[i] * fb; }; if (Poutsub != 0) for (i = 0; i < param->PERIOD; i++) { efxoutl[i] *= -1.0f; efxoutr[i] *= -1.0f; }; for (int i = 0; i < param->PERIOD; i++) { efxoutl[i] *= panning; efxoutr[i] *= (1.0f - panning); }; } //end awesome_mode test };
/* * Apply the effect */ void Chorus::out (float * smpsl, float * smpsr) { int i; dl1 = dl2; dr1 = dr2; lfo.effectlfoout (&lfol, &lfor); dl2 = getdelay (lfol); dr2 = getdelay (lfor); for (i = 0; i < PERIOD; i++) { float inl = smpsl[i]; float inr = smpsr[i]; //LRcross float l = inl; float r = inr; inl = l * (1.0f - lrcross) + r * lrcross; inr = r * (1.0f - lrcross) + l * lrcross; //Left channel //compute the delay in samples using linear interpolation between the lfo delays mdel = (dl1 * (float)(PERIOD - i) + dl2 * (float)i) / fPERIOD; if (++dlk >= maxdelay) dlk = 0; float tmp = (float) dlk - mdel + (float)maxdelay * 2.0f; //where should I get the sample from F2I (tmp, dlhi); dlhi %= maxdelay; dlhi2 = (dlhi - 1 + maxdelay) % maxdelay; dllo = 1.0f - fmodf (tmp, 1.0f); efxoutl[i] = delayl[dlhi2] * dllo + delayl[dlhi] * (1.0f - dllo); delayl[dlk] = inl + efxoutl[i] * fb; //Right channel //compute the delay in samples using linear interpolation between the lfo delays mdel = (dr1 * (float)(PERIOD - i) + dr2 * (float)i) / fPERIOD; if (++drk >= maxdelay) drk = 0; tmp = (float)drk - mdel + (float)maxdelay * 2.0f; //where should I get the sample from F2I (tmp, dlhi); dlhi %= maxdelay; dlhi2 = (dlhi - 1 + maxdelay) % maxdelay; dllo = 1.0f - fmodf (tmp, 1.0f); efxoutr[i] = delayr[dlhi2] * dllo + delayr[dlhi] * (1.0f - dllo); delayr[dlk] = inr + efxoutr[i] * fb; }; if (Poutsub != 0) for (i = 0; i < PERIOD; i++) { efxoutl[i] *= -1.0f; efxoutr[i] *= -1.0f; }; for (int i = 0; i < PERIOD; i++) { efxoutl[i] *= panning; efxoutr[i] *= (1.0f - panning); }; };