/*^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
/*     synth - the synthesizer treatment for YOUR wavefiles!       */
/*           term project for Computational Physics                */
/*                       spring 1997                               */
/*                   by Richard Metzler                            */
/*_________________________________________________________________*/

/*-----------------------------------------------------------------*/
/*                   include-files                                 */
/*-----------------------------------------------------------------*/


#include <stdio.h>
#include <math.h>
#include <string.h>
#include "Xgraphics.h"
#include "/usr2/people/metzler/synth/AFsp-V2R2/include/libtsp.h"



/*-----------------------------------------------------------------*/
/*                    declarations                                 */
/*-----------------------------------------------------------------*/


/* GUI windows and worlds */

Window mainwindow, freqwindow, ampwindow,filtwindow;
World  mainworld, mainwrite;
  
World fvalues, feg, avalues, aeg, ivalues, ieg;        

XEvent mainmenu;

/* functions for envelopes etc. */

float env(float lvl0, float lvl1,float lvl2, float lvl3, float lvl4,
               float time1, float time2, float time3, float time4,
               float time);
float lfo(int form, float offset,float pos,float amp, float freq, float time);


/* subroutines for editing parameters */ 

void mainrenew();

void freqpage();
void frenew(char menu, float ftmpfloat);
void freqwrite();

void amppage();
void arenew(char amenu, float atmpfloat);
void awrite();

void filtpage();
void irenew(char menu, float tmpfloat);
void iwrite();

void drawenv(World w, float lvl0, float lvl1, float lvl2, 
float lvl3, float lvl4, float tm1, float tm2, float tm3, float tm4);


/* subroutines for calculating modified wave file */

void recalculate();

float timestretch(float time, float pos);
float lint(float y[], float x);
float resfct(float f,float f0, float resonance);

/* functions from fftpack  */

void srffti_(int *n, float wsave[]);
void srfftf_(int *n, float r[], float wsave[]);
void srfftb_(int *n, float r[], float wsave[]);


/* some flags */

int    done = 0;
int    stop = 0;



/* names for input and output files   */

char   infile[60]  = "in.wav";
char   tempfile[30] = "tmp.wav";
char   tem2file[30] = "tm2.wav";
char   outfile[60]= "out.wav";


AFILE *inptr;
AFILE *tmpptr;
AFILE *outptr;

/*  counters for old and new sample      */

long int   channels;
long int   length1,length2;

/* sample rate                           */

float  samplerate;

/* parameters                            */

float  flvl0 = 0.5, flvl1=0.5,flvl2=0.5,flvl3=0.5,flvl4=0.5;
float  ftime1=0.25,ftime2=0.5,ftime3=0.75,ftime4=1.0;
float  flforate=0.3,flfooffset=0.2,flfoamp= 0.00;
int    flfoform= 1;

float  alvl0=0,alvl1=1.0, alvl2=0.8, alvl3=0.7,alvl4=0.0;
float  atime1=0.05,atime2=0.15,atime3=.75,atime4=1.0;
float  alforate= 0.3,alfooffset=0.2, alfoamp = 0.0;
int    alfoform=1;

float  ilvl0=0,ilvl1=1,ilvl2=0.8,ilvl3=0.7,ilvl4=0.0;
float  itime1=0.1, itime2=0.25, itime3=0.75, itime4=1.0;
float  resonance=0;

/*-----------------------------------------------------------------*/
/*                        main menu                                */
/*-----------------------------------------------------------------*/

void main(int argc, char* argv[3]) { 

int j;
char wstring[40];
 
InitX();
mainwindow = CreateWindow(500,265,"Synth - Main Menu");

freqwindow = CreateWindow(600, 530, "Frequency menu");
ampwindow  = CreateWindow(600, 530, "Amplitude menu");
filtwindow = CreateWindow(600, 465, "Filter menu");
 
if(argc>1)
  {strcpy(infile, argv[1]);}
if(argc>2)
  {strcpy(outfile,argv[2]);}
if(argc>3)
  {fprintf(stderr, "Usage: synth [<input.wav>] [<output.wav>]\n");
   fprintf(stderr, "Additional arguments ignored\n");}

/*   show parameters of input file   */

inptr= AFopenRead(infile, &length1, &channels, &samplerate, NULL);
AFclose(inptr);

mainwrite= CreateWorld(mainwindow, 0, 0, 300, 260, 0.0,0.0,300.0,260.0,0,0);

mainrenew();

ShowWindow(mainwindow);

while(done == 0)
 {
   if (GetEvent(&mainmenu,1)){
     switch(mainmenu.type) { 
     case Expose:
          mainrenew();
	  break;
     case KeyPress:
       switch(ExtractChar(mainmenu)){
       case 'r':
          recalculate();
	  mainrenew();
          break; 
       case 'f':
          freqpage();
	  mainrenew();
          break;
       case 'a':
          amppage();
	  mainrenew();
          break;
       case 'i':
          filtpage();
	  mainrenew();
          break;
       case 'x':
          done = 1; 
          break;
              
       } /*switch*/
     }  /*switch */
   }   /*if*/ 
  
  
 }    /*while*/

ExitX();

}  /* end of main*/     

