src/tiff/tif_color.c

/* $Header$ */

/*
 * Copyright (c) 1988-1997 Sam Leffler
 * Copyright (c) 1991-1997 Silicon Graphics, Inc.
 *
 * Permission to use, copy, modify, distribute, and sell this software and
 * its documentation for any purpose is hereby granted without fee, provided
 * that (i) the above copyright notices and this permission notice appear in
 * all copies of the software and related documentation, and (ii) the names of
 * Sam Leffler and Silicon Graphics may not be used in any advertising or
 * publicity relating to the software without the specific, prior written
 * permission of Sam Leffler and Silicon Graphics.
 *
 * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
 *
 * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
 * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
 * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
 * OF THIS SOFTWARE.
 */

/*
 * CIE L*a*b* to CIE XYZ and CIE XYZ to RGB conversion routines are taken
 * from the VIPS library (http://www.vips.ecs.soton.ac.uk) with
 * the permission of John Cupitt, the VIPS author.
 */

/*
 * TIFF Library.
 *
 * Color space conversion routines.
 */

#include "tiffiop.h"
#include <math.h>

/*
 * Convert color value from the CIE L*a*b* 1976 space to CIE XYZ.
 */
void
TIFFCIELabToXYZ(TIFFCIELabToRGB *cielab, uint32 l, int32 a, int32 b,
		float *X, float *Y, float *Z)
{
	float L = (float)l * 100.0F / 255.0F;
	float cby, tmp;

	if( L < 8.856F ) {
		*Y = (L * cielab->Y0) / 903.292F;
		cby = 7.787F * (*Y / cielab->Y0) + 16.0F / 116.0F;
	} else {
		cby = (L + 16.0F) / 116.0F;
		*Y = cielab->Y0 * cby * cby * cby;
	}

	tmp = (float)a / 500.0F + cby;
	if( tmp < 0.2069F )
		*X = cielab->X0 * (tmp - 0.13793F) / 7.787F;
	else
		*X = cielab->X0 * tmp * tmp * tmp;

	tmp = cby - (float)b / 200.0F;
	if( tmp < 0.2069F )
		*Z = cielab->Z0 * (tmp - 0.13793F) / 7.787F;
	else
		*Z = cielab->Z0 * tmp * tmp * tmp;
}

#define RINT(R) ((uint32)((R)>0?((R)+0.5):((R)-0.5)))
/*
 * Convert color value from the XYZ space to RGB.
 */
void
TIFFXYZToRGB(TIFFCIELabToRGB *cielab, float X, float Y, float Z,
	     uint32 *r, uint32 *g, uint32 *b)
{
	int i;
	float Yr, Yg, Yb;
	float *matrix = &cielab->display.d_mat[0][0];

	/* Multiply through the matrix to get luminosity values. */
	Yr =  matrix[0] * X + matrix[1] * Y + matrix[2] * Z;
	Yg =  matrix[3] * X + matrix[4] * Y + matrix[5] * Z;
	Yb =  matrix[6] * X + matrix[7] * Y + matrix[8] * Z;

	/* Clip input */
	Yr = TIFFmax( Yr, cielab->display.d_Y0R );
	Yg = TIFFmax( Yg, cielab->display.d_Y0G );
	Yb = TIFFmax( Yb, cielab->display.d_Y0B );

	/* Turn luminosity to colour value. */
	i = TIFFmin(cielab->range,
		    (int)((Yr - cielab->display.d_Y0R) / cielab->rstep));
	*r = RINT(cielab->Yr2r[i]);

	i = TIFFmin(cielab->range,
		    (int)((Yg - cielab->display.d_Y0G) / cielab->gstep));
	*g = RINT(cielab->Yg2g[i]);

	i = TIFFmin(cielab->range,
		    (int)((Yb - cielab->display.d_Y0B) / cielab->bstep));
	*b = RINT(cielab->Yb2b[i]);

	/* Clip output. */
	*r = TIFFmin( *r, cielab->display.d_Vrwr );
	*g = TIFFmin( *g, cielab->display.d_Vrwg );
	*b = TIFFmin( *b, cielab->display.d_Vrwb );
}
#undef RINT

