quantutil.c

好东西呢

int sign;
double multer,val;

	multer = 1.0/factor;

	for(y=0;y<h;y++) {
		for(x=0;x<w;x++) {
			val = *fmptr++;
			if ( val == 0 ) *toptr++ = 0;
			else {
				if ( val < 0 ) { sign = -1; val = -val; }
				else sign = 1;
				*toptr++ = sign * (int)( multer * val );
			}
		}
		fmptr += rowpad;
		toptr += rowpad;
	}
}


void dequantizeBandsDZ(image *im,imageFloat *to,int levels,float * factors)
{
int p,l,sizeX,sizeY;
double **torows;
int **fmrows;
int band;

	for(p=0;p<im->planes;p++) {
		fmrows = im->data[p];
		torows = to->data[p];
		band = 0;
		for (l = levels; l > 0; l--) {
			sizeX = im->width >> l;
			sizeY = im->height >> l;

			if (l == levels) {
#ifdef NEVER_QUANT_LL
				band++;
				dequantizeBandDZ(fmrows[0],torows[0], 		sizeX, sizeY, im->width, 1.0);
#else
				dequantizeBandDZ(fmrows[0],torows[0], 		sizeX, sizeY, im->width, factors[band++]);
#endif
			}

			dequantizeBandDZ(fmrows[0] + sizeX,torows[0] + sizeX, 	sizeX, sizeY, im->width, factors[band++]);
			dequantizeBandDZ(fmrows[sizeY], torows[sizeY], 		sizeX, sizeY, im->width, factors[band++]);
			dequantizeBandDZ(fmrows[sizeY]+sizeX,torows[sizeY]+sizeX,	sizeX, sizeY, im->width, factors[band++]);
		}
	}

}

void quantizeBandsDZ(imageFloat *im,image *to,int levels,float * factors)
{
int p,l,sizeX,sizeY;
double **fmrows;
int **torows;
int band;

	for(p=0;p<im->planes;p++) {
		fmrows = im->data[p];
		torows = to->data[p];
		band = 0;
		for (l = levels; l > 0; l--) {
			sizeX = im->width >> l;
			sizeY = im->height >> l;

			if (l == levels) {
#ifdef NEVER_QUANT_LL
				band++;
				quantizeBandDZ(fmrows[0],torows[0], 		sizeX, sizeY, im->width, 1.0);
#else
				quantizeBandDZ(fmrows[0],torows[0], 		sizeX, sizeY, im->width, factors[band++]);
#endif
			}

			quantizeBandDZ(fmrows[0] + sizeX,torows[0] + sizeX, 	sizeX, sizeY, im->width, factors[band++]);
			quantizeBandDZ(fmrows[sizeY], torows[sizeY], 		sizeX, sizeY, im->width, factors[band++]);
			quantizeBandDZ(fmrows[sizeY]+sizeX,torows[sizeY]+sizeX,	sizeX, sizeY, im->width, factors[band++]);
		}
	}

}



void dequantizeBandsDZU(image *im,imageFloat *to,int levels,double q)
{
int p,l,sizeX,sizeY;
double **torows;
int **fmrows;

	for(p=0;p<im->planes;p++) {
		fmrows = im->data[p];
		torows = to->data[p];
		for (l = levels; l > 0; l--) {
			sizeX = im->width >> l;
			sizeY = im->height >> l;

			if (l == levels) {
#ifdef NEVER_QUANT_LL
				dequantizeBandDZ(fmrows[0],torows[0], 		sizeX, sizeY, im->width, 1.0);
#else
				dequantizeBandDZ(fmrows[0],torows[0], 		sizeX, sizeY, im->width, q);
#endif
			}

			dequantizeBandDZ(fmrows[0] + sizeX,torows[0] + sizeX, 	sizeX, sizeY, im->width, q);
			dequantizeBandDZ(fmrows[sizeY], torows[sizeY], 		sizeX, sizeY, im->width, q);
			dequantizeBandDZ(fmrows[sizeY]+sizeX,torows[sizeY]+sizeX,	sizeX, sizeY, im->width, q);
		}
	}

}

