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

     2  *

     3  * OpenVG 1.1 Reference Implementation

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

     5  *

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

     7  *

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

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

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

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

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

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

    14  * subject to the following conditions: 

    15  *

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

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

    18  *

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

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

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

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

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

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

    25  * THE USE OR OTHER DEALINGS IN THE MATERIALS.

    26  *

    27  *//**

    28  * \file

    29  * \brief	Implementations of OpenVG API functions.

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

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

    32 

    33 #include "openvg.h"

    34 #include "egl.h"

    35 #include "riMiniEGL.h"

    36 #include "riContext.h"

    37 #include "riRasterizer.h"

    38 #include "riPixelPipe.h"

    39 #include "riPath.h"

    40 #include <stdio.h>

    41 #include <e32debug.h>

    42 

    43 #ifdef BUILD_WITH_PRIVATE_OPENVG

    44 #include "openvginternal.h"

    45 #endif

    46 

    47 //==============================================================================================

    48 

    49 namespace OpenVGRI

    50 {

    51 

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

    53 void* eglvgGetCurrentVGContext(void);

    54 bool  eglvgIsInUse(void* image);

    55 void  OSAcquireMutex(void);

    56 void  OSReleaseMutex(void);

    57 

    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 bool isValidImageFormat(EGLNativePixmapType f)

   105   {

   106 #warning TODO: implement isValidImageFormat for EGLNativePixmapType arg

   107   return false;

   108   }

   109 

   110 }	//namespace OpenVGRI

   111 

   112 using namespace OpenVGRI;

   113 

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

   115 * \brief	

   116 * \param	

   117 * \return	

   118 * \note		

   119 *//*-------------------------------------------------------------------*/

   120 

   121 #ifdef BUILD_WITH_PRIVATE_OPENVG

   122 void RI_APIENTRY do_vgFlush(void)

   123 #else

   124 void RI_APIENTRY vgFlush(void)

   125 #endif

   126 {

   127 	RI_GET_CONTEXT(RI_NO_RETVAL);

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

   129 	RI_RETURN(RI_NO_RETVAL);

   130 }

   131 

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

   133 * \brief	

   134 * \param	

   135 * \return	

   136 * \note		

   137 *//*-----

   138 *//*-------------------------------------------------------------------*/

   139 

   140 #ifdef BUILD_WITH_PRIVATE_OPENVG

   141 void RI_APIENTRY do_vgFinish(void)

   142 #else

   143 void RI_APIENTRY vgFinish(void)

   144 #endif

   145 {

   146 	RI_GET_CONTEXT(RI_NO_RETVAL);

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

   148 	RI_RETURN(RI_NO_RETVAL);

   149 }

   150 

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

   152 * \brief	

   153 * \param	

   154 * \return	

   155 * \note		

   156 *//*-------------------------------------------------------------------*/

   157 

   158 #ifdef BUILD_WITH_PRIVATE_OPENVG

   159 VGErrorCode RI_APIENTRY do_vgGetError(void)

   160 #else

   161 VGErrorCode RI_APIENTRY vgGetError(void)

   162 #endif

   163 {

   164 	RI_GET_CONTEXT(VG_NO_CONTEXT_ERROR);

   165 	VGErrorCode error = context->m_error;

   166 	context->m_error = VG_NO_ERROR;

   167 	RI_RETURN(error);

   168 }

   169 

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

   171 * \brief	

   172 * \param	

   173 * \return	

   174 * \note		

   175 *//*-------------------------------------------------------------------*/

   176 

   177 namespace OpenVGRI

   178 {

   179 

   180 RIfloat inputFloat(VGfloat f)

   181 {

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

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

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

   185 }

   186 

   187 Vector2 inputVector2(const Vector2& v)

   188 {

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

   190 }

   191 

   192 Color inputColor(const Color& c)

   193 {

   194     Color r = c;

   195     r.r = inputFloat(r.r);

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

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

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

   199     return r;

   200 }

   201 

   202 static int inputFloatToInt(VGfloat value)

   203 {

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

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

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

   207 	return (int)v;

   208 }

   209 

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

   211 {

   212 	RI_ASSERT(i >= 0);

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

   214 		return 0;

   215 	if(floats)

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

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

   218 }

   219 

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

   221 {

   222 	RI_ASSERT(i >= 0);

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

   224 		return 0.0f;

   225 	if(floats)

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

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

   228 }

   229 

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

   231 {

   232 	RI_ASSERT(i >= 0);

   233 	RI_ASSERT(output);

   234 	if(i >= count)

   235 		return;

   236 	if(outputFloats)

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

   238 	else

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

   240 }

   241 

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

   243 {

   244 	RI_ASSERT(i >= 0);

   245 	RI_ASSERT(output);

   246 	if(i >= count)

   247 		return;

   248 	if(outputFloats)

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

   250 	else

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

   252 }

   253 

   254 }	//namespace OpenVGRI

   255 

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

   257 * \brief	

   258 * \param	

   259 * \return	

   260 * \note		

   261 *//*-------------------------------------------------------------------*/

   262 

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

   264 {

   265 	RI_ASSERT(context);

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

   267 

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

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

   270 

   271 	switch(type)

   272 	{

   273 	case VG_MATRIX_MODE:

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

   275 		context->m_matrixMode = (VGMatrixMode)ivalue;

   276 		break;

   277 

   278 	case VG_FILL_RULE:

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

   280 		context->m_fillRule = (VGFillRule)ivalue;

   281 		break;

   282 

   283 	case VG_IMAGE_QUALITY:

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

   285 		context->m_imageQuality = (VGImageQuality)ivalue;

   286 		break;

   287 

   288 	case VG_RENDERING_QUALITY:

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

   290 		context->m_renderingQuality = (VGRenderingQuality)ivalue;

   291 		break;

   292 

   293 	case VG_BLEND_MODE:

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

   295 		context->m_blendMode = (VGBlendMode)ivalue;

   296 		break;

   297 

   298 	case VG_IMAGE_MODE:

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

   300 		context->m_imageMode = (VGImageMode)ivalue;

   301 		break;

   302 

   303 	case VG_SCISSOR_RECTS:

   304 	{

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

   306 		try

   307 		{

   308 			Array<Rectangle> scissor;

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

   310 			{

   311 				Rectangle s;

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

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

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

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

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

   317 			}

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

   319 		}

   320 		catch(std::bad_alloc)

   321 		{

   322 			context->setError(VG_OUT_OF_MEMORY_ERROR);

   323 		}

   324 		break;

   325 	}

   326 

   327 	case VG_COLOR_TRANSFORM:

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

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

   330 		break;

   331 

   332 	case VG_COLOR_TRANSFORM_VALUES:

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

   334         {

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

   336             {

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

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

   339             }

   340         }

   341 		break;

   342 

   343 	case VG_STROKE_LINE_WIDTH:

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

   345 		context->m_inputStrokeLineWidth = fvalue;

   346         context->m_strokeLineWidth = inputFloat(fvalue);

   347 		break;

   348 

   349 	case VG_STROKE_CAP_STYLE:

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

   351 		context->m_strokeCapStyle = (VGCapStyle)ivalue;

   352 		break;

   353 

   354 	case VG_STROKE_JOIN_STYLE:

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

   356 		context->m_strokeJoinStyle = (VGJoinStyle)ivalue;

   357 		break;

   358 

   359 	case VG_STROKE_MITER_LIMIT:

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

   361 		context->m_inputStrokeMiterLimit = fvalue;

   362 		context->m_strokeMiterLimit = inputFloat(fvalue);

   363 		break;

   364 

   365 	case VG_STROKE_DASH_PATTERN:

   366 	{

   367 		try

   368 		{

   369 			Array<RIfloat> inputStrokeDashPattern;

   370 			Array<RIfloat> strokeDashPattern;

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

   372             {

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

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

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

   376             }

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

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

   379 		}

   380 		catch(std::bad_alloc)

   381 		{

   382 			context->setError(VG_OUT_OF_MEMORY_ERROR);

   383 		}

   384 		break;

   385 	}

   386 

   387 	case VG_STROKE_DASH_PHASE:

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

   389 		context->m_inputStrokeDashPhase = fvalue;

   390 		context->m_strokeDashPhase = inputFloat(fvalue);

   391 		break;

   392 

   393 	case VG_STROKE_DASH_PHASE_RESET:

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

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

   396 		break;

   397 

   398 	case VG_TILE_FILL_COLOR:

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

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

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

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

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

   404 									 Color::sRGBA);

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

   406 		break;

   407 

   408 	case VG_GLYPH_ORIGIN:

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

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

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

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

   413 		break;

   414 

   415 	case VG_CLEAR_COLOR:

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

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

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

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

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

   421 								  Color::sRGBA);

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

   423 		break;

   424 

   425 	case VG_MASKING:

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

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

   428 		break;

   429 

   430 	case VG_SCISSORING:

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

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

   433 		break;

   434 

   435 	case VG_PIXEL_LAYOUT:

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

   437 		context->m_pixelLayout = (VGPixelLayout)ivalue;

   438 		break;

   439 

   440 	case VG_SCREEN_LAYOUT:

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

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

   443 

   444 	case VG_FILTER_FORMAT_LINEAR:

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

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

   447 		break;

   448 

   449 	case VG_FILTER_FORMAT_PREMULTIPLIED:

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

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

   452 		break;

   453 

   454 	case VG_FILTER_CHANNEL_MASK:

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

   456 		//undefined bits are ignored

   457 		context->m_filterChannelMask = (VGbitfield)ivalue;

   458 		break;

   459 

   460 	case VG_MAX_SCISSOR_RECTS:

   461 	case VG_MAX_DASH_COUNT:

   462 	case VG_MAX_KERNEL_SIZE:

   463 	case VG_MAX_SEPARABLE_KERNEL_SIZE:

   464 	case VG_MAX_COLOR_RAMP_STOPS:

   465 	case VG_MAX_IMAGE_WIDTH:

   466 	case VG_MAX_IMAGE_HEIGHT:

   467 	case VG_MAX_IMAGE_PIXELS:

   468 	case VG_MAX_IMAGE_BYTES:

   469 	case VG_MAX_FLOAT:

   470 	case VG_MAX_GAUSSIAN_STD_DEVIATION:

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

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

   473 

   474 	default:

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

   476 		break;

   477 	}

   478 }

   479 

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

   481 * \brief	

   482 * \param	

   483 * \return	

   484 * \note		

   485 *//*-------------------------------------------------------------------*/

   486 

   487 #ifdef BUILD_WITH_PRIVATE_OPENVG

   488 void RI_APIENTRY do_vgSetf(VGParamType type, VGfloat value)

   489 #else

   490 void RI_APIENTRY vgSetf(VGParamType type, VGfloat value)

   491 #endif

   492 {

   493 	RI_GET_CONTEXT(RI_NO_RETVAL);

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

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

   496 	VGfloat values[1] = {value};

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

   498 	RI_RETURN(RI_NO_RETVAL);

   499 }

   500 

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

   502 * \brief	

   503 * \param	

   504 * \return	

   505 * \note		

   506 *//*-------------------------------------------------------------------*/

   507 

   508 #ifdef BUILD_WITH_PRIVATE_OPENVG

   509 void RI_APIENTRY do_vgSeti(VGParamType type, VGint value)

   510 #else

   511 void RI_APIENTRY vgSeti(VGParamType type, VGint value)

   512 #endif

   513 {

   514 	RI_GET_CONTEXT(RI_NO_RETVAL);

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

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

   517 	VGint values[1] = {value};

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

   519 	RI_RETURN(RI_NO_RETVAL);

   520 }

   521 

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

   523 * \brief	

   524 * \param	

   525 * \return	

   526 * \note		

   527 *//*-------------------------------------------------------------------*/

   528 #ifdef BUILD_WITH_PRIVATE_OPENVG

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

   530 #else 

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

   532 #endif

   533 {

   534 	RI_GET_CONTEXT(RI_NO_RETVAL);

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

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

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

   538 	RI_RETURN(RI_NO_RETVAL);

   539 }

   540 

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

   542 * \brief	

   543 * \param	

   544 * \return	

   545 * \note		

   546 *//*-------------------------------------------------------------------*/

   547 

   548 #ifdef BUILD_WITH_PRIVATE_OPENVG

   549 void RI_APIENTRY do_vgSetfv(VGParamType type, VGint count, const VGfloat * values)

   550 #else

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

   552 #endif

   553 {

   554 	RI_GET_CONTEXT(RI_NO_RETVAL);

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

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

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

   558 	RI_RETURN(RI_NO_RETVAL);

   559 }

   560 

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

   562 * \brief	

   563 * \param	

   564 * \return	

   565 * \note		

   566 *//*-------------------------------------------------------------------*/

   567 

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

   569 {

   570 	switch(type)

   571 	{

   572 	case VG_MATRIX_MODE:

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

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

   575 		break;

   576 

   577 	case VG_FILL_RULE:

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

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

   580 		break;

   581 

   582 	case VG_IMAGE_QUALITY:

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

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

   585 		break;

   586 

   587 	case VG_RENDERING_QUALITY:

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

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

   590 		break;

   591 

   592 	case VG_BLEND_MODE:

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

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

   595 		break;

   596 

   597 	case VG_IMAGE_MODE:

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

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

   600 		break;

   601 

   602 	case VG_SCISSOR_RECTS:

   603 	{

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

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

   606 		{

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

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

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

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

   611 		}

   612 		break;

   613 	}

   614 

   615 	case VG_COLOR_TRANSFORM:

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

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

   618 		break;

   619 

   620 	case VG_COLOR_TRANSFORM_VALUES:

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

   622         {

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

   624             {

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

   626             }

   627         }

   628 		break;

   629 

   630 	case VG_STROKE_LINE_WIDTH:

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

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

   633 		break;

   634 

   635 	case VG_STROKE_CAP_STYLE:

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

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

   638 		break;

   639 

   640 	case VG_STROKE_JOIN_STYLE:

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

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

   643 		break;

   644 

   645 	case VG_STROKE_MITER_LIMIT:

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

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

   648 		break;

   649 

   650 	case VG_STROKE_DASH_PATTERN:

   651 	{

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

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

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

   655 		break;

   656 	}

   657 

   658 	case VG_STROKE_DASH_PHASE:

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

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

   661 		break;

   662 

   663 	case VG_STROKE_DASH_PHASE_RESET:

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

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

   666 		break;

   667 

   668 	case VG_TILE_FILL_COLOR:

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

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

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

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

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

   674 		break;

   675 

   676 	case VG_CLEAR_COLOR:

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

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

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

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

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

   682 		break;

   683 

   684 	case VG_GLYPH_ORIGIN:

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

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

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

   688 		break;

   689 

   690 	case VG_MASKING:

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

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

   693 		break;

   694 

   695 	case VG_SCISSORING:

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

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

   698 		break;

   699 

   700 	case VG_PIXEL_LAYOUT:

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

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

   703 		break;

   704 

   705 	case VG_SCREEN_LAYOUT:

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

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

   708 		break;

   709 

   710 	case VG_FILTER_FORMAT_LINEAR:

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

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

   713 		break;

   714 

   715 	case VG_FILTER_FORMAT_PREMULTIPLIED:

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

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

   718 		break;

   719 

   720 	case VG_FILTER_CHANNEL_MASK:

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

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

   723 		break;

   724 

   725 	case VG_MAX_SCISSOR_RECTS:

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

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

   728 		break;

   729 

   730 	case VG_MAX_DASH_COUNT:

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

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

   733 		break;

   734 

   735 	case VG_MAX_KERNEL_SIZE:

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

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

   738 		break;

   739 

   740 	case VG_MAX_SEPARABLE_KERNEL_SIZE:

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

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

   743 		break;

   744 

   745 	case VG_MAX_COLOR_RAMP_STOPS:

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

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

   748 		break;

   749 

   750 	case VG_MAX_IMAGE_WIDTH:

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

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

   753 		break;

   754 

   755 	case VG_MAX_IMAGE_HEIGHT:

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

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

   758 		break;

   759 

   760 	case VG_MAX_IMAGE_PIXELS:

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

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

   763 		break;

   764 

   765 	case VG_MAX_IMAGE_BYTES:

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

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

   768 		break;

   769 

   770 	case VG_MAX_FLOAT:

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

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

   773 		break;

   774 

   775 	case VG_MAX_GAUSSIAN_STD_DEVIATION:

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

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

   778 		break;

   779 

   780 	default:

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

   782 		break;

   783 	}

   784 }

   785 

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

   787 * \brief	

   788 * \param	

   789 * \return	

   790 * \note		

   791 *//*-------------------------------------------------------------------*/

   792 

   793 #ifdef BUILD_WITH_PRIVATE_OPENVG

   794 VGfloat RI_APIENTRY do_vgGetf(VGParamType type)

   795 #else

   796 VGfloat RI_APIENTRY vgGetf(VGParamType type)

   797 #endif

   798 {

   799 	RI_GET_CONTEXT(0.0f);

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

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

   802 	RIfloat ret = 0.0f;

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

   804 	RI_RETURN(ret);

   805 }

   806 

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

   808 * \brief	

   809 * \param	

   810 * \return	

   811 * \note		

   812 *//*-------------------------------------------------------------------*/

   813 

   814 #ifdef BUILD_WITH_PRIVATE_OPENVG

   815 VGint RI_APIENTRY do_vgGeti(VGParamType type)

   816 #else

   817 VGint RI_APIENTRY vgGeti(VGParamType type)

   818 #endif

   819 {

   820 	RI_GET_CONTEXT(0);

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

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

   823 	VGint ret = 0;

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

   825 	RI_RETURN(ret);

   826 }

   827 

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

   829 * \brief	

   830 * \param	

   831 * \return	

   832 * \note		

   833 *//*-------------------------------------------------------------------*/

   834 

   835 #ifdef BUILD_WITH_PRIVATE_OPENVG

   836 void RI_APIENTRY do_vgGetiv(VGParamType type, VGint count, VGint * values)

   837 #else

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

   839 #endif

   840 {

   841 	RI_GET_CONTEXT(RI_NO_RETVAL);

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

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

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

   845 	RI_RETURN(RI_NO_RETVAL);

   846 }

   847 

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

   849 * \brief	

   850 * \param	

   851 * \return	

   852 * \note		

   853 *//*-------------------------------------------------------------------*/

   854 

   855 #ifdef BUILD_WITH_PRIVATE_OPENVG

   856 void RI_APIENTRY do_vgGetfv(VGParamType type, VGint count, VGfloat * values)

   857 #else

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

   859 #endif

   860 {

   861 	RI_GET_CONTEXT(RI_NO_RETVAL);

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

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

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

   865 	RI_RETURN(RI_NO_RETVAL);

   866 }

   867 

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

   869 * \brief	

   870 * \param	

   871 * \return	

   872 * \note		

   873 *//*-------------------------------------------------------------------*/

   874 

   875 #ifdef BUILD_WITH_PRIVATE_OPENVG

   876 VGint RI_APIENTRY do_vgGetVectorSize(VGParamType type)

   877 #else

   878 VGint RI_APIENTRY vgGetVectorSize(VGParamType type)

   879 #endif

   880 {

   881 	RI_GET_CONTEXT(0);

   882 	VGint ret = 0;

   883 	switch(type)

   884 	{

   885 	case VG_MATRIX_MODE:

   886 	case VG_FILL_RULE:

   887 	case VG_IMAGE_QUALITY:

   888 	case VG_RENDERING_QUALITY:

   889 	case VG_BLEND_MODE:

   890 	case VG_IMAGE_MODE:

   891 		ret = 1;

   892 		break;

   893 

   894 	case VG_SCISSOR_RECTS:

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

   896 		break;

   897 

   898     case VG_COLOR_TRANSFORM:

   899         ret = 1;

   900         break;

   901 

   902     case VG_COLOR_TRANSFORM_VALUES:

   903         ret = 8;

   904         break;

   905 

   906 	case VG_STROKE_LINE_WIDTH:

   907 	case VG_STROKE_CAP_STYLE:

   908 	case VG_STROKE_JOIN_STYLE:

   909 	case VG_STROKE_MITER_LIMIT:

   910 		ret = 1;

   911 		break;

   912 

   913 	case VG_STROKE_DASH_PATTERN:

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

   915 		break;

   916 

   917 	case VG_STROKE_DASH_PHASE:

   918 	case VG_STROKE_DASH_PHASE_RESET:

   919 		ret = 1;

   920 		break;

   921 

   922 	case VG_TILE_FILL_COLOR:

   923 	case VG_CLEAR_COLOR:

   924 		ret = 4;

   925 		break;

   926 

   927 	case VG_GLYPH_ORIGIN:

   928 		ret = 2;

   929 		break;

   930 

   931 	case VG_MASKING:

   932 	case VG_SCISSORING:

   933 	case VG_PIXEL_LAYOUT:

   934 	case VG_SCREEN_LAYOUT:

   935 	case VG_FILTER_FORMAT_LINEAR:

   936 	case VG_FILTER_FORMAT_PREMULTIPLIED:

   937 	case VG_FILTER_CHANNEL_MASK:

   938 	case VG_MAX_SCISSOR_RECTS:

   939 	case VG_MAX_DASH_COUNT:

   940 	case VG_MAX_KERNEL_SIZE:

   941 	case VG_MAX_SEPARABLE_KERNEL_SIZE:

   942 	case VG_MAX_COLOR_RAMP_STOPS:

   943 	case VG_MAX_IMAGE_WIDTH:

   944 	case VG_MAX_IMAGE_HEIGHT:

   945 	case VG_MAX_IMAGE_PIXELS:

   946 	case VG_MAX_IMAGE_BYTES:

   947 	case VG_MAX_FLOAT:

   948 	case VG_MAX_GAUSSIAN_STD_DEVIATION:

   949 		ret = 1;

   950 		break;

   951 

   952 	default:

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

   954 		break;

   955 	}

   956 	RI_RETURN(ret);

   957 }

   958 

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

   960 * \brief	

   961 * \param	

   962 * \return	

   963 * \note		

   964 *//*-------------------------------------------------------------------*/

   965 

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

   967 {

   968 	RI_ASSERT(context);

   969 	RI_ASSERT(paint);

   970 

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

   972 

   973 	switch(paramType)

   974 	{

   975 	case VG_PAINT_TYPE:

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

   977 		paint->m_paintType = (VGPaintType)ivalue;

   978 		break;

   979 

   980 	case VG_PAINT_COLOR:

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

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

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

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

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

   986 									 Color::sRGBA);

   987 		paint->m_paintColor = inputColor(paint->m_inputPaintColor);

   988 		paint->m_paintColor.clamp();

   989 		paint->m_paintColor.premultiply();

   990 		break;

   991 

   992 	case VG_PAINT_COLOR_RAMP_SPREAD_MODE:

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

   994 		paint->m_colorRampSpreadMode = (VGColorRampSpreadMode)ivalue;

   995 		break;

   996 

   997 	case VG_PAINT_COLOR_RAMP_STOPS:

   998 	{

   999 		int numStops = count/5;

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

  1001 		try

  1002 		{

  1003 			Array<Paint::GradientStop> colorRampStops;

  1004 			Array<Paint::GradientStop> inputColorRampStops;

  1005 			RIfloat prevOffset = -RI_FLOAT_MAX;

  1006 			bool valid = true;

  1007 			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

  1008 			{

  1009 				Paint::GradientStop gs;

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

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

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

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

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

  1015 							 Color::sRGBA);

  1016 				inputColorRampStops.push_back(gs);

  1017 

  1018 				if(gs.offset < prevOffset)

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

  1020 

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

  1022 				{

  1023 					gs.color.clamp();

  1024 

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

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

  1027 						RIfloat tmp = gs.offset;

  1028 						gs.offset = 0.0f;

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

  1030 						gs.offset = tmp;

  1031 					}

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

  1033 				}

  1034 				prevOffset = gs.offset;

  1035 			}

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

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

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

  1039 				gs.offset = 1.0f;

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

  1041 			}

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

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

  1044 				colorRampStops.clear();

  1045 				Paint::GradientStop gs;

  1046 				gs.offset = 0.0f;

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

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

  1049 				gs.offset = 1.0f;

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

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

  1052 			}

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

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

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

  1056 		}

  1057 		catch(std::bad_alloc)

  1058 		{

  1059 			context->setError(VG_OUT_OF_MEMORY_ERROR);

  1060 		}

  1061 		break;

  1062 	}

  1063 

  1064 	case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:

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

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

  1067 		break;

  1068 

  1069 	case VG_PAINT_LINEAR_GRADIENT:

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

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

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

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

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

  1075         paint->m_linearGradientPoint0 = inputVector2(paint->m_inputLinearGradientPoint0);

  1076         paint->m_linearGradientPoint1 = inputVector2(paint->m_inputLinearGradientPoint1);

  1077 		break;

  1078 

  1079 	case VG_PAINT_RADIAL_GRADIENT:

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

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

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

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

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

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

  1086         paint->m_radialGradientCenter = inputVector2(paint->m_inputRadialGradientCenter);

  1087         paint->m_radialGradientFocalPoint = inputVector2(paint->m_inputRadialGradientFocalPoint);

  1088         paint->m_radialGradientRadius = inputFloat(paint->m_inputRadialGradientRadius);

  1089 		break;

  1090 

  1091 	case VG_PAINT_PATTERN_TILING_MODE:

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

  1093 		paint->m_patternTilingMode = (VGTilingMode)ivalue;

  1094 		break;

  1095 

  1096 	default:

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

  1098 		break;

  1099 	}

  1100 }

  1101 

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

  1103 * \brief	

  1104 * \param	

  1105 * \return	

  1106 * \note		

  1107 *//*-------------------------------------------------------------------*/

  1108 

  1109 #ifdef BUILD_WITH_PRIVATE_OPENVG

  1110 void RI_APIENTRY do_vgSetParameterf(VGHandle object, VGint paramType, VGfloat value)

  1111 #else

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

  1113 #endif

  1114 {

  1115 	RI_GET_CONTEXT(RI_NO_RETVAL);

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

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

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

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

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

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

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

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

  1124 	VGfloat values[1] = {value};

  1125 	if(isImage)

  1126 	{	//read only, the function does nothing

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

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

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

  1130 	}

  1131 	else if(isPath)

  1132 	{	//read only, the function does nothing

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

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