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

 *

 * 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	Implementations of OpenVG API functions.

 * \note	The actual processing is done in Path, Image, Rasterizer and PixelPipe classes.

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

#include "openvg.h"

#include "egl.h"

#include "riContext.h"

#include "riRasterizer.h"

#include "riPixelPipe.h"

#include "riPath.h"

#include <stdio.h>

#ifdef BUILD_WITH_PRIVATE_OPENVG

#include "openvginternal.h"

#endif

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

namespace OpenVGRI

{

/* EGL&OS functions for use in an OpenVG implementation */

void* eglvgGetCurrentVGContext(void);

bool  eglvgIsInUse(void* image);

void  OSAcquireMutex(void);

void  OSReleaseMutex(void);

#define RI_NO_RETVAL

//this must be the first line in an API function

#define RI_GET_CONTEXT(RETVAL) \

	OSAcquireMutex(); \

	VGContext* context = (VGContext*)eglvgGetCurrentVGContext(); \

	if(!context) \

	{ \

		OSReleaseMutex(); \

		return RETVAL;\

	}

#define RI_IF_ERROR(COND, ERRORCODE, RETVAL) \

	if(COND) { context->setError(ERRORCODE); OSReleaseMutex(); return RETVAL; }

//all API functions must call this as their last operation (also functions that don't return values)

//NOTE: don't evaluate anything or read state in RETVAL (it'll be executed after the mutex has been released)

#define RI_RETURN(RETVAL) \

	{ OSReleaseMutex(); \

	return RETVAL; }

static bool isAligned(const void* ptr, int alignment)

{

	RI_ASSERT(alignment == 1 || alignment == 2 || alignment == 4);

	if(((RIuintptr)ptr) & (alignment-1))

		return false;

	return true;

}

static bool isAligned(const void* ptr, VGImageFormat format)

{

	RI_ASSERT(isValidImageFormat(format));

	int alignment = Color::formatToDescriptor(format).bitsPerPixel >> 3;

	if(alignment <= 1)

		return true;	//one bit or byte per pixel

	return isAligned(ptr, alignment);

}

bool isValidImageFormat(int f)

{

	if(f < VG_sRGBX_8888 || f > VG_lABGR_8888_PRE)

		return false;

	return true;

}

bool isValidImageFormat(EGLNativePixmapType f)

  {

#warning TODO: implement isValidImageFormat for EGLNativePixmapType arg

  return false;

  }

}	//namespace OpenVGRI

using namespace OpenVGRI;

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

* \brief	

* \param	

* \return	

* \note		

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

#ifdef BUILD_WITH_PRIVATE_OPENVG

void RI_APIENTRY do_vgFlush(void)

#else

void RI_APIENTRY vgFlush(void)

#endif

{

	RI_GET_CONTEXT(RI_NO_RETVAL);

	//the RI doesn't cache anything, so this is a no-op

	RI_RETURN(RI_NO_RETVAL);

}

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

* \brief	

* \param	

* \return	

* \note		

*//*-----

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

#ifdef BUILD_WITH_PRIVATE_OPENVG

void RI_APIENTRY do_vgFinish(void)

#else

void RI_APIENTRY vgFinish(void)

#endif

{

	RI_GET_CONTEXT(RI_NO_RETVAL);

	//the RI doesn't cache anything, so this is a no-op

	RI_RETURN(RI_NO_RETVAL);

}

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

* \brief	

* \param	

* \return	

* \note		

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

#ifdef BUILD_WITH_PRIVATE_OPENVG

VGErrorCode RI_APIENTRY do_vgGetError(void)

#else

VGErrorCode RI_APIENTRY vgGetError(void)

#endif

{

	RI_GET_CONTEXT(VG_NO_CONTEXT_ERROR);

	VGErrorCode error = context->m_error;

	context->m_error = VG_NO_ERROR;

	RI_RETURN(error);

}

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

* \brief	

* \param	

* \return	

* \note		

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

namespace OpenVGRI