void quantizeBandsDZU(imageFloat *im,image *to,int levels,double q)
{
int p,l,sizeX,sizeY;
double **fmrows;
int **torows;

	for(p=0;p<im->planes;p++) {
		fmrows = im->data[p];
		torows = to->data[p];
		for (l = levels; l > 0; l--) {
			sizeX = im->width >> l;
			sizeY = im->height >> l;

			if (l == levels) {
#ifdef NEVER_QUANT_LL
				quantizeBandDZ(fmrows[0],torows[0], 		sizeX, sizeY, im->width, 1.0);
#else
				quantizeBandDZ(fmrows[0],torows[0], 		sizeX, sizeY, im->width, q);
#endif
			}

			quantizeBandDZ(fmrows[0] + sizeX,torows[0] + sizeX, 	sizeX, sizeY, im->width, q);
			quantizeBandDZ(fmrows[sizeY], torows[sizeY], 		sizeX, sizeY, im->width, q);
			quantizeBandDZ(fmrows[sizeY]+sizeX,torows[sizeY]+sizeX,	sizeX, sizeY, im->width, q);
		}
	}

}



/*************************************************************/


void dequantizeBandDZInt(int *ptr,int w,int h,int fullw,double factor)
{
int x,y,rowpad = fullw-w;
int v,multme,multme_o2;

	multme = (int)(FASTQUANT_ONE * factor);
	multme_o2 = (int)(FASTQUANT_HALF * factor);

	for(y=0;y<h;y++) {
		for(x=0;x<w;x++) {
			v = *ptr;
			if ( v == 0 ) *ptr++; 
			else {
				if ( v < 0 ) 
					*ptr++ = - (( multme * (-v) + multme_o2)>>FASTQUANT_SHIFT);
				else
					*ptr++ = (( multme * v + multme_o2)>>FASTQUANT_SHIFT);
			}
		}
		ptr += rowpad;
	}
}

void quantizeBandDZInt(int *ptr,int w,int h,int fullw,double factor)
{
int x,y,rowpad = fullw-w;
int val;
int multer;

	multer = (int)(FASTQUANT_ONE/factor);

	for(y=0;y<h;y++) {
		for(x=w;x--;) {
			if ( (val = *ptr) == 0 ) ptr++;
			else {
				if ( val < 0 )
					*ptr++ = - (( multer * (-val) )>>FASTQUANT_SHIFT);
				else 
					*ptr++ = (( multer * val )>>FASTQUANT_SHIFT);
			}
		}
		ptr += rowpad;
	}
}


void dequantizeBandsDZInt(image *im,int levels,float * factors)
{
int p,l,sizeX,sizeY;
int **rows;
int band;

	for(p=0;p<im->planes;p++) {
		rows = im->data[p];
		band = 0;
		for (l = levels; l > 0; l--) {
			sizeX = im->width >> l;
			sizeY = im->height >> l;

			if (l == levels) 
#ifdef NEVER_QUANT_LL
				band++;
#else
				dequantizeBandDZInt(rows[0],		sizeX, sizeY, im->width, factors[band++]);
#endif

			dequantizeBandDZInt(rows[0] + sizeX,	sizeX, sizeY, im->width, factors[band++]);
			dequantizeBandDZInt(rows[sizeY], 		sizeX, sizeY, im->width, factors[band++]);
			dequantizeBandDZInt(rows[sizeY]+sizeX,sizeX, sizeY, im->width, factors[band++]);
		}
	}

}

