#include <stdio.h> 
#include <ctype.h>
#include <stdlib.h> 
#include <math.h>
#include <fcntl.h>
 
#define SRATE 16000
#undef TEXT 
#define BINARY 


typedef struct _DelayLine
{
        short   *data;
        int     length;
        short   *pointer;
        short   *end;
      
} DelayLine;
 

 
/* Delay line init routine */
static DelayLine *initDelayLine(int len)
{
        DelayLine *dl = (DelayLine *)malloc(sizeof(DelayLine));
        dl->length = len;
        if (len > 0)
                dl->data = (short *)malloc(len * sizeof(short));
        else
                dl->data = 0;
        dl->pointer = dl->data;
        dl->end = dl->data+len-1;
        
        return dl;
}
 
 
/* Frees memory associated with a delay line */
static void freeDelayLine(DelayLine *dl)
{
        if (dl && dl->data)
                free(dl->data);
        dl->data = 0;
        free(dl);
 
}
 
 
 
/* Initialize delayline contents */
inline static void setDelayLine (DelayLine *dl, double *values, double scale)
{
        int i;
        for (i = 0; i < dl->length; i++)
                dl->data[i] = (short)(32768.0 * scale * values[i]);
}
 
 
/* update the delay lines */
inline static short dl_update(DelayLine *dl, short insamp)
{
        short *ptr = dl->pointer;
        short outsamp = *ptr;
        *ptr++ = insamp;
        if (ptr > dl->end)
                ptr = dl->data;
        dl->pointer = ptr;
 
        return outsamp;
}
 
 
/* get the value of a sample at a certain offset */
static inline short dl_access(DelayLine *dl, int position)
{
        short *outloc = dl->pointer - position;
        while (outloc < dl->data)
                outloc += dl->length;
        while (outloc > dl->end)
                outloc -= dl->length;
 
        return *outloc;
}
 
 
/* allocate global dl's for a waveguide */
static DelayLine *upper_rail,
                 *lower_rail;
 
 
/* reverse elements of an array */
static inline void flipArray(double *a, int n)
{
        int     i, 
                j, 
                nh = n/2;
        double  temp;
 
        for (i = 0; i < nh; i++)
        {
                j = n - i - 1;
                temp = a[i];
                a[i] = a[j];
                a[j] = temp;
        }
}

int max(int a, int b)
{
	if (a<b)
		return b;
	else
		return a;
}
 
/* initialize a pluck... */
static inline int initString(double amplitude, int pitch, double pick, double pickup)
{
        int i;
        int    rail_length = SRATE / pitch / 2;
        int    pickPoint = max(rail_length * pick, 1);
        double upslope = amplitude / pickPoint;
        double downslope = amplitude / (rail_length - pickPoint - 1);
        double initial_shape[rail_length];
 
        upper_rail = initDelayLine(rail_length);
        lower_rail = initDelayLine(rail_length);
 
        for (i=0; i<pickPoint; i++)
                initial_shape[i] = upslope * i;
        for (i=pickPoint; i<rail_length; i++) 
                initial_shape[i] = downslope * (rail_length-1-i);
 
        setDelayLine(lower_rail, initial_shape, 0.5);
        flipArray(initial_shape, rail_length);
        setDelayLine(upper_rail, initial_shape, 0.5);
 
        return (pickup * rail_length);
}
 
 
/* free the two delay lines for the string */
static inline void freeString(void)
{
        freeDelayLine(upper_rail);
        freeDelayLine(lower_rail);
}
 
 
/* Implement a filter at the reflecting point */
static inline short bridgeReflection(int insamp)
{
  static short state1 = 0,
               state2 = 0,
               state3 = 0,
               temp;
      
  temp = (insamp >> 1) + (state1 >> 2) + (state2 >> 2);
  state2 = state1;
  state1 = insamp;
  return(temp);

}
 
/* return the next output sample from the simulator at a given picup
   location */
 
