third_party/libtiff/tif_color.c - pdfium - Git at Google

 /*
  * 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_t l, int32_t a, int32_t b,
                      float *X, float *Y, float *Z)
 {
     TIFFCIELab16ToXYZ(cielab, l * 257, a * 256, b * 256, X, Y, Z);
 }

 /*
  * For CIELab encoded in 16 bits, L is an unsigned integer range [0,65535].
  * The a* and b* components are signed integers range [-32768,32767]. The 16
  * bit chrominance values are encoded as 256 times the 1976 CIE a* and b*
  * values
  */
 void TIFFCIELab16ToXYZ(TIFFCIELabToRGB *cielab, uint32_t l, int32_t a,
                        int32_t b, float *X, float *Y, float *Z)
 {
     float L = (float)l * 100.0F / 65535.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 / 256.0F / 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 / 256.0F / 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_t)((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_t *r, uint32_t *g, uint32_t *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);

     /* Avoid overflow in case of wrong input values */
     Yr = TIFFmin(Yr, cielab->display.d_YCR);
     Yg = TIFFmin(Yg, cielab->display.d_YCG);
     Yb = TIFFmin(Yb, cielab->display.d_YCB);

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

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

     i = (int)((Yb - cielab->display.d_Y0B) / cielab->bstep);
     i = TIFFmin(cielab->range, i);
     *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, const TIFFDisplay *display,
                         float *refWhite)
 {
     int i;
     double dfGamma;

     cielab->range = CIELABTORGB_TABLE_RANGE;

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

     /* Red */
     dfGamma = 1.0 / 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, dfGamma));
     }

     /* Green */
     dfGamma = 1.0 / 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, dfGamma));
     }

     /* Blue */
     dfGamma = 1.0 / 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, dfGamma));
     }

     /* 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 RGB.
  * 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_t)((x) * (1L << SHIFT) + 0.5))
 #define ONE_HALF ((int32_t)(1 << (SHIFT - 1)))
 #define Code2V(c, RB, RW, CR)                                                  \
     ((((c) - (int32_t)(RB)) * (float)(CR)) /                                   \
      (float)(((RW) - (RB) != 0) ? ((RW) - (RB)) : 1))
 /* !((f)>=(min)) written that way to deal with NaN */
 #define CLAMP(f, min, max)                                                     \
     ((!((f) >= (min))) ? (min) : (f) > (max) ? (max) : (f))
 #define HICLAMP(f, max) ((f) > (max) ? (max) : (f))

 void TIFFYCbCrtoRGB(TIFFYCbCrToRGB *ycbcr, uint32_t Y, int32_t Cb, int32_t Cr,
                     uint32_t *r, uint32_t *g, uint32_t *b)
 {
     int32_t i;

     /* XXX: Only 8-bit YCbCr input supported for now */
     Y = HICLAMP(Y, 255);
     Cb = CLAMP(Cb, 0, 255);
     Cr = CLAMP(Cr, 0, 255);

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

 /* Clamp function for sanitization purposes. Normally clamping should not */
 /* occur for well behaved chroma and refBlackWhite coefficients */
 static float CLAMPw(float v, float vmin, float vmax)
 {
     if (v < vmin)
     {
         /* printf("%f clamped to %f\n", v, vmin); */
         return vmin;
     }
     if (v > vmax)
     {
         /* printf("%f clamped to %f\n", v, vmax); */
         return vmax;
     }
     return v;
 }

 /*
  * 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 *)((uint8_t *)ycbcr +
                          TIFFroundup_32(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_t *)(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_t D1 = FIX(CLAMP(f1, 0.0F, 2.0F));
         float f2 = LumaRed * f1 / LumaGreen;
         int32_t D2 = -FIX(CLAMP(f2, 0.0F, 2.0F));
         float f3 = 2 - 2 * LumaBlue;
         int32_t D3 = FIX(CLAMP(f3, 0.0F, 2.0F));
         float f4 = LumaBlue * f3 / LumaGreen;
         int32_t D4 = -FIX(CLAMP(f4, 0.0F, 2.0F));
         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_t Cr = (int32_t)CLAMPw(Code2V(x, refBlackWhite[4] - 128.0F,
                                                 refBlackWhite[5] - 128.0F, 127),
                                          -128.0F * 32, 128.0F * 32);
             int32_t Cb = (int32_t)CLAMPw(Code2V(x, refBlackWhite[2] - 128.0F,
                                                 refBlackWhite[3] - 128.0F, 127),
                                          -128.0F * 32, 128.0F * 32);

             ycbcr->Cr_r_tab[i] = (int32_t)((D1 * Cr + ONE_HALF) >> SHIFT);
             ycbcr->Cb_b_tab[i] = (int32_t)((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_t)CLAMPw(
                 Code2V(x + 128, refBlackWhite[0], refBlackWhite[1], 255),
                 -128.0F * 32, 128.0F * 32);
         }
     }

     return 0;
 }
 #undef HICLAMP
 #undef CLAMP
 #undef Code2V
 #undef SHIFT
 #undef ONE_HALF
 #undef FIX
	/*
	* 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 Lab* 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 Lab* 1976 space to CIE XYZ.
	*/
	void TIFFCIELabToXYZ(TIFFCIELabToRGB *cielab, uint32_t l, int32_t a, int32_t b,
	float X, float Y, float *Z)
	{
	TIFFCIELab16ToXYZ(cielab, l * 257, a * 256, b * 256, X, Y, Z);
	}

	/*
	* For CIELab encoded in 16 bits, L is an unsigned integer range [0,65535].
	* The a* and b* components are signed integers range [-32768,32767]. The 16
	* bit chrominance values are encoded as 256 times the 1976 CIE a* and b*
	* values
	*/
	void TIFFCIELab16ToXYZ(TIFFCIELabToRGB *cielab, uint32_t l, int32_t a,
	int32_t b, float X, float Y, float *Z)
	{
	float L = (float)l * 100.0F / 65535.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 / 256.0F / 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 / 256.0F / 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_t)((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_t r, uint32_t g, uint32_t *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);

	/* Avoid overflow in case of wrong input values */
	Yr = TIFFmin(Yr, cielab->display.d_YCR);
	Yg = TIFFmin(Yg, cielab->display.d_YCG);
	Yb = TIFFmin(Yb, cielab->display.d_YCB);

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

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

	i = (int)((Yb - cielab->display.d_Y0B) / cielab->bstep);
	i = TIFFmin(cielab->range, i);
	*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, const TIFFDisplay display,
	float *refWhite)
	{
	int i;
	double dfGamma;

	cielab->range = CIELABTORGB_TABLE_RANGE;

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

	/* Red */
	dfGamma = 1.0 / 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, dfGamma));
	}

	/* Green */
	dfGamma = 1.0 / 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, dfGamma));
	}

	/* Blue */
	dfGamma = 1.0 / 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, dfGamma));
	}

	/* 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 RGB.
	* 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_t)((x) * (1L << SHIFT) + 0.5))
	#define ONE_HALF ((int32_t)(1 << (SHIFT - 1)))
	#define Code2V(c, RB, RW, CR) \
	((((c) - (int32_t)(RB)) * (float)(CR)) / \
	(float)(((RW) - (RB) != 0) ? ((RW) - (RB)) : 1))
	/* !((f)>=(min)) written that way to deal with NaN */
	#define CLAMP(f, min, max) \
	((!((f) >= (min))) ? (min) : (f) > (max) ? (max) : (f))
	#define HICLAMP(f, max) ((f) > (max) ? (max) : (f))

	void TIFFYCbCrtoRGB(TIFFYCbCrToRGB *ycbcr, uint32_t Y, int32_t Cb, int32_t Cr,
	uint32_t r, uint32_t g, uint32_t *b)
	{
	int32_t i;

	/* XXX: Only 8-bit YCbCr input supported for now */
	Y = HICLAMP(Y, 255);
	Cb = CLAMP(Cb, 0, 255);
	Cr = CLAMP(Cr, 0, 255);

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

	/* Clamp function for sanitization purposes. Normally clamping should not */
	/* occur for well behaved chroma and refBlackWhite coefficients */
	static float CLAMPw(float v, float vmin, float vmax)
	{
	if (v < vmin)
	{
	/* printf("%f clamped to %f\n", v, vmin); */
	return vmin;
	}
	if (v > vmax)
	{
	/* printf("%f clamped to %f\n", v, vmax); */
	return vmax;
	}
	return v;
	}

	/*
	* Initialize the YCbCr->RGB conversion tables. The conversion
	* is done according to the 6.0 spec:
	*
	* R = Y + Cr(2 - 2LumaRed)
	* B = Y + Cb(2 - 2LumaBlue)
	* G = Y
	* - LumaBlueCb(2-2*LumaBlue)/LumaGreen
	* - LumaRedCr(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 )((uint8_t )ycbcr +
	TIFFroundup_32(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_t *)(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_t D1 = FIX(CLAMP(f1, 0.0F, 2.0F));
	float f2 = LumaRed * f1 / LumaGreen;
	int32_t D2 = -FIX(CLAMP(f2, 0.0F, 2.0F));
	float f3 = 2 - 2 * LumaBlue;
	int32_t D3 = FIX(CLAMP(f3, 0.0F, 2.0F));
	float f4 = LumaBlue * f3 / LumaGreen;
	int32_t D4 = -FIX(CLAMP(f4, 0.0F, 2.0F));
	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_t Cr = (int32_t)CLAMPw(Code2V(x, refBlackWhite[4] - 128.0F,
	refBlackWhite[5] - 128.0F, 127),
	-128.0F * 32, 128.0F * 32);
	int32_t Cb = (int32_t)CLAMPw(Code2V(x, refBlackWhite[2] - 128.0F,
	refBlackWhite[3] - 128.0F, 127),
	-128.0F * 32, 128.0F * 32);

	ycbcr->Cr_r_tab[i] = (int32_t)((D1 * Cr + ONE_HALF) >> SHIFT);
	ycbcr->Cb_b_tab[i] = (int32_t)((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_t)CLAMPw(
	Code2V(x + 128, refBlackWhite[0], refBlackWhite[1], 255),
	-128.0F * 32, 128.0F * 32);
	}
	}

	return 0;
	}
	#undef HICLAMP
	#undef CLAMP
	#undef Code2V
	#undef SHIFT
	#undef ONE_HALF
	#undef FIX