void quantizeBandsDZInt(image *im,int levels,float * factors)
{
int p,l,sizeX,sizeY;
int **rows;
int band;

	for(p=0;p<im->planes;p++) {
		rows = im->data[p];
		band = 0;
		for (l = levels; l > 0; l--) {
			sizeX = im->width >> l;
			sizeY = im->height >> l;

			if (l == levels) 
#ifdef NEVER_QUANT_LL
				band++;
#else
				quantizeBandDZInt(rows[0],		sizeX, sizeY, im->width, factors[band++]);
#endif

			quantizeBandDZInt(rows[0] + sizeX, 	sizeX, sizeY, im->width, factors[band++]);
			quantizeBandDZInt(rows[sizeY], 		sizeX, sizeY, im->width, factors[band++]);
			quantizeBandDZInt(rows[sizeY]+sizeX,	sizeX, sizeY, im->width, factors[band++]);
		}
	}

}



void dequantizeBandsDZIntU(image *im,int levels,double q)
{
int p;

	for(p=0;p<im->planes;p++) {
#ifdef NEVER_QUANT_LL
		int ll_width,ll_height;
		ll_width = im->width >> levels;
		ll_height = im->height >> levels;
		dequantizeBandDZInt(im->data[p][0] + ll_width,im->width - ll_width,ll_height,im->width,q);
		dequantizeBandDZInt(im->data[p][ll_height],im->width,im->height - ll_height,im->width,q);
#else
		dequantizeBandDZInt(im->data[p][0],im->width,im->height,im->width,q);
#endif
	}
}

void quantizeBandsDZIntU(image *im,int levels,double q)
{
int p;

	for(p=0;p<im->planes;p++) {

#ifdef NEVER_QUANT_LL
		int ll_width,ll_height;
		ll_width = im->width >> levels;
		ll_height = im->height >> levels;
		quantizeBandDZInt(im->data[p][0] + ll_width,im->width - ll_width,ll_height,im->width,q);
		quantizeBandDZInt(im->data[p][ll_height],im->width,im->height - ll_height,im->width,q);
#else
		quantizeBandDZInt(im->data[p][0],im->width,im->height,im->width,q);
#endif
	}
}


/**************************** $$

ESZZ : Equal Size Zero Zone quantizers

	quantized = (val * (1.0/quantizer)) + 0.5

	val = quantizer * quantized;

*********/

void dequantizeBandESZZ(int *fmptr,double *toptr,int w,int h,int fullw,double factor)
{
int x,y,v,rowpad = fullw-w;

	for(y=0;y<h;y++) {
		for(x=0;x<w;x++) {
			if ( (v = *fmptr++) == 0 ) { *toptr++ = 0; 
			} else {
				*toptr++ = factor * v;
			}
		}
		fmptr += rowpad;
		toptr += rowpad;
	}
}

void quantizeBandESZZ(double *fmptr,int *toptr,int w,int h,int fullw,double factor)
{
int x,y,rowpad = fullw-w;
double multer,val;

	multer = 1.0/factor;

	for(y=0;y<h;y++) {
		for(x=0;x<w;x++) {
			val = *fmptr++;
			if ( val < 0 ) {
				*toptr++ = - (int)( multer * (-val) + 0.5 );
			} else {
				*toptr++ = (int)( multer * val + 0.5 );
			}
		}
		fmptr += rowpad;
		toptr += rowpad;
	}
}


void dequantizeBandsESZZ(image *im,imageFloat *to,int levels,float * factors)
{
int p,l,sizeX,sizeY;
double **torows;
int **fmrows;
int band;

	for(p=0;p<im->planes;p++) {
		fmrows = im->data[p];
		torows = to->data[p];
		band = 0;
		for (l = levels; l > 0; l--) {
			sizeX = im->width >> l;
			sizeY = im->height >> l;

			if (l == levels) {
#ifdef NEVER_QUANT_LL
				band++;
				dequantizeBandESZZ(fmrows[0],torows[0], 		sizeX, sizeY, im->width, 1.0);
#else
				dequantizeBandESZZ(fmrows[0],torows[0], 		sizeX, sizeY, im->width, factors[band++]);
#endif
			}

			dequantizeBandESZZ(fmrows[0] + sizeX,torows[0] + sizeX, 	sizeX, sizeY, im->width, factors[band++]);
			dequantizeBandESZZ(fmrows[sizeY], torows[sizeY], 		sizeX, sizeY, im->width, factors[band++]);
			dequantizeBandESZZ(fmrows[sizeY]+sizeX,torows[sizeY]+sizeX,	sizeX, sizeY, im->width, factors[band++]);
		}
	}

}

