#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <crblib/inc.h>
#include "quantim.h"
#include "quantutil.h"
#include "coder.h"
#include "subbands.h"

char * qtype_names[] = {
	"deadzone","ESZZ",NULL
};

quantInfo * findQuantizers(int qtype,int qflags,double quant_target,
	imageFloat *imF,int levels,int stoplen,coder *coder_template)
{
quantInfo *qi;

	if ( qflags == QFLAG_UNIFORM ) {

		if ( quant_target == 1.0 ) {
			if ( (qi = newQI(0)) == NULL ) return NULL;
			qi->nquants = 0;
			qi->qtype = qtype;	
		} else {
			if ( (qi = newQI(1)) == NULL ) return NULL;
			qi->nquants = 1;
			qi->qtype = qtype;	
			qi->quantizers[0] = quant_target;
		}
	} else {
		int i,nq;

		nq = 3*levels + 1;

		if ( (qi = newQI(nq)) == NULL ) return NULL;
		qi->nquants = nq;
		qi->qtype = qtype;	
		for(i=0;i<nq;i++) qi->quantizers[i] = quant_target;

		if ( qflags & QFLAG_SEEKSTOP ) 
			seekStoppedQuantizers(imF,levels,qi->quantizers,stoplen,coder_template);

		if ( qflags & QFLAG_FIDDLE ) 
			fiddleQuantizers(imF,levels,qi->quantizers,coder_template);
	}

return qi;
}

void   quantizeImage(image *im,int levels,quantInfo *qi)
{
	switch(qi->qtype) {
		case QTYPE_ESZZ:
			if ( qi->nquants == 1 ) 
				quantizeBandsESZZIntU(im,levels,qi->quantizers[0]);
			else if ( qi->nquants == (3*levels + 1) ) 
				quantizeBandsESZZInt(im,levels,qi->quantizers);
			break;
		case QTYPE_DEADZONE:
		default:
			if ( qi->nquants == 1 ) 
				quantizeBandsDZIntU(im,levels,qi->quantizers[0]);
			else if ( qi->nquants == (3*levels + 1) ) 
				quantizeBandsDZInt(im,levels,qi->quantizers);
			break;
	}
}
void dequantizeImage(image *im,int levels,quantInfo *qi)
{
	switch(qi->qtype) {
		case QTYPE_ESZZ:
			if ( qi->nquants == 1 ) 
				dequantizeBandsESZZIntU(im,levels,qi->quantizers[0]);
			else if ( qi->nquants == (3*levels + 1) ) 
				dequantizeBandsESZZInt(im,levels,qi->quantizers);
			break;
		case QTYPE_DEADZONE:
		default:
			if ( qi->nquants == 1 ) 
				dequantizeBandsDZIntU(im,levels,qi->quantizers[0]);
			else if ( qi->nquants == (3*levels + 1) ) 
				dequantizeBandsDZInt(im,levels,qi->quantizers);
			break;
	}
}
void   quantizeImageF(image *im,imageFloat *imF,int levels,quantInfo *qi)
{
	switch(qi->qtype) {
		case QTYPE_ESZZ:
			if ( qi->nquants == 1 ) 
				quantizeBandsESZZU(imF,im,levels,qi->quantizers[0]);
			else if ( qi->nquants == (3*levels + 1) ) 
				quantizeBandsESZZ(imF,im,levels,qi->quantizers);
			else
				quantizeBandsESZZU(imF,im,levels,1.0);
			break;
		case QTYPE_DEADZONE:
		default:
			if ( qi->nquants == 1 ) 
				quantizeBandsDZU(imF,im,levels,qi->quantizers[0]);
			else if ( qi->nquants == (3*levels + 1) ) 
				quantizeBandsDZ(imF,im,levels,qi->quantizers);
			else
				quantizeBandsDZU(imF,im,levels,1.0);
			break;
	}
}
void dequantizeImageF(image *im,imageFloat *imF,int levels,quantInfo *qi)
{
	switch(qi->qtype) {
		case QTYPE_ESZZ:
			if ( qi->nquants == 1 ) 
				dequantizeBandsESZZU(im,imF,levels,qi->quantizers[0]);
			else if ( qi->nquants == (3*levels + 1) ) 
				dequantizeBandsESZZ(im,imF,levels,qi->quantizers);
			else
				dequantizeBandsESZZU(im,imF,levels,1.0);
			break;
		case QTYPE_DEADZONE:
		default:
			if ( qi->nquants == 1 ) 
				dequantizeBandsDZU(im,imF,levels,qi->quantizers[0]);
			else if ( qi->nquants == (3*levels + 1) ) 
				dequantizeBandsDZ(im,imF,levels,qi->quantizers);
			else
				dequantizeBandsDZU(im,imF,levels,1.0);
			break;
	}
}



void deTransQuantIm(image *im,int levels,int transformN,quantInfo *qi)
{

	if ( ! levels ) return;

	transposeLHs(im,levels);

	if ( (transformN&TRANS_INT_TO_INT) && ( qi == NULL || qi->nquants == 0 ) ) {
		transformImageInt(im,levels,1,transformN);
	} else if ( (transformN&TRANS_INT_TO_INT) && qi->nquants == 1 && qi->quantizers[0] == (int)qi->quantizers[0] ) {

		dequantizeImage(im,levels,qi);

		transformImageInt(im,levels,1,transformN);
	} else {
		imageFloat *imF = NULL;

		if ( (imF = newImageFloatFrom(im)) == NULL )
			errexit("newImageFloat failed");

		dequantizeImageF(im,imF,levels,qi);

		if ( transformN == TRANS_DCT  ) {
			deshuffleDctImage(&imF);
		}
		transformImage(im,imF,levels,1,transformN);

		freeImageFloat(imF);
	}
}

quantInfo * doTransQuantIm(image *im,int levels,int transformN,
		int qtype,int qflags,double q,
		int stoplen,const coder *coder_template)
{
quantInfo *qi;

	if ( levels == 0 ) return NULL;

	if ( (transformN&TRANS_INT_TO_INT) && qflags == QFLAG_UNIFORM && (int)q == q ) {
		qi = findQuantizers(qtype,qflags,q, NULL,levels,0,NULL);
		transformImageInt(im,levels,0,transformN);
		if ( q != 1 )
			quantizeImage(im,levels,qi);
	} else {
		imageFloat *imF;
		if ( (imF = newImageFloatFrom(im)) == NULL )
			errexit("newImage failed");

		transformImage(im,imF,levels,0,transformN);

		if ( transformN == TRANS_DCT  ) {
			shuffleDctImage(&imF);
		}

		qi = findQuantizers(qtype,qflags,q, imF,levels,stoplen,(coder *)coder_template);

		quantizeImageF(im,imF,levels,qi);

		freeImageFloat(imF);
	}

	transposeLHs(im,levels);

return qi;
}


wavelet * makeTransQuantWavelet(image *im,int levels,int transformN,
				int qtype,int qflags,double q,
				int stoplen,const coder *coder_template)
{
wavelet * w;

	if ( (w = newWavelet(im,levels)) == NULL )
		return NULL;

	w->stoplen = stoplen;
	w->coder_template = coder_template;

	w->transform = transformN;
	w->qi = doTransQuantIm(im,levels,transformN,	
		qtype,qflags,q,
		stoplen,coder_template);

	w->subband_root = imageToSubbands(im,levels);

	activitySubbands(w->subband_root);

return w;
}

void deTransQuantWavelet(wavelet * w)
{
	deTransQuantIm(w->im,w->levels,w->transform,w->qi);
}