/*------------------------------------------------------------------------

 *

 * OpenVG 1.1 Reference Implementation

 * -----------------------------------

 *

 * Copyright (c) 2007 The Khronos Group Inc.

 *

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

 * copy of this software and /or associated documentation files

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

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

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

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

 * subject to the following conditions: 

 *

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

 * in all copies or substantial portions of the Materials. 

 *

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

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

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

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

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

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

 * THE USE OR OTHER DEALINGS IN THE MATERIALS.

 *

 *//**

 * \file

 * \brief	Implementation of Color and Image functions.

 * \note	

 *//*-------------------------------------------------------------------*/

#include "riImage.h"

#include "riRasterizer.h"

//==============================================================================================

namespace OpenVGRI

{

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

* \brief	Converts from numBits into a shifted mask

* \param	

* \return	

* \note

*//*-------------------------------------------------------------------*/

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

{

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

}

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

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

*			given maximum with round-to-nearest semantics.

* \param	

* \return	

* \note		

*//*-------------------------------------------------------------------*/

static unsigned int colorToInt(RIfloat c, int maxc)

{

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

}

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

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

*			mapped to 1.0f.

* \param	

* \return	

* \note		

*//*-------------------------------------------------------------------*/

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

{

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

}

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

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

* \param	

* \return	

* \note		

*//*-------------------------------------------------------------------*/

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

{

	int rb = inputDesc.redBits;

	int gb = inputDesc.greenBits;

	int bb = inputDesc.blueBits;

	int ab = inputDesc.alphaBits;

	int lb = inputDesc.luminanceBits;

	int rs = inputDesc.redShift;

	int gs = inputDesc.greenShift;

	int bs = inputDesc.blueShift;

	int as = inputDesc.alphaShift;

	int ls = inputDesc.luminanceShift;

	m_format = inputDesc.internalFormat;

	if(lb)

	{	//luminance

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

		a = 1.0f;

	}

	else

	{	//rgba

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

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

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

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

		if(isPremultiplied())

		{	//clamp premultiplied color to alpha to enforce consistency

			r = RI_MIN(r, a);

			g = RI_MIN(g, a);

			b = RI_MIN(b, a);

		}

	}

    assertConsistency();

}

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

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

* \param	

* \return	

* \note		

*//*-------------------------------------------------------------------*/

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

{

    assertConsistency();

	int rb = outputDesc.redBits;

	int gb = outputDesc.greenBits;

	int bb = outputDesc.blueBits;

	int ab = outputDesc.alphaBits;

	int lb = outputDesc.luminanceBits;

	int rs = outputDesc.redShift;

	int gs = outputDesc.greenShift;

	int bs = outputDesc.blueShift;

	int as = outputDesc.alphaShift;

	int ls = outputDesc.luminanceShift;

	if(lb)

	{	//luminance

		RI_ASSERT(isLuminance());

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

	}

	else

	{	//rgb

		RI_ASSERT(!isLuminance());

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

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

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

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

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

	}

}

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

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

* \param	

* \return	

* \note		

*//*-------------------------------------------------------------------*/

static RIfloat gamma(RIfloat c)

{

	if( c <= 0.00304f )

		c *= 12.92f;

	else

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

	return c;

}

static RIfloat invgamma(RIfloat c)

{

	if( c <= 0.03928f )

		c /= 12.92f;

	else

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

	return c;

}

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

{

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

}

void Color::convert(InternalFormat outputFormat)

{

    assertConsistency();

	if( m_format == outputFormat )

		return;

	if(isPremultiplied())

	{	//unpremultiply

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

		r *= ooa;

		g *= ooa;

		b *= ooa;

	}

	//From Section 3.4.2 of OpenVG spec

	//1: sRGB = gamma(lRGB)

	//2: lRGB = invgamma(sRGB)

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

	//4: lRGB = lL

	//5: sL = gamma(lL)

	//6: lL = invgamma(sL)

	//7: sRGB = sL

	//Source/Dest lRGB sRGB   lL   sL 

	//lRGB          -    1    3    3,5 

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

	//lL            4    4,1  -    5 

	//sL            7,2  7    6    - 

	const unsigned int shift = 3;

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

	switch(conversion)

	{

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

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

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

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

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

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

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

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

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

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

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

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

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

	}

	if(outputFormat & PREMULTIPLIED)

	{	//premultiply

		r *= a;

		g *= a;

		b *= a;

	}

	m_format = outputFormat;

    assertConsistency();

}

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

* \brief	Creates a pixel format descriptor out of VGImageFormat

* \param	

* \return	

* \note		

*//*-------------------------------------------------------------------*/

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

{

	Descriptor desc;

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

	RI_ASSERT(isValidImageFormat(format));

	int baseFormat = (int)format & 15;

	const int numBaseFormats = 15;

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

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

	/* base formats

	VG_sRGBX_8888                               =  0,

	VG_sRGBA_8888                               =  1,

	VG_sRGBA_8888_PRE                           =  2,

	VG_sRGB_565                                 =  3,

	VG_sRGBA_5551                               =  4,

	VG_sRGBA_4444                               =  5,

	VG_sL_8                                     =  6,

	VG_lRGBX_8888                               =  7,

	VG_lRGBA_8888                               =  8,

	VG_lRGBA_8888_PRE                           =  9,

	VG_lL_8                                     = 10,

	VG_A_8                                      = 11,

	VG_BW_1                                     = 12,

	VG_A_1                                      = 13,

	VG_A_4                                      = 14,

	*/

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	desc.redBits = redBits[baseFormat];

	desc.greenBits = greenBits[baseFormat];

	desc.blueBits = blueBits[baseFormat];

	desc.alphaBits = alphaBits[baseFormat];

	desc.luminanceBits = luminanceBits[baseFormat];

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

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

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

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

	desc.luminanceShift = 0;	//always zero

	desc.format = format;

	desc.bitsPerPixel = bpps[baseFormat];

	desc.internalFormat = internalFormats[baseFormat];

	return desc;

}

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

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

*           values are supported by the RI)