/*
 * Allocate conversion state structures and make look_up tables for
 * the Yr,Yb,Yg <=> r,g,b conversions.
 */
int
TIFFCIELabToRGBInit(TIFFCIELabToRGB* cielab,
		    TIFFDisplay *display, float *refWhite)
{
	int i;
	float gamma;

	cielab->range = CIELABTORGB_TABLE_RANGE;

	_TIFFmemcpy(&cielab->display, display, sizeof(TIFFDisplay));

	/* Red */
	gamma = 1.0F / cielab->display.d_gammaR ;
	cielab->rstep =
		(cielab->display.d_YCR - cielab->display.d_Y0R)	/ cielab->range;
	for(i = 0; i <= cielab->range; i++) {
		cielab->Yr2r[i] = cielab->display.d_Vrwr
		    * ((float)pow((double)i / cielab->range, gamma));
	}

	/* Green */
	gamma = 1.0F / cielab->display.d_gammaG ;
	cielab->gstep =
	    (cielab->display.d_YCR - cielab->display.d_Y0R) / cielab->range;
	for(i = 0; i <= cielab->range; i++) {
		cielab->Yg2g[i] = cielab->display.d_Vrwg
		    * ((float)pow((double)i / cielab->range, gamma));
	}

	/* Blue */
	gamma = 1.0F / cielab->display.d_gammaB ;
	cielab->bstep =
	    (cielab->display.d_YCR - cielab->display.d_Y0R) / cielab->range;
	for(i = 0; i <= cielab->range; i++) {
		cielab->Yb2b[i] = cielab->display.d_Vrwb
		    * ((float)pow((double)i / cielab->range, gamma));
	}

	/* Init reference white point */
	cielab->X0 = refWhite[0];
	cielab->Y0 = refWhite[1];
	cielab->Z0 = refWhite[2];

	return 0;
}

/*
 * Convert color value from the YCbCr space to CIE XYZ.
 * The colorspace conversion algorithm comes from the IJG v5a code;
 * see below for more information on how it works.
 */
#define	SHIFT			16
#define	FIX(x)			((int32)((x) * (1L<<SHIFT) + 0.5))
#define	ONE_HALF		((int32)(1<<(SHIFT-1)))
#define	Code2V(c, RB, RW, CR)	((((c)-(int32)(RB))*(float)(CR))/(float)((RW)-(RB)))
#define	CLAMP(f,min,max)	((f)<(min)?(min):(f)>(max)?(max):(f))

void
TIFFYCbCrtoRGB(TIFFYCbCrToRGB *ycbcr, uint32 Y, int32 Cb, int32 Cr,
	       uint32 *r, uint32 *g, uint32 *b)
{
	/* XXX: Only 8-bit YCbCr input supported for now */
	Y = CLAMP(Y, 0, 255), Cb = CLAMP(Cb, 0, 255), Cr = CLAMP(Cr, 0, 255);

	*r = ycbcr->clamptab[ycbcr->Y_tab[Y] + ycbcr->Cr_r_tab[Cr]];
	*g = ycbcr->clamptab[ycbcr->Y_tab[Y]
	    + (int)((ycbcr->Cb_g_tab[Cb] + ycbcr->Cr_g_tab[Cr]) >> SHIFT)];
	*b = ycbcr->clamptab[ycbcr->Y_tab[Y] + ycbcr->Cb_b_tab[Cb]];
}

/*
 * Initialize the YCbCr->RGB conversion tables.  The conversion
 * is done according to the 6.0 spec:
 *
 *    R = Y + Cr*(2 - 2*LumaRed)
 *    B = Y + Cb*(2 - 2*LumaBlue)
 *    G =   Y
 *        - LumaBlue*Cb*(2-2*LumaBlue)/LumaGreen
 *        - LumaRed*Cr*(2-2*LumaRed)/LumaGreen
 *
 * To avoid floating point arithmetic the fractional constants that
 * come out of the equations are represented as fixed point values
 * in the range 0...2^16.  We also eliminate multiplications by
 * pre-calculating possible values indexed by Cb and Cr (this code
 * assumes conversion is being done for 8-bit samples).
 */