{

RIfloat inputFloat(VGfloat f)

{

	//this function is used for all floating point input values

	if(RI_ISNAN(f)) return 0.0f;	//convert NaN to zero

	return RI_CLAMP(f, -RI_FLOAT_MAX, RI_FLOAT_MAX);	//clamp +-inf to +-RIfloat max

}

Vector2 inputVector2(const Vector2& v)

{

    return Vector2(inputFloat(v.x), inputFloat(v.y));

}

Color inputColor(const Color& c)

{

    Color r = c;

    r.r = inputFloat(r.r);

    r.g = inputFloat(r.g);

    r.b = inputFloat(r.b);

    r.a = inputFloat(r.a);

    return r;

}

static int inputFloatToInt(VGfloat value)

{

	double v = (double)floor(value);

	v = v > (double)RI_INT32_MAX ? (double)RI_INT32_MAX : v;

	v = v < (double)RI_INT32_MIN ? (double)RI_INT32_MIN : v;

	return (int)v;

}

static int paramToInt(const void* values, bool floats, int count, int i)

{

	RI_ASSERT(i >= 0);

	if(i >= count || !values)

		return 0;

	if(floats)

		return inputFloatToInt(((const VGfloat*)values)[i]);

	return (int)((const VGint*)values)[i];

}

static RIfloat paramToFloat(const void* values, bool floats, int count, int i)

{

	RI_ASSERT(i >= 0);

	if(i >= count || !values)

		return 0.0f;

	if(floats)

		return ((const VGfloat*)values)[i];

	return (RIfloat)((const VGint*)values)[i];

}

static void floatToParam(void* output, bool outputFloats, int count, int i, VGfloat value)

{

	RI_ASSERT(i >= 0);

	RI_ASSERT(output);

	if(i >= count)

		return;

	if(outputFloats)

		((VGfloat*)output)[i] = value;

	else

		((VGint*)output)[i] = (VGint)inputFloatToInt(value);

}

static void intToParam(void* output, bool outputFloats, int count, int i, VGint value)

{

	RI_ASSERT(i >= 0);

	RI_ASSERT(output);

	if(i >= count)

		return;

	if(outputFloats)

		((VGfloat*)output)[i] = (VGfloat)value;

	else

		((VGint*)output)[i] = value;

}

}	//namespace OpenVGRI

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

* \brief	

* \param	

* \return	

* \note		

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

static void setifv(VGContext* context, VGParamType type, VGint count, const void* values, bool floats)