* \param	

* \return	

* \note		

*//*-------------------------------------------------------------------*/

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

{

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

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

	int rb = desc.redBits;

	int gb = desc.greenBits;

	int bb = desc.blueBits;

	int ab = desc.alphaBits;

	int lb = desc.luminanceBits;

	int rs = desc.redShift;

	int gs = desc.greenShift;

	int bs = desc.blueShift;

	int as = desc.alphaShift;

	int ls = desc.luminanceShift;

	int bpp = desc.bitsPerPixel;

	int rgbaBits = rb + gb + bb + ab;

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

		return false;	//invalid channel description

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

		return false;	//invalid channel description

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

		return false;	//invalid channel description

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

		return false;	//invalid channel description

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

		return false;	//invalid channel description

	if(rgbaBits && lb)

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

	if(!rgbaBits && !lb)

		return false;	//must have either rgba or luminance

	if(rgbaBits)

	{	//rgba

		if(rb+gb+bb == 0)

		{	//alpha only

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

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

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

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

		}

		else

		{	//rgba

			if(rgbaBits > bpp)

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

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

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

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

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

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

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

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

				return false;	//channels overlap

		}

	}

	else

	{	//luminance

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

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

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

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

	}

	if(desc.format != -1)

	{

		if(!isValidImageFormat(desc.format))

			return false;	//invalid image format

		Descriptor d = formatToDescriptor(desc.format);

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

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

		   d.bitsPerPixel != bpp)

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

	}

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

		return false;	//invalid internal format

	return true;

}

//==============================================================================================

//==============================================================================================

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

* \brief	Constructs a blank image.

* \param	

* \return	

* \note		

*//*-------------------------------------------------------------------*/

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

	m_desc(desc),

	m_width(width),

	m_height(height),

	m_allowedQuality(allowedQuality),

	m_inUse(0),

	m_stride(0),

	m_data(NULL),

	m_referenceCount(0),

	m_ownsData(true),

	m_parent(NULL),

    m_storageOffsetX(0),

    m_storageOffsetY(0),

	m_mipmapsValid(false),

	m_mipmaps()

{

	RI_ASSERT(Color::isValidDescriptor(m_desc));

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

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

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

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

}

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

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

*			storage.

* \param	

* \return	

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

*//*-------------------------------------------------------------------*/

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

	m_desc(desc),

	m_width(width),

	m_height(height),

	m_allowedQuality(0),

	m_inUse(0),

	m_stride(stride),

	m_data(data),

	m_referenceCount(0),

	m_ownsData(false),

	m_parent(NULL),

    m_storageOffsetX(0),

    m_storageOffsetY(0),

	m_mipmapsValid(false),

	m_mipmaps()

{

	RI_ASSERT(Color::isValidDescriptor(m_desc));

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

	RI_ASSERT(data);

}

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

* \brief	Construcs a child image.

* \param	

* \return	

* \note		

*//*-------------------------------------------------------------------*/

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

	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)

	m_width(width),

	m_height(height),

	m_allowedQuality(0),

	m_inUse(0),

	m_stride(0),

	m_data(NULL),

	m_referenceCount(0),

	m_ownsData(false),

	m_parent(parent),

    m_storageOffsetX(0),

    m_storageOffsetY(0),

	m_mipmapsValid(false),

	m_mipmaps()

{

	RI_ASSERT(parent);

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

	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

	m_desc = parent->m_desc;

	RI_ASSERT(Color::isValidDescriptor(m_desc));

	m_allowedQuality = parent->m_allowedQuality;

	m_stride = parent->m_stride;

	m_data = parent->m_data;

    m_storageOffsetX = parent->m_storageOffsetX + x;

    m_storageOffsetY = parent->m_storageOffsetY + y;

	//increase the reference and use count of the parent