#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 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 rwmbno;
	float rhmbno;
	
	FILE  *f1;
/****************  VARIABLE DECLEARATION END ***********************************************************/
/**************** Calculation of rescaled height and width  ***********************************************************/
	if(resecho){
        	  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(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();}
		
		
	
/***************** 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;
	  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);
	
/***************** Averaging the values ENDS **************************************************************************************************/
         if(resecho){
	 printf("sum2=%f  avg=%f\n",sum2,avg);			 	  	  
         printf("convertvalues=%d\n",convertvalues[a][b]);
         getchar();}	
	}

	    if (ECHO_RESIZE){
	    printf("\tOUT of resize.c\n");
	    }
        
}	
/***************** Averaging the values ends  **************************************************************************************************/