#include "wavelet.h"	
	
void WaveletForward2D(int *data, int height, int width, int level)
{
	int m,n,datalen1,datalen2,data1,data2;
	int *buffer;

	if ((buffer = (int *) malloc (max(height, width) * sizeof(int))) == NULL)
	{
		printf("fail to allocate buffer.\n");
		exit(1);
	}

	datalen1 = width;
	datalen2 = height;


	for(m=0;m<height;m++)
	{
		for(n=0;n<width;n++)
		{
			*(data+m*width+n)=*(data+m*width+n)*1;
		}
	}
    for (m = 0; m < level; m++) 
	{
		for (n = 0; n < datalen2; n++)
		{
			CopyRow(buffer, data + n * width, datalen1);
			WaveletForward1D(buffer, datalen1);
			CopyRow(data + n * width, buffer, datalen1);
		}
		
		for (n = 0; n < datalen1; n++)
		{
			CopyCol(buffer, data + n, width, datalen2);
			WaveletForward1D(buffer, datalen2);
			CopyColBack(data + n, buffer, width, datalen2);
		}
		datalen1=datalen1/2;
		datalen2=datalen2/2;
	}

	free(buffer);
	data1=*data;
	data2=*data;
	for(m=0;m<height;m++)
	{
		for(n=0;n<width;n++)
		{
			if(data1>=data[m*width+n])
			{
				data1=data[m*width+n];
			}
			if(data2<=data[m*width+n])
			{
				data2=data[m*width+n];
			}
		}
	}
	printf("min=%d,max=%d\n",data1,data2);
}

void WaveletForward1D(int *data, int Datalen)
{
	int c;
	int mid = Datalen/2;
	int *d,*s;
	if ((d = (int *) malloc (mid * sizeof(int))) == NULL)
	{
		printf("fail to allocate d.\n");
		exit(1);
	}
	if ((s = (int *) malloc (mid * sizeof(int))) == NULL)
	{
		printf("fail to allocate s.\n");
		exit(1);
	}

	for(c=0;c<mid;c++)
	{
		*(s+c)=*(data+2*c);
		*(d+c)=*(data+2*c+1);
	}

	for(c=0;c<mid-1;c++)
	{
		*(d+c)+=(int)floor(ALPHA*(*(s+c)+*(s+c+1))+0.5);
	}
	*(d+mid-1)+=(int)floor(ALPHA*(*(s+mid-1))*2+0.5);

	*s+=(int)floor(BELTA*(*d)*2+0.5);
	for(c=1;c<mid;c++)
	{
		*(s+c)+=(int)floor(BELTA*(*(d+c-1)+*(d+c))+0.5);
	}

	for(c=0;c<mid-1;c++)
	{
		*(d+c)+=(int)floor(GAMMA*(*(s+c)+*(s+c+1))+0.5);
	}
	*(d+mid-1)+=(int)floor(GAMMA*(*(s+mid-1))*2+0.5);

	*s+=(int)floor(DELTA*(*d)*2+0.5);
	for(c=1;c<mid;c++)
	{
		*(s+c)+=(int)floor(DELTA*(*(d+c-1)+*(d+c))+0.5);
	}

	for(c=0;c<mid;c++)
	{
		*(d+c)+=*(s+c);
	}

	for(c=0;c<mid;c++)
	{
		*(s+c)+=(int)floor((ROW-1)*(*(d+c))+0.5);
	}

	for(c=0;c<mid;c++)
	{
		*(d+c)+=(int)floor(0-(*(s+c)/ROW)+0.5);
		*(s+c)+=(int)floor((ROW-ROW*ROW)*(*(d+c))+0.5);
	}

	for(c=0;c<mid;c++)
	{
		*(data+c)=*(s+c);
		*(data+c+mid)=*(d+c);
	}

	free(d);
	free(s);
}

