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

 *

 * OpenVG 1.1 Reference Implementation

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

 *

 * Copyright (c) 2007 The Khronos Group Inc.

 * Portions copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

 *

 * 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 "VG/openvg.h"

#include "VG/vgext.h"

#include "riContext.h"

#include "riRasterizer.h"

#include "riPixelPipe.h"

#include "riPath.h"

#include <stdio.h>

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

namespace OpenVGRI

{

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

// \note To ensure that different EGLs work in parallel, these functions must be implemented.

// They may be wrappers if the underlying EGL is more complicated that miniEGL.

void* eglvgGetCurrentVGContext(void);

bool  eglvgIsInUse(void* image);

bool  eglvgLockSurface(bool read, bool write);

bool  eglvgUnlockSurface();

void  OSAcquireMutex(void);

void  OSReleaseMutex(void);

void  eglvgGetImageDescriptor( void* image, Color::Descriptor &desc, int &width, int &height, int &stride );

void*  eglvgGetImageData( void* image );

#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;

}

}	//namespace OpenVGRI

using namespace OpenVGRI;

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

* \brief

* \param

* \return

* \note

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

void RI_APIENTRY vgFlush(void)

{

    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

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

void RI_APIENTRY vgFinish(void)

{

    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

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

VGErrorCode RI_APIENTRY vgGetError(void)

{

    RI_GET_CONTEXT(VG_NO_CONTEXT_ERROR);

    VGErrorCode error = context->m_error;

    context->m_error = VG_NO_ERROR;

    RI_RETURN(error);

}

VGErrorCode RI_APIENTRY vgSimulatorGetError(void)

{

    RI_GET_CONTEXT(VG_NO_CONTEXT_ERROR);

    VGErrorCode error = context->m_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_FASTER || 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_FASTER || 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<OpenVGRI::Rectangle> scissor;

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

            {

                OpenVGRI::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

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

void RI_APIENTRY vgSetf(VGParamType type, VGfloat value)

{

    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

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

void RI_APIENTRY vgSeti(VGParamType type, VGint value)

{

    RI_GET_CONTEXT(RI_NO_RETVAL);