/*-----                 ---------------------------------------*/
/* mainrenew writes stuff to the main menu when necessary      */
/*-----                 ---------------------------------------*/
 
void mainrenew()
{
char wstring[60];

sprintf(wstring,"Input file:        %s",infile);
  WDrawString(mainwrite,50, 33, wstring, 1);
sprintf(wstring,"Length:           %i samples",length1);
  WDrawString(mainwrite,50, 66, wstring,1);
sprintf(wstring,"Sample rate:   %6.2f Hz", samplerate);
  WDrawString(mainwrite,50, 100,wstring,1);
sprintf(wstring,"Channels:        %i",channels);
  WDrawString(mainwrite,50, 133,wstring,1);
sprintf(wstring,"Output file:      %s",outfile);
  WDrawString(mainwrite,50, 166,wstring,1);

InitButtons(mainwindow, "b,recalculate,r,b,frequency page,f,b,amplitude page,\
a,b,filter page,i,b,exit,x",200);

return;
}

/*----------------------------------------------------------------*/
/*          subroutines for calculating new wave file             */
/*----------------------------------------------------------------*/

/*------                                           ---------------*/
/*      recalculate basically does all the work...                */
/*------                                           ---------------*/


void recalculate()
{
float pos,time;
int i,j,l,m,n;
int nsamp;
int blocksize;
float x, xtemp[9];
int   xnr, xcount=0;
float y[2050], y2a[2050];
float sampbuff[4100],fftbuff[4100],backbuff[4100];
float wtemp[8300];
float yout[8200];
float sampout[16400];
float cutoff;
char wstring[40];


/*----                                                 -----------*/
/*                 1st task: frequency                            */
/*----                                                 -----------*/

/*      important: always proclaim that you ARE working  ;-)      */
  WDrawString(mainwrite,50, 250,"Working...                   ",1);

inptr= AFopenRead(infile, &length1, &channels, &samplerate, NULL);
tmpptr = AFopenWrite(tempfile, 261, channels, samplerate, NULL); 

for(j=0;j<channels;j++)
  {xtemp[j]=0.0;}

for(i = 0; 2048*channels*i<length1; i=i+1){
  
   nsamp = AFreadData(inptr,2048*channels*i,sampbuff, 2048*channels);
   blocksize = channels*2048;      

       for(j=0; j<channels; j++){
       for(l=0; l<2048;l++){
	 y[l]=sampbuff[l*channels + j];
         }/* for(l) */
     x=xtemp[j];
     xnr=0;
     
      while(x<=2048.0){
       yout[xnr]= lint(y,x);
       x = x + timestretch((float)(xcount+xnr)/(samplerate*(float)channels),
                ((float)(i*blocksize)+x*(float)channels)/((float)(length1)));
       sampout[xnr*channels + j] = yout[xnr];
       xnr= xnr+1;
      }

 
       xtemp[j] = x - 2048.0;  
       xcount= xcount + xnr;
     }/* for(j) */    
  AFwriteData(tmpptr, sampout, channels*xnr); 
  } /*for(i)*/   

AFclose(tmpptr);
AFclose(inptr);
/*----                                              -----------------*/
/*          2nd task: amplitude                                      */
/*----                                              -----------------*/

tmpptr=AFopenRead(tempfile,&length2,&channels,&samplerate,NULL);
outptr=AFopenWrite(tem2file,261, channels,samplerate,NULL);

for(i=0; 2048*channels*i<length2; i++)
 {

  nsamp = AFreadData(tmpptr, 2048*channels*i, sampbuff, 2048*channels);
  blocksize = channels*2048;

    for(j=0; j<channels;j++){
      for(l=0; l<2048; l++){
        y[l]=sampbuff[l*channels + j];
        pos=(float)(i*blocksize +l*channels)/((float)(length2));
        time=(float)(i*blocksize +l*channels)/(samplerate*(float)channels);
        y[l]=(env(alvl0,alvl1,alvl2,alvl3,alvl4,atime1,atime2,atime3,atime4,
              pos)+
             lfo(alfoform, alfooffset,pos,alfoamp, 20.0*alforate, time))
             *y[l];
        
       
        sampout[l*channels + j]=y[l];
      }
     } 
     AFwriteData(outptr, sampout, blocksize);
}
AFclose(tmpptr);
AFclose(outptr);
 
/*----                                                       ----------*/
/*       3rd task: filter                                              */
/*----                                                       ----------*/

tmpptr=AFopenRead(tem2file,&length2,&channels,&samplerate,NULL);
outptr=AFopenWrite(outfile,261, channels,samplerate,NULL);
blocksize = 4096;


/*   initialize temporary buffer for fft  */
srffti_(&blocksize, wtemp);

 
/*   read samples    */

for(i=0; 2048*channels*i<length2; i++)
 {   
  nsamp = AFreadData(tmpptr, 2048*channels*i, sampbuff, 2048*channels);
 
  for(j=1; j<=channels;j++){
     for(l=0; l<2048; l++){
       fftbuff[l]=sampbuff[(l)*channels + (j-1)];
       fftbuff[l+2048]= 0.0;  /* padding with zeros  */
      }/* for (l) */
      
     srfftf_(&blocksize, fftbuff, wtemp);

     }
     for (m = 0; m< 8; m++){
       pos = (float)(i*channels*2048+m*256*channels)/(float)length2;
       cutoff=env(ilvl0,ilvl1,ilvl2,ilvl3,ilvl4,
                   itime1,itime2,itime3,itime4,pos); 
       
       for (n = 0; n<=4096; n++){ 
         backbuff[n]=resfct((float)n/4096.0,cutoff,resonance)*fftbuff[n];
	         }
       srfftb_(&blocksize, backbuff,wtemp);
       for(n = 0;n<= 255;n++)
         { sampout[n*channels + m*256*channels] =
	     backbuff[n + m*256]/8096.0;}
     }/*for (m)  */
  } /* for (j)  */ 
  AFwriteData(outptr,sampout,2048*channels); 
 } /* for (i) */
