1 /*------------------------------------------------------------------------

     2  *

     3  * OpenVG 1.1 Reference Implementation

     4  * -----------------------------------

     5  *

     6  * Copyright (c) 2007 The Khronos Group Inc.

     7  *

     8  * Permission is hereby granted, free of charge, to any person obtaining a

     9  * copy of this software and /or associated documentation files

    10  * (the "Materials "), to deal in the Materials without restriction,

    11  * including without limitation the rights to use, copy, modify, merge,

    12  * publish, distribute, sublicense, and/or sell copies of the Materials,

    13  * and to permit persons to whom the Materials are furnished to do so,

    14  * subject to the following conditions: 

    15  *

    16  * The above copyright notice and this permission notice shall be included 

    17  * in all copies or substantial portions of the Materials. 

    18  *

    19  * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

    20  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

    21  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

    22  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

    23  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

    24  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR

    25  * THE USE OR OTHER DEALINGS IN THE MATERIALS.

    26  *

    27  *//**

    28  * \file

    29  * \brief	Implementation of Color and Image functions.

    30  * \note	

    31  *//*-------------------------------------------------------------------*/

    32 

    33 #include "riImage.h"

    34 #include "riRasterizer.h"

    35 //==============================================================================================

    36 

    37 namespace OpenVGRI

    38 {

    39 

    40 /*-------------------------------------------------------------------*//*!

    41 * \brief	Converts from numBits into a shifted mask

    42 * \param	

    43 * \return	

    44 * \note

    45 *//*-------------------------------------------------------------------*/

    46 	

    47 static unsigned int bitsToMask(unsigned int bits, unsigned int shift)

    48 {

    49 	return ((1<<bits)-1) << shift;

    50 }

    51 

    52 /*-------------------------------------------------------------------*//*!

    53 * \brief	Converts from color (RIfloat) to an int with 1.0f mapped to the

    54 *			given maximum with round-to-nearest semantics.

    55 * \param	

    56 * \return	

    57 * \note		

    58 *//*-------------------------------------------------------------------*/

    59 	

    60 static unsigned int colorToInt(RIfloat c, int maxc)

    61 {

    62 	return RI_INT_MIN(RI_INT_MAX((int)floor(c * (RIfloat)maxc + 0.5f), 0), maxc);

    63 }

    64 

    65 /*-------------------------------------------------------------------*//*!

    66 * \brief	Converts from int to color (RIfloat) with the given maximum

    67 *			mapped to 1.0f.

    68 * \param	

    69 * \return	

    70 * \note		

    71 *//*-------------------------------------------------------------------*/

    72 

    73 static RI_INLINE RIfloat intToColor(unsigned int i, unsigned int maxi)

    74 {

    75 	return (RIfloat)(i & maxi) / (RIfloat)maxi;

    76 }

    77 

    78 /*-------------------------------------------------------------------*//*!

    79 * \brief	Converts from packed integer in a given format to a Color.

    80 * \param	

    81 * \return	

    82 * \note		

    83 *//*-------------------------------------------------------------------*/

    84 

    85 void Color::unpack(unsigned int inputData, const Color::Descriptor& inputDesc)

    86 {

    87 	int rb = inputDesc.redBits;

    88 	int gb = inputDesc.greenBits;

    89 	int bb = inputDesc.blueBits;

    90 	int ab = inputDesc.alphaBits;

    91 	int lb = inputDesc.luminanceBits;

    92 	int rs = inputDesc.redShift;

    93 	int gs = inputDesc.greenShift;

    94 	int bs = inputDesc.blueShift;

    95 	int as = inputDesc.alphaShift;

    96 	int ls = inputDesc.luminanceShift;

    97 

    98 	m_format = inputDesc.internalFormat;

    99 	if(lb)

   100 	{	//luminance

   101 		r = g = b = intToColor(inputData >> ls, (1<<lb)-1);

   102 		a = 1.0f;

   103 	}

   104 	else

   105 	{	//rgba

   106 		r = rb ? intToColor(inputData >> rs, (1<<rb)-1) : (RIfloat)1.0f;

   107 		g = gb ? intToColor(inputData >> gs, (1<<gb)-1) : (RIfloat)1.0f;

   108 		b = bb ? intToColor(inputData >> bs, (1<<bb)-1) : (RIfloat)1.0f;

   109 		a = ab ? intToColor(inputData >> as, (1<<ab)-1) : (RIfloat)1.0f;

   110 

   111 		if(isPremultiplied())

   112 		{	//clamp premultiplied color to alpha to enforce consistency

   113 			r = RI_MIN(r, a);

   114 			g = RI_MIN(g, a);

   115 			b = RI_MIN(b, a);

   116 		}

   117 	}

   118 

   119     assertConsistency();

   120 }

   121 

   122 /*-------------------------------------------------------------------*//*!

   123 * \brief	Converts from Color to a packed integer in a given format.

   124 * \param	

   125 * \return	

   126 * \note		

   127 *//*-------------------------------------------------------------------*/

   128 

   129 unsigned int Color::pack(const Color::Descriptor& outputDesc) const

   130 {

   131     assertConsistency();

   132 

   133 	int rb = outputDesc.redBits;

   134 	int gb = outputDesc.greenBits;

   135 	int bb = outputDesc.blueBits;

   136 	int ab = outputDesc.alphaBits;

   137 	int lb = outputDesc.luminanceBits;

   138 	int rs = outputDesc.redShift;

   139 	int gs = outputDesc.greenShift;

   140 	int bs = outputDesc.blueShift;

   141 	int as = outputDesc.alphaShift;

   142 	int ls = outputDesc.luminanceShift;

   143 

   144 	if(lb)

   145 	{	//luminance

   146 		RI_ASSERT(isLuminance());

   147 		return colorToInt(r, (1<<lb)-1) << ls;

   148 	}

   149 	else

   150 	{	//rgb

   151 		RI_ASSERT(!isLuminance());

   152 		unsigned int cr = rb ? colorToInt(r, (1<<rb)-1) : 0;

   153 		unsigned int cg = gb ? colorToInt(g, (1<<gb)-1) : 0;

   154 		unsigned int cb = bb ? colorToInt(b, (1<<bb)-1) : 0;

   155 		unsigned int ca = ab ? colorToInt(a, (1<<ab)-1) : 0;

   156 		return (cr << rs) | (cg << gs) | (cb << bs) | (ca << as);

   157 	}

   158 }

   159 

   160 /*-------------------------------------------------------------------*//*!

   161 * \brief	Converts from the current internal format to another.

   162 * \param	

   163 * \return	

   164 * \note		

   165 *//*-------------------------------------------------------------------*/

   166 

   167 static RIfloat gamma(RIfloat c)

   168 {

   169 	if( c <= 0.00304f )

   170 		c *= 12.92f;

   171 	else

   172 		c = 1.0556f * (RIfloat)pow(c, 1.0f/2.4f) - 0.0556f;

   173 	return c;

   174 }

   175 

   176 static RIfloat invgamma(RIfloat c)

   177 {

   178 	if( c <= 0.03928f )

   179 		c /= 12.92f;

   180 	else

   181 		c = (RIfloat)pow((c + 0.0556f)/1.0556f, 2.4f);

   182 	return c;

   183 }

   184 

   185 static RIfloat lRGBtoL(RIfloat r, RIfloat g, RIfloat b)

   186 {

   187 	return 0.2126f*r + 0.7152f*g + 0.0722f*b;

   188 }

   189 

   190 void Color::convert(InternalFormat outputFormat)

   191 {

   192     assertConsistency();

   193 

   194 	if( m_format == outputFormat )

   195 		return;

   196 

   197 	if(isPremultiplied())

   198 	{	//unpremultiply

   199 		RIfloat ooa = (a != 0.0f) ? 1.0f / a : (RIfloat)0.0f;

   200 		r *= ooa;

   201 		g *= ooa;

   202 		b *= ooa;

   203 	}

   204 

   205 	//From Section 3.4.2 of OpenVG spec

   206 	//1: sRGB = gamma(lRGB)

   207 	//2: lRGB = invgamma(sRGB)

   208 	//3: lL = 0.2126 lR + 0.7152 lG + 0.0722 lB

   209 	//4: lRGB = lL

   210 	//5: sL = gamma(lL)

   211 	//6: lL = invgamma(sL)

   212 	//7: sRGB = sL

   213 

   214 	//Source/Dest lRGB sRGB   lL   sL 

   215 	//lRGB          -    1    3    3,5 

   216 	//sRGB          2    -    2,3  2,3,5 

   217 	//lL            4    4,1  -    5 

   218 	//sL            7,2  7    6    - 

   219 

   220 	const unsigned int shift = 3;

   221 	unsigned int conversion = (m_format & (NONLINEAR | LUMINANCE)) | ((outputFormat & (NONLINEAR | LUMINANCE)) << shift);

   222 

   223 	switch(conversion)

   224 	{

   225 	case lRGBA | (sRGBA << shift): r = gamma(r); g = gamma(g); b = gamma(b); break;							//1

   226 	case lRGBA | (lLA << shift)  : r = g = b = lRGBtoL(r, g, b); break;										//3

   227 	case lRGBA | (sLA << shift)  : r = g = b = gamma(lRGBtoL(r, g, b)); break;								//3,5

   228 	case sRGBA | (lRGBA << shift): r = invgamma(r); g = invgamma(g); b = invgamma(b); break;				//2

   229 	case sRGBA | (lLA << shift)  : r = g = b = lRGBtoL(invgamma(r), invgamma(g), invgamma(b)); break;		//2,3

   230 	case sRGBA | (sLA << shift)  : r = g = b = gamma(lRGBtoL(invgamma(r), invgamma(g), invgamma(b))); break;//2,3,5

   231 	case lLA   | (lRGBA << shift): break;																	//4

   232 	case lLA   | (sRGBA << shift): r = g = b = gamma(r); break;												//4,1

   233 	case lLA   | (sLA << shift)  : r = g = b = gamma(r); break;												//5

   234 	case sLA   | (lRGBA << shift): r = g = b = invgamma(r); break;											//7,2

   235 	case sLA   | (sRGBA << shift): break;																	//7

   236 	case sLA   | (lLA << shift)  : r = g = b = invgamma(r); break;											//6

   237 	default: RI_ASSERT((m_format & (LUMINANCE | NONLINEAR)) == (outputFormat & (LUMINANCE | NONLINEAR))); break;	//nop

   238 	}

   239 

   240 	if(outputFormat & PREMULTIPLIED)

   241 	{	//premultiply

   242 		r *= a;

   243 		g *= a;

   244 		b *= a;

   245 	}

   246 	m_format = outputFormat;

   247 

   248     assertConsistency();

   249 }

   250 

   251 /*-------------------------------------------------------------------*//*!

   252 * \brief	Creates a pixel format descriptor out of VGImageFormat

   253 * \param	

   254 * \return	

   255 * \note		

   256 *//*-------------------------------------------------------------------*/

   257 

   258 Color::Descriptor Color::formatToDescriptor(VGImageFormat format)

   259 {

   260 	Descriptor desc;

   261 	memset(&desc, 0, sizeof(Descriptor));

   262 	RI_ASSERT(isValidImageFormat(format));

   263 

   264 	int baseFormat = (int)format & 15;

   265 	const int numBaseFormats = 15;

   266 	RI_ASSERT(baseFormat >= 0 && baseFormat < numBaseFormats);

   267 	int swizzleBits = ((int)format >> 6) & 3;

   268 

   269 	/* base formats

   270 	VG_sRGBX_8888                               =  0,

   271 	VG_sRGBA_8888                               =  1,

   272 	VG_sRGBA_8888_PRE                           =  2,

   273 	VG_sRGB_565                                 =  3,

   274 	VG_sRGBA_5551                               =  4,

   275 	VG_sRGBA_4444                               =  5,

   276 	VG_sL_8                                     =  6,

   277 	VG_lRGBX_8888                               =  7,

   278 	VG_lRGBA_8888                               =  8,

   279 	VG_lRGBA_8888_PRE                           =  9,

   280 	VG_lL_8                                     = 10,

   281 	VG_A_8                                      = 11,

   282 	VG_BW_1                                     = 12,

   283 	VG_A_1                                      = 13,

   284 	VG_A_4                                      = 14,

   285 	*/

   286 

   287 	static const int redBits[numBaseFormats] =       {8, 8, 8, 5, 5, 4, 0, 8, 8, 8, 0, 0, 0, 0, 0};

   288 	static const int greenBits[numBaseFormats] =     {8, 8, 8, 6, 5, 4, 0, 8, 8, 8, 0, 0, 0, 0, 0};

   289 	static const int blueBits[numBaseFormats] =      {8, 8, 8, 5, 5, 4, 0, 8, 8, 8, 0, 0, 0, 0, 0};

   290 	static const int alphaBits[numBaseFormats] =     {0, 8, 8, 0, 1, 4, 0, 0, 8, 8, 0, 8, 0, 1, 4};

   291 	static const int luminanceBits[numBaseFormats] = {0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 8, 0, 1, 0, 0};

   292 

   293 	static const int redShifts[4*numBaseFormats] = {24, 24, 24, 11, 11, 12, 0, 24, 24, 24, 0, 0, 0, 0, 0,	//RGBA

   294 													16, 16, 16, 11, 10, 8,  0, 16, 16, 16, 0, 0, 0, 0, 0,	//ARGB

   295 													8,  8,  8,  0,  1,  4,  0, 8,  8,  8,  0, 0, 0, 0, 0,	//BGRA

   296 													0,  0,  0,  0,  0,  0,  0, 0,  0,  0,  0, 0, 0, 0, 0};	//ABGR

   297 

   298 	static const int greenShifts[4*numBaseFormats] = {16, 16, 16, 5,  6,  8,  0, 16, 16, 16, 0, 0, 0, 0, 0,	//RGBA

   299 													  8,  8,  8,  5,  5,  4,  0, 8,  8,  8,  0, 0, 0, 0, 0,	//ARGB

   300 													  16, 16, 16, 5,  6,  8,  0, 16, 16, 16, 0, 0, 0, 0, 0,	//BGRA

   301 													  8,  8,  8,  5,  5,  4,  0, 8,  8,  8,  0, 0, 0, 0, 0};//ABGR

   302 

   303 	static const int blueShifts[4*numBaseFormats] =  {8,  8,  8,  0,  1,  4,  0, 8,  8,  8,  0, 0, 0, 0, 0,	//RGBA

   304 													  0,  0,  0,  0,  0,  0,  0, 0,  0,  0,  0, 0, 0, 0, 0,	//ARGB

   305 													  24, 24, 24, 11, 11, 12, 0, 24, 24, 24, 0, 0, 0, 0, 0,	//BGRA

   306 													  16, 16, 16, 11, 10, 8,  0, 16, 16, 16, 0, 0, 0, 0, 0};//ABGR

   307 

   308 	static const int alphaShifts[4*numBaseFormats] = {0,  0,  0,  0,  0,  0,  0, 0,  0,  0,  0, 0, 0, 0, 0,	//RGBA

   309 													  0,  24, 24, 0,  15, 12, 0, 0,  24, 24, 0, 0, 0, 0, 0,	//ARGB

   310 													  0,  0,  0,  0,  0,  0,  0, 0,  0,  0,  0, 0, 0, 0, 0,	//BGRA

   311 													  0,  24, 24, 0,  15, 12, 0, 0,  24, 24, 0, 0, 0, 0, 0};//ABGR

   312 

   313 	static const int bpps[numBaseFormats] = {32, 32, 32, 16, 16, 16, 8, 32, 32, 32, 8, 8, 1, 1, 4};

   314 

   315 	static const InternalFormat internalFormats[numBaseFormats] = {sRGBA, sRGBA, sRGBA_PRE, sRGBA, sRGBA, sRGBA, sLA, lRGBA, lRGBA, lRGBA_PRE, lLA, lRGBA, lLA, lRGBA, lRGBA};

   316 

   317 	desc.redBits = redBits[baseFormat];

   318 	desc.greenBits = greenBits[baseFormat];

   319 	desc.blueBits = blueBits[baseFormat];

   320 	desc.alphaBits = alphaBits[baseFormat];

   321 	desc.luminanceBits = luminanceBits[baseFormat];

   322 

   323 	desc.redShift = redShifts[swizzleBits * numBaseFormats + baseFormat];

   324 	desc.greenShift = greenShifts[swizzleBits * numBaseFormats + baseFormat];

   325 	desc.blueShift = blueShifts[swizzleBits * numBaseFormats + baseFormat];

   326 	desc.alphaShift = alphaShifts[swizzleBits * numBaseFormats + baseFormat];

   327 	desc.luminanceShift = 0;	//always zero

   328 

   329 	desc.format = format;

   330 	desc.bitsPerPixel = bpps[baseFormat];

   331 	desc.internalFormat = internalFormats[baseFormat];

   332 

   333 	return desc;

   334 }

   335 

   336 /*-------------------------------------------------------------------*//*!

   337 * \brief	Checks if the pixel format descriptor is valid (i.e. all the

   338 *           values are supported by the RI)

   339 * \param	

   340 * \return	

   341 * \note		

   342 *//*-------------------------------------------------------------------*/

   343 

   344 bool Color::isValidDescriptor(const Color::Descriptor& desc)

   345 {

   346 	//A valid descriptor has 1, 2, 4, 8, 16, or 32 bits per pixel, and either luminance or rgba channels, but not both.

   347 	//Any of the rgba channels can be missing, and not all bits need to be used. Maximum channel bit depth is 8.

   348 	int rb = desc.redBits;

   349 	int gb = desc.greenBits;

   350 	int bb = desc.blueBits;

   351 	int ab = desc.alphaBits;

   352 	int lb = desc.luminanceBits;

   353 	int rs = desc.redShift;

   354 	int gs = desc.greenShift;

   355 	int bs = desc.blueShift;

   356 	int as = desc.alphaShift;

   357 	int ls = desc.luminanceShift;

   358 	int bpp = desc.bitsPerPixel;

   359 

   360 	int rgbaBits = rb + gb + bb + ab;

   361 	if(rb < 0 || rb > 8 || rs < 0 || rs + rb > bpp || !(rb || !rs))

   362 		return false;	//invalid channel description

   363 	if(gb < 0 || gb > 8 || gs < 0 || gs + gb > bpp || !(gb || !gs))

   364 		return false;	//invalid channel description

   365 	if(bb < 0 || bb > 8 || bs < 0 || bs + bb > bpp || !(bb || !bs))

   366 		return false;	//invalid channel description

   367 	if(ab < 0 || ab > 8 || as < 0 || as + ab > bpp || !(ab || !as))

   368 		return false;	//invalid channel description

   369 	if(lb < 0 || lb > 8 || ls < 0 || ls + lb > bpp || !(lb || !ls))

   370 		return false;	//invalid channel description

   371 

   372 	if(rgbaBits && lb)

   373 		return false;	//can't have both rgba and luminance

   374 	if(!rgbaBits && !lb)

   375 		return false;	//must have either rgba or luminance

   376 	if(rgbaBits)

   377 	{	//rgba

   378 		if(rb+gb+bb == 0)

   379 		{	//alpha only

   380 			if(rs || gs || bs || as || ls)

   381 				return false;	//wrong shifts (even alpha shift must be zero)

   382 			if((ab != 1 && ab != 2  && ab != 4 && ab != 8) || bpp != ab)

   383 				return false;	//alpha size must be 1, 2, 4, or, 8, bpp must match

   384 		}

   385 		else

   386 		{	//rgba

   387 			if(rgbaBits > bpp)

   388 				return false;	//bpp must be greater than or equal to the sum of rgba bits

   389 			if(!(bpp == 32 || bpp == 16 || bpp == 8))

   390 				return false;	//only 1, 2, and 4 byte formats are supported for rgba

   391 			

   392 			unsigned int rm = bitsToMask((unsigned int)rb, (unsigned int)rs);

   393 			unsigned int gm = bitsToMask((unsigned int)gb, (unsigned int)gs);

   394 			unsigned int bm = bitsToMask((unsigned int)bb, (unsigned int)bs);

   395 			unsigned int am = bitsToMask((unsigned int)ab, (unsigned int)as);

   396 			if((rm & gm) || (rm & bm) || (rm & am) || (gm & bm) || (gm & am) || (bm & am))

   397 				return false;	//channels overlap

   398 		}

   399 	}

   400 	else

   401 	{	//luminance

   402 		if(rs || gs || bs || as || ls)

   403 			return false;	//wrong shifts (even luminance shift must be zero)

   404 		if(!(lb == 1 || lb == 8) || bpp != lb)

   405 			return false;	//luminance size must be either 1 or 8, bpp must match

   406 	}

   407 

   408 	if(desc.format != -1)

   409 	{

   410 		if(!isValidImageFormat(desc.format))

   411 			return false;	//invalid image format

   412 

   413 		Descriptor d = formatToDescriptor(desc.format);

   414 		if(d.redBits != rb || d.greenBits != gb || d.blueBits != bb || d.alphaBits != ab || d.luminanceBits != lb ||

   415 		   d.redShift != rs || d.greenShift != gs || d.blueShift != bs || d.alphaShift != as || d.luminanceShift != ls ||

   416 		   d.bitsPerPixel != bpp)

   417 		   return false;	//if the descriptor has a VGImageFormat, it must match the bits, shifts, and bpp

   418 	}

   419 

   420 	if((unsigned int)desc.internalFormat & ~(Color::PREMULTIPLIED | Color::NONLINEAR | Color::LUMINANCE))

   421 		return false;	//invalid internal format

   422 

   423 	return true;

   424 }

   425 

   426 //==============================================================================================

   427 

   428 

   429 

   430 

   431 //==============================================================================================

   432 

   433 /*-------------------------------------------------------------------*//*!

   434 * \brief	Constructs a blank image.

   435 * \param	

   436 * \return	

   437 * \note		

   438 *//*-------------------------------------------------------------------*/

   439 

   440 Image::Image(const Color::Descriptor& desc, int width, int height, VGbitfield allowedQuality) :

   441 	m_desc(desc),

   442 	m_width(width),

   443 	m_height(height),

   444 	m_allowedQuality(allowedQuality),

   445 	m_inUse(0),

   446 	m_stride(0),

   447 	m_data(NULL),

   448 	m_referenceCount(0),

   449 	m_ownsData(true),

   450 	m_parent(NULL),

   451     m_storageOffsetX(0),

   452     m_storageOffsetY(0),

   453 	m_mipmapsValid(false),

   454 	m_mipmaps()

   455 {

   456 	RI_ASSERT(Color::isValidDescriptor(m_desc));

   457 	RI_ASSERT(width > 0 && height > 0);

   458 	

   459 	m_stride = (m_width*m_desc.bitsPerPixel+7)/8;

   460 	

   461 	m_data = RI_NEW_ARRAY(RIuint8, m_stride*m_height);	//throws bad_alloc

   462 	memset(m_data, 0, m_stride*m_height);	//clear image

   463 }

   464 

   465 /*-------------------------------------------------------------------*//*!

   466 * \brief	Constructs an image that uses an external array for its data

   467 *			storage.

   468 * \param	

   469 * \return	

   470 * \note		this is meant for internal use to make blitting easier

   471 *//*-------------------------------------------------------------------*/

   472 

   473 Image::Image(const Color::Descriptor& desc, int width, int height, int stride, RIuint8* data) :

   474 	m_desc(desc),

   475 	m_width(width),

   476 	m_height(height),

   477 	m_allowedQuality(0),

   478 	m_inUse(0),

   479 	m_stride(stride),

   480 	m_data(data),

   481 	m_referenceCount(0),

   482 	m_ownsData(false),

   483 	m_parent(NULL),

   484     m_storageOffsetX(0),

   485     m_storageOffsetY(0),

   486 	m_mipmapsValid(false),

   487 	m_mipmaps()

   488 {

   489 	RI_ASSERT(Color::isValidDescriptor(m_desc));

   490 	RI_ASSERT(width > 0 && height > 0);

   491 	RI_ASSERT(data);

   492 }

   493 

   494 /*-------------------------------------------------------------------*//*!

   495 * \brief	Construcs a child image.

   496 * \param	

   497 * \return	

   498 * \note		

   499 *//*-------------------------------------------------------------------*/

   500 

   501 Image::Image(Image* parent, int x, int y, int width, int height) :

   502 	m_desc(Color::formatToDescriptor(VG_sRGBA_8888)),	//dummy initialization, will be overwritten below (can't read from parent->m_desc before knowing the pointer is valid)

   503 	m_width(width),

   504 	m_height(height),

   505 	m_allowedQuality(0),

   506 	m_inUse(0),

   507 	m_stride(0),

   508 	m_data(NULL),

   509 	m_referenceCount(0),

   510 	m_ownsData(false),

   511 	m_parent(parent),

   512     m_storageOffsetX(0),

   513     m_storageOffsetY(0),

   514 	m_mipmapsValid(false),

   515 	m_mipmaps()

   516 {

   517 	RI_ASSERT(parent);

   518 	RI_ASSERT(x >= 0 && y >= 0 && width > 0 && height > 0);

   519 	RI_ASSERT(RI_INT_ADDSATURATE(x,width) <= parent->m_width && RI_INT_ADDSATURATE(y,height) <= parent->m_height);	//child image must be contained in parent

   520 

   521 	m_desc = parent->m_desc;

   522 	RI_ASSERT(Color::isValidDescriptor(m_desc));

   523 	m_allowedQuality = parent->m_allowedQuality;

   524 	m_stride = parent->m_stride;

   525 	m_data = parent->m_data;

   526     m_storageOffsetX = parent->m_storageOffsetX + x;

   527     m_storageOffsetY = parent->m_storageOffsetY + y;

   528 

   529 	//increase the reference and use count of the parent

   530 	addInUse();

   531 	parent->addInUse();

   532 	parent->addReference();

   533 }

   534 

   535 /*-------------------------------------------------------------------*//*!

   536 * \brief	Image destructor.

   537 * \param	

   538 * \return	

   539 * \note		

   540 *//*-------------------------------------------------------------------*/

   541 

   542 Image::~Image()

   543 {

   544 	RI_ASSERT(m_referenceCount == 0);

   545 

   546 	if(m_parent)

   547 	{

   548 		//decrease the reference and use count of the parent

   549 		removeInUse();

   550 		m_parent->removeInUse();

   551 		if(!m_parent->removeReference())

   552 			RI_DELETE(m_parent);

   553 	}

   554 	RI_ASSERT(m_inUse == 0);

   555 

   556 	for(int i=0;i<m_mipmaps.size();i++)

   557 	{

   558 		if(!m_mipmaps[i]->removeReference())

   559 			RI_DELETE(m_mipmaps[i]);

   560 		else

   561 		{

   562 			RI_ASSERT(0);	//there can't be any other references to the mipmap levels

   563 		}

   564 	}

   565 	m_mipmaps.clear();

   566 

   567 	if(m_ownsData)

   568 	{

   569 		RI_ASSERT(!m_parent);		//can't have parent if owns the data

   570 		RI_DELETE_ARRAY(m_data);	//delete image data if we own it

   571 	}

   572 }

   573 

   574 /*-------------------------------------------------------------------*//*!

   575 * \brief	Returns true if the two images share pixels.

   576 * \param	

   577 * \return	

   578 * \note		

   579 *//*-------------------------------------------------------------------*/

   580 

   581 bool Image::overlaps(const Image* src) const

   582 {

   583 	RI_ASSERT(src);

   584 

   585 	if(m_data != src->m_data)

   586 		return false;	//images don't share data

   587 

   588 	//check if the image storage regions overlap

   589 	Rectangle r(m_storageOffsetX, m_storageOffsetY, m_width, m_height);

   590 	r.intersect(Rectangle(src->m_storageOffsetX, src->m_storageOffsetY, src->m_width, src->m_height));

   591 	if(!r.width || !r.height)

   592 		return false;	//intersection is empty, images don't overlap	

   593 

   594 	return true;

   595 }

   596 

   597 /*-------------------------------------------------------------------*//*!

   598 * \brief	Clears a rectangular portion of an image with the given clear color.

   599 * \param	

   600 * \return	

   601 * \note		

   602 *//*-------------------------------------------------------------------*/

   603 

   604 void Image::clear(const Color& clearColor, int x, int y, int w, int h)

   605 {

   606 	RI_ASSERT(m_data);

   607 	RI_ASSERT(m_referenceCount > 0);

   608 

   609 	//intersect clear region with image bounds

   610 	Rectangle r(0,0,m_width,m_height);

   611 	r.intersect(Rectangle(x,y,w,h));

   612 	if(!r.width || !r.height)

   613 		return;		//intersection is empty or one of the rectangles is invalid

   614 

   615 	Color col = clearColor;

   616 	col.clamp();

   617 	col.convert(m_desc.internalFormat);

   618 

   619 	for(int j=r.y;j<r.y + r.height;j++)

   620 	{

   621 		for(int i=r.x;i<r.x + r.width;i++)

   622 		{

   623 			writePixel(i, j, col);

   624 		}

   625 	}

   626 

   627 	m_mipmapsValid = false;

   628 }

   629 

   630 /*-------------------------------------------------------------------*//*!

   631 * \brief	Blits a source region to destination. Source and destination

   632 *			can overlap.

   633 * \param	

   634 * \return	

   635 * \note		

   636 *//*-------------------------------------------------------------------*/

   637 

   638 static RIfloat ditherChannel(RIfloat c, int bits, RIfloat m)

   639 {

   640 	RIfloat fc = c * (RIfloat)((1<<bits)-1);

   641 	RIfloat ic = (RIfloat)floor(fc);

   642 	if(fc - ic > m) ic += 1.0f;

   643 	return RI_MIN(ic / (RIfloat)((1<<bits)-1), 1.0f);

   644 }

   645 

   646 static void computeBlitRegion(int& sx, int& sy, int& dx, int& dy, int& w, int& h, int srcWidth, int srcHeight, int dstWidth, int dstHeight)

   647 {

   648 	RI_ASSERT(w > 0 && h > 0);

   649 	sx = RI_INT_MIN(RI_INT_MAX(sx, (int)(RI_INT32_MIN>>2)), (int)(RI_INT32_MAX>>2));

   650 	sy = RI_INT_MIN(RI_INT_MAX(sy, (int)(RI_INT32_MIN>>2)), (int)(RI_INT32_MAX>>2));

   651 	dx = RI_INT_MIN(RI_INT_MAX(dx, (int)(RI_INT32_MIN>>2)), (int)(RI_INT32_MAX>>2));

   652 	dy = RI_INT_MIN(RI_INT_MAX(dy, (int)(RI_INT32_MIN>>2)), (int)(RI_INT32_MAX>>2));

   653 	w = RI_INT_MIN(w, (int)(RI_INT32_MAX>>2));

   654 	h = RI_INT_MIN(h, (int)(RI_INT32_MAX>>2));

   655 	int srcsx = sx, srcex = sx + w, dstsx = dx, dstex = dx + w;

   656 	if(srcsx < 0)

   657 	{

   658 		dstsx -= srcsx;

   659 		srcsx = 0;

   660 	}

   661 	if(srcex > srcWidth)

   662 	{

   663 		dstex -= srcex - srcWidth;

   664 		srcex = srcWidth;

   665 	}

   666 	if(dstsx < 0)

   667 	{

   668 		srcsx -= dstsx;

   669 		dstsx = 0;

   670 	}

   671 	if(dstex > dstWidth)

   672 	{

   673 		srcex -= dstex - dstWidth;

   674 		dstex = dstWidth;

   675 	}

   676 	RI_ASSERT(srcsx >= 0 && dstsx >= 0 && srcex <= srcWidth && dstex <= dstWidth);

   677 	w = srcex - srcsx;

   678 	RI_ASSERT(w == dstex - dstsx);

   679 

   680 	int srcsy = sy, srcey = sy + h, dstsy = dy, dstey = dy + h;

   681 	if(srcsy < 0)

   682 	{

   683 		dstsy -= srcsy;

   684 		srcsy = 0;

   685 	}

   686 	if(srcey > srcHeight)

   687 	{

   688 		dstey -= srcey - srcHeight;

   689 		srcey = srcHeight;

   690 	}

   691 	if(dstsy < 0)

   692 	{

   693 		srcsy -= dstsy;

   694 		dstsy = 0;

   695 	}

   696 	if(dstey > dstHeight)

   697 	{

   698 		srcey -= dstey - dstHeight;

   699 		dstey = dstHeight;

   700 	}

   701 	RI_ASSERT(srcsy >= 0 && dstsy >= 0 && srcey <= srcHeight && dstey <= dstHeight);

   702 	h = srcey - srcsy;

   703 	RI_ASSERT(h == dstey - dstsy);

   704 	sx = srcsx;

   705 	sy = srcsy;

   706 	dx = dstsx;

   707 	dy = dstsy;

   708 }

   709 

   710 void Image::blit(const Image& src, int sx, int sy, int dx, int dy, int w, int h, bool dither)

   711 {

   712 	//img=>img: vgCopyImage

   713 	//img=>user: vgGetImageSubData

   714 	//user=>img: vgImageSubData

   715 	RI_ASSERT(src.m_data);	//source exists

   716 	RI_ASSERT(m_data);	//destination exists

   717 	RI_ASSERT(m_referenceCount > 0 && src.m_referenceCount > 0);

   718 

   719 	computeBlitRegion(sx, sy, dx, dy, w, h, src.m_width, src.m_height, m_width, m_height);

   720 	if(w <= 0 || h <= 0)

   721 		return;	//zero area

   722 

   723 	Array<Color> tmp;

   724 	tmp.resize(w*h);	//throws bad_alloc

   725 

   726 	//copy source region to tmp

   727 	for(int j=0;j<h;j++)

   728 	{

   729 		for(int i=0;i<w;i++)

   730 		{

   731 			Color c = src.readPixel(sx + i, sy + j);

   732 			c.convert(m_desc.internalFormat);

   733 			tmp[j*w+i] = c;

   734 		}

   735 	}

   736 

   737 	int rbits = m_desc.redBits, gbits = m_desc.greenBits, bbits = m_desc.blueBits, abits = m_desc.alphaBits;

   738 	if(m_desc.isLuminance())

   739 	{

   740 		rbits = gbits = bbits = m_desc.luminanceBits;

   741 		abits = 0;

   742 	}

   743 

   744 	//write tmp to destination region

   745 	for(int j=0;j<h;j++)

   746 	{

   747 		for(int i=0;i<w;i++)

   748 		{

   749 			Color col = tmp[j*w+i];

   750 

   751 			if(dither)

   752 			{

   753 				static const int matrix[16] = {

   754 					0,  8,  2,  10,

   755 					12, 4,  14, 6,

   756 					3,  11, 1,  9,

   757 					15, 7,  13, 5};

   758 				int x = i & 3;

   759 				int y = j & 3;

   760 				RIfloat m = matrix[y*4+x] / 16.0f;

   761 

   762 				if(rbits) col.r = ditherChannel(col.r, rbits, m);

   763 				if(gbits) col.g = ditherChannel(col.g, gbits, m);

   764 				if(bbits) col.b = ditherChannel(col.b, bbits, m);

   765 				if(abits) col.a = ditherChannel(col.a, abits, m);

   766 			}

   767 

   768 			writePixel(dx + i, dy + j, col);

   769 		}

   770 	}

   771 	m_mipmapsValid = false;

   772 }

   773 

   774 /*-------------------------------------------------------------------*//*!

   775 * \brief	Converts from multisampled format to display format.

   776 * \param	

   777 * \return	

   778 * \note

   779 *//*-------------------------------------------------------------------*/

   780 

   781 void Image::blit(const Surface* src, int sx, int sy, int dx, int dy, int w, int h)

   782 {

   783 	//fb=>img: vgGetPixels

   784 	//fb=>user: vgReadPixels

   785 	RI_ASSERT(!src->isInUse(this));

   786 

   787 	computeBlitRegion(sx, sy, dx, dy, w, h, src->getWidth(), src->getHeight(), m_width, m_height);

   788 	if(w <= 0 || h <= 0)

   789 		return;	//zero area

   790 

   791 	for(int y=0;y<h;y++)

   792 	{

   793 		for(int x=0;x<w;x++)

   794 		{

   795 			Color r = src->FSAAResolve(sx + x, sy + y);

   796 			r.convert(getDescriptor().internalFormat);

   797 			writePixel(dx + x, dy + y, r);

   798 		}

   799 	}

   800 }

   801 

   802 /*-------------------------------------------------------------------*//*!

   803 * \brief	Returns the color at pixel (x,y).

   804 * \param	

   805 * \return	

   806 * \note		

   807 *//*-------------------------------------------------------------------*/

   808 

   809 Color Image::readPixel(int x, int y) const

   810 {

   811 	RI_ASSERT(m_data);

   812 	RI_ASSERT(x >= 0 && x < m_width);

   813 	RI_ASSERT(y >= 0 && y < m_height);

   814 	RI_ASSERT(m_referenceCount > 0);

   815     x += m_storageOffsetX;

   816     y += m_storageOffsetY;

   817 

   818 	unsigned int p = 0;

   819 	RIuint8* scanline = m_data + y * m_stride;

   820 	switch(m_desc.bitsPerPixel)

   821 	{

   822 	case 32:

   823 	{

   824 		RIuint32* s = (((RIuint32*)scanline) + x);

   825 		p = (unsigned int)*s;

   826 		break;

   827 	}

   828 

   829 	case 16:

   830 	{

   831 		RIuint16* s = ((RIuint16*)scanline) + x;

   832 		p = (unsigned int)*s;

   833 		break;

   834 	}

   835 

   836     case 8:

   837 	{

   838 		RIuint8* s = ((RIuint8*)scanline) + x;

   839 		p = (unsigned int)*s;

   840 		break;

   841 	}

   842 

   843     case 4:

   844 	{

   845 		RIuint8* s = ((RIuint8*)scanline) + (x>>1);

   846 		p = (unsigned int)(*s >> ((x&1)<<2)) & 0xf;

   847 		break;

   848 	}

   849 

   850     case 2:

   851 	{

   852 		RIuint8* s = ((RIuint8*)scanline) + (x>>2);

   853 		p = (unsigned int)(*s >> ((x&3)<<1)) & 0x3;

   854 		break;

   855 	}

   856 

   857     default:

   858 	{

   859 		RI_ASSERT(m_desc.bitsPerPixel == 1);

   860 		RIuint8* s = ((RIuint8*)scanline) + (x>>3);

   861 		p = (unsigned int)(*s >> (x&7)) & 0x1;

   862 		break;

   863 	}

   864 	}

   865 	Color c;

   866 	c.unpack(p, m_desc);

   867 	return c;

   868 }

   869 

   870 /*-------------------------------------------------------------------*//*!

   871 * \brief	Writes the color to pixel (x,y). Internal color formats must

   872 *			match.

   873 * \param	

   874 * \return	

   875 * \note		

   876 *//*-------------------------------------------------------------------*/

   877 

   878 void Image::writePixel(int x, int y, const Color& c)

   879 {

   880 	RI_ASSERT(m_data);

   881 	RI_ASSERT(x >= 0 && x < m_width);

   882 	RI_ASSERT(y >= 0 && y < m_height);

   883 	RI_ASSERT(m_referenceCount > 0);

   884 	RI_ASSERT(c.getInternalFormat() == m_desc.internalFormat);

   885     x += m_storageOffsetX;

   886     y += m_storageOffsetY;

   887 

   888 	unsigned int p = c.pack(m_desc);

   889 	RIuint8* scanline = m_data + y * m_stride;

   890 	switch(m_desc.bitsPerPixel)

   891 	{

   892 	case 32:

   893 	{

   894 		RIuint32* s = ((RIuint32*)scanline) + x;

   895 		*s = (RIuint32)p;

   896 		break;

   897 	}

   898 

   899 	case 16:

   900 	{

   901 		RIuint16* s = ((RIuint16*)scanline) + x;

   902 		*s = (RIuint16)p;

   903 		break;

   904 	}

   905 

   906 	case 8:

   907 	{

   908 		RIuint8* s = ((RIuint8*)scanline) + x;

   909 		*s = (RIuint8)p;

   910 		break;

   911 	}

   912     case 4:

   913 	{

   914 		RIuint8* s = ((RIuint8*)scanline) + (x>>1);

   915         *s = (RIuint8)((p << ((x&1)<<2)) | ((unsigned int)*s & ~(0xf << ((x&1)<<2))));

   916 		break;

   917 	}

   918 

   919     case 2:

   920 	{

   921 		RIuint8* s = ((RIuint8*)scanline) + (x>>2);

   922         *s = (RIuint8)((p << ((x&3)<<1)) | ((unsigned int)*s & ~(0x3 << ((x&3)<<1))));

   923 		break;

   924 	}

   925 

   926     default:

   927 	{

   928 		RI_ASSERT(m_desc.bitsPerPixel == 1);

   929 		RIuint8* s = ((RIuint8*)scanline) + (x>>3);

   930         *s = (RIuint8)((p << (x&7)) | ((unsigned int)*s & ~(0x1 << (x&7))));

   931 		break;

   932 	}

   933 	}

   934 	m_mipmapsValid = false;

   935 }

   936 

   937 /*-------------------------------------------------------------------*//*!

   938 * \brief	Writes a filtered color to destination surface

   939 * \param	

   940 * \return	

   941 * \note		

   942 *//*-------------------------------------------------------------------*/

   943 

   944 void Image::writeFilteredPixel(int i, int j, const Color& color, VGbitfield channelMask)

   945 {

   946 	//section 3.4.4: before color space conversion, premultiplied colors are

   947 	//clamped to alpha, and the color is converted to nonpremultiplied format

   948 	//section 11.2: how to deal with channel mask

   949 	//step 1

   950 	Color f = color;

   951 	f.clamp();			//vgColorMatrix and vgLookups can produce colors that exceed alpha or [0,1] range

   952 

   953 	//step 2: color space conversion

   954 	f.convert((Color::InternalFormat)(m_desc.internalFormat & (Color::NONLINEAR | Color::LUMINANCE)));

   955 

   956 	//step 3: read the destination color and convert it to nonpremultiplied

   957 	Color d = readPixel(i,j);

   958 	d.unpremultiply();

   959 	RI_ASSERT(d.getInternalFormat() == f.getInternalFormat());

   960 

   961 	//step 4: replace the destination channels specified by the channelMask (channelmask is ignored for luminance formats)

   962     if(!m_desc.isLuminance())

   963     {   //rgba format => use channelmask

   964         if(channelMask & VG_RED)

   965             d.r = f.r;

   966         if(channelMask & VG_GREEN)

   967             d.g = f.g;

   968         if(channelMask & VG_BLUE)

   969             d.b = f.b;

   970         if(channelMask & VG_ALPHA)

   971             d.a = f.a;

   972     }

   973     else d = f;

   974 

   975 	//step 5: if destination is premultiplied, convert to premultiplied format

   976 	if(m_desc.isPremultiplied())

   977 		d.premultiply();

   978 	//write the color to destination

   979 	writePixel(i,j,d);

   980 }

   981 

   982 /*-------------------------------------------------------------------*//*!

   983 * \brief	Reads the pixel (x,y) and converts it into an alpha mask value.

   984 * \param	

   985 * \return	

   986 * \note		

   987 *//*-------------------------------------------------------------------*/

   988 

   989 RIfloat Image::readMaskPixel(int x, int y) const

   990 {

   991 	RI_ASSERT(m_data);

   992 	RI_ASSERT(x >= 0 && x < m_width);

   993 	RI_ASSERT(y >= 0 && y < m_height);

   994 	RI_ASSERT(m_referenceCount > 0);

   995 

   996 	Color c = readPixel(x,y);

   997 	if(m_desc.isLuminance())

   998 	{

   999 		return c.r;

  1000 	}

  1001 	else

  1002 	{	//rgba

  1003 		if(m_desc.alphaBits)

  1004 			return c.a;

  1005 		return c.r;

  1006 	}

  1007 }

  1008 

  1009 /*-------------------------------------------------------------------*//*!

  1010 * \brief	Writes the alpha mask to pixel (x,y).

  1011 * \param	

  1012 * \return	

  1013 * \note		Overwrites color.

  1014 *//*-------------------------------------------------------------------*/

  1015 

  1016 void Image::writeMaskPixel(int x, int y, RIfloat m)

  1017 {

  1018 	RI_ASSERT(m_data);

  1019 	RI_ASSERT(x >= 0 && x < m_width);

  1020 	RI_ASSERT(y >= 0 && y < m_height);

  1021 	RI_ASSERT(m_referenceCount > 0);

  1022 

  1023     //if luminance or no alpha, red channel will be used, otherwise alpha channel will be used

  1024     writePixel(x, y, Color(m,m,m,m,m_desc.internalFormat));

  1025 }

  1026 

  1027 /*-------------------------------------------------------------------*//*!

  1028 * \brief	Reads a texel (u,v) at the given mipmap level. Tiling modes and

  1029 *			color space conversion are applied. Outputs color in premultiplied

  1030 *			format.

  1031 * \param	

  1032 * \return	

  1033 * \note		

  1034 *//*-------------------------------------------------------------------*/

  1035 

  1036 Color Image::readTexel(int u, int v, int level, VGTilingMode tilingMode, const Color& tileFillColor) const

  1037 {

  1038 	const Image* image = this;

  1039 	if( level > 0 )

  1040 	{

  1041 		RI_ASSERT(level <= m_mipmaps.size());

  1042 		image = m_mipmaps[level-1];

  1043 	}

  1044 	RI_ASSERT(image);

  1045 

  1046 	Color p;

  1047 	if(tilingMode == VG_TILE_FILL)

  1048 	{

  1049 		if(u < 0 || v < 0 || u >= image->m_width || v >= image->m_height)

  1050 			p = tileFillColor;

  1051 		else

  1052 			p = image->readPixel(u, v);

  1053 	}

  1054 	else if(tilingMode == VG_TILE_PAD)

  1055 	{

  1056 		u = RI_INT_MIN(RI_INT_MAX(u,0),image->m_width-1);

  1057 		v = RI_INT_MIN(RI_INT_MAX(v,0),image->m_height-1);

  1058 		p = image->readPixel(u, v);

  1059 	}

  1060 	else if(tilingMode == VG_TILE_REPEAT)

  1061 	{

  1062 		u = RI_INT_MOD(u, image->m_width);

  1063 		v = RI_INT_MOD(v, image->m_height);

  1064 		p = image->readPixel(u, v);

  1065 	}

  1066 	else

  1067 	{

  1068 		RI_ASSERT(tilingMode == VG_TILE_REFLECT);

  1069 

  1070 		u = RI_INT_MOD(u, image->m_width*2);

  1071 		v = RI_INT_MOD(v, image->m_height*2);

  1072 		if( u >= image->m_width ) u = image->m_width*2-1 - u;

  1073 		if( v >= image->m_height ) v = image->m_height*2-1 - v;

  1074 		p = image->readPixel(u, v);

  1075 	}

  1076 

  1077 	p.premultiply();    //interpolate in premultiplied format

  1078 	return p;

  1079 }

  1080 

  1081 /*-------------------------------------------------------------------*//*!

  1082 * \brief	Maps point (x,y) to an image and returns a filtered,

  1083 *			premultiplied color value.

  1084 * \param	

  1085 * \return	

  1086 * \note		

  1087 *//*-------------------------------------------------------------------*/

  1088 

  1089 Color Image::resample(RIfloat x, RIfloat y, const Matrix3x3& surfaceToImage, VGImageQuality quality, VGTilingMode tilingMode, const Color& tileFillColor)	//throws bad_alloc

  1090 {

  1091 	RI_ASSERT(m_referenceCount > 0);

  1092 

  1093 	VGbitfield aq = getAllowedQuality();

  1094 	aq &= (VGbitfield)quality;

  1095 

  1096 	Vector3 uvw(x,y,1.0f);

  1097 	uvw = surfaceToImage * uvw;

  1098 	RIfloat oow = 1.0f / uvw.z;

  1099 	uvw *= oow;

  1100 

  1101 	if(aq & VG_IMAGE_QUALITY_BETTER)

  1102 	{	//EWA on mipmaps

  1103 		makeMipMaps();	//throws bad_alloc

  1104 

  1105 		Color::InternalFormat procFormat = (Color::InternalFormat)(m_desc.internalFormat | Color::PREMULTIPLIED);

  1106 

  1107 		RIfloat m_pixelFilterRadius = 1.25f;

  1108 		RIfloat m_resamplingFilterRadius = 1.25f;

  1109 

  1110 		RIfloat Ux = (surfaceToImage[0][0] - uvw.x * surfaceToImage[2][0]) * oow * m_pixelFilterRadius;

  1111 		RIfloat Vx = (surfaceToImage[1][0] - uvw.y * surfaceToImage[2][0]) * oow * m_pixelFilterRadius;

  1112 		RIfloat Uy = (surfaceToImage[0][1] - uvw.x * surfaceToImage[2][1]) * oow * m_pixelFilterRadius;

  1113 		RIfloat Vy = (surfaceToImage[1][1] - uvw.y * surfaceToImage[2][1]) * oow * m_pixelFilterRadius;

  1114 		RIfloat U0 = uvw.x;

  1115 		RIfloat V0 = uvw.y;

  1116 

  1117 		//calculate mip level

  1118 		int level = 0;

  1119 		RIfloat axis1sq = Ux*Ux + Vx*Vx;

  1120 		RIfloat axis2sq = Uy*Uy + Vy*Vy;

  1121 		RIfloat minorAxissq = RI_MIN(axis1sq,axis2sq);

  1122 		while(minorAxissq > 9.0f && level < m_mipmaps.size())	//half the minor axis must be at least three texels

  1123 		{

  1124 			level++;

  1125 			minorAxissq *= 0.25f;

  1126 		}

  1127 

  1128 		RIfloat sx = 1.0f;

  1129 		RIfloat sy = 1.0f;

  1130 		if(level > 0)

  1131 		{

  1132 			sx = (RIfloat)m_mipmaps[level-1]->m_width / (RIfloat)m_width;

  1133 			sy = (RIfloat)m_mipmaps[level-1]->m_height / (RIfloat)m_height;

  1134 		}