void quantizeBandsESZZ(imageFloat *im,image *to,int levels,float * factors)
{
int p,l,sizeX,sizeY;
double **fmrows;
int **torows;
int band;

	for(p=0;p<im->planes;p++) {
		fmrows = im->data[p];
		torows = to->data[p];
		band = 0;
		for (l = levels; l > 0; l--) {
			sizeX = im->width >> l;
			sizeY = im->height >> l;

			if (l == levels) {
#ifdef NEVER_QUANT_LL
				band++;
				quantizeBandESZZ(fmrows[0],torows[0], 		sizeX, sizeY, im->width, 1.0);
#else
				quantizeBandESZZ(fmrows[0],torows[0], 		sizeX, sizeY, im->width, factors[band++]);
#endif
			}

			quantizeBandESZZ(fmrows[0] + sizeX,torows[0] + sizeX, 	sizeX, sizeY, im->width, factors[band++]);
			quantizeBandESZZ(fmrows[sizeY], torows[sizeY], 		sizeX, sizeY, im->width, factors[band++]);
			quantizeBandESZZ(fmrows[sizeY]+sizeX,torows[sizeY]+sizeX,	sizeX, sizeY, im->width, factors[band++]);
		}
	}

}



void dequantizeBandsESZZU(image *im,imageFloat *to,int levels,double q)
{
int p,l,sizeX,sizeY;
double **torows;
int **fmrows;

	for(p=0;p<im->planes;p++) {
		fmrows = im->data[p];
		torows = to->data[p];
		for (l = levels; l > 0; l--) {
			sizeX = im->width >> l;
			sizeY = im->height >> l;

			if (l == levels) {
#ifdef NEVER_QUANT_LL
				dequantizeBandESZZ(fmrows[0],torows[0], 		sizeX, sizeY, im->width, 1.0);
#else
				dequantizeBandESZZ(fmrows[0],torows[0], 		sizeX, sizeY, im->width, q);
#endif
			}

			dequantizeBandESZZ(fmrows[0] + sizeX,torows[0] + sizeX, 	sizeX, sizeY, im->width, q);
			dequantizeBandESZZ(fmrows[sizeY], torows[sizeY], 		sizeX, sizeY, im->width, q);
			dequantizeBandESZZ(fmrows[sizeY]+sizeX,torows[sizeY]+sizeX,	sizeX, sizeY, im->width, q);
		}
	}

}

void quantizeBandsESZZU(imageFloat *im,image *to,int levels,double q)
{
int p,l,sizeX,sizeY;
double **fmrows;
int **torows;

	for(p=0;p<im->planes;p++) {
		fmrows = im->data[p];
		torows = to->data[p];
		for (l = levels; l > 0; l--) {
			sizeX = im->width >> l;
			sizeY = im->height >> l;

			if (l == levels) {
#ifdef NEVER_QUANT_LL
				quantizeBandESZZ(fmrows[0],torows[0], 		sizeX, sizeY, im->width, 1.0);
#else
				quantizeBandESZZ(fmrows[0],torows[0], 		sizeX, sizeY, im->width, q);
#endif
			}

			quantizeBandESZZ(fmrows[0] + sizeX,torows[0] + sizeX, 	sizeX, sizeY, im->width, q);
			quantizeBandESZZ(fmrows[sizeY], torows[sizeY], 		sizeX, sizeY, im->width, q);
			quantizeBandESZZ(fmrows[sizeY]+sizeX,torows[sizeY]+sizeX,	sizeX, sizeY, im->width, q);
		}
	}

}

void dequantizeBandESZZInt(int *ptr,int w,int h,int fullw,double factor)
{
int x,y,rowpad = fullw-w;
int multme;

	multme = (int)(factor * FASTQUANT_ONE);

	for(y=0;y<h;y++) {
		for(x=w;x--;) {
			*ptr++ = ( multme * (*ptr) )>>FASTQUANT_SHIFT; 
		}
		ptr += rowpad;
	}
}