AFclose(tmpptr);
AFclose(outptr);

  WDrawString(mainwrite,50, 250,"Done recalculating   ",1);
       
} 

/*--------------------------------------------------------------*/
/*          timestretch                                         */

float timestretch(float time, float pos)
{
return  0.5*fexp(
        (env(flvl0,flvl1,flvl2,flvl3,flvl4,ftime1,ftime2,ftime3,ftime4,pos) +
         lfo(flfoform, flfooffset, pos, flfoamp,20.0*flforate, time)/3.0)
         *2*flog(2));}



/*--------------------------------------------------------------*/
/*           linear interpolation between sample points         */

float lint(float y[],float x)
{
int xint= (int)x;
float xround = (float)((int)x);

if(x<0)
 return ((2-x)*y[1]+(x-1)*y[2]);
else if(x>2047)
 { return (2047-x)*y[2046]+ (x-2046)*y[2047];}
else 
 {return (xround+1.0-x)*y[xint] + (x - xround)*y[xint+1];} 
}	  

/*---------------------------------------------------------------*/
/*           resonance function                                  */

float resfct(float f,float f0, float resonance)
{
  float r;
  float eps = 1e-8;
  float damp = 0.95; /* prevents resonance catastrophe */
  r = 2*f0*f0*(1 - damp*resonance);

    return (f0*f0 +eps)/(sqrt(pow((f*f -f0*f0),2)+ r*f*f)+eps);
  /* eps prevents numerical divergence */
}	

/*---------------------------------------------------------------*/
/*            envelope generator                                 */
 