{

	RI_ASSERT(context);

	RI_ASSERT(!count || (count && values));

	int ivalue = paramToInt(values, floats, count, 0);

	RIfloat fvalue = paramToFloat(values, floats, count, 0);

	switch(type)

	{

	case VG_MATRIX_MODE:

		if(count != 1 || ivalue < VG_MATRIX_PATH_USER_TO_SURFACE || ivalue > VG_MATRIX_GLYPH_USER_TO_SURFACE)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

		context->m_matrixMode = (VGMatrixMode)ivalue;

		break;

	case VG_FILL_RULE:

		if(count != 1 || ivalue < VG_EVEN_ODD || ivalue > VG_NON_ZERO)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

		context->m_fillRule = (VGFillRule)ivalue;

		break;

	case VG_IMAGE_QUALITY:

		if(count != 1 || ivalue < VG_IMAGE_QUALITY_NONANTIALIASED || ivalue > VG_IMAGE_QUALITY_BETTER)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

		context->m_imageQuality = (VGImageQuality)ivalue;

		break;

	case VG_RENDERING_QUALITY:

		if(count != 1 || ivalue < VG_RENDERING_QUALITY_NONANTIALIASED || ivalue > VG_RENDERING_QUALITY_BETTER)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

		context->m_renderingQuality = (VGRenderingQuality)ivalue;

		break;

	case VG_BLEND_MODE:

		if(count != 1 || ivalue < VG_BLEND_SRC || ivalue > VG_BLEND_ADDITIVE)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

		context->m_blendMode = (VGBlendMode)ivalue;

		break;

	case VG_IMAGE_MODE:

		if(count != 1 || ivalue < VG_DRAW_IMAGE_NORMAL || ivalue > VG_DRAW_IMAGE_STENCIL)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

		context->m_imageMode = (VGImageMode)ivalue;

		break;

	case VG_SCISSOR_RECTS:

	{

		if(count & 3)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }	//count must be a multiple of four

		try

		{

			Array<Rectangle> scissor;

			for(int i=0;i<RI_INT_MIN(count, RI_MAX_SCISSOR_RECTANGLES*4);i+=4)

			{

				Rectangle s;

				s.x = paramToInt(values, floats, count, i+0);

				s.y = paramToInt(values, floats, count, i+1);

				s.width = paramToInt(values, floats, count, i+2);

				s.height = paramToInt(values, floats, count, i+3);

				scissor.push_back(s);	//throws bad_alloc

			}

			context->m_scissor.swap(scissor);	//replace context data

		}

		catch(std::bad_alloc)

		{

			context->setError(VG_OUT_OF_MEMORY_ERROR);

		}

		break;

	}

	case VG_COLOR_TRANSFORM:

		if(count != 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

		context->m_colorTransform = ivalue ? VG_TRUE : VG_FALSE;

		break;

	case VG_COLOR_TRANSFORM_VALUES:

		if(count != 8 || !values) { context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

        {

            for(int i=0;i<8;i++)

            {

                context->m_inputColorTransformValues[i] = paramToFloat(values, floats, count, i);

                context->m_colorTransformValues[i] = inputFloat(context->m_inputColorTransformValues[i]);

            }

        }

		break;

	case VG_STROKE_LINE_WIDTH:

		if(count != 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

		context->m_inputStrokeLineWidth = fvalue;

        context->m_strokeLineWidth = inputFloat(fvalue);

		break;

	case VG_STROKE_CAP_STYLE:

		if(count != 1 || ivalue < VG_CAP_BUTT || ivalue > VG_CAP_SQUARE)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

		context->m_strokeCapStyle = (VGCapStyle)ivalue;

		break;

	case VG_STROKE_JOIN_STYLE:

		if(count != 1 || ivalue < VG_JOIN_MITER || ivalue > VG_JOIN_BEVEL)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

		context->m_strokeJoinStyle = (VGJoinStyle)ivalue;

		break;

	case VG_STROKE_MITER_LIMIT:

		if(count != 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

		context->m_inputStrokeMiterLimit = fvalue;

		context->m_strokeMiterLimit = inputFloat(fvalue);

		break;

	case VG_STROKE_DASH_PATTERN:

	{

		try

		{

			Array<RIfloat> inputStrokeDashPattern;

			Array<RIfloat> strokeDashPattern;

			for(int i=0;i<RI_INT_MIN(count, RI_MAX_DASH_COUNT);i++)

            {

                RIfloat v = paramToFloat(values, floats, count, i);

				inputStrokeDashPattern.push_back(v);	//throws bad_alloc

				strokeDashPattern.push_back(inputFloat(v));	//throws bad_alloc

            }

			context->m_inputStrokeDashPattern.swap(inputStrokeDashPattern);	//replace context data

			context->m_strokeDashPattern.swap(strokeDashPattern);	//replace context data

		}

		catch(std::bad_alloc)

		{

			context->setError(VG_OUT_OF_MEMORY_ERROR);

		}

		break;

	}

	case VG_STROKE_DASH_PHASE:

		if(count != 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

		context->m_inputStrokeDashPhase = fvalue;

		context->m_strokeDashPhase = inputFloat(fvalue);

		break;

	case VG_STROKE_DASH_PHASE_RESET:

		if(count != 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

		context->m_strokeDashPhaseReset = ivalue ? VG_TRUE : VG_FALSE;

		break;

	case VG_TILE_FILL_COLOR:

		if(count != 4 || !values) { context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

		context->m_inputTileFillColor.set(paramToFloat(values, floats, count, 0),

									 paramToFloat(values, floats, count, 1),

									 paramToFloat(values, floats, count, 2),

									 paramToFloat(values, floats, count, 3),

									 Color::sRGBA);

        context->m_tileFillColor = inputColor(context->m_inputTileFillColor);

		break;

	case VG_GLYPH_ORIGIN:

		if(count != 2 || !values) { context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

		context->m_inputGlyphOrigin.x = paramToFloat(values, floats, count, 0);

		context->m_inputGlyphOrigin.y = paramToFloat(values, floats, count, 1);

		context->m_glyphOrigin = inputVector2(context->m_inputGlyphOrigin);

		break;

	case VG_CLEAR_COLOR:

		if(count != 4 || !values) { context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

		context->m_inputClearColor.set(paramToFloat(values, floats, count, 0),

								  paramToFloat(values, floats, count, 1),

								  paramToFloat(values, floats, count, 2),

								  paramToFloat(values, floats, count, 3),

								  Color::sRGBA);

        context->m_clearColor = inputColor(context->m_inputClearColor);

		break;

	case VG_MASKING:

		if(count != 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

		context->m_masking = ivalue ? VG_TRUE : VG_FALSE;

		break;

	case VG_SCISSORING:

		if(count != 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

		context->m_scissoring = ivalue ? VG_TRUE : VG_FALSE;

		break;

	case VG_PIXEL_LAYOUT:

		if(count != 1 || ivalue < VG_PIXEL_LAYOUT_UNKNOWN || ivalue > VG_PIXEL_LAYOUT_BGR_HORIZONTAL)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

		context->m_pixelLayout = (VGPixelLayout)ivalue;

		break;

	case VG_SCREEN_LAYOUT:

		if(count != 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

		break;	//setting read-only values has no effect

	case VG_FILTER_FORMAT_LINEAR:

		if(count != 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

		context->m_filterFormatLinear = ivalue ? VG_TRUE : VG_FALSE;

		break;

	case VG_FILTER_FORMAT_PREMULTIPLIED:

		if(count != 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

		context->m_filterFormatPremultiplied = ivalue ? VG_TRUE : VG_FALSE;

		break;

	case VG_FILTER_CHANNEL_MASK:

		if(count != 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

		//undefined bits are ignored

		context->m_filterChannelMask = (VGbitfield)ivalue;

		break;

	case VG_MAX_SCISSOR_RECTS:

	case VG_MAX_DASH_COUNT:

	case VG_MAX_KERNEL_SIZE:

	case VG_MAX_SEPARABLE_KERNEL_SIZE:

	case VG_MAX_COLOR_RAMP_STOPS:

	case VG_MAX_IMAGE_WIDTH:

	case VG_MAX_IMAGE_HEIGHT:

	case VG_MAX_IMAGE_PIXELS:

	case VG_MAX_IMAGE_BYTES:

	case VG_MAX_FLOAT:

	case VG_MAX_GAUSSIAN_STD_DEVIATION:

		if(count != 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

		break;	//setting read-only values has no effect

	default:

		context->setError(VG_ILLEGAL_ARGUMENT_ERROR);	//invalid VGParamType

		break;

	}

}

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

* \brief	

* \param	

* \return	

* \note		

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

#ifdef BUILD_WITH_PRIVATE_OPENVG

void RI_APIENTRY do_vgSetf(VGParamType type, VGfloat value)

#else

void RI_APIENTRY vgSetf(VGParamType type, VGfloat value)

#endif

{

	RI_GET_CONTEXT(RI_NO_RETVAL);

	RI_IF_ERROR(type == VG_SCISSOR_RECTS || type == VG_STROKE_DASH_PATTERN || type == VG_TILE_FILL_COLOR ||

				type == VG_CLEAR_COLOR, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);	//vector type value

	VGfloat values[1] = {value};

	setifv(context, type, 1, values, true);

	RI_RETURN(RI_NO_RETVAL);

}

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

* \brief	

* \param	

* \return	

* \note		

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

#ifdef BUILD_WITH_PRIVATE_OPENVG

void RI_APIENTRY do_vgSeti(VGParamType type, VGint value)

#else

void RI_APIENTRY vgSeti(VGParamType type, VGint value)

#endif

{

	RI_GET_CONTEXT(RI_NO_RETVAL);

	RI_IF_ERROR(type == VG_SCISSOR_RECTS || type == VG_STROKE_DASH_PATTERN || type == VG_TILE_FILL_COLOR ||

				type == VG_CLEAR_COLOR, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);	//vector type value

	VGint values[1] = {value};

	setifv(context, type, 1, values, false);

	RI_RETURN(RI_NO_RETVAL);

}

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

* \brief	

* \param	

* \return	

* \note		

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

#ifdef BUILD_WITH_PRIVATE_OPENVG

void RI_APIENTRY do_vgSetiv(VGParamType type, VGint count, const VGint * values)

#else