#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <unistd.h>
/******************************/
#include "global.h"
#include "config.h"
#include "mpeg2dec.h"
#include "common.h"

void resizefunc(int width,int height)
{

/****************    VARIABLE DECLEARATION ***********************************************************/
	int  i,j,a,b,q,r,c,d,c1,d1,x,y;
	int  hr_st_integer,hr_end_integer,vr_st_integer,vr_end_integer;
	int vr_start,vr_end,hr_start,hr_end;      /*intermediate indexes*/
	//int res_width,res_height;
	int x1,y1,x2,y2,x3,y3,x4,y4,type;
        float sum2;
	float  current_hor_total,hr_st_decimal,hr_end_decimal;
	float  current_ver_total,vr_st_decimal,vr_end_decimal;
	float tmp,avg;
	float curwindow[10][10],curwindow1[10][10];
	//float sum[100][100];
        float rwmbno;
	float rhmbno;

	FILE  *f1;
/****************  VARIABLE DECLEARATION END ***********************************************************/
/**************** Calculation of rescaled height and width  ***********************************************************/

	/*if((f1=fopen("/home/usr/dpatel/mar19/1/xdec/inputdata.txt","r"))==NULL)
      	  		printf("file inputdata.txt does not open\n");

	   		fscanf(f1,"%f\t%f\n",&hor_factor,&ver_factor);
      			printf("%f %f\n",hor_factor,ver_factor);
      		fclose(f1);*/

	/*res_width = (int) (width/hor_factor);
	res_height = (int)(height/ver_factor);

	if(res_width%2 != 0)				//making sure that rescaled height&width are even integers
	res_width = res_width - 1;

	if(res_height%2 != 0)
	res_height = res_height - 1;*/




	if(resecho){
        //printf("res_width=%d res_height=%d\n",res_width,res_height);
	  printf("width=%d height=%d\n",width,height);
	getchar();}
/****************  Calculation of rescaled height and width ENDS  ***********************************************************/

/****************  Setting type values to 1or 2 according to the orig_height and width  ***********************************************************/



/****************  Setting type values to 1or 2 according to the orig_height and width ENDS  **********************************************/

 /****************  Initialising the buffers used and the variables used  ***********************************************************/







 //Initialisation of the convertvalue matrix
 	for(x1 = 0; x1<1000;x1++)
        for(y1 = 0; y1<1000;y1++)
	 	{

		  convertvalues[x1][y1] = 0;

	 	}

 /*initialisation of first window
	for(x2 = 0; x2<10;x2++)
 	for(y2 = 0; y2<10;y2++)
		{

		  curwindow[x2][y2] = 0;

		}*/


//initialisation of second window
	for(x3 = 0; x3<10;x3++)
 	for(y3 = 0; y3<10;y3++)
		 {

		  curwindow1[x3][y3] = 0;

		 }




/****************   Initialising the buffers used and the variables used ENDS  ***********************************************************/

/***************** Calculation beigns  **************************************************************************************************/

//	fprintf(convalfd,"the y comp-begins\n");	
	for(a = 0;a<height;a++)
	for(b = 0;b<width;b++)
	{	
	
			q = a + 1;
	        	r = b + 1;
			
	current_hor_total = 0;
        current_ver_total = 0;		

	//initialisation of first window
	for(x2 = 0; x2<10;x2++)
 	for(y2 = 0; y2<10;y2++)
		{

		  curwindow[x2][y2] = 0;

		}



/***************** Calculation for determining the size of the window *****************************************************************************/
        current_hor_total = hor_factor * r;
        current_ver_total = ver_factor * q;
if(ECHO_RESIZE){
	printf("current_hor_total=%f\n",current_hor_total);
	printf("current_ver_total=%f\n",current_ver_total);
	getchar();}

	if(resecho){
	printf("h_total=%f v_total=%f\n",current_hor_total,current_ver_total);
		getchar();}


        hr_end_decimal = 	current_hor_total - (floor(current_hor_total))	;
        hr_end_integer =  	(int)(current_hor_total) ;
        hr_st_decimal  =  	(current_hor_total - hor_factor) - floor(current_hor_total - hor_factor);
	hr_st_integer  = 	(int)(current_hor_total - hor_factor);

	vr_end_decimal = 	current_ver_total - (floor(current_ver_total));
	vr_end_integer = 	(int)(current_ver_total);
	vr_st_decimal  =  	(current_ver_total - ver_factor) - floor(current_ver_total - ver_factor);
	vr_st_integer  =  	(int)(floor(current_ver_total - ver_factor));

	if(resecho){
	printf("hr_st_integer=%d\thr_st_decimal=%f\thr_end_integer=%d\thr_end_decimal=%f\n",hr_st_integer,hr_st_decimal,hr_end_integer,hr_end_decimal);
	printf("vr_st_integer=%d\tvr_st_decimal=%f\tvr_end_integer=%d\tvr_end_decimal=%f\n",vr_st_integer,vr_st_decimal,vr_end_integer,vr_end_decimal);
	getchar();}

        c=0;
	d=0;

	c1=0;
	d1=0;


	
	vr_start = vr_st_integer + 1;
	if(vr_end_decimal != 0.0)
	vr_end = vr_end_integer+1;
	else
	vr_end = vr_end_integer;
	
	if((hr_st_integer != 0) && (hr_st_decimal) < 0.0 )
	hr_start = hr_st_integer+2;
	else
	hr_start = hr_st_integer+1;
	
	if(hr_end_decimal == 0.0)
	hr_end = hr_end_integer;
	else
	hr_end = hr_end_integer + 1;
	
	if(resecho){
	printf("vr_start=%d\tvr_end=%d\thr_start=%d\thr_end=%d\n",vr_start,vr_end,hr_start,hr_end);
		getchar();}
		
/***************** Calculation for determining the size of the  ENDS **************************************************************************************************/		
	
	
/***************** Selecting the macroblocks of the window from the original array into window buffer **************************************************************************************************/		
	
		for(x=vr_start;x<=vr_end;x++)
		{
		for(y=hr_start;y<=hr_end;y++)
			{
			curwindow[c][d] = (float)pixelvalues[x-1][y-1];
			d++;
			}
			c1 = c;
			d1 = d - 1;
			d=0;
			c++;
	
		}
		
		if(resecho){
		printf("c1=%d d1=%d\n",c1,d1);
		
		printf("WINDOW before HORIZONTAL scanning\n");
		for( i=0;i<=c1;i++)
		{	for( j=0;j<=d1;j++)
				{
				  printf("%f ",curwindow[i][j]);
			}
			printf("\n");
		}
		
			getchar();}
		
		
		/*for(i=60;i<92;i++){
 		for(j=176;j<208;j++){
 			printf("%d ",pixelvalues[i][j]);
 			}
 		printf("\n");
 		}
		
		printf("b=%d\n",b);
		for(i=0;i<2;i++){
	 		for(j=0;j<2;j++){
 			printf("%f ",curwindow[i][j]);
 			}
 		printf("\n");
 		}
		
                getchar();*/
              
/***************** Selecting the macroblocks of the window from the original array into window buffer **************************************************************************************************/			
	
/***************** Horizontal scanning begins here **************************************************************************************************/			
	/* HORIZONTAL SCANNING*/
	
	tmp = 0;
	avg = 0.0;
	
	if(resecho){
	printf("avg at point 1=%f\n",avg);
	getchar();}
        i=0;
	j=0;
	
        for( i=0;i<=c1;i++)
	{
		for( j=0;j<=d1;j++)
		{
	      
	 
	  		if(j==0 )
	  		{
	  		curwindow1[i][j]  = (1.0 - hr_st_decimal) * curwindow[i][j];
	  		avg = avg + (1.0 - hr_st_decimal);
	  		}
	   
	  
	  		if(j==d1 && d1!=0)
	  		{
			   if(hr_end_decimal == 0.0 )
	   			{
				   curwindow1[i][j] = curwindow[i][j];
				   avg = avg + 1;
	   			}
	   			else
	   			{
				   curwindow1[i][j] = hr_end_decimal*curwindow[i][j];
				   avg = avg + hr_end_decimal;
	   			}
	  		}
	  
	   
		   if(j != 0 && j != d1)
		   {
	   		   curwindow1[i][j]   = curwindow[i][j];
			   avg = avg + 1.0;
	   	   }
	   
	         
	  	}
		  
	}//for loop for horizontal scanning ends here
	
	
	if(resecho){
	printf("avg at point 2=%f\n",avg);
	printf("WINDOW after HORIZONTAL scanning\n");
	for( i=0;i<=c1;i++)
		{	for( j=0;j<=d1;j++)
				{
				  printf("%f ",curwindow1[i][j]);
			}
			printf("\n");
	}
		getchar();}
	
	
/***************** Horizontal scanning ends here **************************************************************************************************/				

/***************** Vertical scanning begins here **************************************************************************************************/		
	 /* VERTICAL SCANNING*/	  
	 
	
	  i=0;
	  j=0;
	  
	  for( i=0; i<=c1;i++)
	  for(	 j=0; j<=d1;j++)
	  {
	  
/***************** If there is a start Vertical non-alignment **************************************************************************************************/				  
		  if(vr_st_decimal != 0.0 && i==0 )				
	  	  {
	  
	  
	  		if(j==0)
	 		{
			  if( hr_st_decimal != 0.0 )					/*and also horizontal non_alignment*/
	  			{
	  				avg = avg - (1.0 - hr_st_decimal);	  
					curwindow1[i][j] =  (1.0 - vr_st_decimal)*curwindow1[i][j];     /* only multiply the vertical component since horizontal is already done before*/
				        avg = avg + ((1.0 -hr_st_decimal)*(1.0-vr_st_decimal));
	  			}
	  			else
	  			{
			                avg = avg - 1;
				        curwindow1[i][j] = (1 - vr_st_decimal) * curwindow1[i][j];    /*horizontally aligned but vertical start non_aligned*/
				        avg = avg + (1 - vr_st_decimal);
	  			}
	  		}
	  
	  		if(j==d1)
	  		{
			  if( hr_end_decimal != 0.0 )                                  /*  horizontally non_alined at end */
			  {	
				  avg = avg - hr_end_decimal;
				  curwindow1[i][j] = (1-vr_st_decimal) * curwindow1[i][j];
				  avg = avg + ((1-vr_st_decimal)*hr_end_decimal);
	  		  }
			  else								/* horizontally aligned at the end */
	  		  {
				  avg = avg - 1;
			          curwindow1[i][j] = (1 - vr_st_decimal) * curwindow1[i][j];
			          avg = avg + (1 - vr_st_decimal);
	  		  }
	  	       }
		       
	  		if(j!=0 && j!=d1)
			{
			   avg = avg - 1;
			   curwindow1[i][j] = (1 - vr_st_decimal) * curwindow1[i][j];
			   avg = avg + (1 - vr_st_decimal);
	  
	 		}
		    }	
		    else								/* else just copy the block as it is after horizontal scanning */			
		    {
	  
	  		   curwindow1[i][j] = curwindow1[i][j];
	  	    }
/***************** If there is a start Vertical non-alignment ENDS **************************************************************************************************/				  	  
	  if(resecho){
	  printf("avg at point 3=%f\n",avg);
	  getchar(); }
/***************** If there is a end Vertical non-alignment **************************************************************************************************/				  
	  if(vr_end_decimal != 0.0 && i==c1)				
	  {
	  	if(j==0)
	  	{
	  		if( hr_st_decimal != 0.0)
	  		{
	  			avg = avg - (1.0 - hr_st_decimal);	  
	  			curwindow1[i][j] =  (vr_end_decimal)*curwindow1[i][j];
	  			avg = avg + ((1.0 - hr_st_decimal)*(vr_end_decimal));
	  		}
	  		else
	 	 	{
	  			avg = avg - 1;
	  			curwindow1[i][j] = ( vr_end_decimal) * curwindow1[i][j];
	  			avg = avg + vr_end_decimal;
	  	 	}
	  
	  	}
	  
	  	if(j==d1)
	 	 {
	  		if( hr_end_decimal != 0.0)
	  		{
	  			avg = avg - hr_end_decimal;
	    			curwindow1[i][j] = vr_end_decimal * curwindow1[i][j];
	  	        	avg = avg + (vr_end_decimal*hr_end_decimal);
	  		}
	  		else
	  		{
	  			avg = avg - 1.0;
	   			curwindow1[i][j] = ( vr_end_decimal) * curwindow[i][j];
	   			avg = avg + vr_end_decimal;
	  		}
	  	}	
	  
	  	if(j!=0 && j!=d1)
	  	{
	  		avg = avg - 1.0;
	   		curwindow1[i][j] = ( vr_end_decimal) * curwindow[i][j];
	   		avg = avg + vr_end_decimal;
	   	}
	  }
	  else
	  {
	  curwindow1[i][j] = curwindow1[i][j];
	  }
	  
	  }//for loop for vertical scanning ends here
	 
/***************** Vertical scanning ends here **************************************************************************************************/			  
 	if(resecho){
	 printf("avg at point 4=%f\n",avg);
  	printf("WINDOW after VERTICAL scanning\n");
	for( i=0;i<=c1;i++)
		{	for( j=0;j<=d1;j++)
				{
				  printf("%f ",curwindow1[i][j]);
			}
			printf("\n");
	}
		getchar();}
 
 
/***************** Summing up the selected values  **************************************************************************************************/			 
	  i=0;
	  j=0;
	  
	  /*for(x4 = 0; x4<100;x4++)
	         for(y4 = 0; y4<100;y4++) 
		 {
 
		  sum[x4][y4] = 0;
 
		 }*/
	  sum2=0.0;
	  for( i=0; i<=c1;i++)
	    for( j=0; j<=d1;j++)
	  {
	   sum2 += curwindow1[i][j];
	   
	   	  } 
	  
/***************** Summing up the selected values ends here **************************************************************************************************/			   
	  
/***************** Averaging the values  **************************************************************************************************/			 	  
	 
	  convertvalues[a][b] = (int)((sum2/avg)+0.5);
	    //convertvalues[a][b] = (sum[a][b]/4);
/***************** Averaging the values ENDS **************************************************************************************************/
         if(resecho){
	 printf("sum2=%f  avg=%f\n",sum2,avg);			 	  	  
         printf("convertvalues=%d\n",convertvalues[a][b]);
         getchar();}	
//	  fprintf(convalfd,"the value of convertvalues[%d][%d]=%d\n",a,b,convertvalues[a][b]);
	  
	}
	
	
	
	
	/*for(i=0;i<16;i++){
 		for(j=0;j<16;j++){
 			printf("%d ",pixelvalues[i][j]);
 		}
 		printf("\n");
 	}
	        
 
	printf("converted values are\n");
        
	for(i=0;i<8;i++){
 		for(j=0;j<8;j++){
 			printf("%d ",convertvalues[i][j]);
 		}
 		printf("\n");
 	}
         
	// getchar();*/
	    if (ECHO_RESIZE){
	    printf("\tOUT of resize.c\n");
	    }
        
}	
/***************** Averaging the values ends  **************************************************************************************************/