float env(float lvl0, float lvl1,float lvl2, float lvl3, float lvl4,
          float time1, float time2, float time3, float time4,
          float time)

	  {


if(time <= time1)
  {if (time1==0.0) return lvl1;
  else  return lvl0 + (time/time1)*(lvl1-lvl0);}

else if(time <=time2)
          return lvl1 - (lvl1-lvl2)*(time - time1)/(time2 - time1);

else if(time <=time3)       
          return lvl2 - (lvl2-lvl3)*(time - time2)/(time3 - time2);

else if(time <= time4)
          return lvl3 - (lvl3-lvl4)*(time - time3)/(time4 - time3);

else 
          return lvl4;
  }

/*---------------------------------------------------------------*/
/*          low frequency oscillator                             */


float lfo(int form, float offset,float pos, float amp, float freq, float time)
{
float pi = 3.1415927;
float modulo = (freq*time) -(float)((int)(freq*time));
float stor;

if(form == 1){

stor=amp*sin(2*pi*freq*time);}


else if(form ==2){

if(modulo<=0.5) stor = -amp;
else stor= amp;}
 
else if(form ==3)
{
stor= 2*amp*(modulo-0.5);}

else if(form ==4){
if(modulo<0.5) stor = amp*(1 + 4*modulo);
else  stor = amp*(3 - 4*modulo);
}

if((pos+0.1)<offset) return 0;

else if (pos<offset) return (1-10.0*(offset-pos))*stor;

else return stor;}




/*---------------------------------------------------------------*/
/*         subroutines for editing frequency parameters          */
/*---------------------------------------------------------------*/        

/*   getting parameters for frequency page  */
      
void freqpage()
{ 
 World envelope;
 XEvent freqevent;

 int leave = 0; 
 int temp = 1;
 float tempfloat=0;
 char  fmenu;
 
 feg = CreateWorld(freqwindow,
          5, 5, 350, 350, 0, 1,1 , 0, 0, 0); 

 fvalues = CreateWorld(freqwindow,
          365, 0, 65, 420, 0,0,1,12,0, 0);

 freqwrite();
 
 InitButtons(freqwindow, "b, Level 1,a,b,Level 2,b,b,Level 3,c,b,Level 4,d,b,Time 1,e,b,Time 2,f,b,Time 3,g,b,Time 4,h,b, Lfo Form,i,b, Lfo Rate,j,b, Lfo Offset,k,b, Lfo Amplitude,l,b,Decrease(-),-,b, Increase(+),+,b,return,x", 150);
 
 ShowWindow(freqwindow);
 while(leave == 0)
   {
   if (GetEvent(&mainmenu,1)){
      
     switch(mainmenu.type) {
     case Expose:
        freqwrite();
        InitButtons(freqwindow, "b, Level 1,a,b,Level 2,b,b,Level 3,c,b,Level 4,d,b,Time 1,e,b,Time 2,f,b,Time 3,g,b,Time 4,h,b, Lfo Form,i,b, Lfo Rate,j,b, Lfo Offset,k,b, Lfo Amplitude,l,b,Decrease(-),-,b, Increase(+),+,b,return,x", 150);
         break;
     case KeyPress:
     switch(ExtractChar(mainmenu)){
       case 'a':
	 fmenu = 'a'; tempfloat = flvl1;break;       
       case 'b':       
	 fmenu = 'b';tempfloat = flvl2;break;       
       case 'c':       
 	 fmenu = 'c';tempfloat = flvl3;break;       
      case 'd':       
	 fmenu = 'd';tempfloat = flvl4;break;       
       case 'e':       
	 fmenu = 'e';tempfloat = ftime1;break;       
       case 'f':       
	 fmenu = 'f';tempfloat = ftime2;break;
       case 'g':       
	 fmenu = 'g';tempfloat = ftime3;break;
       case 'h':       
	 fmenu = 'h';tempfloat = ftime4;break;
       case 'i':
         flfoform = flfoform + 1; 
         if (flfoform == 5) flfoform = 1;
         freqwrite();  
         break; 
       case 'j':
         fmenu = 'j'; tempfloat = flforate;break;
       case 'k': 
         fmenu = 'k'; tempfloat = flfooffset; break; 
       case 'l':
         fmenu = 'l'; tempfloat = flfoamp;break;

       case '-' : 
           tempfloat = tempfloat -0.01;
           if(tempfloat<0.0) tempfloat = 0.0;
           frenew(fmenu, tempfloat);
           break;
       case '+':
           tempfloat = tempfloat + 0.01;
	 if(tempfloat>1.0) tempfloat = 1.0;
         frenew(fmenu, tempfloat);  /* assign tempfloat to 
                                      corresponding parameter */ 
         break; 
       case 'x':
         leave =1;
	 HideWindow(freqwindow);
         break;  
        }; /*switch */     
     }/*switch*/
   }/*if*/
 }/*while */ 

 
}