void quantizeBandESZZInt(int *ptr,int w,int h,int fullw,double factor)
{
int val,x,y,rowpad = fullw-w;
int multer;

	multer = (int)(FASTQUANT_ONE / factor);

	for(y=0;y<h;y++) {
		for(x=w;x--;) {
			val = *ptr;
			if ( val < 0 ) {
				*ptr++ = - (( multer * (-val) + FASTQUANT_HALF)>>FASTQUANT_SHIFT);
			} else {
				*ptr++ = ( multer * val + FASTQUANT_HALF)>>FASTQUANT_SHIFT;
			}
		}
		ptr += rowpad;
	}
}


void dequantizeBandsESZZInt(image *im,int levels,float * factors)
{
int p,l,sizeX,sizeY;
int **rows;
int band;

	for(p=0;p<im->planes;p++) {
		rows = im->data[p];
		band = 0;
		for (l = levels; l > 0; l--) {
			sizeX = im->width >> l;
			sizeY = im->height >> l;

			if (l == levels) 
#ifdef NEVER_QUANT_LL
				band++;
#else
				dequantizeBandESZZInt(rows[0],		sizeX, sizeY, im->width, factors[band++]);
#endif

			dequantizeBandESZZInt(rows[0] + sizeX,	sizeX, sizeY, im->width, factors[band++]);
			dequantizeBandESZZInt(rows[sizeY], 		sizeX, sizeY, im->width, factors[band++]);
			dequantizeBandESZZInt(rows[sizeY]+sizeX,sizeX, sizeY, im->width, factors[band++]);
		}
	}

}

void quantizeBandsESZZInt(image *im,int levels,float * factors)
{
int p,l,sizeX,sizeY;
int **rows;
int band;

	for(p=0;p<im->planes;p++) {
		rows = im->data[p];
		band = 0;
		for (l = levels; l > 0; l--) {
			sizeX = im->width >> l;
			sizeY = im->height >> l;

			if (l == levels) 
#ifdef NEVER_QUANT_LL
				band++;
#else
				quantizeBandESZZInt(rows[0],		sizeX, sizeY, im->width, factors[band++]);
#endif

			quantizeBandESZZInt(rows[0] + sizeX, 	sizeX, sizeY, im->width, factors[band++]);
			quantizeBandESZZInt(rows[sizeY], 		sizeX, sizeY, im->width, factors[band++]);
			quantizeBandESZZInt(rows[sizeY]+sizeX,	sizeX, sizeY, im->width, factors[band++]);
		}
	}

}



void dequantizeBandsESZZIntU(image *im,int levels,double q)
{
int p;

	for(p=0;p<im->planes;p++) {
#ifdef NEVER_QUANT_LL
		int ll_width,ll_height;
		ll_width = im->width >> levels;
		ll_height = im->height >> levels;
		dequantizeBandESZZInt(im->data[p][0] + ll_width,im->width - ll_width,ll_height,im->width,q);
		dequantizeBandESZZInt(im->data[p][ll_height],im->width,im->height - ll_height,im->width,q);
#else
		dequantizeBandESZZInt(im->data[p][0],im->width,im->height,im->width,q);
#endif
	}
}

void quantizeBandsESZZIntU(image *im,int levels,double q)
{
int p;

	for(p=0;p<im->planes;p++) {

#ifdef NEVER_QUANT_LL
		int ll_width,ll_height;
		ll_width = im->width >> levels;
		ll_height = im->height >> levels;
		quantizeBandESZZInt(im->data[p][0] + ll_width,im->width - ll_width,ll_height,im->width,q);
		quantizeBandESZZInt(im->data[p][ll_height],im->width,im->height - ll_height,im->width,q);
#else
		quantizeBandESZZInt(im->data[p][0],im->width,im->height,im->width,q);
#endif
	}
}