int
TIFFYCbCrToRGBInit(TIFFYCbCrToRGB* ycbcr, float *luma, float *refBlackWhite)
{
    TIFFRGBValue* clamptab;
    int i;

#define LumaRed	    luma[0]
#define LumaGreen   luma[1]
#define LumaBlue    luma[2]

    clamptab = (TIFFRGBValue*)(
	(tidata_t) ycbcr+TIFFroundup(sizeof (TIFFYCbCrToRGB), sizeof (long)));
    _TIFFmemset(clamptab, 0, 256);		/* v < 0 => 0 */
    ycbcr->clamptab = (clamptab += 256);
    for (i = 0; i < 256; i++)
	clamptab[i] = (TIFFRGBValue) i;
    _TIFFmemset(clamptab+256, 255, 2*256);	/* v > 255 => 255 */
    ycbcr->Cr_r_tab = (int*) (clamptab + 3*256);
    ycbcr->Cb_b_tab = ycbcr->Cr_r_tab + 256;
    ycbcr->Cr_g_tab = (int32*) (ycbcr->Cb_b_tab + 256);
    ycbcr->Cb_g_tab = ycbcr->Cr_g_tab + 256;
    ycbcr->Y_tab = ycbcr->Cb_g_tab + 256;

    { float f1 = 2-2*LumaRed;		int32 D1 = FIX(f1);
      float f2 = LumaRed*f1/LumaGreen;	int32 D2 = -FIX(f2);
      float f3 = 2-2*LumaBlue;		int32 D3 = FIX(f3);
      float f4 = LumaBlue*f3/LumaGreen;	int32 D4 = -FIX(f4);
      int x;

#undef LumaBlue
#undef LumaGreen
#undef LumaRed

      /*
       * i is the actual input pixel value in the range 0..255
       * Cb and Cr values are in the range -128..127 (actually
       * they are in a range defined by the ReferenceBlackWhite
       * tag) so there is some range shifting to do here when
       * constructing tables indexed by the raw pixel data.
       */
      for (i = 0, x = -128; i < 256; i++, x++) {
	    int32 Cr = (int32)Code2V(x, refBlackWhite[4] - 128.0F,
			    refBlackWhite[5] - 128.0F, 127);
	    int32 Cb = (int32)Code2V(x, refBlackWhite[2] - 128.0F,
			    refBlackWhite[3] - 128.0F, 127);

	    ycbcr->Cr_r_tab[i] = (int32)((D1*Cr + ONE_HALF)>>SHIFT);
	    ycbcr->Cb_b_tab[i] = (int32)((D3*Cb + ONE_HALF)>>SHIFT);
	    ycbcr->Cr_g_tab[i] = D2*Cr;
	    ycbcr->Cb_g_tab[i] = D4*Cb + ONE_HALF;
	    ycbcr->Y_tab[i] =
		    (int32)Code2V(x + 128, refBlackWhite[0], refBlackWhite[1], 255);
      }
    }

    return 0;
}
#undef	CLAMP
#undef	Code2V
#undef	SHIFT
#undef	ONE_HALF
#undef	FIX
Commit	Line	Data
	1	/* $Header$ */
	2
	3	/*
	4	* Copyright (c) 1988-1997 Sam Leffler
	5	* Copyright (c) 1991-1997 Silicon Graphics, Inc.
	6	*
	7	* Permission to use, copy, modify, distribute, and sell this software and
	8	* its documentation for any purpose is hereby granted without fee, provided
	9	* that (i) the above copyright notices and this permission notice appear in
	10	* all copies of the software and related documentation, and (ii) the names of
	11	* Sam Leffler and Silicon Graphics may not be used in any advertising or
	12	* publicity relating to the software without the specific, prior written
	13	* permission of Sam Leffler and Silicon Graphics.
	14	*
	15	* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
	16	* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
	17	* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
	18	*
	19	* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
	20	* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
	21	* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
	22	* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
	23	* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
	24	* OF THIS SOFTWARE.
	25	*/
	26
	27	/*
	28	* CIE Lab* to CIE XYZ and CIE XYZ to RGB conversion routines are taken
	29	* from the VIPS library (http://www.vips.ecs.soton.ac.uk) with
	30	* the permission of John Cupitt, the VIPS author.
	31	*/
	32
	33	/*
	34	* TIFF Library.
	35	*
	36	* Color space conversion routines.
	37	*/
	38
	39	#include "tiffiop.h"
	40	#include <math.h>
	41
	42	/*
	43	* Convert color value from the CIE Lab* 1976 space to CIE XYZ.
	44	*/
	45	void
	46	TIFFCIELabToXYZ(TIFFCIELabToRGB *cielab, uint32 l, int32 a, int32 b,
	47	float X, float Y, float *Z)
	48	{
	49	float L = (float)l * 100.0F / 255.0F;
	50	float cby, tmp;
	51
	52	if( L < 8.856F ) {
	53	Y = (L cielab->Y0) / 903.292F;
	54	cby = 7.787F * (*Y / cielab->Y0) + 16.0F / 116.0F;
	55	} else {
	56	cby = (L + 16.0F) / 116.0F;
	57	Y = cielab->Y0 cby * cby * cby;
	58	}
	59
	60	tmp = (float)a / 500.0F + cby;
	61	if( tmp < 0.2069F )
	62	X = cielab->X0 (tmp - 0.13793F) / 7.787F;
	63	else
	64	X = cielab->X0 tmp * tmp * tmp;
	65
	66	tmp = cby - (float)b / 200.0F;
	67	if( tmp < 0.2069F )
	68	Z = cielab->Z0 (tmp - 0.13793F) / 7.787F;
	69	else
	70	Z = cielab->Z0 tmp * tmp * tmp;
	71	}
	72
	73	#define RINT(R) ((uint32)((R)>0?((R)+0.5):((R)-0.5)))
	74	/*
	75	* Convert color value from the XYZ space to RGB.
	76	*/
	77	void
	78	TIFFXYZToRGB(TIFFCIELabToRGB *cielab, float X, float Y, float Z,
	79	uint32 r, uint32 g, uint32 *b)
	80	{
	81	int i;
	82	float Yr, Yg, Yb;
	83	float *matrix = &cielab->display.d_mat[0][0];
	84
	85	/* Multiply through the matrix to get luminosity values. */
	86	Yr = matrix[0] * X + matrix[1] * Y + matrix[2] * Z;
	87	Yg = matrix[3] * X + matrix[4] * Y + matrix[5] * Z;
	88	Yb = matrix[6] * X + matrix[7] * Y + matrix[8] * Z;
	89
	90	/* Clip input */
	91	Yr = TIFFmax( Yr, cielab->display.d_Y0R );
	92	Yg = TIFFmax( Yg, cielab->display.d_Y0G );
	93	Yb = TIFFmax( Yb, cielab->display.d_Y0B );
	94
	95	/* Turn luminosity to colour value. */
	96	i = TIFFmin(cielab->range,
	97	(int)((Yr - cielab->display.d_Y0R) / cielab->rstep));
	98	*r = RINT(cielab->Yr2r[i]);
	99
	100	i = TIFFmin(cielab->range,
	101	(int)((Yg - cielab->display.d_Y0G) / cielab->gstep));
	102	*g = RINT(cielab->Yg2g[i]);
	103
	104	i = TIFFmin(cielab->range,
	105	(int)((Yb - cielab->display.d_Y0B) / cielab->bstep));
	106	*b = RINT(cielab->Yb2b[i]);
	107
	108	/* Clip output. */
	109	r = TIFFmin( r, cielab->display.d_Vrwr );
	110	g = TIFFmin( g, cielab->display.d_Vrwg );
	111	b = TIFFmin( b, cielab->display.d_Vrwb );
	112	}
	113	#undef RINT
	114
	115	/*
	116	* Allocate conversion state structures and make look_up tables for
	117	* the Yr,Yb,Yg <=> r,g,b conversions.
	118	*/
	119	int
	120	TIFFCIELabToRGBInit(TIFFCIELabToRGB* cielab,
	121	TIFFDisplay display, float refWhite)
	122	{
	123	int i;
	124	float gamma;
	125
	126	cielab->range = CIELABTORGB_TABLE_RANGE;
	127
	128	_TIFFmemcpy(&cielab->display, display, sizeof(TIFFDisplay));
	129
	130	/* Red */
	131	gamma = 1.0F / cielab->display.d_gammaR ;
	132	cielab->rstep =
	133	(cielab->display.d_YCR - cielab->display.d_Y0R) / cielab->range;
	134	for(i = 0; i <= cielab->range; i++) {
	135	cielab->Yr2r[i] = cielab->display.d_Vrwr
	136	* ((float)pow((double)i / cielab->range, gamma));
	137	}
	138
	139	/* Green */
	140	gamma = 1.0F / cielab->display.d_gammaG ;
	141	cielab->gstep =
	142	(cielab->display.d_YCR - cielab->display.d_Y0R) / cielab->range;
	143	for(i = 0; i <= cielab->range; i++) {
	144	cielab->Yg2g[i] = cielab->display.d_Vrwg
	145	* ((float)pow((double)i / cielab->range, gamma));
	146	}
	147
	148	/* Blue */
	149	gamma = 1.0F / cielab->display.d_gammaB ;
	150	cielab->bstep =
	151	(cielab->display.d_YCR - cielab->display.d_Y0R) / cielab->range;
	152	for(i = 0; i <= cielab->range; i++) {
	153	cielab->Yb2b[i] = cielab->display.d_Vrwb
	154	* ((float)pow((double)i / cielab->range, gamma));
	155	}
	156
	157	/* Init reference white point */
	158	cielab->X0 = refWhite[0];
	159	cielab->Y0 = refWhite[1];
	160	cielab->Z0 = refWhite[2];
	161
	162	return 0;
	163	}
	164
	165	/*
	166	* Convert color value from the YCbCr space to CIE XYZ.
	167	* The colorspace conversion algorithm comes from the IJG v5a code;
	168	* see below for more information on how it works.
	169	*/
	170	#define SHIFT 16
	171	#define FIX(x) ((int32)((x) * (1L<<SHIFT) + 0.5))
	172	#define ONE_HALF ((int32)(1<<(SHIFT-1)))
	173	#define Code2V(c, RB, RW, CR) ((((c)-(int32)(RB))*(float)(CR))/(float)((RW)-(RB)))
	174	#define CLAMP(f,min,max) ((f)<(min)?(min):(f)>(max)?(max):(f))
	175
	176	void
	177	TIFFYCbCrtoRGB(TIFFYCbCrToRGB *ycbcr, uint32 Y, int32 Cb, int32 Cr,
	178	uint32 r, uint32 g, uint32 *b)
	179	{
	180	/* XXX: Only 8-bit YCbCr input supported for now */
	181	Y = CLAMP(Y, 0, 255), Cb = CLAMP(Cb, 0, 255), Cr = CLAMP(Cr, 0, 255);
	182
	183	*r = ycbcr->clamptab[ycbcr->Y_tab[Y] + ycbcr->Cr_r_tab[Cr]];
	184	*g = ycbcr->clamptab[ycbcr->Y_tab[Y]
	185	+ (int)((ycbcr->Cb_g_tab[Cb] + ycbcr->Cr_g_tab[Cr]) >> SHIFT)];
	186	*b = ycbcr->clamptab[ycbcr->Y_tab[Y] + ycbcr->Cb_b_tab[Cb]];
	187	}
	188
	189	/*
	190	* Initialize the YCbCr->RGB conversion tables. The conversion
	191	* is done according to the 6.0 spec:
	192	*
	193	* R = Y + Cr(2 - 2LumaRed)
	194	* B = Y + Cb(2 - 2LumaBlue)
	195	* G = Y
	196	* - LumaBlueCb(2-2*LumaBlue)/LumaGreen
	197	* - LumaRedCr(2-2*LumaRed)/LumaGreen
	198	*
	199	* To avoid floating point arithmetic the fractional constants that
	200	* come out of the equations are represented as fixed point values
	201	* in the range 0...2^16. We also eliminate multiplications by
	202	* pre-calculating possible values indexed by Cb and Cr (this code
	203	* assumes conversion is being done for 8-bit samples).
	204	*/
	205	int
	206	TIFFYCbCrToRGBInit(TIFFYCbCrToRGB* ycbcr, float luma, float refBlackWhite)
	207	{
	208	TIFFRGBValue* clamptab;
	209	int i;
	210
	211	#define LumaRed luma[0]
	212	#define LumaGreen luma[1]
	213	#define LumaBlue luma[2]
	214
	215	clamptab = (TIFFRGBValue*)(
	216	(tidata_t) ycbcr+TIFFroundup(sizeof (TIFFYCbCrToRGB), sizeof (long)));
	217	_TIFFmemset(clamptab, 0, 256); /* v < 0 => 0 */
	218	ycbcr->clamptab = (clamptab += 256);
	219	for (i = 0; i < 256; i++)
	220	clamptab[i] = (TIFFRGBValue) i;
	221	_TIFFmemset(clamptab+256, 255, 2256); / v > 255 => 255 */
	222	ycbcr->Cr_r_tab = (int) (clamptab + 3256);
	223	ycbcr->Cb_b_tab = ycbcr->Cr_r_tab + 256;
	224	ycbcr->Cr_g_tab = (int32*) (ycbcr->Cb_b_tab + 256);
	225	ycbcr->Cb_g_tab = ycbcr->Cr_g_tab + 256;
	226	ycbcr->Y_tab = ycbcr->Cb_g_tab + 256;
	227
	228	{ float f1 = 2-2*LumaRed; int32 D1 = FIX(f1);
	229	float f2 = LumaRed*f1/LumaGreen; int32 D2 = -FIX(f2);
	230	float f3 = 2-2*LumaBlue; int32 D3 = FIX(f3);
	231	float f4 = LumaBlue*f3/LumaGreen; int32 D4 = -FIX(f4);
	232	int x;
	233
	234	#undef LumaBlue
	235	#undef LumaGreen
	236	#undef LumaRed
	237
	238	/*
	239	* i is the actual input pixel value in the range 0..255
	240	* Cb and Cr values are in the range -128..127 (actually
	241	* they are in a range defined by the ReferenceBlackWhite
	242	* tag) so there is some range shifting to do here when
	243	* constructing tables indexed by the raw pixel data.
	244	*/
	245	for (i = 0, x = -128; i < 256; i++, x++) {
	246	int32 Cr = (int32)Code2V(x, refBlackWhite[4] - 128.0F,
	247	refBlackWhite[5] - 128.0F, 127);
	248	int32 Cb = (int32)Code2V(x, refBlackWhite[2] - 128.0F,
	249	refBlackWhite[3] - 128.0F, 127);
	250
	251	ycbcr->Cr_r_tab[i] = (int32)((D1*Cr + ONE_HALF)>>SHIFT);
	252	ycbcr->Cb_b_tab[i] = (int32)((D3*Cb + ONE_HALF)>>SHIFT);
	253	ycbcr->Cr_g_tab[i] = D2*Cr;
	254	ycbcr->Cb_g_tab[i] = D4*Cb + ONE_HALF;
	255	ycbcr->Y_tab[i] =
	256	(int32)Code2V(x + 128, refBlackWhite[0], refBlackWhite[1], 255);
	257	}
	258	}
	259
	260	return 0;
	261	}
	262	#undef CLAMP
	263	#undef Code2V
	264	#undef SHIFT
	265	#undef ONE_HALF
	266	#undef FIX
	267
	268