/*-------------------------------------------------------------------*/
/*    frenew updates values of parameters, calls freqwrite           */


void frenew(char menu, float tmpfloat)
{

  switch(menu){
   case 'a':
      flvl1 = tmpfloat;break;
   case 'b':
      flvl2 = tmpfloat;break;
   case 'c':
      flvl3 = tmpfloat;break;  
   case 'd':
      flvl4 = tmpfloat;break;  
   case 'e':
      ftime1 = tmpfloat; 
      if (ftime1> ftime2) ftime1= ftime2;
      break; 
   case 'f':
      ftime2 = tmpfloat;
      if(ftime2<ftime1) ftime2=ftime1;
      if(ftime2>ftime3) ftime2=ftime3;
      break;   
   case 'g':
      ftime3 = tmpfloat;
      if(ftime3<ftime2) ftime3=ftime2;
      if(ftime3>ftime4) ftime3=ftime4;
      break;  
   case 'h':
      ftime4 = tmpfloat;
      if(ftime4<ftime3) ftime4=ftime3;
      break;
    case 'j':
      flforate = tmpfloat; break;
   case 'k':
      flfooffset = tmpfloat; break;
   case 'l':
      flfoamp = tmpfloat; break;
   
   }/*switch*/
  
   freqwrite();

}

/*-------------------------------------------------------------*/

/* freqwrite writes values of frequency parameters to screen   */

void freqwrite()
{
 char str[12];

 ClearArea(freqwindow,0,0, 355,355);
 drawenv(feg, flvl0, flvl1,flvl2, flvl3,flvl4, ftime1,ftime2,
        ftime3,ftime4);

 sprintf(str,"%4.2f", flvl1);
  WDrawString(fvalues,0.0, 0.6, str, 1); 
 sprintf(str,"%4.2f", flvl2);
  WDrawString(fvalues,0.0, 1.6, str, 1); 
 sprintf(str,"%4.2f", flvl3);
  WDrawString(fvalues,0.0, 2.6, str, 1);
 sprintf(str,"%4.2f", flvl4);
  WDrawString(fvalues,0.0, 3.6, str, 1);
 sprintf(str,"%4.2f", ftime1);
  WDrawString(fvalues,0.0, 4.6, str, 1);
 sprintf(str,"%4.2f", ftime2);
  WDrawString(fvalues,0.0, 5.6, str, 1);
 sprintf(str,"%4.2f", ftime3);
  WDrawString(fvalues,0.0, 6.6, str, 1);
 sprintf(str,"%4.2f", ftime4);
  WDrawString(fvalues,0.0, 7.6, str, 1);
   
 WDrawString(fvalues,0.0, 8.6, "                ",1);
    if(flfoform ==1) 
 WDrawString(fvalues,0.0, 8.6, "Sine", 1);   
    else if (flfoform ==2)
 WDrawString(fvalues,0.0, 8.6, "Square", 1);
    else if (flfoform ==3 )
 WDrawString(fvalues,0.0, 8.6, "Sawtooth", 1);
    else if (flfoform ==4)
 WDrawString(fvalues,0.0, 8.6, "Triangle", 1);     
    else 
 WDrawString(fvalues,0.0, 8.6, "undefined", 1);
     
 WDrawString(fvalues, 0.0, 9.6, "            ",1);
 sprintf(str,"%5.2f",20.0*flforate );
  WDrawString(fvalues,0.0, 9.6, str, 1);
 sprintf(str,"%5.2f",flfooffset );
  WDrawString(fvalues,0.0, 10.6, str, 1);
 sprintf(str,"%5.2f",flfoamp );
  WDrawString(fvalues,0.0, 11.6, str, 1);
}/* end of freqwrite */



/*----------------------------------------------------------------*/
/*          subroutines for amplitude parameters                  */
/*      (basically the same with other parameter names)           */
/*----------------------------------------------------------------*/


/*   getting parameters for amplitude page  */
      
