#include <stdio.h>

#define MEGS_PER_FILE 18
#define IMGS_PER_TOT  2 
#define FILTER_LEVEL  4
#define LOVE          244
#define HATE          245
#define FLT           246
#define CHUNK_SIZE    256

__inline__ unsigned long long rdtsc()
{
   unsigned long long int x;
   __asm__ volatile(".byte 0x0f, 0x31" : "=A" (x));
   return x;
}


int main(int argc, char **argv)
{
   FILE *file;
   char *imgA, *filter_im1A, *filter_im2A, *edgey_imA, *edgex_imA;
   char *imgB, *filter_im1B, *filter_im2B, *edgey_imB, *edgex_imB;
   char *tot_im, *tmp_ptr, hom;
   int cnt = 0, i, j, tot_img_size, chunk_size, mem_size, pg_size = 4096;
   unsigned long long int start_time, stop_time;
   unsigned long int mjr_flt;   
   if( argc != 3 )
   {
      fprintf( stderr, "There were %d filenames\n", argc);
      fprintf( stderr, "Usage: main <filename1> <filename2>\n");
      return -1;
   }
   mjr_flt = syscall(FLT);   
   //The amount of image data that 
   mem_size = 1024*1024*MEGS_PER_FILE;
   tot_img_size = IMGS_PER_TOT * mem_size;
   chunk_size = CHUNK_SIZE * pg_size;
   //get the start time 
  // start_time = rdtsc();
   //Create the total image
   if( !(tot_im = (char*)malloc(tot_img_size)) ) return -5;
   cnt = 10;
   for( i = 10; i < tot_img_size; i+=100 )
      *(tot_im + cnt) = 35;
   j = 200;
   for( i = 0; i < tot_img_size; i+=chunk_size )
   {
      syscall( LOVE, (tot_im+i), chunk_size, j);
      j-=2;
   }   
   ////////////Open img A and read it in/////////////////
   cnt = 0;
   if( !(file = fopen( argv[1], "r" ))) return -6;
   if( !(imgA = (char*)malloc(mem_size)) ) return -5;
   do{
      *(imgA + cnt++) = getc(file);
   } while ( cnt < mem_size &&  *(imgA+cnt) != EOF);
   fclose(file);

   //filter image
   if( !(filter_im1A= (char*)malloc(mem_size)) ) return -1;
   if( !(filter_im2A= (char*)malloc(mem_size)) ) return -1;
   for( i = 0; i < mem_size; i++)
      *(filter_im1A+i) = *(imgA+i);
   syscall( HATE, imgA, mem_size);   
   
   for( j = 0; j < FILTER_LEVEL; j++)
   {
      for( i = 0; i < mem_size; i++)
         *(filter_im2A+i) = *(filter_im2A+i);
      tmp_ptr = filter_im1A;
      filter_im1A = filter_im2A;
      filter_im2A = tmp_ptr;
   }
   syscall( HATE, filter_im2A, mem_size);   
   syscall( LOVE, filter_im1A, mem_size/2, 150);   
   //make the edgex image 
   if( !(edgex_imA = (char*)malloc(mem_size)) ) return -3;
   for( i = 0; i < mem_size; i++)
      *(edgex_imA+i) = *(filter_im1A+i);
    
   //make the edgey image 
   if( !(edgey_imA = (char*)malloc(mem_size)) ) return -3;
   for( i = 0; i < mem_size; i++)
      *(edgey_imA+i) = *(filter_im1A+i);
   
   for( i = 0; i < mem_size; i++)
      hom = *(edgey_imA+i) + *(edgex_imA+i);
   syscall( HATE, edgey_imA, mem_size);   
   syscall( HATE, edgex_imA, mem_size);   
   free( filter_im2A );
   free( imgA );
  ////////////// Found the image 1 courners\features ///////////////////
   
   //Open img 2 and read it in
   cnt = 0;
   if( !(file = fopen( argv[2], "r" ))) return -6;
   if( !(imgB = (char*)malloc(mem_size)) ) return -5;
   do{
      *(imgB + cnt++) = getc(file);
   } while ( cnt < mem_size &&  *(imgB+cnt) != EOF);
   fclose(file);

   //filter image
   if( !(filter_im1B = (char*)malloc(mem_size)) ) return -1;
   if( !(filter_im2B = (char*)malloc(mem_size)) ) return -1;
   for( i = 0; i < mem_size; i++)
      *(filter_im1B+i) = *(imgB+i);
   syscall( HATE, imgB, mem_size);   
   
   for( j = 0; j < FILTER_LEVEL; j++)
   {
      for( i = 0; i < mem_size; i++)
         *(filter_im2B+i) = *(filter_im1B+i);
      tmp_ptr = filter_im1B;
      filter_im1B = filter_im2B;
      filter_im2B = tmp_ptr;
   }
   syscall( HATE, filter_im2B, mem_size);   
   syscall( LOVE, filter_im1B, mem_size/2, 150);   
  
   //make the edgex image 
   if( !(edgex_imB = (char*)malloc(mem_size)) ) return -3;
   for( i = 0; i < mem_size; i++)
      *(edgex_imB+i) = *(filter_im1B+i);
    
   //make the edgey image 
   if( !(edgey_imB = (char*)malloc(mem_size)) ) return -3;
   for( i = 0; i < mem_size; i++)
      *(edgey_imB+i) = *(filter_im1B+i);
   
   for( i = 0; i < mem_size; i++)
      hom = *(edgey_imB+i) + *(edgex_imB+i);
   syscall( HATE, edgey_imB, mem_size);   
   syscall( HATE, edgex_imB, mem_size);   

   free( imgB );
   free(filter_im2B);
//////////////End of the b image /////////////////////////
   
   //copy the results into the tot img
   for( i = 0; i < mem_size; i++)
      *(tot_im + IMGS_PER_TOT*i) = *(filter_im1B+i) + *(filter_im1A+i); 
   start_time = rdtsc();
   *(tot_im) = 59;
   stop_time = rdtsc();

   fprintf( stdout, "The program took: %llu\n", stop_time-start_time);
   mjr_flt = syscall(FLT) - mjr_flt;   
   fprintf( stdout, "The program generated %lu major faults\n", mjr_flt);
   free(edgey_imA);
   free(edgex_imA);
   free(edgex_imB);
   free(edgey_imB);
   free( tot_im );
   free(filter_im1A);
   free(filter_im1B);
   return 1;
}