void WaveletInvert2D(int *data, int height, int width, int level)
{
	int m,n,datalen1,datalen2;
	int *buffer;
	if ((buffer = (int *) malloc (max(height, width) * sizeof(int))) == NULL)
	{
		printf("fail to allocate buffer.\n");
		exit(1);
	}

	datalen1 = (int)(width/pow(2,(level-1)));
	datalen2 = (int)(height/pow(2,(level-1)));

    for (m = 0; m < level; m++) 
	{
		for (n = 0; n < datalen1; n++)
		{
			CopyCol(buffer, data + n, width, datalen2);
			WaveletInvert1D(buffer, datalen2);
			CopyColBack(data + n, buffer, width, datalen2);
		}

		for (n = 0; n < datalen2; n++)
		{
			CopyRow(buffer, data + n * width, datalen1);
			WaveletInvert1D(buffer, datalen1);
			CopyRow(data + n * width, buffer, datalen1);
		}
		
		datalen1=datalen1*2;
		datalen2=datalen2*2;
	}
	for(m=0;m<height;m++)
	{
		for(n=0;n<width;n++)
		{
			*(data+m*width+n)=*(data+m*width+n)/1;
		}
	}

	free(buffer);
}

void WaveletInvert1D(int *data, int Datalen)
{
	int c;
	int mid = Datalen/2;
	int *d,*s;
	if ((d = (int *) malloc (mid * sizeof(int))) == NULL)
	{
		printf("fail to allocate d.\n");
		exit(1);
	}
	if ((s = (int *) malloc (mid * sizeof(int))) == NULL)
	{
		printf("fail to allocate s.\n");
		exit(1);
	}

	for(c=0;c<mid;c++)
	{
		*(s+c)=*(data+c);
		*(d+c)=*(data+mid+c);
	}

	for(c=0;c<mid;c++)
	{
		*(s+c)-=(int)floor((ROW-ROW*ROW)*(*(d+c))+0.5);
		*(d+c)-=(int)floor(0-(*(s+c)/ROW)+0.5);
	}

	for(c=0;c<mid;c++)
	{
		*(s+c)-=(int)floor((ROW-1)*(*(d+c))+0.5);
	}
	for(c=0;c<mid;c++)
	{
		*(d+c)-=*(s+c);
	}

	*s-=(int)floor(DELTA*(*d)*2+0.5);
	for(c=1;c<mid;c++)
	{
		*(s+c)-=(int)floor(DELTA*(*(d+c-1)+*(d+c))+0.5);
	}
	
	for(c=0;c<mid-1;c++)
	{
		*(d+c)-=(int)floor(GAMMA*(*(s+c)+*(s+c+1))+0.5);
	}
	*(d+mid-1)-=(int)floor(GAMMA*(*(s+mid-1))*2+0.5);

	for(c=1;c<mid;c++)
	{
		*(s+c)-=(int)floor(BELTA*(*(d+c-1)+*(d+c))+0.5);
	}
	*s-=(int)floor(BELTA*(*d)*2+0.5);

	for(c=0;c<mid-1;c++)
	{
		*(d+c)-=(int)floor(ALPHA*(*(s+c)+*(s+c+1))+0.5);
	}
	*(d+mid-1)-=(int)floor(ALPHA*(*(s+mid-1))*2+0.5);
	
	for(c=0;c<mid;c++)
	{
		*(data+2*c)=*(s+c);
		*(data+2*c+1)=*(d+c);
	}

	free(d);
	free(s);

}
void CopyRow(int *DstData, int *SrcData, int TransWidth)
{
	int n;

	for (n = 0; n < TransWidth; n++)
	{
		DstData[n] = SrcData[n];
	}
}


void CopyCol(int *DstData, int *SrcData, int width, int TransHeight)
{
	int n;

	for (n = 0; n < TransHeight; n++)
	{
		DstData[n] = SrcData[n * width];
	}
}


void CopyColBack(int *DstData, int *SrcData, int width, int TransHeight)
{
	int n;

	for (n = 0; n < TransHeight; n++)
	{
		DstData[n * width] = SrcData[n];
	}
}