void amppage()
{ 
 World envelope;

 
 XEvent ampevent;
 int leave = 0; 
 int temp = 1;
 float tempfloat=0;
 char  amenu;


 aeg = CreateWorld(ampwindow,
          5, 5, 350, 350, 0, 1,1 , 0, 0, 0);
 
 avalues = CreateWorld(ampwindow,
          365, 0, 65, 420, 0,0,1,12,0, 0);

 awrite();

 InitButtons(ampwindow, "b, Level 1,a,b,Level 2,b,b,Level 3,c,b,Level 4,d,b,Time 1,e,b,Time 2,f,b,Time 3,g,b,Time 4,h,b, Lfo Form,i,b, Lfo Rate,j,b, Lfo Offset,k,b, Lfo Amplitude,l,b,Decrease(-),-,b, Increase(+),+,b,return,x", 150);
 
 ShowWindow(ampwindow);

 while(leave == 0)
   {
   if (GetEvent(&mainmenu,1)){
      
     switch(mainmenu.type) { 
     case Expose:
       awrite();
  InitButtons(ampwindow, "b, Level 1,a,b,Level 2,b,b,Level 3,c,b,Level 4,d,b,Time 1,e,b,Time 2,f,b,Time 3,g,b,Time 4,h,b, Lfo Form,i,b, Lfo Rate,j,b, Lfo Offset,k,b, Lfo Amplitude,l,b,Decrease(-),-,b, Increase(+),+,b,return,x", 150);
      break;
     case KeyPress:
     switch(ExtractChar(mainmenu)){
       case 'a':
	 amenu = 'a'; tempfloat = alvl1;break;       
       case 'b':       
	 amenu = 'b';tempfloat = alvl2;break;       
       case 'c':       
 	 amenu = 'c';tempfloat = alvl3;break;       
      case 'd':       
	 amenu = 'd';tempfloat = alvl4;break;       
       case 'e':       
	 amenu = 'e';tempfloat = atime1;break;       
       case 'f':       
	 amenu = 'f';tempfloat = atime2;break;
       case 'g':       
	 amenu = 'g';tempfloat = atime3;break;
       case 'h':       
	 amenu = 'h';tempfloat = atime4;break;
       case 'i':
         alfoform = alfoform + 1; 
         if (alfoform == 5) alfoform = 1;
         awrite();  
         break; 
       case 'j':
         amenu = 'j'; tempfloat = alforate;break;
       case 'k': 
         amenu = 'k'; tempfloat = alfooffset; break; 
       case 'l':
         amenu = 'l'; tempfloat = alfoamp;break;

       case '-' : 
           tempfloat = tempfloat -0.01;
           if(tempfloat<0.0) tempfloat = 0.0;
           arenew(amenu, tempfloat);
           break;
       case '+':
           tempfloat = tempfloat + 0.01;
	 if(tempfloat>1.0) tempfloat = 1.0;
         arenew(amenu, tempfloat);  /* assign tempfloat to 
                                      corresponding parameter */ 
         break; 
       case 'x':
         leave =1;
         HideWindow(ampwindow);
         break;  
        }; /*switch */     
     }/*switch*/
   }/*if*/
 }/*while */
}

/*-------------------------------------------------------------------*/
           
/*    arenew updates values of parameters, calls awrite to print     */
/*    them and draw envelope                                         */


void arenew(char menu, float tmpfloat)
{

  switch(menu){
   case 'a':
      alvl1 = tmpfloat;break;
   case 'b':
      alvl2 = tmpfloat;break;
   case 'c':
      alvl3 = tmpfloat;break;  
   case 'd':
      alvl4 = tmpfloat;break;  
   case 'e':
      atime1 = tmpfloat; 
      if (atime1>atime2) atime1= atime2;
      break;
   case 'f':
      atime2 = tmpfloat;
      if(atime2<atime1) atime2=atime1;
      if(atime2>atime3) atime2=atime3;
      break;   
   case 'g':
      atime3 = tmpfloat;
      if(atime3<atime2) atime3= atime2;
      if(atime3>atime4) atime3=atime4;
      break;  
   case 'h':
      atime4 = tmpfloat;
      if(atime4<atime3) atime4= atime3;
      break;
    case 'j':
      alforate = tmpfloat; break;
   case 'k':
      alfooffset = tmpfloat; break;
   case 'l':
      alfoamp = tmpfloat; break;
   
   }/*switch*/
  
   awrite();
}