static inline short nextSample (int pickup_loc)
{
        short yp0, ym0, ypM, ymM;
        short outsamp;
 
        outsamp = dl_access(upper_rail, pickup_loc);
        outsamp += dl_access(lower_rail, -pickup_loc);
 
        ym0 = dl_access(lower_rail, 0);
 
        ypM = dl_access(upper_rail, upper_rail->length-1);
 
        ymM = -ypM;
 
        yp0 = -bridgeReflection(ym0);
 
        dl_update(upper_rail, yp0);
        dl_update(lower_rail, ymM);
 
        return outsamp;
}
 
 
/* Here's the output part... */
writeSound(char *name, short *soundData, int sampleCount)
{
        int    i, err;
	FILE   *filedesc, *tmp;

	
#ifdef BINARY	
	filedesc = fopen(name, "w");
	fwrite(soundData,sizeof(short),sampleCount,filedesc);
#endif
#ifdef TEXT
	tmp = fopen("tmp.dat","w");
	for(i=0;i<sampleCount;i++) fprintf(tmp,"%d\t%d\n",i,soundData[i]);
#endif
}
 
static void writeString(void)
{
        int i;
        int sampleCount = upper_rail->length;
        short data[sampleCount];
 
        for (i=0; i<sampleCount; i++)
                data[i] = dl_access(upper_rail, i);
        writeSound("upper.raw",data,sampleCount);
 
        for (i=0; i<sampleCount; i++)
                data[i] = dl_access(lower_rail, i);
        writeSound("lower.raw",data,sampleCount);
 
        for (i=0; i<sampleCount; i++)
                data[i] = dl_access(upper_rail, i) + dl_access(lower_rail, -i);
        writeSound("string.raw",data,sampleCount);
}


int nametofreq(char note, char string, char accidental)
{

        /* integral frequency values for the notes on a string */
        /* the G */
	int Gnaturals[7] = {196,220,247,262,294,330,349};
	int Gsharps[7] = {208,233,262,277,311,349,370};
	int Gflats[7] = {370,208,233,247,277,311,330};
	/* the D */
	int Dnaturals[7] = {294,330,349,392,440,494,523};
	int Dsharps[7] = {311,349,370,415,466,523,554};
	int Dflats[7] = {554,311,330,370,415,466,494};
        /* the A */
	int Anaturals[7] = {440,494,523,587,659,699,784};
	int Asharps[7] = {466,523,554,622,699,740,831};
	int Aflats[7] = {831,466,494,554,622,659,740};
	/* the E */
        int Enaturals[7] = {659,699,784,880,988,1047,1175};
	int Esharps[7] = {699,740,831,932,1047,1109,1245};
	int Eflats[7] = {1245,659,740,831,932,988,1109};

	if (string > note) note += 7;
	
        if (string == 'G')
	{
	  if (accidental == 'F') return(*(Gflats + (note - string)));
	  if (accidental == 'N') return(*(Gnaturals + (note - string)));
	  if (accidental == 'S') return(*(Gsharps +  (note - string)));
	}
	if (string == 'D')
	{
	  if (accidental == 'F') return(*(Dflats +  (note - string)));
	  if (accidental == 'N') return(*(Dnaturals +  (note - string)));
	  if (accidental == 'S') return(*(Dsharps +  (note - string)));
	}
	if (string == 'A')
	{
	  if (accidental == 'F') return(*(Aflats +  (note - string)));
	  if (accidental == 'N') return(*(Anaturals +  (note - string)));
	  if (accidental == 'S') return(*(Asharps +  (note - string)));
	}
	if (string == 'E')
	{
	  if (accidental == 'F') return(*(Eflats +  (note - string)));
	  if (accidental == 'N') return(*(Enaturals +  (note - string)));
	  if (accidental == 'S') return(*(Esharps +  (note - string)));
	}

}
 
 
 
/* main */
 
void main (int argc, char *argv[])
{
        int i, sampleCount, pitch;
	int frequency;
        short *data;
        double amp, duration;
        double pick, pickup, writesample;
        int pickupSample;
	char note;
	char string;
	char accident;
	int instrument;
	char *outfile;

        if (argc != 6)
        {
                fprintf(stderr, "Usage: nbn <note> <F,N,S> <G,D,A,E> <model> <output file>\n");
                exit(1);
        } 
        note = *argv[1];
        accident = *argv[2];  
        string = *argv[3];
        instrument= *argv[4];
        outfile = argv[5];
	
	duration = 5;
        sampleCount = duration * SRATE;
        data = (short *)malloc(sampleCount * sizeof(short));
	frequency = nametofreq(note,string,accident);
        pickupSample = initString(.1, frequency, .1, .1);
        for (i=0; i<sampleCount; i++)
        {
                
	  data[i] = nextSample(pickupSample);
        }
        writeSound(outfile,data,sampleCount);
        freeString();
        exit(0);
}