1 // Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // C++ version of Open VG API.

    15 

    16 #include "openvg.inl"

    17 #include "remotefunctioncall.h"

    18 #include "openvgrfc.h"

    19 

    20 

    21 // normalized IEEE 754 representations

    22 const float KFloatMinusOne = -1.0f;

    23 const float KFloatZero = 0.0f;

    24 

    25 const TInt KTransformMatrixSize = 9;

    26 

    27 /////////////////////////////////////////////////////////////////////////////////////////////

    28 // TGuestOpenVg

    29 /////////////////////////////////////////////////////////////////////////////////////////////

    30 

    31 // ---------------------------------------------------------------------

    32 // TGuestOpenVg - private inline & paramater checking functions

    33 

    34 // helper function

    35 ///////////////////////////////////////////////////////////////////////////////////////////////

    36 // Implementation of Open VG APIs ... with comments summarising possible errors.

    37 

    38 ////////////////////////////////////////////////////////////////////////////////////////////

    39 //Functions returning value

    40 ////////////////////////////////////////////////////////////////////////////////////////////

    41 

    42 /*

    43  ERRORS

    44    VG_ILLEGAL_ARGUMENT_ERROR

    45    – if paintMode is not a valid value from the VGPaintMode enumeration

    46  */

    47 VGPaint TGuestOpenVg::vgGetPaint(VGPaintMode aPaintMode)

    48 	{

    49 	VGPaint paintHandle = VG_INVALID_HANDLE;

    50 	MVgContext* vgContext = CVghwUtils::VgContext();

    51 	if (vgContext && TCheck::ChkVGPaintMode(*vgContext, aPaintMode))

    52 		{

    53 		TCleanupVgLocks vgLock(*vgContext);

    54 		paintHandle = vgLock.GetPaint(aPaintMode);

    55 		}

    56 	else if (!vgContext)

    57 		{

    58 		OPENVG_TRACE("  TGuestOpenVg::vgGetPaint - no VG context");

    59 		}

    60 	else

    61 		{

    62 		OPENVG_TRACE("  TGuestOpenVg::vgGetPaint - ParamCheck failed");

    63 		}

    64 	return paintHandle;

    65 	}

    66 

    67 

    68 /*

    69  If insufficient memory is available to allocate a new object, VG_INVALID_HANDLE is returned.

    70  */

    71 VGPaint TGuestOpenVg::vgCreatePaint()

    72 	{

    73 	VGPaint paintHandle = VG_INVALID_HANDLE;

    74 	MVgContext* vgContext = CVghwUtils::VgContext();

    75 	if (vgContext)

    76 		{

    77 		TCleanupVgLocks vgLock(*vgContext);

    78 		paintHandle = vgLock.CreatePaint();

    79 		}

    80 	else

    81 		{

    82 		OPENVG_TRACE("  TGuestOpenVg::vgCreatePaint - no VG context");

    83 		}

    84 

    85 	return paintHandle;

    86 	}

    87 

    88 

    89 /*

    90  ERRORS

    91    VG_BAD_HANDLE_ERROR

    92    – if any of dstPath, startPath, or endPath is not a valid path handle, or is

    93      not shared with the current context

    94    VG_PATH_CAPABILITY_ERROR

    95    – if VG_PATH_CAPABILITY_INTERPOLATE_TO is not enabled for dstPath

    96    – if VG_PATH_CAPABILITY_INTERPOLATE_FROM is not enabled for startPath or endPath

    97  */

    98 VGboolean TGuestOpenVg::vgInterpolatePath(VGPath aDstPath, VGPath aStartPath, VGPath aEndPath, VGfloat aAmount)

    99 	{

   100 	VGboolean result = VG_FALSE;

   101 	MVgContext* vgContext = CVghwUtils::VgContext();

   102 

   103 	if ( vgContext )

   104 		{

   105 		CVgPathInfo* dstPathInfo = NULL;

   106 		CVgPathInfo* startPathInfo = NULL;

   107 		CVgPathInfo* endPathInfo = NULL;

   108 		TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction

   109 

   110 		if ( vgLock.CheckVGPath(aDstPath, &dstPathInfo, VG_PATH_CAPABILITY_INTERPOLATE_TO) &&

   111 				vgLock.CheckVGPath(aStartPath, &startPathInfo, VG_PATH_CAPABILITY_INTERPOLATE_FROM) &&

   112 				vgLock.CheckVGPath(aEndPath, &endPathInfo, VG_PATH_CAPABILITY_INTERPOLATE_FROM) )

   113 			{

   114 			result = dstPathInfo->InterpolatePath(*vgContext, *startPathInfo, *endPathInfo, aAmount);

   115 			}

   116 		}

   117 	return result;

   118 	}

   119 

   120 

   121 /*

   122  ERRORS

   123    VG_BAD_HANDLE_ERROR

   124    – if path is not a valid path handle, or is not shared with the current context

   125    VG_PATH_CAPABILITY_ERROR

   126    – if VG_PATH_CAPABILITY_PATH_LENGTH is not enabled for path

   127    VG_ILLEGAL_ARGUMENT_ERROR

   128    – if startSegment is less than 0 or greater than the index of the final path

   129      segment

   130    – if numSegments is less than or equal to 0

   131    – if (startSegment + numSegments – 1) is greater than the index of the final

   132      path segment

   133  */

   134 VGfloat TGuestOpenVg::vgPathLength(VGPath aPath, VGint aStartSegment, VGint aNumSegments)

   135 	{

   136 	VGfloat result = KFloatMinusOne;

   137 	MVgContext* vgContext = CVghwUtils::VgContext();

   138 	if ( vgContext )

   139 		{

   140 		CVgPathInfo* pathInfo = NULL;

   141 		TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction

   142 

   143 		if ( vgLock.CheckVGPath(aPath, &pathInfo, VG_PATH_CAPABILITY_PATH_LENGTH) )

   144 			{

   145 			if ( (aStartSegment < 0) || (aNumSegments <= 0) )

   146 				{

   147 				vgContext->SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

   148 				}

   149 			else

   150 				{

   151 				result = pathInfo->PathLength(*vgContext, aStartSegment, aNumSegments);

   152 				}

   153 			}

   154 		}

   155 	return result;

   156 	}

   157 

   158 

   159 /*

   160  ERRORS

   161    VG_BAD_HANDLE_ERROR

   162    – if path is not a valid path handle, or is not shared with the current context

   163  */

   164 VGbitfield TGuestOpenVg::vgGetPathCapabilities(VGPath aPath)

   165 	{

   166 	VGbitfield result = 0;

   167 	MVgContext* vgContext = CVghwUtils::VgContext();

   168 	if ( vgContext )

   169 		{

   170 		CVgPathInfo* pathInfo = NULL;

   171 		TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction

   172 

   173 		if ( vgLock.CheckVGPath(aPath, &pathInfo) )

   174 			{

   175 			result = pathInfo->GetPathCapabilities(*vgContext);

   176 			}

   177 		}

   178 	return result;

   179 	}

   180 

   181 

   182 /*

   183  ERRORS

   184    VG_UNSUPPORTED_PATH_FORMAT_ERROR

   185    – if pathFormat is not a supported format

   186    VG_ILLEGAL_ARGUMENT_ERROR

   187    – if datatype is not a valid value from the VGPathDatatype enumeration

   188    – if scale is equal to 0

   189  */

   190 VGPath TGuestOpenVg::vgCreatePath(VGint aPathFormat, VGPathDatatype aDatatype, VGfloat aScale, VGfloat aBias,

   191 		VGint aSegmentCapacityHint, VGint aCoordCapacityHint, VGbitfield aCapabilities)

   192 	{

   193 	VGPath pathHandle = VG_INVALID_HANDLE;

   194 	MVgContext* vgContext = CVghwUtils::VgContext();

   195 	if ( vgContext && TCheck::ChkVGPathFormat(*vgContext, aPathFormat) && TCheck::ChkVGPathDataType(*vgContext, aDatatype) )

   196 		{

   197 		if (aScale == KFloatZero)

   198 			{

   199 			vgContext->SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

   200 			}

   201 		else

   202 			{

   203 			TCleanupVgLocks vgLock(*vgContext); // Waits & holds VG mutex until destruction 

   204 			pathHandle = vgLock.CreatePath(aPathFormat, aDatatype, aScale, aBias, aSegmentCapacityHint, aCoordCapacityHint, aCapabilities);

   205 			}

   206 		}

   207 	else if (!vgContext)

   208 		{

   209 		OPENVG_TRACE("  TGuestOpenVg::vgCreatePath - no VG context");

   210 		}

   211 	else

   212 		{

   213 		OPENVG_TRACE("  TGuestOpenVg::vgCreatePath - ParamCheck failed");

   214 		}

   215 

   216 	return pathHandle;

   217 	}

   218 

   219 

   220 /* For vgGeti, vgGetf, and vgGetVectorSize.

   221 If an error occurs during a call to vgGetf, vgGeti, or vgGetVectorSize, the return value

   222 is undefined.

   223 

   224 ERRORS

   225   VG_ILLEGAL_ARGUMENT_ERROR

   226   – if paramType is not a valid value from the VGParamType enumeration

   227   – if paramType refers to a vector parameter in vgGetf or vgGeti

   228 */

   229 VGint TGuestOpenVg::HostGeti(MVgContext& aVgContext, VGParamType aType)

   230 	{

   231 	RemoteFunctionCallData data; OpenVgRFC vgApiData(data);

   232 	vgApiData.Init(OpenVgRFC::EvgGeti);

   233 	vgApiData.AppendParam(aType);

   234 	VGPANIC_ASSERT_DEBUG(vgApiData.Data().Header().iOpType == RemoteFunctionCallData::EOpRequestWithReply, EVgPanicNotReplyOpcode);

   235 	aVgContext.ExecuteVgCommand(vgApiData);

   236 	return static_cast<VGint>(vgApiData.ReturnValue());

   237 	}

   238 

   239 

   240 VGfloat TGuestOpenVg::HostGetf(MVgContext& aVgContext, VGParamType aType)

   241 	{

   242 	RemoteFunctionCallData data; OpenVgRFC vgApiData(data);

   243 	vgApiData.Init(OpenVgRFC::EvgGetf);

   244 	vgApiData.AppendParam(aType);

   245 	VGPANIC_ASSERT_DEBUG(vgApiData.Data().Header().iOpType == RemoteFunctionCallData::EOpRequestWithReply, EVgPanicNotReplyOpcode);

   246 	aVgContext.ExecuteVgCommand(vgApiData);

   247 	return static_cast<VGfloat>(vgApiData.ReturnValue());

   248 	}

   249 

   250 

   251 VGint TGuestOpenVg::vgGeti(VGParamType aType)

   252 	{

   253 	// TODO validate aType

   254 	VGint result = 0;

   255 	MVgContext* vgContext = CVghwUtils::VgContext();

   256 	if (vgContext)

   257 		{

   258 		result = HostGeti(*vgContext, aType);

   259 		}

   260 	return result;

   261 	}

   262 

   263 

   264 VGfloat TGuestOpenVg::vgGetf(VGParamType aType)

   265 	{

   266 	// TODO validate aType

   267 	VGfloat result = KFloatMinusOne;

   268 	MVgContext* vgContext = CVghwUtils::VgContext();

   269 	if (vgContext)

   270 		{

   271 		result = HostGetf(*vgContext, aType);

   272 		}

   273 	return result;

   274 	}

   275 

   276 

   277 /*

   278  ERRORS

   279    VG_BAD_HANDLE_ERROR

   280    – if object is not a valid handle, or is not shared with the current context

   281    VG_ILLEGAL_ARGUMENT_ERROR

   282    – if paramType is not a valid value from the appropriate enumeration

   283    – if paramType refers to a vector parameter in vgGetParameterf or

   284      vgGetParameteri

   285  */

   286 VGint TGuestOpenVg::vgGetParameteri(VGHandle aObject, VGint aParamType)

   287 	{

   288 	MVgContext* vgContext = CVghwUtils::VgContext();

   289 	if ( vgContext )

   290 		{

   291 		CVgHandleBase* handleInfo;

   292 		TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction

   293 

   294 		if ( vgLock.CheckVGAnyHandle(aObject, &handleInfo) )

   295 			{

   296 			return handleInfo->GetParameteri(*vgContext, aParamType);

   297 			}

   298 		}

   299 	return 0;

   300 	}

   301 

   302 

   303 VGint TGuestOpenVg::HostGetVectorSize(MVgContext& aVgContext, VGParamType aType)

   304 	{

   305 	RemoteFunctionCallData data; OpenVgRFC vgApiData(data);

   306 	vgApiData.Init(OpenVgRFC::EvgGetVectorSize);

   307 	vgApiData.AppendParam(aType);

   308 	VGPANIC_ASSERT_DEBUG(vgApiData.Data().Header().iOpType == RemoteFunctionCallData::EOpRequestWithReply, EVgPanicNotReplyOpcode);

   309 	aVgContext.ExecuteVgCommand(vgApiData);

   310 	return static_cast<VGint>(vgApiData.ReturnValue());

   311 	}

   312 

   313 

   314 VGint TGuestOpenVg::vgGetVectorSize(VGParamType aType)

   315 	{

   316 	MVgContext* vgContext = CVghwUtils::VgContext();

   317 	if (vgContext)

   318 		{ // **** Desirable: check aType

   319 		return HostGetVectorSize(*vgContext, aType);

   320 		}

   321 	return 0;

   322 	}

   323 

   324 

   325 VGfloat TGuestOpenVg::vgGetParameterf(VGHandle aObject, VGint aParamType)

   326 	{

   327 	MVgContext* vgContext = CVghwUtils::VgContext();

   328 	if ( vgContext )

   329 		{

   330 		CVgHandleBase* handleInfo;

   331 		TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction

   332 

   333 		if ( vgLock.CheckVGAnyHandle(aObject, &handleInfo) )

   334 			{

   335 			return handleInfo->GetParameterf(*vgContext, aParamType);

   336 			}

   337 		}

   338 	return KFloatMinusOne;

   339 	}

   340 

   341 

   342 /*

   343  ERRORS

   344    VG_BAD_HANDLE_ERROR

   345    – if object is not a valid handle, or is not shared with the current context

   346    VG_ILLEGAL_ARGUMENT_ERROR

   347    – if paramType is not a valid value from the appropriate enumeration

   348  */

   349 VGint TGuestOpenVg::vgGetParameterVectorSize(VGHandle aObject, VGint aParamType)

   350 	{

   351 	MVgContext* vgContext = CVghwUtils::VgContext();

   352 	if ( vgContext )

   353 		{

   354 		CVgHandleBase* handleInfo;

   355 		TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction

   356 

   357 		// **** Desirable: check aParamType

   358 		if ( vgLock.CheckVGAnyHandle(aObject, &handleInfo) )

   359 			{

   360 			return handleInfo->GetParameterVectorSize(*vgContext, aParamType);

   361 			}

   362 		}

   363 	return 0;

   364  	}

   365 

   366 

   367 /*

   368   ERRORS

   369    VG_ILLEGAL_ARGUMENT_ERROR

   370    – if width or height are less than or equal to 0

   371    – if width is greater than VG_MAX_IMAGE_WIDTH

   372    – if height is greater than VG_MAX_IMAGE_HEIGHT

   373    – if width*height is greater than VG_MAX_IMAGE_PIXELS

   374  */

   375 VGMaskLayer TGuestOpenVg::vgCreateMaskLayer(VGint aWidth, VGint aHeight)

   376 	{

   377 	VGMaskLayer maskLayerHandle = VG_INVALID_HANDLE;

   378 	MVgContext* vgContext = CVghwUtils::VgContext();

   379 	if ( vgContext && TCheck::ChkNewImageSize(*vgContext, aWidth, aHeight) )

   380 		{

   381 		TCleanupVgLocks vgLock(*vgContext);

   382 		maskLayerHandle = vgLock.CreateMaskLayer(aWidth, aHeight);

   383 		}

   384 	else if (!vgContext)

   385 		{

   386 		OPENVG_TRACE("  TGuestOpenVg::vgCreateMaskLayer - no VG context");

   387 		}

   388 	else

   389 		{

   390 		OPENVG_TRACE("  TGuestOpenVg::vgCreateMaskLayer - ParamCheck failed");

   391 		}

   392 

   393 	return maskLayerHandle;

   394 	}

   395 

   396 

   397 /*

   398  ERRORS

   399    VG_BAD_HANDLE_ERROR

   400    – if paint is not a valid paint handle, or is not shared with the current context

   401  */

   402 VGuint TGuestOpenVg::vgGetColor(VGPaint aPaint)

   403 	{

   404 	VGuint result = 0;

   405 	MVgContext* vgContext = CVghwUtils::VgContext();

   406 	if ( vgContext )

   407 		{

   408 		CVgPaintInfo* paintInfo = NULL;

   409 		TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction

   410 

   411 		if ( vgLock.CheckVGPaint(aPaint, &paintInfo) )

   412 			{

   413 			result = paintInfo->GetColor(*vgContext);

   414 			}

   415 		}

   416 	return result;

   417 	}

   418 

   419 

   420 /*

   421  ERRORS

   422    VG_UNSUPPORTED_IMAGE_FORMAT_ERROR

   423    – if format is not a valid value from the VGImageFormat enumeration

   424    VG_ILLEGAL_ARGUMENT_ERROR

   425    – if width or height are less than or equal to 0

   426    – if width is greater than VG_MAX_IMAGE_WIDTH

   427    – if height is greater than VG_MAX_IMAGE_HEIGHT

   428    – if width*height is greater than VG_MAX_IMAGE_PIXELS

   429    – if width*height*(pixel size of format) is greater than

   430    VG_MAX_IMAGE_BYTES

   431    – if allowedQuality is not a bitwise OR of values from the

   432      VGImageQuality enumeration

   433  */

   434 VGImage TGuestOpenVg::vgCreateImage(VGImageFormat aFormat, VGint aWidth, VGint aHeight, VGbitfield aAllowedQuality)

   435 	{

   436 	VGHandle imageHandle = VG_INVALID_HANDLE;

   437 	MVgContext* vgContext = CVghwUtils::VgContext();

   438 	if ( vgContext && TCheck::ChkNewImageSize(*vgContext, aWidth, aHeight) && TCheck::ChkVgImageFormat(*vgContext, aFormat) )

   439 		{ // width > 0 && height > 0

   440 		TCleanupVgLocks vgLock(*vgContext);

   441 		imageHandle = vgLock.CreateImage(aFormat, aWidth, aHeight, aAllowedQuality);

   442 		}

   443 	else if (!vgContext)

   444 		{

   445 		OPENVG_TRACE("  TGuestOpenVg::vgCreateImage - no VG context");

   446 		}

   447 	else

   448 		{

   449 		OPENVG_TRACE("  TGuestOpenVg::vgCreateImage - ParamCheck failed");

   450 		}

   451 

   452 	return imageHandle;

   453 	}

   454 

   455 

   456 /*

   457  Returns a new VGImage handle that refers to a portion of the parent image. The

   458  region is given by the intersection of the bounds of the parent image with the

   459  rectangle beginning at pixel (x, y) with dimensions width and height, which

   460  must define a positive region contained entirely within parent.

   461 

   462  ERRORS

   463    VG_BAD_HANDLE_ERROR

   464    – if parent is not a valid image handle, or is not shared with the current

   465      context

   466    VG_IMAGE_IN_USE_ERROR

   467    – if parent is currently a rendering target

   468    VG_ILLEGAL_ARGUMENT_ERROR

   469    – if x is less than 0 or greater than or equal to the parent width

   470    – if y is less than 0 or greater than or equal to the parent height

   471    – if width or height is less than or equal to 0

   472    – if x + width is greater than the parent width

   473    – if y + height is greater than the parent height

   474  */

   475 VGImage TGuestOpenVg::vgChildImage(VGImage aParent, VGint aX, VGint aY, VGint aWidth, VGint aHeight)

   476 	{

   477 	VGHandle imageHandle = VG_INVALID_HANDLE;

   478 	MVgContext* vgContext = CVghwUtils::VgContext();

   479 	if ( vgContext )

   480 		{

   481 		CVgImageInfo* parentInfo = NULL;

   482 		TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction

   483 

   484 		if ( vgLock.CheckVGImage(aParent, &parentInfo) && TCheck::ChkAreaIsWithinImage(*vgContext, parentInfo, aX, aY, aWidth, aHeight) )

   485 			{ // child image area is within parent image

   486 			imageHandle = vgLock.ChildImage(*parentInfo, aX, aY, aWidth, aHeight);

   487 			}

   488 		}

   489 	else

   490 		{

   491 		OPENVG_TRACE("  TGuestOpenVg::vgChildImage - no VG context");

   492 		}

   493 

   494 	return imageHandle;

   495 	}

   496 

   497 

   498 /*

   499  ERRORS

   500    VG_BAD_HANDLE_ERROR

   501    – if image is not a valid image handle, or is not shared with the current

   502      context

   503    VG_IMAGE_IN_USE_ERROR

   504    – if image is currently a rendering target

   505  */

   506 VGImage TGuestOpenVg::vgGetParent(VGImage aImage)

   507 	{

   508 	VGImage parentImage = VG_INVALID_HANDLE;

   509 	MVgContext* vgContext = CVghwUtils::VgContext();

   510 	if ( vgContext )

   511 		{

   512 		CVgImageInfo* imageInfo = NULL;

   513 		TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction

   514 

   515 		if ( vgLock.CheckVGImage(aImage, &imageInfo) )

   516 			{

   517 			// baseline for a valid image is to return its own ClientHandle

   518 			parentImage = aImage;

   519 			// try to find a non-destroyed ancestor

   520 			// ToDo add getParent Api to CVgImageInfo

   521 			CVgImageInfo* parentInfo = imageInfo->Parent();

   522 			while (parentInfo)

   523 				{

   524 				if ( !parentInfo->IsDestroyed() )

   525 					{ // nearest an ancestor

   526 					parentImage = parentInfo->ClientHandle();

   527 					break;

   528 					}

   529 				parentInfo = parentInfo->Parent();

   530 				}

   531 			}

   532 		}

   533 	return parentImage;

   534 	}

   535 

   536 

   537 /*

   538  ERRORS

   539    VG_ILLEGAL_ARGUMENT_ERROR

   540    – if glyphCapacityHint is negative

   541  */

   542 VGFont TGuestOpenVg::vgCreateFont(VGint aGlyphCapacityHint)

   543 	{

   544 	VGHandle fontHandle = VG_INVALID_HANDLE;

   545 	MVgContext* vgContext = CVghwUtils::VgContext();

   546 	if (vgContext)

   547 		{

   548 		TCleanupVgLocks vgLock(*vgContext);

   549 		fontHandle = vgLock.CreateFont(aGlyphCapacityHint);

   550 		}

   551 	else

   552 		{

   553 		OPENVG_TRACE("  TGuestOpenVg::vgCreateFont - no VG context");

   554 		}

   555 

   556 	return fontHandle;

   557 	}

   558 

   559 

   560 /* Hardware Queries */

   561 

   562 /*

   563  ERRORS

   564    VG_ILLEGAL_ARGUMENT_ERROR

   565    – if key is not one of the values from the VGHardwareQueryType enumeration

   566    – if setting is not one of the values from the enumeration associated with

   567      key

   568  */

   569 VGHardwareQueryResult TGuestOpenVg::vgHardwareQuery(VGHardwareQueryType aKey, VGint aSetting)

   570 	{

   571 	TBool paramsValid = EFalse;

   572 

   573 	MVgContext* vgContext = CVghwUtils::VgContext();

   574 	if (vgContext)

   575 		{

   576 		switch (aKey)

   577 			{

   578 			case VG_IMAGE_FORMAT_QUERY:

   579 				if (TCheck::ImageFormatByteDepth(static_cast<VGImageFormat>(aSetting)) > 0)

   580 					paramsValid = ETrue;

   581 				break;

   582 			case VG_PATH_DATATYPE_QUERY:

   583 				switch (aSetting)

   584 					{

   585 					case VG_PATH_DATATYPE_S_8:

   586 					case VG_PATH_DATATYPE_S_16:

   587 					case VG_PATH_DATATYPE_S_32:

   588 					case VG_PATH_DATATYPE_F:

   589 						paramsValid = ETrue;

   590 					}

   591 				break;

   592 			}

   593 		if (paramsValid)

   594 			{

   595 			RemoteFunctionCallData data; OpenVgRFC vgApiData(data);

   596 			vgApiData.Init(OpenVgRFC::EvgHardwareQuery);

   597 			vgApiData.AppendParam(aKey);

   598 			vgApiData.AppendParam(aSetting);

   599 			VGPANIC_ASSERT_DEBUG(vgApiData.Data().Header().iOpType == RemoteFunctionCallData::EOpRequestWithReply, EVgPanicNotReplyOpcode);

   600 			vgContext->ExecuteVgCommand(vgApiData);

   601 			return static_cast<VGHardwareQueryResult>(vgApiData.ReturnValue());

   602 			}

   603 		vgContext->SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

   604 		}

   605 	return VG_HARDWARE_UNACCELERATED;

   606 	}

   607 

   608 

   609 /*

   610  ERRORS

   611    VG_BAD_HANDLE_ERROR

   612    – if object is not a valid handle, or is not shared with the current context

   613    VG_ILLEGAL_ARGUMENT_ERROR

   614    – if paramType is not a valid value from the appropriate enumeration

   615    – if values is NULL in vgGetParameterfv or vgGetParameteriv

   616    – if values is not properly aligned in vgGetParameterfv or vgGetParameteriv

   617    – if count is less than or equal to 0 in vgGetParameterfv or vgGetParameteriv

   618    – if count is greater than the value returned by vgGetParameterVectorSize for

   619      the given parameter in vgGetParameterfv or vgGetParameteriv

   620  */

   621 void TGuestOpenVg::vgGetParameterfv(VGHandle aObject, VGint aParamType, VGint aCount, VGfloat * aValues)

   622 	{

   623 	MVgContext* vgContext = CVghwUtils::VgContext();

   624 	if ( vgContext )

   625 		{

   626 		CVgHandleBase* handleInfo;

   627 		TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction

   628 

   629 		if ( vgLock.CheckVGAnyHandle(aObject, &handleInfo) && TCheck::Chk32bitPtr(*vgContext, aValues) )

   630 			{

   631 			handleInfo->GetParameterfv(*vgContext, aParamType, aCount, aValues);

   632 			}

   633 		}

   634 	}

   635 

   636 

   637 void TGuestOpenVg::vgGetParameteriv(VGHandle aObject, VGint aParamType, VGint aCount, VGint * aValues)

   638 	{

   639 	MVgContext* vgContext = CVghwUtils::VgContext();

   640 	if ( vgContext )

   641 		{

   642 		CVgHandleBase* handleInfo;

   643 		TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction

   644 

   645 		if ( vgLock.CheckVGAnyHandle(aObject, &handleInfo) && TCheck::Chk32bitPtr(*vgContext, aValues) )

   646 			{

   647 			handleInfo->GetParameteriv(*vgContext, aParamType, aCount, aValues);

   648 			}

   649 		}

   650 	}

   651 

   652 

   653 /* Renderer and Extension Information */

   654 

   655 /* Getxv supports vgGetfv & vgGetiv APIs.

   656 

   657  ERRORS

   658    VG_ILLEGAL_ARGUMENT_ERROR

   659    – if paramType is not a valid value from the VGParamType enumeration

   660    – if values is NULL in vgGetfv or vgGetiv

   661    – if values is not properly aligned in vgGetfv or vgGetiv

   662    – if count is less than or equal to 0 in vgGetfv or vgGetiv

   663    – if count is greater than the value returned by vgGetVectorSize for the

   664      given parameter in vgGetfv or vgGetiv

   665  */

   666 // **** Desirable: can probably do common VGParamType checking for Getx & Getxv, Setx, & Setxv.

   667 void TGuestOpenVg::vgGetfv(VGParamType aType, VGint aCount, const VGfloat * aValues)

   668 	{

   669 	MVgContext* vgContext = CVghwUtils::VgContext();

   670 	if (vgContext && TCheck::Chk32bitPtr(*vgContext, aValues))

   671 		{

   672 		// **** Desirable: check all parameters

   673 		if ( (aCount <= 0) || (aCount > HostGetVectorSize(*vgContext, aType)) )

   674 			{

   675 			vgContext->SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

   676 			}

   677 		else

   678 			{

   679 			RemoteFunctionCallData data; OpenVgRFC vgApiData(data);

   680 			vgApiData.Init(OpenVgRFC::EvgGetfv);

   681 			vgApiData.AppendParam(aType);

   682 			vgApiData.AppendParam(aCount);

   683 			vgApiData.AppendVector(aValues, aCount, RemoteFunctionCallData::EOut);

   684 			vgContext->ExecuteVgCommand(vgApiData);

   685 			}

   686 		}

   687 	}

   688 

   689 

   690 void TGuestOpenVg::vgGetiv(VGParamType aType, VGint aCount, const VGint * aValues)

   691 	{

   692 	MVgContext* vgContext = CVghwUtils::VgContext();

   693 	if ( vgContext && TCheck::Chk32bitPtr(*vgContext, aValues) )

   694 		{

   695 		// **** Desirable: check all parameters

   696 		if ( (aCount <= 0) || (aCount > HostGetVectorSize(*vgContext, aType)) )

   697 			{

   698 			vgContext->SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

   699 			}

   700 		else

   701 			{

   702 			RemoteFunctionCallData data; OpenVgRFC vgApiData(data);

   703 			vgApiData.Init(OpenVgRFC::EvgGetiv);

   704 			vgApiData.AppendParam(aType);

   705 			vgApiData.AppendParam(aCount);

   706 			vgApiData.AppendVector(aValues, aCount, RemoteFunctionCallData::EOut);

   707 			vgContext->ExecuteVgCommand(vgApiData);

   708 			}

   709 		}

   710 	}

   711 

   712 

   713 /*

   714  ERRORS

   715  VG_ILLEGAL_ARGUMENT_ERROR

   716  – if m is NULL

   717  – if m is not properly aligned

   718  */

   719 void TGuestOpenVg::vgGetMatrix(VGfloat* aM)

   720 	{

   721 	// check mat pointer is 32-bit aligned

   722 	MVgContext* vgContext = CVghwUtils::VgContext();

   723 	if ( vgContext && TCheck::Chk32bitPtr(*vgContext, aM) )

   724 		{

   725 		RemoteFunctionCallData data; OpenVgRFC vgApiData(data);

   726 		vgApiData.Init(OpenVgRFC::EvgGetMatrix);

   727 		vgApiData.AppendVector(aM, KTransformMatrixSize, RemoteFunctionCallData::EOut);

   728 		vgContext->ExecuteVgCommand(vgApiData);

   729 		}

   730 	}

   731 

   732 

   733 /*

   734  ERRORS

   735    VG_BAD_HANDLE_ERROR

   736    – if image is not a valid image handle, or is not shared with the current context

   737    VG_IMAGE_IN_USE_ERROR

   738    – if image is currently a rendering target

   739    VG_UNSUPPORTED_IMAGE_FORMAT_ERROR

   740    – if dataFormat is not a valid value from the VGImageFormat enumeration

   741    VG_ILLEGAL_ARGUMENT_ERROR

   742    – if width or height is less than or equal to 0

   743    – if data is NULL

   744    – if data is not properly aligned

   745  */

   746 void TGuestOpenVg::vgGetImageSubData(VGImage aImage, void* aData, VGint aDataStride, VGImageFormat aDataFormat,

   747 		VGint aX, VGint aY, VGint aWidth, VGint aHeight)

   748 	{

   749 	MVgContext* vgContext = CVghwUtils::VgContext();

   750 	if ( vgContext )

   751 		{

   752 		CVgImageInfo* imageInfo = NULL;

   753 		TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction

   754 

   755 		if ( vgLock.CheckVGImage(aImage, &imageInfo) && TCheck::ChkImageAlignment(*vgContext, aDataFormat, aData) &&

   756 				TCheck::ChkPositiveImageSize(*vgContext, aWidth, aHeight) )

   757 			{

   758 			imageInfo->GetImageSubData(*vgContext, aData, aDataStride, aDataFormat, aX, aY, aWidth, aHeight);

   759 			}

   760 		}

   761 	}

   762 

   763 

   764 /*

   765  ERRORS

   766    VG_UNSUPPORTED_IMAGE_FORMAT_ERROR

   767    – if dataFormat is not a valid value from the VGImageFormat enumeration

   768    VG_ILLEGAL_ARGUMENT_ERROR

   769    – if width or height is less than or equal to 0

   770    – if data is NULL

   771    – if data is not properly aligned

   772  */

   773 void TGuestOpenVg::HostVgReadPixels(MVgContext& aVgContext, void* aPixmap, size_t aPixmapSize, VGint aHostDataStride,

   774 		VGImageFormat aDataFormat, VGint aSx, VGint aSy, VGint aWidth, VGint aHeight)

   775 	{

   776 	VGPANIC_ASSERT(aPixmap != NULL, EVgPanicNullPixmapPointer);

   777 	VGPANIC_ASSERT(aPixmapSize >= (aHostDataStride * aHeight), EVgPanicPixmapSizeError);

   778 	RemoteFunctionCallData rfcdata; OpenVgRFC vgApiData(rfcdata);

   779 	vgApiData.Init(OpenVgRFC::EvgReadPixels);

   780 	vgApiData.AppendVector(aPixmap, aPixmapSize, RemoteFunctionCallData::EOut);

   781 	vgApiData.AppendParam(aHostDataStride);

   782 	vgApiData.AppendParam(aDataFormat);

   783 	vgApiData.AppendParam(aSx);

   784 	vgApiData.AppendParam(aSy);

   785 	vgApiData.AppendParam(aWidth);

   786 	vgApiData.AppendParam(aHeight);

   787 	vgApiData.AppendParam((VGint)aPixmapSize);

   788 	aVgContext.ExecuteVgCommand(vgApiData);

   789 	}

   790 

   791 

   792 void TGuestOpenVg::vgReadPixels(void* aData, VGint aDataStride, VGImageFormat aDataFormat, VGint aSx, VGint aSy,

   793 		VGint aWidth, VGint aHeight)

   794 	{

   795 	// **** Desirable: check all parameters

   796 	MVgContext* vgContext = CVghwUtils::VgContext();

   797 	if ( vgContext && TCheck::ChkImageAlignment(*vgContext, aDataFormat, aData) && TCheck::ChkPositiveImageSize(*vgContext, aWidth, aHeight) )

   798 		{ // width > 0 && height > 0

   799 		TInt bitsPerPixel = CVgImageInfo::BitsPerPixelForVgImageFormat(aDataFormat);

   800 		TUint32 lineLength = static_cast<TUint32>(aWidth) * static_cast<TUint32>(bitsPerPixel);

   801 		TUint32 tailBits = lineLength & 7;

   802 		lineLength = (lineLength + 7) / 8;

   803 		OPENVG_TRACE("vgReadPixels.1 bitsPerPixel=%d, lineLength=%d, tailBits=%d", bitsPerPixel, lineLength, tailBits);

   804 		// ToDo clip aWidth & aHeight to the surface width & height

   805 

   806 		if (bitsPerPixel <= 0)

   807 			{

   808 			vgContext->SetVgError(VG_UNSUPPORTED_IMAGE_FORMAT_ERROR);

   809 			}

   810 		else

   811 			{

   812 			if (lineLength  == aDataStride)

   813 				{ // use original params

   814 				OPENVG_TRACE("vgReadPixels.2a: lineLength == dataStride");

   815 				HostVgReadPixels(*vgContext, aData, aDataStride * aHeight, aDataStride, aDataFormat, aSx, aSy, aWidth, aHeight);

   816 				}

   817 			else if (0 == aDataStride)

   818 				{ // unlikely unless aHeight = 1, but symmetric to fill function for vgWritePixels

   819 				OPENVG_TRACE("vgReadPixels.2b: 0 == dataStride");

   820 				HostVgReadPixels(*vgContext, aData, lineLength, aDataStride, aDataFormat, aSx, aSy, aWidth, aHeight);

   821 				}

   822 			else

   823 				{ // datastride maybe negative or simply > lineLength

   824 				TInt pixmapSize = lineLength * aHeight;

   825 				TUint8* localBuffer = (TUint8*) CVghwUtils::Alloc(pixmapSize);

   826 				OPENVG_TRACE("vgReadPixels.2c: dataStride not 0 or lineLength, localBuffer=0x%x", localBuffer);

   827 

   828 				if (localBuffer != NULL)

   829 					{ // read pixels into temporary buffer

   830 					HostVgReadPixels(*vgContext, localBuffer, pixmapSize, lineLength, aDataFormat, aSx, aSy, aWidth, aHeight);

   831 					// reformat into client memory

   832 					CVgImageInfo::PixmapBlit(static_cast<TUint8*>(aData), localBuffer, aDataStride, lineLength, aHeight, lineLength, tailBits);

   833 					CVghwUtils::Free(localBuffer);

   834 					}

   835 				else

   836 					{ // alloc failed, so do VG operation row by row

   837 					TUint8* dest = static_cast<TUint8*>(aData);

   838 					for (VGint row = 0; row < aHeight; ++row)

   839 						{

   840 						HostVgReadPixels(*vgContext, dest, lineLength, lineLength, aDataFormat, aSx + row, aSy, aWidth, 1);

   841 						dest += aDataStride;

   842 						}

   843 					}

   844 				}

   845 			}

   846 		}

   847 	}

   848 

   849 

   850 /*

   851  ERRORS

   852    VG_BAD_HANDLE_ERROR

   853    – if path is not a valid path handle, or is not shared with the current context

   854    VG_ILLEGAL_ARGUMENT_ERROR

   855    – if minX, minY, width, or height is NULL

   856    – if minX, minY, width, or height is not properly aligned

   857    VG_PATH_CAPABILITY_ERROR

   858    – if VG_PATH_CAPABILITY_PATH_BOUNDS is not enabled for path

   859  */

   860 void TGuestOpenVg::vgPathBounds(VGPath aPath, VGfloat* aMinX, VGfloat* aMinY, VGfloat* aWidth, VGfloat* aHeight)

   861 	{

   862 	MVgContext* vgContext = CVghwUtils::VgContext();

   863 	if ( vgContext )

   864 		{

   865 		CVgPathInfo* pathInfo = NULL;

   866 		TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction

   867 

   868 		if ( vgLock.CheckVGPath(aPath, &pathInfo, VG_PATH_CAPABILITY_PATH_BOUNDS) )

   869 			{

   870 			pathInfo->PathBounds(*vgContext, aMinX, aMinY, aWidth, aHeight);

   871 			}

   872 		}

   873 	}

   874 

   875 

   876 /*

   877  ERRORS

   878    VG_BAD_HANDLE_ERROR

   879    – if path is not a valid path handle, or is not shared with the current context

   880    VG_ILLEGAL_ARGUMENT_ERROR

   881    – if minX, minY, width, or height is NULL

   882    – if minX, minY, width, or height is not properly aligned

   883    VG_PATH_CAPABILITY_ERROR

   884    – if VG_PATH_CAPABILITY_PATH_TRANSFORMED_BOUNDS is not enabled

   885      for path

   886  */

   887 void  TGuestOpenVg::vgPathTransformedBounds(VGPath aPath, VGfloat* aMinX, VGfloat* aMinY, VGfloat* aWidth, VGfloat* aHeight)

   888 	{

   889 	MVgContext* vgContext = CVghwUtils::VgContext();

   890 	if ( vgContext )

   891 		{

   892 		CVgPathInfo* pathInfo = NULL;

   893 		TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction

   894 

   895 		if ( vgLock.CheckVGPath(aPath, &pathInfo, VG_PATH_CAPABILITY_PATH_TRANSFORMED_BOUNDS) )

   896 			{

   897 			pathInfo->PathTransformedBounds(*vgContext, aMinX, aMinY, aWidth, aHeight);

   898 			}

   899 		}

   900 	}

   901 

   902 

   903 ////////////////////////////////////////////////////////////////////////////////////////////

   904 //Functions not returning value (possible to buffer)

   905 ////////////////////////////////////////////////////////////////////////////////////////////

   906 /* Getters and Setters */

   907 

   908 /*

   909  vgSeti and vgSetf

   910 

   911  ERRORS

   912    VG_ILLEGAL_ARGUMENT_ERROR

   913    – if paramType is not a valid value from the VGParamType enumeration

   914    – if paramType refers to a vector parameter in vgSetf or vgSeti

   915    – if value is not a legal enumerated value for the given parameter in vgSetf or

   916      vgSeti

   917  */

   918 void TGuestOpenVg::vgSeti(VGParamType aType, VGint aValue)

   919 	{

   920 	// **** Desirable: check aType

   921 	MVgContext* vgContext = CVghwUtils::VgContext();

   922 	if (vgContext)

   923 		{

   924 		RemoteFunctionCallData data; OpenVgRFC vgApiData(data);

   925 		vgApiData.Init(OpenVgRFC::EvgSeti, RemoteFunctionCallData::EOpRequest);

   926 		vgApiData.AppendParam(aType);

   927 		vgApiData.AppendParam(aValue);

   928 		vgContext->ExecuteVgCommand(vgApiData);

   929 		}

   930 	}

   931 

   932 

   933 void TGuestOpenVg::vgSetf(VGParamType aType, VGfloat aValue)

   934 	{

   935 	// **** Desirable: check aType

   936 	MVgContext* vgContext = CVghwUtils::VgContext();

   937 	if (vgContext)

   938 		{

   939 		RemoteFunctionCallData data; OpenVgRFC vgApiData(data);

   940 		vgApiData.Init(OpenVgRFC::EvgSetf, RemoteFunctionCallData::EOpRequest);

   941 		vgApiData.AppendParam(aType);

   942 		vgApiData.AppendParam(aValue);

   943 		vgContext->ExecuteVgCommand(vgApiData);

   944 		}

   945 	}

   946 

   947 

   948 /*

   949  vgSetiv and vgSetfv

   950 

   951  ERRORS

   952    VG_ILLEGAL_ARGUMENT_ERROR

   953    – if paramType is not a valid value from the VGParamType enumeration

   954    – if paramType refers to a scalar parameter in vgSetfv or vgSetiv and count is

   955      not equal to 1

   956    – if values[i] is not a legal enumerated value for the given parameter in vgSetfv

   957      or vgSetiv for 0 <= i < count

   958    – if values is NULL in vgSetfv or vgSetiv and count is greater than 0

   959    – if values is not properly aligned in vgSetfv or vgSetiv

   960    – if count is less than 0 in vgSetfv or vgSetiv

   961    – if count is not a valid value for the given parameter

   962  */

   963 void TGuestOpenVg::vgSetfv(VGParamType aType, VGint aCount, const VGfloat * aValues)

   964 	{

   965 	MVgContext* vgContext = CVghwUtils::VgContext();

   966 	if (vgContext && TCheck::Chk32bitPtr(*vgContext, aValues))

   967 		{

   968 		// **** Desirable: check all params

   969 		// we should check count for not being too large for serialization, but

   970 		// there is no limit in spec for VG_SCISSOR_RECTS and VG_STROKE_DASH_PATTERN

   971 		if ( (aCount < 0) || (aCount > 100000) )

   972 			{

   973 			vgContext->SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

   974 			}

   975 		else

   976 			{

   977 			RemoteFunctionCallData data; OpenVgRFC vgApiData(data);

   978 			vgApiData.Init(OpenVgRFC::EvgSetfv, RemoteFunctionCallData::EOpRequest);

   979 			vgApiData.AppendParam(aType);

   980 			vgApiData.AppendParam(aCount);

   981 			vgApiData.AppendVector(aValues, aCount);

   982 			vgContext->ExecuteVgCommand(vgApiData);

   983 			}

   984 		}

   985 	}

   986 

   987 

   988 void TGuestOpenVg::vgSetiv(VGParamType aType, VGint aCount, const VGint * aValues)

   989 	{

   990 	MVgContext* vgContext = CVghwUtils::VgContext();

   991 	if ( vgContext && TCheck::Chk32bitPtr(*vgContext, aValues) )

   992 		{

   993 		// **** Desirable: check all params

   994 		// we should check count for not being too large for serialization, but

   995 		// there is no limit in spec for VG_SCISSOR_RECTS and VG_STROKE_DASH_PATTERN

   996 		if ( (aCount < 0) || (aCount > 100000) )

   997 			{

   998 			vgContext->SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

   999 			}

  1000 		else

  1001 			{

  1002 			RemoteFunctionCallData data; OpenVgRFC vgApiData(data);

  1003 			vgApiData.Init(OpenVgRFC::EvgSetiv, RemoteFunctionCallData::EOpRequest);

  1004 			vgApiData.AppendParam(aType);

  1005 			vgApiData.AppendParam(aCount);

  1006 			vgApiData.AppendVector(aValues, aCount);

  1007 			vgContext->ExecuteVgCommand(vgApiData);

  1008 			}

  1009 		}

  1010 	}

  1011 

  1012 

  1013 /*

  1014  For vgSetParameterf and vgSetParameteri.

  1015 

  1016  ERRORS

  1017    VG_BAD_HANDLE_ERROR

  1018    – if object is not a valid handle, or is not shared with the current context

  1019    VG_ILLEGAL_ARGUMENT_ERROR

  1020    – if paramType is not a valid value from the appropriate enumeration

  1021    – if paramType refers to a vector parameter in vgSetParameterf or

  1022      vgSetParameteri

  1023    – if value is not a legal enumerated value for the given parameter in

  1024      vgSetParameterf or vgSetParameteri

  1025  */

  1026 

  1027 void TGuestOpenVg::vgSetParameteri(VGHandle aObject, VGint aParamType, VGint aValue)

  1028 	{

  1029 	MVgContext* vgContext = CVghwUtils::VgContext();

  1030 	if ( vgContext )

  1031 		{

  1032 		CVgHandleBase* handleInfo;

  1033 		TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction

  1034 

  1035 		if ( vgLock.CheckVGAnyHandle(aObject, &handleInfo) )

  1036 			{

  1037 			handleInfo->SetParameteri(*vgContext, aParamType, aValue);

  1038 			}

  1039 		}

  1040 	}

  1041 

  1042 

  1043 void TGuestOpenVg::vgSetParameterf(VGHandle aObject, VGint aParamType, VGfloat aValue)

  1044 	{

  1045 	MVgContext* vgContext = CVghwUtils::VgContext();

  1046 	if ( vgContext )

  1047 		{

  1048 		CVgHandleBase* handleInfo;

  1049 		TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction

  1050 

  1051 		if ( vgLock.CheckVGAnyHandle(aObject, &handleInfo) )

  1052 			{

  1053 			handleInfo->SetParameterf(*vgContext, aParamType, aValue);

  1054 			}

  1055 		}

  1056 	}

  1057 

  1058 

  1059 /*

  1060  For vgSetParameterfv and vgSetParameteriv.

  1061 

  1062  The vgSetParameter functions set the value of a parameter on a given VGHandlebased

  1063  object.

  1064 

  1065  ERRORS

  1066    VG_BAD_HANDLE_ERROR

  1067    – if object is not a valid handle, or is not shared with the current context

  1068    VG_ILLEGAL_ARGUMENT_ERROR

  1069    – if paramType is not a valid value from the appropriate enumeration

  1070    – if paramType refers to a scalar parameter in vgSetParameterfv or

  1071      vgSetParameteriv and count is not equal to 1

  1072    – if values[i] is not a legal enumerated value for the given parameter

  1073      in vgSetParameterfv or vgSetParameteriv for 0 <= i < count

  1074    – if values is NULL in vgSetParameterfv or vgSetParameteriv and count is

  1075      greater than 0

  1076    – if values is not properly aligned in vgSetParameterfv or vgSetParameteriv

  1077    – if count is less than 0 in vgSetParameterfv or vgSetParameteriv

  1078    – if count is not a valid value for the given parameter

  1079  */

  1080 void TGuestOpenVg::vgSetParameterfv(VGHandle aObject, VGint aParamType, VGint aCount, const VGfloat * aValues)

  1081 	{

  1082 	MVgContext* vgContext = CVghwUtils::VgContext();

  1083 	if ( vgContext )

  1084 		{

  1085 		CVgHandleBase* handleInfo;

  1086 		TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction

  1087 

  1088 		// ToDo review overlapping checks between TCheck::ParamCountAndValuesPtr to SetParameterfv

  1089 		if ( vgLock.CheckVGAnyHandle(aObject, &handleInfo) && TCheck::ChkParamCountAndValuesPtr(*vgContext, aCount, aValues) )

  1090 			{

  1091 			handleInfo->SetParameterfv(*vgContext, aParamType, aCount, aValues);

  1092 			}

  1093 		}

  1094 	}

  1095 

  1096 

  1097 void TGuestOpenVg::vgSetParameteriv(VGHandle aObject, VGint aParamType, VGint aCount, const VGint * aValues)

  1098 	{

  1099 	MVgContext* vgContext = CVghwUtils::VgContext();

  1100 	if ( vgContext )

  1101 		{

  1102 		CVgHandleBase* handleInfo;

  1103 		TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction

  1104 

  1105 		if ( vgLock.CheckVGAnyHandle(aObject, &handleInfo) && TCheck::ChkParamCountAndValuesPtr(*vgContext, aCount, aValues) )

  1106 			{

  1107 			handleInfo->SetParameteriv(*vgContext, aParamType, aCount, aValues);

  1108 			}

  1109 		}

  1110 	}

  1111 

  1112 

  1113 /* Matrix Manipulation */

  1114 /*

  1115  No errors if Context is valid.

  1116  */

  1117 void TGuestOpenVg::vgLoadIdentity()

  1118 	{

  1119 	MVgContext* vgContext = CVghwUtils::VgContext();

  1120 	if (vgContext)

  1121 		{

  1122 		RemoteFunctionCallData data; OpenVgRFC vgApiData(data);

  1123 		vgApiData.Init(OpenVgRFC::EvgLoadIdentity, RemoteFunctionCallData::EOpRequest);

  1124 		vgContext->ExecuteVgCommand(vgApiData);

  1125 		}

  1126 	}

  1127 

  1128 

  1129 /*

  1130  ERRORS

  1131    VG_ILLEGAL_ARGUMENT_ERROR

  1132    – if m is NULL

  1133    – if m is not properly aligned

  1134  */