/*-------------------------------------------------------------*/

/*    awrite writes values of frequency parameters to screen   */
/*    and prints envelope                                      */

void awrite()
{
 char str[12];


ClearArea(ampwindow,0,0, 355,355);
drawenv(aeg, alvl0, alvl1,alvl2, alvl3,alvl4, atime1,atime2,
atime3,atime4);


 sprintf(str,"%4.2f", alvl1);
  WDrawString(avalues,0.0, 0.6, str, 1); 
 sprintf(str,"%4.2f", alvl2);
  WDrawString(avalues,0.0, 1.6, str, 1); 
 sprintf(str,"%4.2f", alvl3);
  WDrawString(avalues,0.0, 2.6, str, 1);
 sprintf(str,"%4.2f", alvl4);
  WDrawString(avalues,0.0, 3.6, str, 1);
 sprintf(str,"%4.2f", atime1);
  WDrawString(avalues,0.0, 4.6, str, 1);
 sprintf(str,"%4.2f", atime2);
  WDrawString(avalues,0.0, 5.6, str, 1);
 sprintf(str,"%4.2f", atime3);
  WDrawString(avalues,0.0, 6.6, str, 1);
 sprintf(str,"%4.2f", atime4);
  WDrawString(avalues,0.0, 7.6, str, 1);
   
 WDrawString(avalues,0.0, 8.6, "                ",1);
    if(alfoform ==1) 
 WDrawString(avalues,0.0, 8.6, "Sine", 1);   
    else if (alfoform ==2)
 WDrawString(avalues,0.0, 8.6, "Square", 1);
    else if (alfoform ==3 )
 WDrawString(avalues,0.0, 8.6, "Sawtooth", 1);
    else if (alfoform ==4)
 WDrawString(avalues,0.0, 8.6, "Triangle", 1);     
    else 
 WDrawString(avalues,0.0, 8.6, "undefined", 1);
     
 WDrawString(avalues, 0.0, 9.6, "            ",1);
 sprintf(str,"%5.2f",20.0*alforate );
  WDrawString(avalues,0.0, 9.6, str, 1);
 sprintf(str,"%5.2f",alfooffset );
  WDrawString(avalues,0.0, 10.6, str, 1);
 sprintf(str,"%5.2f",alfoamp );
  WDrawString(avalues,0.0, 11.6, str, 1);

}/* end of awrite */


/*---------------------------------------------------------------------*/
/*   ...and once more for the filter parameters                        */
/*             long live cut and paste                                 */

/*   getting parameters for filter page  */
      
void filtpage()
{ 
 World envelope;

 
 XEvent filtevent;
 int leave = 0; 
 int temp = 1;
 float tempfloat=0;
 char  imenu;


 ieg = CreateWorld(filtwindow,
          5, 5, 350, 350, 0, 1,1 , 0, 0, 0); 

 ivalues = CreateWorld(filtwindow,
          365, 0, 65, 420, 0,0,1,12,0, 0);

 iwrite();
 
 InitButtons(filtwindow, "b, Level 1,a,b,Level 2,b,b,Level 3,c,b,Level 4,d,b,Time 1,e,b,Time 2,f,b,Time 3,g,b,Time 4,h,b,Resonance,r,b,Decrease(-),-,b, Increase(+),+,b,return,x", 150);
 
 ShowWindow(filtwindow);

 while(leave == 0)
   {
   if (GetEvent(&filtevent,1)){
      
     switch(filtevent.type) { 
     case Expose:
       iwrite();
       InitButtons(filtwindow, "b, Level 1,a,b,Level 2,b,b,Level 3,c,b,Level 4,d,b,Time 1,e,b,Time 2,f,b,Time 3,g,b,Time 4,h,b,Resonance,r,b,Decrease(-),-,b, Increase(+),+,b,return,x", 150);
       break;
     case KeyPress:
     switch(ExtractChar(filtevent)){
       case 'a':
	 imenu = 'a'; tempfloat = ilvl1;break;       
       case 'b':       
	 imenu = 'b';tempfloat = ilvl2;break;       
       case 'c':       
 	 imenu = 'c';tempfloat = ilvl3;break;       
       case 'd':       
	 imenu = 'd';tempfloat = ilvl4;break;       
       case 'e':       
	 imenu = 'e';tempfloat = itime1;break;       
       case 'f':       
	 imenu = 'f';tempfloat = itime2;break;
       case 'g':       
	 imenu = 'g';tempfloat = itime3;break;
       case 'h':       
	 imenu = 'h';tempfloat = itime4;break;
       case 'r':
         imenu = 'r';tempfloat = resonance;
       case '-' : 
           tempfloat = tempfloat -0.01;
           if(tempfloat<0.0) tempfloat = 0.0;
           irenew(imenu, tempfloat);
           break;
       case '+':
           tempfloat = tempfloat + 0.01;
	 if(tempfloat>1.0) tempfloat = 1.0;
         irenew(imenu, tempfloat);  /* assign tempfloat to 
                                      corresponding parameter */ 
         break; 
       case 'x':
         leave =1;
         HideWindow(filtwindow);
         break;  
        }; /*switch */     
     }/*switch*/
   }/*if*/
 }/*while */
}

