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

     2  *

     3  * OpenVG 1.1 Reference Implementation

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

     5  *

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

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

     8  *

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

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

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

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

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

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

    15  * subject to the following conditions:

    16  *

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

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

    19  *

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

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

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

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

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

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

    26  * THE USE OR OTHER DEALINGS IN THE MATERIALS.

    27  *

    28  *//**

    29  * \file

    30  * \brief	Implementations of OpenVG API functions.

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

    32  *//*-------------------------------------------------------------------*/

    33 

    34 #include "openvg.h"

    35 #include "vgext.h"

    36 #include "riContext.h"

    37 #include "riRasterizer.h"

    38 #include "riPixelPipe.h"

    39 #include "riPath.h"

    40 #include <stdio.h>

    41 

    42 //==============================================================================================

    43 

    44 namespace OpenVGRI

    45 {

    46 

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

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

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

    50 void* eglvgGetCurrentVGContext(void);

    51 bool  eglvgIsInUse(void* image);

    52 bool  eglvgLockSurface(bool read, bool write);

    53 bool  eglvgUnlockSurface();

    54 void  OSAcquireMutex(void);

    55 void  OSReleaseMutex(void);

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

    57 void*  eglvgGetImageData( void* image );

    58 

    59 #define RI_NO_RETVAL

    60 

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

    62 #define RI_GET_CONTEXT(RETVAL) \

    63     OSAcquireMutex(); \

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

    65     if(!context) \

    66     { \

    67         OSReleaseMutex(); \

    68         return RETVAL;\

    69     }

    70 

    71 #define RI_IF_ERROR(COND, ERRORCODE, RETVAL) \

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

    73 

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

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

    76 #define RI_RETURN(RETVAL) \

    77     { OSReleaseMutex(); \

    78     return RETVAL; }

    79 

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

    81 {

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

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

    84         return false;

    85     return true;

    86 }

    87 

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

    89 {

    90     RI_ASSERT(isValidImageFormat(format));

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

    92     if(alignment <= 1)

    93         return true;	//one bit or byte per pixel

    94     return isAligned(ptr, alignment);

    95 }

    96 

    97 bool isValidImageFormat(int f)

    98 {

    99     if(f < VG_sRGBX_8888 || f > VG_lABGR_8888_PRE)

   100         return false;

   101     return true;

   102 }

   103 

   104 }	//namespace OpenVGRI

   105 

   106 using namespace OpenVGRI;

   107 

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

   109 * \brief

   110 * \param

   111 * \return

   112 * \note

   113 *//*-------------------------------------------------------------------*/

   114 

   115 void RI_APIENTRY vgFlush(void)

   116 {

   117     RI_GET_CONTEXT(RI_NO_RETVAL);

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

   119     RI_RETURN(RI_NO_RETVAL);

   120 }

   121 

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

   123 * \brief

   124 * \param

   125 * \return

   126 * \note

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

   128 

   129 void RI_APIENTRY vgFinish(void)

   130 {

   131     RI_GET_CONTEXT(RI_NO_RETVAL);

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

   133     RI_RETURN(RI_NO_RETVAL);

   134 }

   135 

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

   137 * \brief

   138 * \param

   139 * \return

   140 * \note

   141 *//*-------------------------------------------------------------------*/

   142 

   143 VGErrorCode RI_APIENTRY vgGetError(void)

   144 {

   145     RI_GET_CONTEXT(VG_NO_CONTEXT_ERROR);

   146     VGErrorCode error = context->m_error;

   147     context->m_error = VG_NO_ERROR;

   148     RI_RETURN(error);

   149 }

   150 

   151 VGErrorCode RI_APIENTRY vgPlatsimGetError(void)

   152 {

   153     RI_GET_CONTEXT(VG_NO_CONTEXT_ERROR);

   154     VGErrorCode error = context->m_error;

   155     RI_RETURN(error);

   156 }

   157 

   158 

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

   160 * \brief

   161 * \param

   162 * \return

   163 * \note

   164 *//*-------------------------------------------------------------------*/

   165 

   166 namespace OpenVGRI

   167 {

   168 

   169 RIfloat inputFloat(VGfloat f)

   170 {

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

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

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

   174 }

   175 

   176 Vector2 inputVector2(const Vector2& v)

   177 {

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

   179 }

   180 

   181 Color inputColor(const Color& c)

   182 {

   183     Color r = c;

   184     r.r = inputFloat(r.r);

   185     r.g = inputFloat(r.g);

   186     r.b = inputFloat(r.b);

   187     r.a = inputFloat(r.a);

   188     return r;

   189 }

   190 

   191 static int inputFloatToInt(VGfloat value)

   192 {

   193     double v = (double)floor(value);

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

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

   196     return (int)v;

   197 }

   198 

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

   200 {

   201     RI_ASSERT(i >= 0);

   202     if(i >= count || !values)

   203         return 0;

   204     if(floats)

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

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

   207 }

   208 

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

   210 {

   211     RI_ASSERT(i >= 0);

   212     if(i >= count || !values)

   213         return 0.0f;

   214     if(floats)

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

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

   217 }

   218 

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

   220 {

   221     RI_ASSERT(i >= 0);

   222     RI_ASSERT(output);

   223     if(i >= count)

   224         return;

   225     if(outputFloats)

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

   227     else

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

   229 }

   230 

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

   232 {

   233     RI_ASSERT(i >= 0);

   234     RI_ASSERT(output);

   235     if(i >= count)

   236         return;

   237     if(outputFloats)

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

   239     else

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

   241 }

   242 

   243 }	//namespace OpenVGRI

   244 

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

   246 * \brief

   247 * \param

   248 * \return

   249 * \note

   250 *//*-------------------------------------------------------------------*/

   251 

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

   253 {

   254     RI_ASSERT(context);

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

   256 

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

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

   259 

   260     switch(type)

   261     {

   262     case VG_MATRIX_MODE:

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

   264         context->m_matrixMode = (VGMatrixMode)ivalue;

   265         break;

   266 

   267     case VG_FILL_RULE:

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

   269         context->m_fillRule = (VGFillRule)ivalue;

   270         break;

   271 

   272     case VG_IMAGE_QUALITY:

   273         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; }

   274         context->m_imageQuality = (VGImageQuality)ivalue;

   275         break;

   276 

   277     case VG_RENDERING_QUALITY:

   278         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; }

   279         context->m_renderingQuality = (VGRenderingQuality)ivalue;

   280         break;

   281 

   282     case VG_BLEND_MODE:

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

   284         context->m_blendMode = (VGBlendMode)ivalue;

   285         break;

   286 

   287     case VG_IMAGE_MODE:

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

   289         context->m_imageMode = (VGImageMode)ivalue;

   290         break;

   291 

   292     case VG_SCISSOR_RECTS:

   293     {

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

   295         try

   296         {

   297             Array<OpenVGRI::Rectangle> scissor;

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

   299             {

   300                 OpenVGRI::Rectangle s;

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

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

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

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

   305                 scissor.push_back(s);	//throws bad_alloc

   306             }

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

   308         }

   309         catch(std::bad_alloc)

   310         {

   311             context->setError(VG_OUT_OF_MEMORY_ERROR);

   312         }

   313         break;

   314     }

   315 

   316     case VG_COLOR_TRANSFORM:

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

   318         context->m_colorTransform = ivalue ? VG_TRUE : VG_FALSE;

   319         break;

   320 

   321     case VG_COLOR_TRANSFORM_VALUES:

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

   323         {

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

   325             {

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

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

   328             }

   329         }

   330         break;

   331 

   332     case VG_STROKE_LINE_WIDTH:

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

   334         context->m_inputStrokeLineWidth = fvalue;

   335         context->m_strokeLineWidth = inputFloat(fvalue);

   336         break;

   337 

   338     case VG_STROKE_CAP_STYLE:

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

   340         context->m_strokeCapStyle = (VGCapStyle)ivalue;

   341         break;

   342 

   343     case VG_STROKE_JOIN_STYLE:

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

   345         context->m_strokeJoinStyle = (VGJoinStyle)ivalue;

   346         break;

   347 

   348     case VG_STROKE_MITER_LIMIT:

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

   350         context->m_inputStrokeMiterLimit = fvalue;

   351         context->m_strokeMiterLimit = inputFloat(fvalue);

   352         break;

   353 

   354     case VG_STROKE_DASH_PATTERN:

   355     {

   356         try

   357         {

   358             Array<RIfloat> inputStrokeDashPattern;

   359             Array<RIfloat> strokeDashPattern;

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

   361             {

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

   363                 inputStrokeDashPattern.push_back(v);	//throws bad_alloc

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

   365             }

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

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

   368         }

   369         catch(std::bad_alloc)

   370         {

   371             context->setError(VG_OUT_OF_MEMORY_ERROR);

   372         }

   373         break;

   374     }

   375 

   376     case VG_STROKE_DASH_PHASE:

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

   378         context->m_inputStrokeDashPhase = fvalue;

   379         context->m_strokeDashPhase = inputFloat(fvalue);

   380         break;

   381 

   382     case VG_STROKE_DASH_PHASE_RESET:

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

   384         context->m_strokeDashPhaseReset = ivalue ? VG_TRUE : VG_FALSE;

   385         break;

   386 

   387     case VG_TILE_FILL_COLOR:

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

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

   390                                      paramToFloat(values, floats, count, 1),

   391                                      paramToFloat(values, floats, count, 2),

   392                                      paramToFloat(values, floats, count, 3),

   393                                      Color::sRGBA);

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

   395         break;

   396 

   397     case VG_GLYPH_ORIGIN:

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

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

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

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

   402         break;

   403 

   404     case VG_CLEAR_COLOR:

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

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

   407                                   paramToFloat(values, floats, count, 1),

   408                                   paramToFloat(values, floats, count, 2),

   409                                   paramToFloat(values, floats, count, 3),

   410                                   Color::sRGBA);

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

   412         break;

   413 

   414     case VG_MASKING:

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

   416         context->m_masking = ivalue ? VG_TRUE : VG_FALSE;

   417         break;

   418 

   419     case VG_SCISSORING:

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

   421         context->m_scissoring = ivalue ? VG_TRUE : VG_FALSE;

   422         break;

   423 

   424     case VG_PIXEL_LAYOUT:

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

   426         context->m_pixelLayout = (VGPixelLayout)ivalue;

   427         break;

   428 

   429     case VG_SCREEN_LAYOUT:

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

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

   432 

   433     case VG_FILTER_FORMAT_LINEAR:

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

   435         context->m_filterFormatLinear = ivalue ? VG_TRUE : VG_FALSE;

   436         break;

   437 

   438     case VG_FILTER_FORMAT_PREMULTIPLIED:

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

   440         context->m_filterFormatPremultiplied = ivalue ? VG_TRUE : VG_FALSE;

   441         break;

   442 

   443     case VG_FILTER_CHANNEL_MASK:

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

   445         //undefined bits are ignored

   446         context->m_filterChannelMask = (VGbitfield)ivalue;

   447         break;

   448 

   449     case VG_MAX_SCISSOR_RECTS:

   450     case VG_MAX_DASH_COUNT:

   451     case VG_MAX_KERNEL_SIZE:

   452     case VG_MAX_SEPARABLE_KERNEL_SIZE:

   453     case VG_MAX_COLOR_RAMP_STOPS:

   454     case VG_MAX_IMAGE_WIDTH:

   455     case VG_MAX_IMAGE_HEIGHT:

   456     case VG_MAX_IMAGE_PIXELS:

   457     case VG_MAX_IMAGE_BYTES:

   458     case VG_MAX_FLOAT:

   459     case VG_MAX_GAUSSIAN_STD_DEVIATION:

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

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

   462 

   463     default:

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

   465         break;

   466     }

   467 }

   468 

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

   470 * \brief

   471 * \param

   472 * \return

   473 * \note

   474 *//*-------------------------------------------------------------------*/

   475 

   476 void RI_APIENTRY vgSetf(VGParamType type, VGfloat value)

   477 {

   478     RI_GET_CONTEXT(RI_NO_RETVAL);

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

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

   481     VGfloat values[1] = {value};

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

   483     RI_RETURN(RI_NO_RETVAL);

   484 }

   485 

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

   487 * \brief

   488 * \param

   489 * \return

   490 * \note

   491 *//*-------------------------------------------------------------------*/

   492 

   493 void RI_APIENTRY vgSeti(VGParamType type, VGint value)

   494 {

   495     RI_GET_CONTEXT(RI_NO_RETVAL);

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

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

   498     VGint values[1] = {value};

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

   500     RI_RETURN(RI_NO_RETVAL);

   501 }

   502 

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

   504 * \brief

   505 * \param

   506 * \return

   507 * \note

   508 *//*-------------------------------------------------------------------*/

   509 

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

   511 {

   512     RI_GET_CONTEXT(RI_NO_RETVAL);

   513     RI_IF_ERROR(count < 0, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);

   514     RI_IF_ERROR((!values && count > 0) || (values && !isAligned(values,4)), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);

   515     setifv(context, type, count, values, false);

   516     RI_RETURN(RI_NO_RETVAL);

   517 }

   518 

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

   520 * \brief

   521 * \param

   522 * \return

   523 * \note

   524 *//*-------------------------------------------------------------------*/

   525 

   526 void RI_APIENTRY vgSetfv(VGParamType type, VGint count, const VGfloat * values)

   527 {

   528     RI_GET_CONTEXT(RI_NO_RETVAL);

   529     RI_IF_ERROR(count < 0, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);

   530     RI_IF_ERROR((!values && count > 0) || (values && !isAligned(values,4)), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);

   531     setifv(context, type, count, values, true);

   532     RI_RETURN(RI_NO_RETVAL);

   533 }

   534 

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

   536 * \brief

   537 * \param

   538 * \return

   539 * \note

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

   541 

   542 static void getifv(VGContext* context, VGParamType type, VGint count, void* values, bool floats)

   543 {

   544     switch(type)

   545     {

   546     case VG_MATRIX_MODE:

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

   548         intToParam(values, floats, count, 0, context->m_matrixMode);

   549         break;

   550 

   551     case VG_FILL_RULE:

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

   553         intToParam(values, floats, count, 0, context->m_fillRule);

   554         break;

   555 

   556     case VG_IMAGE_QUALITY:

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

   558         intToParam(values, floats, count, 0, context->m_imageQuality);

   559         break;

   560 

   561     case VG_RENDERING_QUALITY:

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

   563         intToParam(values, floats, count, 0, context->m_renderingQuality);

   564         break;

   565 

   566     case VG_BLEND_MODE:

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

   568         intToParam(values, floats, count, 0, context->m_blendMode);

   569         break;

   570 

   571     case VG_IMAGE_MODE:

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

   573         intToParam(values, floats, count, 0, context->m_imageMode);

   574         break;

   575 

   576     case VG_SCISSOR_RECTS:

   577     {

   578         if(count > context->m_scissor.size()*4)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

   579         for(int i=0;i<context->m_scissor.size();i++)

   580         {

   581             intToParam(values, floats, count, i*4+0, context->m_scissor[i].x);

   582             intToParam(values, floats, count, i*4+1, context->m_scissor[i].y);

   583             intToParam(values, floats, count, i*4+2, context->m_scissor[i].width);

   584             intToParam(values, floats, count, i*4+3, context->m_scissor[i].height);

   585         }

   586         break;

   587     }

   588 

   589     case VG_COLOR_TRANSFORM:

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

   591         intToParam(values, floats, count, 0, context->m_colorTransform);

   592         break;

   593 

   594     case VG_COLOR_TRANSFORM_VALUES:

   595         if(count > 8) { context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

   596         {

   597             for(int i=0;i<count;i++)

   598             {

   599                 floatToParam(values, floats, count, i, context->m_inputColorTransformValues[i]);

   600             }

   601         }

   602         break;

   603 

   604     case VG_STROKE_LINE_WIDTH:

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

   606         floatToParam(values, floats, count, 0, context->m_inputStrokeLineWidth);

   607         break;

   608 

   609     case VG_STROKE_CAP_STYLE:

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

   611         intToParam(values, floats, count, 0, context->m_strokeCapStyle);

   612         break;

   613 

   614     case VG_STROKE_JOIN_STYLE:

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

   616         intToParam(values, floats, count, 0, context->m_strokeJoinStyle);

   617         break;

   618 

   619     case VG_STROKE_MITER_LIMIT:

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

   621         floatToParam(values, floats, count, 0, context->m_inputStrokeMiterLimit);

   622         break;

   623 

   624     case VG_STROKE_DASH_PATTERN:

   625     {

   626         if(count > context->m_inputStrokeDashPattern.size())	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

   627         for(int i=0;i<context->m_inputStrokeDashPattern.size();i++)

   628             floatToParam(values, floats, count, i, context->m_inputStrokeDashPattern[i]);

   629         break;

   630     }

   631 

   632     case VG_STROKE_DASH_PHASE:

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

   634         floatToParam(values, floats, count, 0, context->m_inputStrokeDashPhase);

   635         break;

   636 

   637     case VG_STROKE_DASH_PHASE_RESET:

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

   639         intToParam(values, floats, count, 0, context->m_strokeDashPhaseReset);

   640         break;

   641 

   642     case VG_TILE_FILL_COLOR:

   643         if(count > 4)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

   644         floatToParam(values, floats, count, 0, context->m_inputTileFillColor.r);

   645         floatToParam(values, floats, count, 1, context->m_inputTileFillColor.g);

   646         floatToParam(values, floats, count, 2, context->m_inputTileFillColor.b);

   647         floatToParam(values, floats, count, 3, context->m_inputTileFillColor.a);

   648         break;

   649 

   650     case VG_CLEAR_COLOR:

   651         if(count > 4)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

   652         floatToParam(values, floats, count, 0, context->m_inputClearColor.r);

   653         floatToParam(values, floats, count, 1, context->m_inputClearColor.g);

   654         floatToParam(values, floats, count, 2, context->m_inputClearColor.b);

   655         floatToParam(values, floats, count, 3, context->m_inputClearColor.a);

   656         break;

   657 

   658     case VG_GLYPH_ORIGIN:

   659         if(count > 2)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

   660         floatToParam(values, floats, count, 0, context->m_inputGlyphOrigin.x);

   661         floatToParam(values, floats, count, 1, context->m_inputGlyphOrigin.y);

   662         break;

   663 

   664     case VG_MASKING:

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

   666         intToParam(values, floats, count, 0, context->m_masking);

   667         break;

   668 

   669     case VG_SCISSORING:

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

   671         intToParam(values, floats, count, 0, context->m_scissoring);

   672         break;

   673 

   674     case VG_PIXEL_LAYOUT:

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

   676         intToParam(values, floats, count, 0, context->m_pixelLayout);

   677         break;

   678 

   679     case VG_SCREEN_LAYOUT:

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

   681         intToParam(values, floats, count, 0, VG_PIXEL_LAYOUT_UNKNOWN);

   682         break;

   683 

   684     case VG_FILTER_FORMAT_LINEAR:

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

   686         intToParam(values, floats, count, 0, context->m_filterFormatLinear);

   687         break;

   688 

   689     case VG_FILTER_FORMAT_PREMULTIPLIED:

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

   691         intToParam(values, floats, count, 0, context->m_filterFormatPremultiplied);

   692         break;

   693 

   694     case VG_FILTER_CHANNEL_MASK:

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

   696         intToParam(values, floats, count, 0, context->m_filterChannelMask);

   697         break;

   698 

   699     case VG_MAX_SCISSOR_RECTS:

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

   701         intToParam(values, floats, count, 0, RI_MAX_SCISSOR_RECTANGLES);

   702         break;

   703 

   704     case VG_MAX_DASH_COUNT:

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

   706         intToParam(values, floats, count, 0, RI_MAX_DASH_COUNT);

   707         break;

   708 

   709     case VG_MAX_KERNEL_SIZE:

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

   711         intToParam(values, floats, count, 0, RI_MAX_KERNEL_SIZE);

   712         break;

   713 

   714     case VG_MAX_SEPARABLE_KERNEL_SIZE:

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

   716         intToParam(values, floats, count, 0, RI_MAX_SEPARABLE_KERNEL_SIZE);

   717         break;

   718 

   719     case VG_MAX_COLOR_RAMP_STOPS:

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

   721         intToParam(values, floats, count, 0, RI_MAX_COLOR_RAMP_STOPS);

   722         break;

   723 

   724     case VG_MAX_IMAGE_WIDTH:

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

   726         intToParam(values, floats, count, 0, RI_MAX_IMAGE_WIDTH);

   727         break;

   728 

   729     case VG_MAX_IMAGE_HEIGHT:

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

   731         intToParam(values, floats, count, 0, RI_MAX_IMAGE_HEIGHT);

   732         break;

   733 

   734     case VG_MAX_IMAGE_PIXELS:

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

   736         intToParam(values, floats, count, 0, RI_MAX_IMAGE_PIXELS);

   737         break;

   738 

   739     case VG_MAX_IMAGE_BYTES:

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

   741         intToParam(values, floats, count, 0, RI_MAX_IMAGE_BYTES);

   742         break;

   743 

   744     case VG_MAX_FLOAT:

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

   746         floatToParam(values, floats, count, 0, RI_FLOAT_MAX);

   747         break;

   748 

   749     case VG_MAX_GAUSSIAN_STD_DEVIATION:

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

   751         floatToParam(values, floats, count, 0, RI_MAX_GAUSSIAN_STD_DEVIATION);

   752         break;

   753 

   754     default:

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

   756         break;

   757     }

   758 }

   759 

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

   761 * \brief

   762 * \param

   763 * \return

   764 * \note

   765 *//*-------------------------------------------------------------------*/

   766 

   767 VGfloat RI_APIENTRY vgGetf(VGParamType type)

   768 {

   769     RI_GET_CONTEXT(0.0f);

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

   771                 type == VG_CLEAR_COLOR, VG_ILLEGAL_ARGUMENT_ERROR, 0.0f);	//vector type value

   772     RIfloat ret = 0.0f;

   773     getifv(context, type, 1, &ret, true);

   774     RI_RETURN(ret);

   775 }

   776 

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

   778 * \brief

   779 * \param

   780 * \return

   781 * \note

   782 *//*-------------------------------------------------------------------*/

   783 

   784 VGint RI_APIENTRY vgGeti(VGParamType type)

   785 {

   786     RI_GET_CONTEXT(0);

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

   788                 type == VG_CLEAR_COLOR, VG_ILLEGAL_ARGUMENT_ERROR, 0);	//vector type value

   789     VGint ret = 0;

   790     getifv(context, type, 1, &ret, false);

   791     RI_RETURN(ret);

   792 }

   793 

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

   795 * \brief

   796 * \param

   797 * \return

   798 * \note

   799 *//*-------------------------------------------------------------------*/

   800 

   801 void RI_APIENTRY vgGetiv(VGParamType type, VGint count, VGint * values)

   802 {

   803     RI_GET_CONTEXT(RI_NO_RETVAL);

   804     RI_IF_ERROR(count <= 0, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);

   805     RI_IF_ERROR(!values || !isAligned(values,4), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);

   806     getifv(context, type, count, values, false);

   807     RI_RETURN(RI_NO_RETVAL);

   808 }

   809 

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

   811 * \brief

   812 * \param

   813 * \return

   814 * \note

   815 *//*-------------------------------------------------------------------*/

   816 

   817 void RI_APIENTRY vgGetfv(VGParamType type, VGint count, VGfloat * values)

   818 {

   819     RI_GET_CONTEXT(RI_NO_RETVAL);

   820     RI_IF_ERROR(count <= 0, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);

   821     RI_IF_ERROR(!values || !isAligned(values,4), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);

   822     getifv(context, type, count, values, true);

   823     RI_RETURN(RI_NO_RETVAL);

   824 }

   825 

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

   827 * \brief

   828 * \param

   829 * \return

   830 * \note

   831 *//*-------------------------------------------------------------------*/

   832 

   833 VGint RI_APIENTRY vgGetVectorSize(VGParamType type)

   834 {

   835     RI_GET_CONTEXT(0);

   836     VGint ret = 0;

   837     switch(type)

   838     {

   839     case VG_MATRIX_MODE:

   840     case VG_FILL_RULE:

   841     case VG_IMAGE_QUALITY:

   842     case VG_RENDERING_QUALITY:

   843     case VG_BLEND_MODE:

   844     case VG_IMAGE_MODE:

   845         ret = 1;

   846         break;

   847 

   848     case VG_SCISSOR_RECTS:

   849         ret = 4*context->m_scissor.size();

   850         break;

   851 

   852     case VG_COLOR_TRANSFORM:

   853         ret = 1;

   854         break;

   855 

   856     case VG_COLOR_TRANSFORM_VALUES:

   857         ret = 8;

   858         break;

   859 

   860     case VG_STROKE_LINE_WIDTH:

   861     case VG_STROKE_CAP_STYLE:

   862     case VG_STROKE_JOIN_STYLE:

   863     case VG_STROKE_MITER_LIMIT:

   864         ret = 1;

   865         break;

   866 

   867     case VG_STROKE_DASH_PATTERN:

   868         ret = context->m_inputStrokeDashPattern.size();

   869         break;

   870 

   871     case VG_STROKE_DASH_PHASE:

   872     case VG_STROKE_DASH_PHASE_RESET:

   873         ret = 1;

   874         break;

   875 

   876     case VG_TILE_FILL_COLOR:

   877     case VG_CLEAR_COLOR:

   878         ret = 4;

   879         break;

   880 

   881     case VG_GLYPH_ORIGIN:

   882         ret = 2;

   883         break;

   884 

   885     case VG_MASKING:

   886     case VG_SCISSORING:

   887     case VG_PIXEL_LAYOUT:

   888     case VG_SCREEN_LAYOUT:

   889     case VG_FILTER_FORMAT_LINEAR:

   890     case VG_FILTER_FORMAT_PREMULTIPLIED:

   891     case VG_FILTER_CHANNEL_MASK:

   892     case VG_MAX_SCISSOR_RECTS:

   893     case VG_MAX_DASH_COUNT:

   894     case VG_MAX_KERNEL_SIZE:

   895     case VG_MAX_SEPARABLE_KERNEL_SIZE:

   896     case VG_MAX_COLOR_RAMP_STOPS:

   897     case VG_MAX_IMAGE_WIDTH:

   898     case VG_MAX_IMAGE_HEIGHT:

   899     case VG_MAX_IMAGE_PIXELS:

   900     case VG_MAX_IMAGE_BYTES:

   901     case VG_MAX_FLOAT:

   902     case VG_MAX_GAUSSIAN_STD_DEVIATION:

   903         ret = 1;

   904         break;

   905 

   906     default:

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

   908         break;

   909     }

   910     RI_RETURN(ret);

   911 }

   912 

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

   914 * \brief

   915 * \param

   916 * \return

   917 * \note

   918 *//*-------------------------------------------------------------------*/

   919 

   920 static void setPaintParameterifv(VGContext* context, Paint* paint, VGPaintParamType paramType, VGint count, const void* values, bool floats)

   921 {

   922     RI_ASSERT(context);

   923     RI_ASSERT(paint);

   924 

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

   926 

   927     switch(paramType)

   928     {

   929     case VG_PAINT_TYPE:

   930         if(count != 1 || ivalue < VG_PAINT_TYPE_COLOR || ivalue > VG_PAINT_TYPE_PATTERN)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

   931         paint->m_paintType = (VGPaintType)ivalue;

   932         break;

   933 

   934     case VG_PAINT_COLOR:

   935         RI_TRACE("\n***** Setting solid color to paint.\n");

   936         RI_TRACE("** ptr: %x\n", (int)paint);

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

   938         paint->m_inputPaintColor.set(paramToFloat(values, floats, count, 0),

   939                                      paramToFloat(values, floats, count, 1),

   940                                      paramToFloat(values, floats, count, 2),

   941                                      paramToFloat(values, floats, count, 3),

   942                                      Color::sRGBA);

   943         RI_TRACE("** input solid color: [%.3f %.3f %.3f %.4f]\n", paint->m_inputPaintColor.r, paint->m_inputPaintColor.g, paint->m_inputPaintColor.b, paint->m_inputPaintColor.a);

   944         paint->setColor(inputColor(paint->m_inputPaintColor));

   945         RI_TRACE("** -> [%.3f %.3f %.3f %.3f]\n", paint->m_paintColor.r, paint->m_paintColor.g, paint->m_paintColor.b, paint->m_paintColor.a);

   946         break;

   947 

   948     case VG_PAINT_COLOR_RAMP_SPREAD_MODE:

   949         if(count != 1 || ivalue < VG_COLOR_RAMP_SPREAD_PAD || ivalue > VG_COLOR_RAMP_SPREAD_REFLECT)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

   950         paint->m_colorRampSpreadMode = (VGColorRampSpreadMode)ivalue;

   951         break;

   952 

   953     case VG_PAINT_COLOR_RAMP_STOPS:

   954     {

   955         int numStops = count/5;

   956         if(count != numStops*5)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }	//count must be a multiple of five

   957         try

   958         {

   959             Array<Paint::GradientStop> colorRampStops;

   960             Array<Paint::GradientStop> inputColorRampStops;

   961             RIfloat prevOffset = -RI_FLOAT_MAX;

   962             bool valid = true;

   963             for(int i=0;i<RI_INT_MIN(numStops, RI_MAX_COLOR_RAMP_STOPS);i++)	//NOTE: ignores the final stop if there is not enough parameters

   964             {

   965                 Paint::GradientStop gs;

   966                 gs.offset = paramToFloat(values, floats, count, i*5);

   967                 gs.color.set(paramToFloat(values, floats, count, i*5+1),

   968                              paramToFloat(values, floats, count, i*5+2),

   969                              paramToFloat(values, floats, count, i*5+3),

   970                              paramToFloat(values, floats, count, i*5+4),

   971                              Color::sRGBA);

   972                 inputColorRampStops.push_back(gs);

   973 

   974                 if(gs.offset < prevOffset)

   975                     valid = false;	//decreasing sequence, ignore it

   976 

   977                 if(gs.offset >= 0.0f && gs.offset <= 1.0f)

   978                 {

   979                     gs.color.clamp();

   980 

   981                     if(!colorRampStops.size() && gs.offset > 0.0f)

   982                     {	//the first valid stop is not at 0, replicate the first one

   983                         RIfloat tmp = gs.offset;

   984                         gs.offset = 0.0f;

   985                         colorRampStops.push_back(gs);	//throws bad_alloc

   986                         gs.offset = tmp;

   987                     }

   988                     colorRampStops.push_back(gs);	//throws bad_alloc

   989                 }

   990                 prevOffset = gs.offset;

   991             }

   992             if(valid && colorRampStops.size() && colorRampStops[colorRampStops.size()-1].offset < 1.0f)

   993             {	//there is at least one stop, but the last one is not at 1, replicate the last one

   994                 Paint::GradientStop gs = colorRampStops[colorRampStops.size()-1];

   995                 gs.offset = 1.0f;

   996                 colorRampStops.push_back(gs);	//throws bad_alloc

   997             }

   998             if(!valid || !colorRampStops.size())

   999             {	//there are no valid stops, add implicit stops

  1000                 colorRampStops.clear();

  1001                 Paint::GradientStop gs;

  1002                 gs.offset = 0.0f;

  1003                 gs.color.set(0,0,0,1,Color::sRGBA);

  1004                 colorRampStops.push_back(gs);	//throws bad_alloc

  1005                 gs.offset = 1.0f;

  1006                 gs.color.set(1,1,1,1,Color::sRGBA);

  1007                 colorRampStops.push_back(gs);	//throws bad_alloc

  1008             }

  1009             RI_ASSERT(colorRampStops.size() >= 2 && colorRampStops.size() <= RI_MAX_COLOR_RAMP_STOPS);

  1010             //paint->m_colorRampStops.swap(colorRampStops);	//set paint array

  1011             //paint->m_inputColorRampStops.swap(inputColorRampStops);	//set paint array

  1012             paint->setGradientStops(inputColorRampStops, colorRampStops);

  1013             //paint->generateLUT();

  1014         }

  1015         catch(std::bad_alloc)

  1016         {

  1017             context->setError(VG_OUT_OF_MEMORY_ERROR);

  1018         }

  1019         break;

  1020     }

  1021 

  1022     case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:

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

  1024         paint->m_colorRampPremultiplied = ivalue ? VG_TRUE : VG_FALSE;

  1025         break;

  1026 

  1027     case VG_PAINT_LINEAR_GRADIENT:

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

  1029         paint->m_inputLinearGradientPoint0.set(paramToFloat(values, floats, count, 0),

  1030                                           paramToFloat(values, floats, count, 1));

  1031         paint->m_inputLinearGradientPoint1.set(paramToFloat(values, floats, count, 2),

  1032                                           paramToFloat(values, floats, count, 3));

  1033         paint->setLinearGradient(

  1034             inputVector2(paint->m_inputLinearGradientPoint0),

  1035             inputVector2(paint->m_inputLinearGradientPoint1));

  1036 

  1037         break;

  1038 

  1039     case VG_PAINT_RADIAL_GRADIENT:

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

  1041         paint->m_inputRadialGradientCenter.set(paramToFloat(values, floats, count, 0),

  1042                                           paramToFloat(values, floats, count, 1));

  1043         paint->m_inputRadialGradientFocalPoint.set(paramToFloat(values, floats, count, 2),

  1044                                               paramToFloat(values, floats, count, 3));

  1045         paint->m_inputRadialGradientRadius = paramToFloat(values, floats, count, 4);

  1046         paint->setRadialGradient(

  1047             inputVector2(paint->m_inputRadialGradientCenter),

  1048             inputVector2(paint->m_inputRadialGradientFocalPoint),

  1049             inputFloat(paint->m_inputRadialGradientRadius));

  1050         //paint->m_radialGradientCenter = inputVector2(paint->m_inputRadialGradientCenter);

  1051         //paint->m_radialGradientFocalPoint = inputVector2(paint->m_inputRadialGradientFocalPoint);

  1052         //paint->m_radialGradientRadius = inputFloat(paint->m_inputRadialGradientRadius);

  1053         break;

  1054 

  1055     case VG_PAINT_PATTERN_TILING_MODE:

  1056         if(count != 1 || ivalue < VG_TILE_FILL || ivalue > VG_TILE_REFLECT)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }

  1057         paint->m_patternTilingMode = (VGTilingMode)ivalue;

  1058         break;

  1059 

  1060     default:

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

  1062         break;

  1063     }

  1064 }

  1065 

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

  1067 * \brief

  1068 * \param

  1069 * \return

  1070 * \note

  1071 *//*-------------------------------------------------------------------*/

  1072 

  1073 void RI_APIENTRY vgSetParameterf(VGHandle object, VGint paramType, VGfloat value)

  1074 {

  1075     RI_GET_CONTEXT(RI_NO_RETVAL);

  1076     bool isImage = context->isValidImage(object);

  1077     bool isPath = context->isValidPath(object);

  1078     bool isPaint = context->isValidPaint(object);

  1079     bool isMaskLayer = context->isValidMaskLayer(object);

  1080     bool isFont = context->isValidFont(object);

  1081     RI_IF_ERROR(!isImage && !isPath && !isPaint && !isMaskLayer && !isFont, VG_BAD_HANDLE_ERROR, RI_NO_RETVAL); //invalid object handle

  1082     RI_IF_ERROR(paramType == VG_PAINT_COLOR || paramType == VG_PAINT_COLOR_RAMP_STOPS || paramType == VG_PAINT_LINEAR_GRADIENT ||

  1083                 paramType == VG_PAINT_RADIAL_GRADIENT, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL); //vector valued parameter

  1084     VGfloat values[1] = {value};

  1085     if(isImage)

  1086     {	//read only, the function does nothing

  1087         RI_ASSERT(!isPath && !isPaint && !isMaskLayer && !isFont);

  1088         if(paramType < VG_IMAGE_FORMAT || paramType > VG_IMAGE_HEIGHT)

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

  1090     }

  1091     else if(isPath)

  1092     {	//read only, the function does nothing

  1093         RI_ASSERT(!isImage && !isPaint && !isMaskLayer && !isFont);

  1094         if(paramType < VG_PATH_FORMAT || paramType > VG_PATH_NUM_COORDS)

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

  1096     }

  1097     else if(isPaint)

  1098     {

  1099         RI_ASSERT(!isImage && !isPath && !isMaskLayer && !isFont);

  1100         setPaintParameterifv(context, (Paint*)object, (VGPaintParamType)paramType, 1, values, true);

  1101     }

  1102     else if(isMaskLayer)

  1103     {

  1104         RI_ASSERT(!isImage && !isPath && !isPaint && !isFont);

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

  1106     }

  1107     else

  1108     {	//read only, the function does nothing

  1109         RI_ASSERT(!isImage && !isPath && !isPaint && !isMaskLayer && isFont);

  1110         if (paramType != VG_FONT_NUM_GLYPHS)

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

  1112     }

  1113     RI_RETURN(RI_NO_RETVAL);

  1114 }

  1115 

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

  1117 * \brief

  1118 * \param

  1119 * \return

  1120 * \note

  1121 *//*-------------------------------------------------------------------*/

  1122 

  1123 void RI_APIENTRY vgSetParameteri(VGHandle object, VGint paramType, VGint value)

  1124 {

  1125     RI_GET_CONTEXT(RI_NO_RETVAL);

  1126     bool isImage = context->isValidImage(object);

  1127     bool isPath = context->isValidPath(object);

  1128     bool isPaint = context->isValidPaint(object);

  1129     bool isMaskLayer = context->isValidMaskLayer(object);

  1130     bool isFont = context->isValidFont(object);

  1131     RI_IF_ERROR(!isImage && !isPath && !isPaint && !isMaskLayer && !isFont, VG_BAD_HANDLE_ERROR, RI_NO_RETVAL); //invalid object handle

  1132     RI_IF_ERROR(paramType == VG_PAINT_COLOR || paramType == VG_PAINT_COLOR_RAMP_STOPS || paramType == VG_PAINT_LINEAR_GRADIENT ||

  1133                 paramType == VG_PAINT_RADIAL_GRADIENT, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);	//vector valued parameter

  1134     VGint values[1] = {value};