#include <stdio.h>

 #include <assert.h>

 #include <string.h>

 #include <sndfile.h>

 #include <stdlib.h>

 

 // foreward declaration. This is defined in DFT.cpp

 int DFT(int dir,int m,double *x1,double *y1);

 const int Points = 32;

 const int Window = 32;

 

 void BubbleSort(double* arr, int* idxs)

 {

   int i, j, flag = 1;

   double temp;

   int tmp1;

   for(i = 1; (i <= Points) && flag; i++)

     {

       flag = 0;

       for (j=0; j < (Points -1); j++)

 	{

 	  if (arr[j+1] > arr[j])

 	    { 

 	      temp = arr[j];    

 	      tmp1 = idxs[j];

 	      arr[j] = arr[j+1];

 	      idxs[j] = idxs[j+1];

 	      arr[j+1] = temp;

 	      idxs[j+1] = tmp1;

 	      flag = 1;

 	    }

 	}

     }

 }

 

 int

 do_check (int drop, int argc, char * argv [])

 {

   int margin_of_error;

   SNDFILE* goldenWavFile;

   SNDFILE* outputWavFile;

   SF_INFO goldenInfo ;

   SF_INFO outputInfo ;

   short int buffA[Points];

   short int buffB[Points];

   double drA[Window][Points];

   double drB[Window][Points];

   double diA[Points];

   double diB[Points];

 

   memset (&goldenInfo, 0, sizeof (goldenInfo)) ;

   memset (&outputInfo, 0, sizeof (outputInfo)) ;

 

   margin_of_error = atoi(argv[1]);

 

   printf("Checking for Margin of Error %d\n", margin_of_error);

 

   goldenWavFile = sf_open(argv[2], SFM_READ, &goldenInfo);

   if (goldenWavFile == NULL){      

     printf ("\nERROR : failed Not able to open wav file named '%s' : %s/\n", argv[2], sf_strerror (NULL)) ;

     exit (1) ;

   }

 

   outputWavFile = sf_open(argv[3], SFM_READ, &outputInfo);

   if (outputWavFile == NULL){      

     printf ("\nERROR : failed Not able to open wav file named '%s' : %s/\n", argv[3], sf_strerror (NULL)) ;

     exit (1) ;

   }

  

   int max_diff = 0;

 

   // it is possible that the modified pipeline might introduce a few

   // dummy tokens at the beginning of the stream, we'll just drop them

   for(int i = 0; i < drop; i++){

     sf_read_short(outputWavFile, buffB, 1);

   }

 

   int count=0;

 

   while(sf_read_short(goldenWavFile, buffA, Points)==Points){

 

     if(sf_read_short(outputWavFile, buffB, Points) != Points){

       // the streams are of different length

       printf("failed (length)\n");

       exit(0);

     }

 

     int wptr = count%Window;

     

     for(int i = 0; i < Points; i++){

       diA[i] = 0.0;

       diB[i] = 0.0;

       drA[wptr][i] = (double)buffA[i];

       drB[wptr][i] = (double)buffB[i];

     }

 

     DFT(1,Points,drA[wptr],diA);

     DFT(1,Points,drB[wptr],diB);

 

     //for(int i = 0; i < Points; i++)

     //  printf("%10d  %10d\n", (int)drA[wptr][i], (int)drB[wptr][i]);

     //printf("\n");

 

     if (count >= Window){

       double avgA[Points];

       double avgB[Points];

       

       // reset averages to zero

       for(int i = 0; i < Points; i++){

 	avgA[i] = 0.0;

 	avgB[i] = 0.0;

       }

 

       // compute the averages in each bin

       for(int i = 0; i <  Window; i++){

 	for(int j = 0; j < Points; j++){

 	  avgA[j] += drA[i][j];

 	  avgB[j] += drB[i][j];

 	}

       }	

 

       for(int i = 0; i < Points; i++){

 	avgA[i] /= Window;

 	avgB[i] /= Window;

       }

 

 

       // this sucks, as we really should be averaging, but i'm lazy

 

       //int idxsA[Points];

       //int idxsB[Points];

 

       //for(int i = 0; i < Points; i++){

       //idxsA[i] = i;

       //idxsB[i] = i;

       //}

 

       //BubbleSort(avgA, idxsA);

       //BubbleSort(avgB, idxsB);

 

       //for(int i = 0; i < 2; i++){

       //int td =  (idxsA[i] > idxsB[i]) ? (idxsA[i] - idxsB[i]) : (idxsB[i] - idxsA[i]);

       //max_diff = (td > max_diff) ? td : max_diff;

       //}

       

 

       int scoreA = 0;

       int scoreB = 0;

       int threshold = 100;

 

       // this is brittle, but it works **for now**

       for(int i = 0; i < Points; i++){

 	if(abs((int)avgA[i]) > threshold)

 	  scoreA++;

 	if(abs((int)avgB[i]) > threshold)

 	  scoreB++;

       }

 

       printf("scoreA %d   scoreB %d\n", scoreA, scoreB);

 

       int td = (scoreA > scoreB) ? (scoreA - scoreB) : (scoreB - scoreA);

       max_diff = (td > max_diff) ? td : max_diff;      

 

       if(max_diff > margin_of_error){

 	printf("max_diff %x on drop %d (count %d)\n", max_diff, drop,count);

 	return 1;

       }

 

     }

 

     count++;

   }

 

   printf("max_diff %d on drop %d\n", max_diff, drop);

 

   if(((int)max_diff) > margin_of_error)

     return 1;

   else

     return 0;

 }

 

 int

 main(int argc, char* argv[])

 {

   for(int drop = 0; drop < 10; drop++){

     if(do_check(drop, argc, argv)==0){

       printf("passed on drop %d\n", drop);

       exit(0);

     }

   }

   printf("failed\n");

   exit(1);

 }