/*-------------------------------------------------------------------*/
/*    irenew updates values of parameters, calls iwrite()            */


void irenew(char menu, float tmpfloat)
{

  switch(menu){
   case 'a':
      ilvl1 = tmpfloat;break;
   case 'b':
      ilvl2 = tmpfloat;break;
   case 'c':
      ilvl3 = tmpfloat;break;  
   case 'd':
      ilvl4 = tmpfloat;break;  
   case 'e':
      itime1 = tmpfloat; 
      if (itime1>itime2) itime1= itime2;
      break;
   case 'f':
      itime2 = tmpfloat;
      if(itime2<itime1) itime2=itime1;
      if(itime2>itime3) itime2=itime3;
      break;   
   case 'g':
      itime3 = tmpfloat;
      if(itime3<itime2) itime3= itime2;
      if(itime3>itime4) itime3=itime4;
      break;  
   case 'h':
      itime4 = tmpfloat;
      if(itime4<itime3) itime4=atime3;
      break;
   case 'r':
      resonance = tmpfloat;break;
      
      
   }/*switch*/
  
   iwrite();
  
}


/*-------------------------------------------------------------*/

/*    iwrite writes values of filter parameters to screen   */


void iwrite()
{
 char str[12];

 ClearArea(filtwindow,0,0, 355,355);

 drawenv(ieg, ilvl0, ilvl1,ilvl2, ilvl3,ilvl4, itime1,itime2,
        itime3,itime4);


 sprintf(str,"%4.2f", ilvl1);
  WDrawString(ivalues,0.0, 0.6, str, 1); 
 sprintf(str,"%4.2f", ilvl2);
  WDrawString(ivalues,0.0, 1.6, str, 1); 
 sprintf(str,"%4.2f", ilvl3);
  WDrawString(ivalues,0.0, 2.6, str, 1);
 sprintf(str,"%4.2f", ilvl4);
  WDrawString(ivalues,0.0, 3.6, str, 1);
 sprintf(str,"%4.2f", itime1);
  WDrawString(ivalues,0.0, 4.6, str, 1);
 sprintf(str,"%4.2f", itime2);
  WDrawString(ivalues,0.0, 5.6, str, 1);
 sprintf(str,"%4.2f", itime3);
  WDrawString(ivalues,0.0, 6.6, str, 1);
 sprintf(str,"%4.2f", itime4);
  WDrawString(ivalues,0.0, 7.6, str, 1);
 sprintf(str,"%4.2f", resonance);
  WDrawString(ivalues,0.0, 8.6, str, 1);
 
}/* end of iwrite */


/*---------------------------------------------------------------*/

/*  drawenv - draws envelope with given parameters               */ 
 
void drawenv(World w,float lvl0, float lvl1, float lvl2, float lvl3, 
float lvl4, float tm1, float tm2, float tm3, float tm4)
{
 WDrawRectangle(w, 0,0,1,1,1);

 WDrawLine(w,0, lvl0, tm1, lvl1,2);
 WDrawLine(w,tm1, lvl1, tm2, lvl2,2);
 WDrawLine(w,tm2, lvl2, tm3, lvl3,2);
 WDrawLine(w,tm3, lvl3, tm4, lvl4,2);
 WDrawLine(w,tm4,lvl4,1,lvl4,2);}