--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/guestrendering/guestopenvg/src/vgapi.cpp Wed Sep 08 17:02:34 2010 +0100
@@ -0,0 +1,2461 @@
+// Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// C++ version of Open VG API.
+
+#include "openvg.inl"
+#include "remotefunctioncall.h"
+#include "openvgrfc.h"
+
+
+// normalized IEEE 754 representations
+const float KFloatMinusOne = -1.0f;
+const float KFloatZero = 0.0f;
+
+const TInt KTransformMatrixSize = 9;
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+// TGuestOpenVg
+/////////////////////////////////////////////////////////////////////////////////////////////
+
+// ---------------------------------------------------------------------
+// TGuestOpenVg - private inline & paramater checking functions
+
+// helper function
+///////////////////////////////////////////////////////////////////////////////////////////////
+// Implementation of Open VG APIs ... with comments summarising possible errors.
+
+////////////////////////////////////////////////////////////////////////////////////////////
+//Functions returning value
+////////////////////////////////////////////////////////////////////////////////////////////
+
+/*
+ ERRORS
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if paintMode is not a valid value from the VGPaintMode enumeration
+ */
+VGPaint TGuestOpenVg::vgGetPaint(VGPaintMode aPaintMode)
+ {
+ VGPaint paintHandle = VG_INVALID_HANDLE;
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if (vgContext && TCheck::ChkVGPaintMode(*vgContext, aPaintMode))
+ {
+ TCleanupVgLocks vgLock(*vgContext);
+ paintHandle = vgLock.GetPaint(aPaintMode);
+ }
+ else if (!vgContext)
+ {
+ OPENVG_TRACE(" TGuestOpenVg::vgGetPaint - no VG context");
+ }
+ else
+ {
+ OPENVG_TRACE(" TGuestOpenVg::vgGetPaint - ParamCheck failed");
+ }
+ return paintHandle;
+ }
+
+
+/*
+ If insufficient memory is available to allocate a new object, VG_INVALID_HANDLE is returned.
+ */
+VGPaint TGuestOpenVg::vgCreatePaint()
+ {
+ VGPaint paintHandle = VG_INVALID_HANDLE;
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if (vgContext)
+ {
+ TCleanupVgLocks vgLock(*vgContext);
+ paintHandle = vgLock.CreatePaint();
+ }
+ else
+ {
+ OPENVG_TRACE(" TGuestOpenVg::vgCreatePaint - no VG context");
+ }
+
+ return paintHandle;
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if any of dstPath, startPath, or endPath is not a valid path handle, or is
+ not shared with the current context
+ VG_PATH_CAPABILITY_ERROR
+ – if VG_PATH_CAPABILITY_INTERPOLATE_TO is not enabled for dstPath
+ – if VG_PATH_CAPABILITY_INTERPOLATE_FROM is not enabled for startPath or endPath
+ */
+VGboolean TGuestOpenVg::vgInterpolatePath(VGPath aDstPath, VGPath aStartPath, VGPath aEndPath, VGfloat aAmount)
+ {
+ VGboolean result = VG_FALSE;
+ MVgContext* vgContext = CVghwUtils::VgContext();
+
+ if ( vgContext )
+ {
+ CVgPathInfo* dstPathInfo = NULL;
+ CVgPathInfo* startPathInfo = NULL;
+ CVgPathInfo* endPathInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGPath(aDstPath, &dstPathInfo, VG_PATH_CAPABILITY_INTERPOLATE_TO) &&
+ vgLock.CheckVGPath(aStartPath, &startPathInfo, VG_PATH_CAPABILITY_INTERPOLATE_FROM) &&
+ vgLock.CheckVGPath(aEndPath, &endPathInfo, VG_PATH_CAPABILITY_INTERPOLATE_FROM) )
+ {
+ result = dstPathInfo->InterpolatePath(*vgContext, *startPathInfo, *endPathInfo, aAmount);
+ }
+ }
+ return result;
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if path is not a valid path handle, or is not shared with the current context
+ VG_PATH_CAPABILITY_ERROR
+ – if VG_PATH_CAPABILITY_PATH_LENGTH is not enabled for path
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if startSegment is less than 0 or greater than the index of the final path
+ segment
+ – if numSegments is less than or equal to 0
+ – if (startSegment + numSegments – 1) is greater than the index of the final
+ path segment
+ */
+VGfloat TGuestOpenVg::vgPathLength(VGPath aPath, VGint aStartSegment, VGint aNumSegments)
+ {
+ VGfloat result = KFloatMinusOne;
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgPathInfo* pathInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGPath(aPath, &pathInfo, VG_PATH_CAPABILITY_PATH_LENGTH) )
+ {
+ if ( (aStartSegment < 0) || (aNumSegments <= 0) )
+ {
+ vgContext->SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);
+ }
+ else
+ {
+ result = pathInfo->PathLength(*vgContext, aStartSegment, aNumSegments);
+ }
+ }
+ }
+ return result;
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if path is not a valid path handle, or is not shared with the current context
+ */
+VGbitfield TGuestOpenVg::vgGetPathCapabilities(VGPath aPath)
+ {
+ VGbitfield result = 0;
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgPathInfo* pathInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGPath(aPath, &pathInfo) )
+ {
+ result = pathInfo->GetPathCapabilities(*vgContext);
+ }
+ }
+ return result;
+ }
+
+
+/*
+ ERRORS
+ VG_UNSUPPORTED_PATH_FORMAT_ERROR
+ – if pathFormat is not a supported format
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if datatype is not a valid value from the VGPathDatatype enumeration
+ – if scale is equal to 0
+ */
+VGPath TGuestOpenVg::vgCreatePath(VGint aPathFormat, VGPathDatatype aDatatype, VGfloat aScale, VGfloat aBias,
+ VGint aSegmentCapacityHint, VGint aCoordCapacityHint, VGbitfield aCapabilities)
+ {
+ VGPath pathHandle = VG_INVALID_HANDLE;
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext && TCheck::ChkVGPathFormat(*vgContext, aPathFormat) && TCheck::ChkVGPathDataType(*vgContext, aDatatype) )
+ {
+ if (aScale == KFloatZero)
+ {
+ vgContext->SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);
+ }
+ else
+ {
+ TCleanupVgLocks vgLock(*vgContext); // Waits & holds VG mutex until destruction
+ pathHandle = vgLock.CreatePath(aPathFormat, aDatatype, aScale, aBias, aSegmentCapacityHint, aCoordCapacityHint, aCapabilities);
+ }
+ }
+ else if (!vgContext)
+ {
+ OPENVG_TRACE(" TGuestOpenVg::vgCreatePath - no VG context");
+ }
+ else
+ {
+ OPENVG_TRACE(" TGuestOpenVg::vgCreatePath - ParamCheck failed");
+ }
+
+ return pathHandle;
+ }
+
+
+/* For vgGeti, vgGetf, and vgGetVectorSize.
+If an error occurs during a call to vgGetf, vgGeti, or vgGetVectorSize, the return value
+is undefined.
+
+ERRORS
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if paramType is not a valid value from the VGParamType enumeration
+ – if paramType refers to a vector parameter in vgGetf or vgGeti
+*/
+VGint TGuestOpenVg::HostGeti(MVgContext& aVgContext, VGParamType aType)
+ {
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgGeti);
+ vgApiData.AppendParam(aType);
+ VGPANIC_ASSERT_DEBUG(vgApiData.Data().Header().iOpType == RemoteFunctionCallData::EOpRequestWithReply, EVgPanicNotReplyOpcode);
+ aVgContext.ExecuteVgCommand(vgApiData);
+ return static_cast<VGint>(vgApiData.ReturnValue());
+ }
+
+
+VGfloat TGuestOpenVg::HostGetf(MVgContext& aVgContext, VGParamType aType)
+ {
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgGetf);
+ vgApiData.AppendParam(aType);
+ VGPANIC_ASSERT_DEBUG(vgApiData.Data().Header().iOpType == RemoteFunctionCallData::EOpRequestWithReply, EVgPanicNotReplyOpcode);
+ aVgContext.ExecuteVgCommand(vgApiData);
+ return static_cast<VGfloat>(vgApiData.ReturnValue());
+ }
+
+
+VGint TGuestOpenVg::vgGeti(VGParamType aType)
+ {
+ // TODO validate aType
+ VGint result = 0;
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if (vgContext)
+ {
+ result = HostGeti(*vgContext, aType);
+ }
+ return result;
+ }
+
+
+VGfloat TGuestOpenVg::vgGetf(VGParamType aType)
+ {
+ // TODO validate aType
+ VGfloat result = KFloatMinusOne;
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if (vgContext)
+ {
+ result = HostGetf(*vgContext, aType);
+ }
+ return result;
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if object is not a valid handle, or is not shared with the current context
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if paramType is not a valid value from the appropriate enumeration
+ – if paramType refers to a vector parameter in vgGetParameterf or
+ vgGetParameteri
+ */
+VGint TGuestOpenVg::vgGetParameteri(VGHandle aObject, VGint aParamType)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgHandleBase* handleInfo;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGAnyHandle(aObject, &handleInfo) )
+ {
+ return handleInfo->GetParameteri(*vgContext, aParamType);
+ }
+ }
+ return 0;
+ }
+
+
+VGint TGuestOpenVg::HostGetVectorSize(MVgContext& aVgContext, VGParamType aType)
+ {
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgGetVectorSize);
+ vgApiData.AppendParam(aType);
+ VGPANIC_ASSERT_DEBUG(vgApiData.Data().Header().iOpType == RemoteFunctionCallData::EOpRequestWithReply, EVgPanicNotReplyOpcode);
+ aVgContext.ExecuteVgCommand(vgApiData);
+ return static_cast<VGint>(vgApiData.ReturnValue());
+ }
+
+
+VGint TGuestOpenVg::vgGetVectorSize(VGParamType aType)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if (vgContext)
+ { // **** Desirable: check aType
+ return HostGetVectorSize(*vgContext, aType);
+ }
+ return 0;
+ }
+
+
+VGfloat TGuestOpenVg::vgGetParameterf(VGHandle aObject, VGint aParamType)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgHandleBase* handleInfo;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGAnyHandle(aObject, &handleInfo) )
+ {
+ return handleInfo->GetParameterf(*vgContext, aParamType);
+ }
+ }
+ return KFloatMinusOne;
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if object is not a valid handle, or is not shared with the current context
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if paramType is not a valid value from the appropriate enumeration
+ */
+VGint TGuestOpenVg::vgGetParameterVectorSize(VGHandle aObject, VGint aParamType)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgHandleBase* handleInfo;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ // **** Desirable: check aParamType
+ if ( vgLock.CheckVGAnyHandle(aObject, &handleInfo) )
+ {
+ return handleInfo->GetParameterVectorSize(*vgContext, aParamType);
+ }
+ }
+ return 0;
+ }
+
+
+/*
+ ERRORS
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if width or height are less than or equal to 0
+ – if width is greater than VG_MAX_IMAGE_WIDTH
+ – if height is greater than VG_MAX_IMAGE_HEIGHT
+ – if width*height is greater than VG_MAX_IMAGE_PIXELS
+ */
+VGMaskLayer TGuestOpenVg::vgCreateMaskLayer(VGint aWidth, VGint aHeight)
+ {
+ VGMaskLayer maskLayerHandle = VG_INVALID_HANDLE;
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext && TCheck::ChkNewImageSize(*vgContext, aWidth, aHeight) )
+ {
+ TCleanupVgLocks vgLock(*vgContext);
+ maskLayerHandle = vgLock.CreateMaskLayer(aWidth, aHeight);
+ }
+ else if (!vgContext)
+ {
+ OPENVG_TRACE(" TGuestOpenVg::vgCreateMaskLayer - no VG context");
+ }
+ else
+ {
+ OPENVG_TRACE(" TGuestOpenVg::vgCreateMaskLayer - ParamCheck failed");
+ }
+
+ return maskLayerHandle;
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if paint is not a valid paint handle, or is not shared with the current context
+ */
+VGuint TGuestOpenVg::vgGetColor(VGPaint aPaint)
+ {
+ VGuint result = 0;
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgPaintInfo* paintInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGPaint(aPaint, &paintInfo) )
+ {
+ result = paintInfo->GetColor(*vgContext);
+ }
+ }
+ return result;
+ }
+
+
+/*
+ ERRORS
+ VG_UNSUPPORTED_IMAGE_FORMAT_ERROR
+ – if format is not a valid value from the VGImageFormat enumeration
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if width or height are less than or equal to 0
+ – if width is greater than VG_MAX_IMAGE_WIDTH
+ – if height is greater than VG_MAX_IMAGE_HEIGHT
+ – if width*height is greater than VG_MAX_IMAGE_PIXELS
+ – if width*height*(pixel size of format) is greater than
+ VG_MAX_IMAGE_BYTES
+ – if allowedQuality is not a bitwise OR of values from the
+ VGImageQuality enumeration
+ */
+VGImage TGuestOpenVg::vgCreateImage(VGImageFormat aFormat, VGint aWidth, VGint aHeight, VGbitfield aAllowedQuality)
+ {
+ VGHandle imageHandle = VG_INVALID_HANDLE;
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext && TCheck::ChkNewImageSize(*vgContext, aWidth, aHeight) && TCheck::ChkVgImageFormat(*vgContext, aFormat) )
+ { // width > 0 && height > 0
+ TCleanupVgLocks vgLock(*vgContext);
+ imageHandle = vgLock.CreateImage(aFormat, aWidth, aHeight, aAllowedQuality);
+ }
+ else if (!vgContext)
+ {
+ OPENVG_TRACE(" TGuestOpenVg::vgCreateImage - no VG context");
+ }
+ else
+ {
+ OPENVG_TRACE(" TGuestOpenVg::vgCreateImage - ParamCheck failed");
+ }
+
+ return imageHandle;
+ }
+
+
+/*
+ Returns a new VGImage handle that refers to a portion of the parent image. The
+ region is given by the intersection of the bounds of the parent image with the
+ rectangle beginning at pixel (x, y) with dimensions width and height, which
+ must define a positive region contained entirely within parent.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if parent is not a valid image handle, or is not shared with the current
+ context
+ VG_IMAGE_IN_USE_ERROR
+ – if parent is currently a rendering target
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if x is less than 0 or greater than or equal to the parent width
+ – if y is less than 0 or greater than or equal to the parent height
+ – if width or height is less than or equal to 0
+ – if x + width is greater than the parent width
+ – if y + height is greater than the parent height
+ */
+VGImage TGuestOpenVg::vgChildImage(VGImage aParent, VGint aX, VGint aY, VGint aWidth, VGint aHeight)
+ {
+ VGHandle imageHandle = VG_INVALID_HANDLE;
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgImageInfo* parentInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGImage(aParent, &parentInfo) && TCheck::ChkAreaIsWithinImage(*vgContext, parentInfo, aX, aY, aWidth, aHeight) )
+ { // child image area is within parent image
+ imageHandle = vgLock.ChildImage(*parentInfo, aX, aY, aWidth, aHeight);
+ }
+ }
+ else
+ {
+ OPENVG_TRACE(" TGuestOpenVg::vgChildImage - no VG context");
+ }
+
+ return imageHandle;
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if image is not a valid image handle, or is not shared with the current
+ context
+ VG_IMAGE_IN_USE_ERROR
+ – if image is currently a rendering target
+ */
+VGImage TGuestOpenVg::vgGetParent(VGImage aImage)
+ {
+ VGImage parentImage = VG_INVALID_HANDLE;
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgImageInfo* imageInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGImage(aImage, &imageInfo) )
+ {
+ // baseline for a valid image is to return its own ClientHandle
+ parentImage = aImage;
+ // try to find a non-destroyed ancestor
+ // ToDo add getParent Api to CVgImageInfo
+ CVgImageInfo* parentInfo = imageInfo->Parent();
+ while (parentInfo)
+ {
+ if ( !parentInfo->IsDestroyed() )
+ { // nearest an ancestor
+ parentImage = parentInfo->ClientHandle();
+ break;
+ }
+ parentInfo = parentInfo->Parent();
+ }
+ }
+ }
+ return parentImage;
+ }
+
+
+/*
+ ERRORS
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if glyphCapacityHint is negative
+ */
+VGFont TGuestOpenVg::vgCreateFont(VGint aGlyphCapacityHint)
+ {
+ VGHandle fontHandle = VG_INVALID_HANDLE;
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if (vgContext)
+ {
+ TCleanupVgLocks vgLock(*vgContext);
+ fontHandle = vgLock.CreateFont(aGlyphCapacityHint);
+ }
+ else
+ {
+ OPENVG_TRACE(" TGuestOpenVg::vgCreateFont - no VG context");
+ }
+
+ return fontHandle;
+ }
+
+
+/* Hardware Queries */
+
+/*
+ ERRORS
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if key is not one of the values from the VGHardwareQueryType enumeration
+ – if setting is not one of the values from the enumeration associated with
+ key
+ */
+VGHardwareQueryResult TGuestOpenVg::vgHardwareQuery(VGHardwareQueryType aKey, VGint aSetting)
+ {
+ TBool paramsValid = EFalse;
+
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if (vgContext)
+ {
+ switch (aKey)
+ {
+ case VG_IMAGE_FORMAT_QUERY:
+ if (TCheck::ImageFormatByteDepth(static_cast<VGImageFormat>(aSetting)) > 0)
+ paramsValid = ETrue;
+ break;
+ case VG_PATH_DATATYPE_QUERY:
+ switch (aSetting)
+ {
+ case VG_PATH_DATATYPE_S_8:
+ case VG_PATH_DATATYPE_S_16:
+ case VG_PATH_DATATYPE_S_32:
+ case VG_PATH_DATATYPE_F:
+ paramsValid = ETrue;
+ }
+ break;
+ }
+ if (paramsValid)
+ {
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgHardwareQuery);
+ vgApiData.AppendParam(aKey);
+ vgApiData.AppendParam(aSetting);
+ VGPANIC_ASSERT_DEBUG(vgApiData.Data().Header().iOpType == RemoteFunctionCallData::EOpRequestWithReply, EVgPanicNotReplyOpcode);
+ vgContext->ExecuteVgCommand(vgApiData);
+ return static_cast<VGHardwareQueryResult>(vgApiData.ReturnValue());
+ }
+ vgContext->SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);
+ }
+ return VG_HARDWARE_UNACCELERATED;
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if object is not a valid handle, or is not shared with the current context
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if paramType is not a valid value from the appropriate enumeration
+ – if values is NULL in vgGetParameterfv or vgGetParameteriv
+ – if values is not properly aligned in vgGetParameterfv or vgGetParameteriv
+ – if count is less than or equal to 0 in vgGetParameterfv or vgGetParameteriv
+ – if count is greater than the value returned by vgGetParameterVectorSize for
+ the given parameter in vgGetParameterfv or vgGetParameteriv
+ */
+void TGuestOpenVg::vgGetParameterfv(VGHandle aObject, VGint aParamType, VGint aCount, VGfloat * aValues)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgHandleBase* handleInfo;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGAnyHandle(aObject, &handleInfo) && TCheck::Chk32bitPtr(*vgContext, aValues) )
+ {
+ handleInfo->GetParameterfv(*vgContext, aParamType, aCount, aValues);
+ }
+ }
+ }
+
+
+void TGuestOpenVg::vgGetParameteriv(VGHandle aObject, VGint aParamType, VGint aCount, VGint * aValues)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgHandleBase* handleInfo;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGAnyHandle(aObject, &handleInfo) && TCheck::Chk32bitPtr(*vgContext, aValues) )
+ {
+ handleInfo->GetParameteriv(*vgContext, aParamType, aCount, aValues);
+ }
+ }
+ }
+
+
+/* Renderer and Extension Information */
+
+/* Getxv supports vgGetfv & vgGetiv APIs.
+
+ ERRORS
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if paramType is not a valid value from the VGParamType enumeration
+ – if values is NULL in vgGetfv or vgGetiv
+ – if values is not properly aligned in vgGetfv or vgGetiv
+ – if count is less than or equal to 0 in vgGetfv or vgGetiv
+ – if count is greater than the value returned by vgGetVectorSize for the
+ given parameter in vgGetfv or vgGetiv
+ */
+// **** Desirable: can probably do common VGParamType checking for Getx & Getxv, Setx, & Setxv.
+void TGuestOpenVg::vgGetfv(VGParamType aType, VGint aCount, const VGfloat * aValues)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if (vgContext && TCheck::Chk32bitPtr(*vgContext, aValues))
+ {
+ // **** Desirable: check all parameters
+ if ( (aCount <= 0) || (aCount > HostGetVectorSize(*vgContext, aType)) )
+ {
+ vgContext->SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);
+ }
+ else
+ {
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgGetfv);
+ vgApiData.AppendParam(aType);
+ vgApiData.AppendParam(aCount);
+ vgApiData.AppendVector(aValues, aCount, RemoteFunctionCallData::EOut);
+ vgContext->ExecuteVgCommand(vgApiData);
+ }
+ }
+ }
+
+
+void TGuestOpenVg::vgGetiv(VGParamType aType, VGint aCount, const VGint * aValues)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext && TCheck::Chk32bitPtr(*vgContext, aValues) )
+ {
+ // **** Desirable: check all parameters
+ if ( (aCount <= 0) || (aCount > HostGetVectorSize(*vgContext, aType)) )
+ {
+ vgContext->SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);
+ }
+ else
+ {
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgGetiv);
+ vgApiData.AppendParam(aType);
+ vgApiData.AppendParam(aCount);
+ vgApiData.AppendVector(aValues, aCount, RemoteFunctionCallData::EOut);
+ vgContext->ExecuteVgCommand(vgApiData);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if m is NULL
+ – if m is not properly aligned
+ */
+void TGuestOpenVg::vgGetMatrix(VGfloat* aM)
+ {
+ // check mat pointer is 32-bit aligned
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext && TCheck::Chk32bitPtr(*vgContext, aM) )
+ {
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgGetMatrix);
+ vgApiData.AppendVector(aM, KTransformMatrixSize, RemoteFunctionCallData::EOut);
+ vgContext->ExecuteVgCommand(vgApiData);
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if image is not a valid image handle, or is not shared with the current context
+ VG_IMAGE_IN_USE_ERROR
+ – if image is currently a rendering target
+ VG_UNSUPPORTED_IMAGE_FORMAT_ERROR
+ – if dataFormat is not a valid value from the VGImageFormat enumeration
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if width or height is less than or equal to 0
+ – if data is NULL
+ – if data is not properly aligned
+ */
+void TGuestOpenVg::vgGetImageSubData(VGImage aImage, void* aData, VGint aDataStride, VGImageFormat aDataFormat,
+ VGint aX, VGint aY, VGint aWidth, VGint aHeight)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgImageInfo* imageInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGImage(aImage, &imageInfo) && TCheck::ChkImageAlignment(*vgContext, aDataFormat, aData) &&
+ TCheck::ChkPositiveImageSize(*vgContext, aWidth, aHeight) )
+ {
+ imageInfo->GetImageSubData(*vgContext, aData, aDataStride, aDataFormat, aX, aY, aWidth, aHeight);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_UNSUPPORTED_IMAGE_FORMAT_ERROR
+ – if dataFormat is not a valid value from the VGImageFormat enumeration
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if width or height is less than or equal to 0
+ – if data is NULL
+ – if data is not properly aligned
+ */
+void TGuestOpenVg::HostVgReadPixels(MVgContext& aVgContext, void* aPixmap, size_t aPixmapSize, VGint aHostDataStride,
+ VGImageFormat aDataFormat, VGint aSx, VGint aSy, VGint aWidth, VGint aHeight)
+ {
+ VGPANIC_ASSERT(aPixmap != NULL, EVgPanicNullPixmapPointer);
+ VGPANIC_ASSERT(aPixmapSize >= (aHostDataStride * aHeight), EVgPanicPixmapSizeError);
+ RemoteFunctionCallData rfcdata; OpenVgRFC vgApiData(rfcdata);
+ vgApiData.Init(OpenVgRFC::EvgReadPixels);
+ vgApiData.AppendVector(aPixmap, aPixmapSize, RemoteFunctionCallData::EOut);
+ vgApiData.AppendParam(aHostDataStride);
+ vgApiData.AppendParam(aDataFormat);
+ vgApiData.AppendParam(aSx);
+ vgApiData.AppendParam(aSy);
+ vgApiData.AppendParam(aWidth);
+ vgApiData.AppendParam(aHeight);
+ vgApiData.AppendParam((VGint)aPixmapSize);
+ aVgContext.ExecuteVgCommand(vgApiData);
+ }
+
+
+void TGuestOpenVg::vgReadPixels(void* aData, VGint aDataStride, VGImageFormat aDataFormat, VGint aSx, VGint aSy,
+ VGint aWidth, VGint aHeight)
+ {
+ // **** Desirable: check all parameters
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext && TCheck::ChkImageAlignment(*vgContext, aDataFormat, aData) && TCheck::ChkPositiveImageSize(*vgContext, aWidth, aHeight) )
+ { // width > 0 && height > 0
+ TInt bitsPerPixel = CVgImageInfo::BitsPerPixelForVgImageFormat(aDataFormat);
+ TUint32 lineLength = static_cast<TUint32>(aWidth) * static_cast<TUint32>(bitsPerPixel);
+ TUint32 tailBits = lineLength & 7;
+ lineLength = (lineLength + 7) / 8;
+ OPENVG_TRACE("vgReadPixels.1 bitsPerPixel=%d, lineLength=%d, tailBits=%d", bitsPerPixel, lineLength, tailBits);
+ // ToDo clip aWidth & aHeight to the surface width & height
+
+ if (bitsPerPixel <= 0)
+ {
+ vgContext->SetVgError(VG_UNSUPPORTED_IMAGE_FORMAT_ERROR);
+ }
+ else
+ {
+ if (lineLength == aDataStride)
+ { // use original params
+ OPENVG_TRACE("vgReadPixels.2a: lineLength == dataStride");
+ HostVgReadPixels(*vgContext, aData, aDataStride * aHeight, aDataStride, aDataFormat, aSx, aSy, aWidth, aHeight);
+ }
+ else if (0 == aDataStride)
+ { // unlikely unless aHeight = 1, but symmetric to fill function for vgWritePixels
+ OPENVG_TRACE("vgReadPixels.2b: 0 == dataStride");
+ HostVgReadPixels(*vgContext, aData, lineLength, aDataStride, aDataFormat, aSx, aSy, aWidth, aHeight);
+ }
+ else
+ { // datastride maybe negative or simply > lineLength
+ TInt pixmapSize = lineLength * aHeight;
+ TUint8* localBuffer = (TUint8*) CVghwUtils::Alloc(pixmapSize);
+ OPENVG_TRACE("vgReadPixels.2c: dataStride not 0 or lineLength, localBuffer=0x%x", localBuffer);
+
+ if (localBuffer != NULL)
+ { // read pixels into temporary buffer
+ HostVgReadPixels(*vgContext, localBuffer, pixmapSize, lineLength, aDataFormat, aSx, aSy, aWidth, aHeight);
+ // reformat into client memory
+ CVgImageInfo::PixmapBlit(static_cast<TUint8*>(aData), localBuffer, aDataStride, lineLength, aHeight, lineLength, tailBits);
+ CVghwUtils::Free(localBuffer);
+ }
+ else
+ { // alloc failed, so do VG operation row by row
+ TUint8* dest = static_cast<TUint8*>(aData);
+ for (VGint row = 0; row < aHeight; ++row)
+ {
+ HostVgReadPixels(*vgContext, dest, lineLength, lineLength, aDataFormat, aSx + row, aSy, aWidth, 1);
+ dest += aDataStride;
+ }
+ }
+ }
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if path is not a valid path handle, or is not shared with the current context
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if minX, minY, width, or height is NULL
+ – if minX, minY, width, or height is not properly aligned
+ VG_PATH_CAPABILITY_ERROR
+ – if VG_PATH_CAPABILITY_PATH_BOUNDS is not enabled for path
+ */
+void TGuestOpenVg::vgPathBounds(VGPath aPath, VGfloat* aMinX, VGfloat* aMinY, VGfloat* aWidth, VGfloat* aHeight)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgPathInfo* pathInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGPath(aPath, &pathInfo, VG_PATH_CAPABILITY_PATH_BOUNDS) )
+ {
+ pathInfo->PathBounds(*vgContext, aMinX, aMinY, aWidth, aHeight);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if path is not a valid path handle, or is not shared with the current context
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if minX, minY, width, or height is NULL
+ – if minX, minY, width, or height is not properly aligned
+ VG_PATH_CAPABILITY_ERROR
+ – if VG_PATH_CAPABILITY_PATH_TRANSFORMED_BOUNDS is not enabled
+ for path
+ */
+void TGuestOpenVg::vgPathTransformedBounds(VGPath aPath, VGfloat* aMinX, VGfloat* aMinY, VGfloat* aWidth, VGfloat* aHeight)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgPathInfo* pathInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGPath(aPath, &pathInfo, VG_PATH_CAPABILITY_PATH_TRANSFORMED_BOUNDS) )
+ {
+ pathInfo->PathTransformedBounds(*vgContext, aMinX, aMinY, aWidth, aHeight);
+ }
+ }
+ }
+
+
+////////////////////////////////////////////////////////////////////////////////////////////
+//Functions not returning value (possible to buffer)
+////////////////////////////////////////////////////////////////////////////////////////////
+/* Getters and Setters */
+
+/*
+ vgSeti and vgSetf
+
+ ERRORS
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if paramType is not a valid value from the VGParamType enumeration
+ – if paramType refers to a vector parameter in vgSetf or vgSeti
+ – if value is not a legal enumerated value for the given parameter in vgSetf or
+ vgSeti
+ */
+void TGuestOpenVg::vgSeti(VGParamType aType, VGint aValue)
+ {
+ // **** Desirable: check aType
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if (vgContext)
+ {
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgSeti, RemoteFunctionCallData::EOpRequest);
+ vgApiData.AppendParam(aType);
+ vgApiData.AppendParam(aValue);
+ vgContext->ExecuteVgCommand(vgApiData);
+ }
+ }
+
+
+void TGuestOpenVg::vgSetf(VGParamType aType, VGfloat aValue)
+ {
+ // **** Desirable: check aType
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if (vgContext)
+ {
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgSetf, RemoteFunctionCallData::EOpRequest);
+ vgApiData.AppendParam(aType);
+ vgApiData.AppendParam(aValue);
+ vgContext->ExecuteVgCommand(vgApiData);
+ }
+ }
+
+
+/*
+ vgSetiv and vgSetfv
+
+ ERRORS
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if paramType is not a valid value from the VGParamType enumeration
+ – if paramType refers to a scalar parameter in vgSetfv or vgSetiv and count is
+ not equal to 1
+ – if values[i] is not a legal enumerated value for the given parameter in vgSetfv
+ or vgSetiv for 0 <= i < count
+ – if values is NULL in vgSetfv or vgSetiv and count is greater than 0
+ – if values is not properly aligned in vgSetfv or vgSetiv
+ – if count is less than 0 in vgSetfv or vgSetiv
+ – if count is not a valid value for the given parameter
+ */
+void TGuestOpenVg::vgSetfv(VGParamType aType, VGint aCount, const VGfloat * aValues)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if (vgContext && TCheck::Chk32bitPtr(*vgContext, aValues))
+ {
+ // **** Desirable: check all params
+ // we should check count for not being too large for serialization, but
+ // there is no limit in spec for VG_SCISSOR_RECTS and VG_STROKE_DASH_PATTERN
+ if ( (aCount < 0) || (aCount > 100000) )
+ {
+ vgContext->SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);
+ }
+ else
+ {
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgSetfv, RemoteFunctionCallData::EOpRequest);
+ vgApiData.AppendParam(aType);
+ vgApiData.AppendParam(aCount);
+ vgApiData.AppendVector(aValues, aCount);
+ vgContext->ExecuteVgCommand(vgApiData);
+ }
+ }
+ }
+
+
+void TGuestOpenVg::vgSetiv(VGParamType aType, VGint aCount, const VGint * aValues)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext && TCheck::Chk32bitPtr(*vgContext, aValues) )
+ {
+ // **** Desirable: check all params
+ // we should check count for not being too large for serialization, but
+ // there is no limit in spec for VG_SCISSOR_RECTS and VG_STROKE_DASH_PATTERN
+ if ( (aCount < 0) || (aCount > 100000) )
+ {
+ vgContext->SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);
+ }
+ else
+ {
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgSetiv, RemoteFunctionCallData::EOpRequest);
+ vgApiData.AppendParam(aType);
+ vgApiData.AppendParam(aCount);
+ vgApiData.AppendVector(aValues, aCount);
+ vgContext->ExecuteVgCommand(vgApiData);
+ }
+ }
+ }
+
+
+/*
+ For vgSetParameterf and vgSetParameteri.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if object is not a valid handle, or is not shared with the current context
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if paramType is not a valid value from the appropriate enumeration
+ – if paramType refers to a vector parameter in vgSetParameterf or
+ vgSetParameteri
+ – if value is not a legal enumerated value for the given parameter in
+ vgSetParameterf or vgSetParameteri
+ */
+
+void TGuestOpenVg::vgSetParameteri(VGHandle aObject, VGint aParamType, VGint aValue)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgHandleBase* handleInfo;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGAnyHandle(aObject, &handleInfo) )
+ {
+ handleInfo->SetParameteri(*vgContext, aParamType, aValue);
+ }
+ }
+ }
+
+
+void TGuestOpenVg::vgSetParameterf(VGHandle aObject, VGint aParamType, VGfloat aValue)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgHandleBase* handleInfo;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGAnyHandle(aObject, &handleInfo) )
+ {
+ handleInfo->SetParameterf(*vgContext, aParamType, aValue);
+ }
+ }
+ }
+
+
+/*
+ For vgSetParameterfv and vgSetParameteriv.
+
+ The vgSetParameter functions set the value of a parameter on a given VGHandlebased
+ object.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if object is not a valid handle, or is not shared with the current context
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if paramType is not a valid value from the appropriate enumeration
+ – if paramType refers to a scalar parameter in vgSetParameterfv or
+ vgSetParameteriv and count is not equal to 1
+ – if values[i] is not a legal enumerated value for the given parameter
+ in vgSetParameterfv or vgSetParameteriv for 0 <= i < count
+ – if values is NULL in vgSetParameterfv or vgSetParameteriv and count is
+ greater than 0
+ – if values is not properly aligned in vgSetParameterfv or vgSetParameteriv
+ – if count is less than 0 in vgSetParameterfv or vgSetParameteriv
+ – if count is not a valid value for the given parameter
+ */
+void TGuestOpenVg::vgSetParameterfv(VGHandle aObject, VGint aParamType, VGint aCount, const VGfloat * aValues)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgHandleBase* handleInfo;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ // ToDo review overlapping checks between TCheck::ParamCountAndValuesPtr to SetParameterfv
+ if ( vgLock.CheckVGAnyHandle(aObject, &handleInfo) && TCheck::ChkParamCountAndValuesPtr(*vgContext, aCount, aValues) )
+ {
+ handleInfo->SetParameterfv(*vgContext, aParamType, aCount, aValues);
+ }
+ }
+ }
+
+
+void TGuestOpenVg::vgSetParameteriv(VGHandle aObject, VGint aParamType, VGint aCount, const VGint * aValues)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgHandleBase* handleInfo;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGAnyHandle(aObject, &handleInfo) && TCheck::ChkParamCountAndValuesPtr(*vgContext, aCount, aValues) )
+ {
+ handleInfo->SetParameteriv(*vgContext, aParamType, aCount, aValues);
+ }
+ }
+ }
+
+
+/* Matrix Manipulation */
+/*
+ No errors if Context is valid.
+ */
+void TGuestOpenVg::vgLoadIdentity()
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if (vgContext)
+ {
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgLoadIdentity, RemoteFunctionCallData::EOpRequest);
+ vgContext->ExecuteVgCommand(vgApiData);
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if m is NULL
+ – if m is not properly aligned
+ */
+void TGuestOpenVg::vgLoadMatrix(const VGfloat* aM)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext && TCheck::Chk32bitPtr(*vgContext, aM) )
+ {
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgLoadMatrix, RemoteFunctionCallData::EOpRequest);
+ vgApiData.AppendVector(aM, KTransformMatrixSize);
+ vgContext->ExecuteVgCommand(vgApiData);
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if m is NULL
+ – if m is not properly aligned
+ */
+void TGuestOpenVg::vgMultMatrix(const VGfloat* aM)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext && TCheck::Chk32bitPtr(*vgContext, aM) )
+ {
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgMultMatrix, RemoteFunctionCallData::EOpRequest);
+ vgApiData.AppendVector(aM, KTransformMatrixSize);
+ vgContext->ExecuteVgCommand(vgApiData);
+ }
+ }
+
+
+/*
+ No errors if Context is valid.
+ */
+void TGuestOpenVg::vgTranslate(VGfloat aTx, VGfloat aTy)
+ {
+ // **** Desirable: check all parameters
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if (vgContext)
+ {
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgTranslate, RemoteFunctionCallData::EOpRequest);
+ vgApiData.AppendParam(aTx);
+ vgApiData.AppendParam(aTy);
+ vgContext->ExecuteVgCommand(vgApiData);
+ }
+ }
+
+
+/*
+ No errors if Context is valid.
+ */
+// **** Desirable: Coalesce with vgTranslate
+void TGuestOpenVg::vgScale(VGfloat aSx, VGfloat aSy)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if (vgContext)
+ {
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgScale, RemoteFunctionCallData::EOpRequest);
+ vgApiData.AppendParam(aSx);
+ vgApiData.AppendParam(aSy);
+ vgContext->ExecuteVgCommand(vgApiData);
+ }
+ }
+
+
+/*
+ No errors if Context is valid.
+ */
+// **** Desirable: Coalesce with vgTranslate
+void TGuestOpenVg::vgShear(VGfloat aShx, VGfloat aShy)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if (vgContext)
+ {
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgShear, RemoteFunctionCallData::EOpRequest);
+ vgApiData.AppendParam(aShx);
+ vgApiData.AppendParam(aShy);
+ vgContext->ExecuteVgCommand(vgApiData);
+ }
+ }
+
+
+/*
+ No errors if Context is valid.
+ */
+void TGuestOpenVg::vgRotate(VGfloat aAngle)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if (vgContext)
+ {
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgRotate, RemoteFunctionCallData::EOpRequest);
+ vgApiData.AppendParam(aAngle);
+ vgContext->ExecuteVgCommand(vgApiData);
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if operation is not VG_CLEAR_MASK or VG_FILL_MASK, and mask is not a
+ valid mask layer or image handle, or is not shared with the current context
+ VG_IMAGE_IN_USE_ERROR
+ – if mask is a VGImage that is currently a rendering target
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if operation is not a valid value from the VGMaskOperation
+ enumeration
+ – if width or height is less than or equal to 0
+ – if mask is a VGMaskLayer and is not compatible with the current surface
+ mask
+ */
+void TGuestOpenVg::vgMask(VGHandle aMask, VGMaskOperation aOperation, VGint aX, VGint aY, VGint aWidth, VGint aHeight)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgImageBase* maskInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ // **** Desirable: mask/surface compatibility check
+ if ( vgLock.CheckVGMaskOperationAndHandle(aOperation, aMask, &maskInfo) && TCheck::ChkPositiveImageSize(*vgContext, aWidth, aHeight) )
+ {
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgMask, RemoteFunctionCallData::EOpRequest);
+ vgApiData.AppendParam( (maskInfo == NULL) ? VG_INVALID_HANDLE : maskInfo->HostHandle() );
+ vgApiData.AppendParam(aOperation);
+ vgApiData.AppendParam(aX);
+ vgApiData.AppendParam(aY);
+ vgApiData.AppendParam(aWidth);
+ vgApiData.AppendParam(aHeight);
+ TUint64 sgId(0L);
+ if ( maskInfo && (maskInfo->HandleType() == EVgHandleForImage) )
+ {
+ CVgImageInfo* imageInfo = (CVgImageInfo*)maskInfo;
+ if (imageInfo->IsEglSibling())
+ {
+ sgId = imageInfo->SgImageId();
+ }
+ }
+ vgApiData.AppendTUint64(sgId);
+ vgContext->ExecuteVgCommand(vgApiData);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if path is not a valid path handle
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if paintModes is not a valid bitwise OR of values from the VGPaintMode
+ enumeration
+ – if operation is not a valid value from the VGMaskOperation enumeration
+ */
+void TGuestOpenVg::vgRenderToMask(VGPath aPath, VGbitfield aPaintModes, VGMaskOperation aOperation)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgPathInfo* pathInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGPath(aPath, &pathInfo) )
+ {
+ pathInfo->RenderToMask(*vgContext, aPaintModes, aOperation);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if maskLayer is not a valid mask handle
+ */
+void TGuestOpenVg::vgDestroyMaskLayer(VGMaskLayer aMaskLayer)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if (vgContext)
+ {
+ CVgMaskLayerInfo* maskLayerInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGMaskLayer(aMaskLayer, &maskLayerInfo) )
+ {
+ maskLayerInfo->Destroy(*vgContext);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if maskLayer is not a valid mask layer handle, or is not shared with the
+ current context
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if value is less than 0 or greater than 1
+ – if width or height is less than or equal to 0
+ – if x or y is less than 0
+ – if x + width is greater than the width of the mask
+ – if y + height is greater than the height of the mask
+ */
+void TGuestOpenVg::vgFillMaskLayer(VGMaskLayer aMaskLayer, VGint aX, VGint aY, VGint aWidth, VGint aHeight, VGfloat aValue)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgMaskLayerInfo* maskLayerInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGMaskLayer(aMaskLayer, &maskLayerInfo) && TCheck::ChkAreaIsWithinImage(*vgContext, maskLayerInfo, aX, aY, aWidth, aHeight) )
+ {
+ maskLayerInfo->FillMaskLayer(*vgContext, aX, aY, aWidth, aHeight, aValue);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if maskLayer is not a valid mask layer handle
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if width or height are less than or equal to 0
+ – if maskLayer is not compatible with the current surface mask
+ */
+void TGuestOpenVg::vgCopyMask(VGMaskLayer aMaskLayer, VGint aSx, VGint aSy, VGint aDx, VGint aDy, VGint aWidth, VGint aHeight)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgMaskLayerInfo* maskLayerInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGMaskLayer(aMaskLayer, &maskLayerInfo) && TCheck::ChkPositiveImageSize(*vgContext, aWidth, aHeight) )
+ {
+ maskLayerInfo->CopyMask(*vgContext, aSx, aSy, aDx, aDy, aWidth, aHeight);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if width or height is less than or equal to 0
+ */
+void TGuestOpenVg::vgClear(VGint aX, VGint aY, VGint aWidth, VGint aHeight)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext && TCheck::ChkPositiveImageSize(*vgContext, aWidth, aHeight) )
+ { // width > 0 && height > 0
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgClear, RemoteFunctionCallData::EOpRequest);
+ vgApiData.AppendParam(aX);
+ vgApiData.AppendParam(aY);
+ vgApiData.AppendParam(aWidth);
+ vgApiData.AppendParam(aHeight);
+ vgContext->ExecuteVgCommand(vgApiData);
+ }
+ }
+
+
+/* Paths */
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if path is not a valid path handle, or is not shared with the current context
+ */
+void TGuestOpenVg::vgClearPath(VGPath aPath, VGbitfield aCapabilities)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgPathInfo* pathInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGPath(aPath, &pathInfo) )
+ {
+ pathInfo->ClearPath(*vgContext, aCapabilities);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if path is not a valid path handle, or is not shared with the current context
+ */
+void TGuestOpenVg::vgDestroyPath(VGPath aPath)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgPathInfo* pathInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGPath(aPath, &pathInfo) )
+ {
+ pathInfo->Destroy(*vgContext);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if path is not a valid path handle, or is not shared with the current context
+ */
+void TGuestOpenVg::vgRemovePathCapabilities(VGPath aPath, VGbitfield aCapabilities)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgPathInfo* pathInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGPath(aPath, &pathInfo) )
+ {
+ pathInfo->RemovePathCapabilities(*vgContext, aCapabilities);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if either dstPath or srcPath is not a valid path handle, or is not shared
+ with the current context
+ VG_PATH_CAPABILITY_ERROR
+ – if VG_PATH_CAPABILITY_APPEND_FROM is not enabled for srcPath
+ – if VG_PATH_CAPABILITY_APPEND_TO is not enabled for dstPath
+ */
+void TGuestOpenVg::vgAppendPath(VGPath aDstPath, VGPath aSrcPath)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgPathInfo* dstPathInfo = NULL;
+ CVgPathInfo* srcPathInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGPath(aDstPath, &dstPathInfo, VG_PATH_CAPABILITY_APPEND_TO) &&
+ vgLock.CheckVGPath(aSrcPath, &srcPathInfo, VG_PATH_CAPABILITY_APPEND_FROM) )
+ {
+ dstPathInfo->AppendPath(*vgContext, *srcPathInfo);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if dstPath is not a valid path handle, or is not shared with the current
+ context
+ VG_PATH_CAPABILITY_ERROR
+ – if VG_PATH_CAPABILITY_APPEND_TO is not enabled for dstPath
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if pathSegments or pathData is NULL
+ – if pathData is not properly aligned
+ – if numSegments is less than or equal to 0
+ – if pathSegments contains an illegal command
+ */
+void TGuestOpenVg::vgAppendPathData(VGPath aDstPath, VGint aNumSegments, const VGubyte* aPathSegments, const void* aPathData)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgPathInfo* dstPathInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGPath(aDstPath, &dstPathInfo, VG_PATH_CAPABILITY_APPEND_TO) )
+ {
+ dstPathInfo->AppendPathData(*vgContext, aNumSegments, aPathSegments, aPathData);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if dstPath is not a valid path handle, or is not shared with the current
+ context
+ VG_PATH_CAPABILITY_ERROR
+ – if VG_PATH_CAPABILITY_MODIFY is not enabled for dstPath
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if pathData is NULL
+ – if pathData is not properly aligned
+ – if startIndex is less than 0
+ – if numSegments is less than or equal to 0
+ – if startIndex + numSegments is greater than the number of segments in the path
+ */
+void TGuestOpenVg::vgModifyPathCoords(VGPath aDstPath, VGint aStartIndex, VGint aNumSegments, const void* aPathData)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgPathInfo* dstPathInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGPath(aDstPath, &dstPathInfo, VG_PATH_CAPABILITY_MODIFY) )
+ {
+ if ( (aStartIndex < 0) || (aNumSegments <= 0) )
+ {
+ vgContext->SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);
+ }
+ else
+ {
+ dstPathInfo->ModifyPathCoords(*vgContext, aStartIndex, aNumSegments, aPathData);
+ }
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if either dstPath or srcPath is not a valid path handle, or is not shared with
+ the current context
+ VG_PATH_CAPABILITY_ERROR
+ – if VG_PATH_CAPABILITY_TRANSFORM_FROM is not enabled for srcPath
+ – if VG_PATH_CAPABILITY_TRANSFORM_TO is not enabled for dstPath
+ */
+void TGuestOpenVg::vgTransformPath(VGPath aDstPath, VGPath aSrcPath)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgPathInfo* dstPathInfo = NULL;
+ CVgPathInfo* srcPathInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGPath(aDstPath, &dstPathInfo, VG_PATH_CAPABILITY_TRANSFORM_TO) &&
+ vgLock.CheckVGPath(aSrcPath, &srcPathInfo, VG_PATH_CAPABILITY_TRANSFORM_FROM) )
+ {
+ dstPathInfo->TransformPath(*vgContext, *srcPathInfo);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if path is not a valid path handle, or is not shared with the current context
+ VG_PATH_CAPABILITY_ERROR
+ – If x and y are both non-NULL, and the VG_PATH_CAPABILITY_POINT_ALONG_PATH is
+ not enabled for path
+ – If tangentX and tangentY are both non-NULL, and the
+ VG_PATH_CAPABILITY_TANGENT_ALONG_PATH capability is not enabled for path
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if startSegment is less than 0 or greater than the index of the final path
+ segment
+ – if numSegments is less than or equal to 0
+ – if (startSegment + numSegments – 1) is less than 0 or greater than the index
+ of the final path segment
+ – if x, y, tangentX or tangentY is not properly aligned
+ */
+void TGuestOpenVg::vgPointAlongPath(VGPath aPath, VGint aStartSegment, VGint aNumSegments, VGfloat aDistance,
+ VGfloat* aX, VGfloat* aY, VGfloat* aTangentX, VGfloat* aTangentY)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgPathInfo* pathInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ TBool getPoint = (aX && aY);
+ TBool getTangent = (aTangentX && aTangentY);
+ VGbitfield reqdCapabilities = 0;
+ if (getPoint)
+ {
+ reqdCapabilities |= VG_PATH_CAPABILITY_POINT_ALONG_PATH;
+ }
+ if (getTangent)
+ {
+ reqdCapabilities |= VG_PATH_CAPABILITY_TANGENT_ALONG_PATH;
+ }
+ if ( vgLock.CheckVGPath(aPath, &pathInfo, reqdCapabilities) )
+ {
+ if ( (aStartSegment < 0) || (aNumSegments <= 0) )
+ {
+ vgContext->SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);
+ }
+ else
+ {
+ pathInfo->PointAlongPath(*vgContext, aStartSegment, aNumSegments, aDistance, aX, aY, aTangentX, aTangentY);
+ }
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if path is not a valid path handle, or is not shared with the current context
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if paintModes is not a valid bitwise OR of values from the VGPaintMode
+ enumeration
+ */
+void TGuestOpenVg::vgDrawPath(VGPath aPath, VGbitfield aPaintModes)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgPathInfo* pathInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGPath(aPath, &pathInfo) )
+ {
+ pathInfo->DrawPath(*vgContext, aPaintModes);
+ }
+ }
+ }
+
+
+/* Paint */
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if paint is not a valid paint handle, or is not shared with the current context
+ */
+void TGuestOpenVg::vgDestroyPaint(VGPaint aPaint)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgPaintInfo* paintInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGPaint(aPaint, &paintInfo) )
+ {
+ paintInfo->Destroy(*vgContext);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if paint is neither a valid paint handle nor equal to VG_INVALID_HANDLE,
+ or is not shared with the current context
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if paintModes is not a valid bitwise OR of values from the VGPaintMode
+ enumeration
+ */
+void TGuestOpenVg::vgSetPaint(VGPaint aPaint, VGbitfield aPaintModes)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgPaintInfo* paintInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckOptionalVGPaint(aPaint, &paintInfo) && TCheck::ChkVGPaintModesCombination(*vgContext, aPaintModes))
+ {
+ if (paintInfo)
+ {
+ paintInfo->SetPaint(*vgContext, aPaintModes);
+ }
+ else
+ {
+ CVgPaintInfo::ResetPaint(*vgContext);
+ }
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if paint is not a valid paint handle, or is not shared with the current context
+ */
+void TGuestOpenVg::vgSetColor(VGPaint aPaint, VGuint aRgba)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgPaintInfo* paintInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGPaint(aPaint, &paintInfo) )
+ {
+ paintInfo->SetColor(*vgContext, aRgba);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if paint is not a valid paint handle, or is not shared with the current context
+ – if pattern is neither a valid image handle nor equal to VG_INVALID_HANDLE, or is
+ not shared with the current context
+ VG_IMAGE_IN_USE_ERROR
+ – if pattern is currently a rendering target
+ */
+void TGuestOpenVg::vgPaintPattern(VGPaint aPaint, VGImage aPattern)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgPaintInfo* paintInfo = NULL;
+ CVgImageInfo* imageInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGPaint(aPaint, &paintInfo) && vgLock.CheckOptionalVGImage(aPattern, &imageInfo) )
+ {
+ paintInfo->PaintPattern(*vgContext, imageInfo);
+ }
+ }
+ }
+
+
+/* Images */
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if image is not a valid image handle, or is not shared with the current
+ context
+ */
+void TGuestOpenVg::vgDestroyImage(VGImage aImage)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgImageInfo* imageInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGImage(aImage, &imageInfo) )
+ {
+ imageInfo->Destroy(*vgContext);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if image is not a valid image handle, or is not shared with the current
+ context
+ VG_IMAGE_IN_USE_ERROR
+ – if image is currently a rendering target
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if width or height is less than or equal to 0
+ */
+void TGuestOpenVg::vgClearImage(VGImage aImage, VGint aX, VGint aY, VGint aWidth, VGint aHeight)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgImageInfo* imageInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGImage(aImage, &imageInfo) && TCheck::ChkPositiveImageSize(*vgContext, aWidth, aHeight) )
+ {
+ imageInfo->ClearImage(*vgContext, aX, aY, aWidth, aHeight);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if image is not a valid image handle, or is not shared with the current
+ context
+ VG_IMAGE_IN_USE_ERROR
+ – if image is currently a rendering target
+ VG_UNSUPPORTED_IMAGE_FORMAT_ERROR
+ – if dataFormat is not a valid value from the VGImageFormat enumeration
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if width or height is less than or equal to 0
+ – if data is NULL
+ – if data is not properly aligned
+ */
+void TGuestOpenVg::vgImageSubData(VGImage aImage, const void* aData, VGint aDataStride, VGImageFormat aDataFormat,
+ VGint aX, VGint aY, VGint aWidth, VGint aHeight)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgImageInfo* imageInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGImage(aImage, &imageInfo) && TCheck::ChkImageAlignment(*vgContext, aDataFormat, aData) &&
+ TCheck::ChkPositiveImageSize(*vgContext, aWidth, aHeight) )
+ {
+ imageInfo->ImageSubData(*vgContext, aData, aDataStride, aDataFormat, aX, aY, aWidth, aHeight);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if either dst or src is not a valid image handle, or is not shared with the
+ current context
+ VG_IMAGE_IN_USE_ERROR
+ – if either dst or src is currently a rendering target
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if width or height is less than or equal to 0
+ */
+void TGuestOpenVg::vgCopyImage(VGImage aDst, VGint aDx, VGint aDy, VGImage aSrc, VGint aSx, VGint aSy,
+ VGint aWidth, VGint aHeight, VGboolean aDither)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgImageInfo* dstImageInfo = NULL;
+ CVgImageInfo* srcImageInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.Check2VGImages(aDst, &dstImageInfo, aSrc, &srcImageInfo) && TCheck::ChkPositiveImageSize(*vgContext, aWidth, aHeight) )
+ {
+ dstImageInfo->CopyImage(*vgContext, aDx, aDy, *srcImageInfo, aSx, aSy, aWidth, aHeight, aDither);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if image is not a valid image handle, or is not shared with the current
+ context
+ VG_IMAGE_IN_USE_ERROR
+ – if image is currently a rendering target
+ */
+void TGuestOpenVg::vgDrawImage(VGImage aImage)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgImageInfo* imageInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGImage(aImage, &imageInfo) )
+ {
+ imageInfo->DrawImage(*vgContext);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if src is not a valid image handle, or is not shared with the current context
+ VG_IMAGE_IN_USE_ERROR
+ – if src is currently a rendering target
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if width or height is less than or equal to 0
+ */
+void TGuestOpenVg::vgSetPixels(VGint aDx, VGint aDy, VGImage aSrc, VGint aSx, VGint aSy, VGint aWidth, VGint aHeight)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgImageInfo* imageInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGImage(aSrc, &imageInfo) && TCheck::ChkPositiveImageSize(*vgContext, aWidth, aHeight) )
+ {
+ imageInfo->SetPixels(*vgContext, aDx, aDy, aSx, aSy, aWidth, aHeight);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_UNSUPPORTED_IMAGE_FORMAT_ERROR
+ – if dataFormat is not a valid value from the VGImageFormat enumeration
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if width or height is less than or equal to 0
+ – if data is NULL
+ – if data is not properly aligned
+ */
+void TGuestOpenVg::HostVgWritePixels(MVgContext& aVgContext, const void* aPixmap, size_t aPixmapSize, VGint aHostDataStride,
+ VGImageFormat aDataFormat, VGint aDx, VGint aDy, VGint aWidth, VGint aHeight)
+ {
+ VGPANIC_ASSERT(aPixmap != NULL, EVgPanicNullPixmapPointer);
+ VGPANIC_ASSERT(aPixmapSize >= (aHostDataStride * aHeight), EVgPanicPixmapSizeError);
+ RemoteFunctionCallData rfcdata; OpenVgRFC vgApiData(rfcdata);
+ vgApiData.Init(OpenVgRFC::EvgWritePixels, RemoteFunctionCallData::EOpRequest);
+ vgApiData.AppendVector(aPixmap, aPixmapSize);
+ vgApiData.AppendParam(aHostDataStride);
+ vgApiData.AppendParam(aDataFormat);
+ vgApiData.AppendParam(aDx);
+ vgApiData.AppendParam(aDy);
+ vgApiData.AppendParam(aWidth);
+ vgApiData.AppendParam(aHeight);
+ aVgContext.ExecuteVgCommand(vgApiData);
+ }
+
+
+void TGuestOpenVg::vgWritePixels(const void* aData, VGint aDataStride, VGImageFormat aDataFormat, VGint aDx, VGint aDy,
+ VGint aWidth, VGint aHeight)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext && TCheck::ChkImageAlignment(*vgContext, aDataFormat, aData) &&
+ TCheck::ChkPositiveImageSize(*vgContext, aWidth, aHeight) )
+ {
+ TInt bitsPerPixel = CVgImageInfo::BitsPerPixelForVgImageFormat(aDataFormat);
+ size_t lineLength = ((static_cast<size_t>(aWidth) * static_cast<size_t>(bitsPerPixel)) + 7) / 8;
+ OPENVG_TRACE("vgWritePixels.1 bitsPerPixel=%d, lineLength=%d", bitsPerPixel, lineLength);
+ // ToDo clip aWidth & aHeight to the surface width & height
+
+ if (bitsPerPixel <= 0)
+ {
+ vgContext->SetVgError(VG_UNSUPPORTED_IMAGE_FORMAT_ERROR);
+ }
+ else
+ {
+ if (lineLength == aDataStride)
+ { // use original parameters
+ OPENVG_TRACE("vgWritePixels.2a: lineLength == dataStride");
+ HostVgWritePixels(*vgContext, aData, aDataStride * aHeight, aDataStride, aDataFormat, aDx, aDy, aWidth, aHeight);
+ }
+ else if (0 == aDataStride)
+ { // Fill operation: pixmap size for the memcpy between Symbian & Host EGL is the lineLength
+ OPENVG_TRACE("vgWritePixels.2b: 0 == dataStride");
+ HostVgWritePixels(*vgContext, aData, lineLength, aDataStride, aDataFormat, aDx, aDy, aWidth, aHeight);
+ }
+ else
+ { // datastride maybe negative or simply > lineLength
+ size_t pixmapSize = lineLength * aHeight;
+ TUint8* localBuffer = (TUint8*) CVghwUtils::Alloc(pixmapSize);
+ OPENVG_TRACE("vgWritePixels.2c: dataStride not 0 or lineLength, localBuffer=0x%x", localBuffer);
+ if (localBuffer != NULL)
+ { // reformat data into temporary buffer
+ CVgImageInfo::PixmapBlit(localBuffer, static_cast<const TUint8*>(aData), lineLength, aDataStride, aHeight, lineLength);
+ HostVgWritePixels(*vgContext, localBuffer, pixmapSize, lineLength, aDataFormat, aDx, aDy, aWidth, aHeight);
+ CVghwUtils::Free(localBuffer);
+ }
+ else
+ { // alloc failed, so do VG operation row by row
+ const TUint8* source = static_cast<const TUint8*>(aData);
+ for (VGint row = 0; row < aHeight; ++row)
+ {
+ HostVgWritePixels(*vgContext, source, lineLength, lineLength, aDataFormat, aDx + row, aDy, aWidth, 1);
+ source += aDataStride;
+ }
+ }
+ }
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if dst is not a valid image handle, or is not shared with the current context
+ VG_IMAGE_IN_USE_ERROR
+ – if dst is currently a rendering target
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if width or height is less than or equal to 0
+ */
+void TGuestOpenVg::vgGetPixels(VGImage aDst, VGint aDx, VGint aDy, VGint aSx, VGint aSy, VGint aWidth, VGint aHeight)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgImageInfo* imageInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGImage(aDst, &imageInfo) && TCheck::ChkPositiveImageSize(*vgContext, aWidth, aHeight) )
+ {
+ imageInfo->GetPixels(*vgContext, aDx, aDy, aSx, aSy, aWidth, aHeight);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if width or height is less than or equal to 0
+ */
+void TGuestOpenVg::vgCopyPixels(VGint aDx, VGint aDy, VGint aSx, VGint aSy, VGint aWidth, VGint aHeight)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext && TCheck::ChkPositiveImageSize(*vgContext, aWidth, aHeight) )
+ {
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgCopyPixels, RemoteFunctionCallData::EOpRequest);
+ vgApiData.AppendParam(aDx);
+ vgApiData.AppendParam(aDy);
+ vgApiData.AppendParam(aSx);
+ vgApiData.AppendParam(aSy);
+ vgApiData.AppendParam(aWidth);
+ vgApiData.AppendParam(aHeight);
+ vgContext->ExecuteVgCommand(vgApiData);
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if font is not a valid font handle, or is not shared with the current context
+ */
+void TGuestOpenVg::vgDestroyFont(VGFont aFont)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgFontInfo* fontInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGFont(aFont, &fontInfo) )
+ {
+ fontInfo->Destroy(*vgContext);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if font is not a valid font handle, or is not shared with the current context
+ – if path is not a valid path handle or VG_INVALID_HANDLE, or is not shared
+ with the current context
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if the pointer to glyphOrigin or escapement is NULL or is not properly
+ aligned
+ */
+void TGuestOpenVg::vgSetGlyphToPath(VGFont aFont, VGuint aGlyphIndex, VGPath aPath, VGboolean aIsHinted,
+ const VGfloat aGlyphOrigin [2], const VGfloat aEscapement[2])
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgFontInfo* fontInfo = NULL;
+ CVgPathInfo* pathInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGFont(aFont, &fontInfo) && vgLock.CheckOptionalVGPath(aPath, &pathInfo) &&
+ TCheck::Chk2x32bitPtr(*vgContext, aGlyphOrigin, aEscapement) )
+ {
+ fontInfo->SetGlyphToPath(*vgContext, aGlyphIndex, pathInfo, aIsHinted, aGlyphOrigin, aEscapement);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if font is not a valid font handle, or is not shared with the current context
+ – if image is not a valid image handle or VG_INVALID_HANDLE, or is not
+ shared with the current context
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if the pointer to glyphOrigin or escapement is NULL or is not properly
+ aligned
+ VG_IMAGE_IN_USE_ERROR
+ – if image is currently a rendering target
+ */
+void TGuestOpenVg::vgSetGlyphToImage(VGFont aFont, VGuint aGlyphIndex, VGImage aImage, const VGfloat aGlyphOrigin [2],
+ const VGfloat aEscapement[2])
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgFontInfo* fontInfo = NULL;
+ CVgImageInfo* imageInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGFont(aFont, &fontInfo) && TCheck::Chk2x32bitPtr(*vgContext, aGlyphOrigin, aEscapement) &&
+ vgLock.CheckOptionalVGImage(aImage, &imageInfo) )
+ {
+ fontInfo->SetGlyphToImage(*vgContext, aGlyphIndex, imageInfo, aGlyphOrigin, aEscapement);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if font is not a valid font handle, or is not shared with the current context
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if glyphIndex is not defined for the font
+ */
+void TGuestOpenVg::vgClearGlyph(VGFont aFont, VGuint aGlyphIndex)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgFontInfo* fontInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGFont(aFont, &fontInfo) )
+ {
+ fontInfo->ClearGlyph(*vgContext, aGlyphIndex);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if font is not a valid font handle, or is not shared with the current context
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if glyphIndex has not been defined for a given font object
+ – if paintModes is not a valid bitwise OR of values from the VGPaintMode
+ enumeration, or 0
+ */
+void TGuestOpenVg::vgDrawGlyph(VGFont aFont, VGuint aGlyphIndex, VGbitfield aPaintModes, VGboolean aAllowAutoHinting)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgFontInfo* fontInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGFont(aFont, &fontInfo) && TCheck::ChkVGPaintModesCombination(*vgContext, aPaintModes) )
+ {
+ fontInfo->DrawGlyph(*vgContext, aGlyphIndex, aPaintModes, aAllowAutoHinting);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if font is not a valid font handle, or is not shared with the current context
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if glyphCount is zero or a negative value
+ – if the pointer to the glyphIndices array is NULL or is not properly
+ aligned
+ – if a pointer to either of the adjustments_x or adjustments_y arrays are
+ non-NULL and are not properly aligned
+ – if any of the glyphIndices has not been defined in a given font object
+ – if paintModes is not a valid bitwise OR of values from the VGPaintMode
+ enumeration, or 0
+ */
+void TGuestOpenVg::vgDrawGlyphs(VGFont aFont, VGint aGlyphCount, const VGuint* aGlyphIndices,
+ const VGfloat* aAdjustmentsX, const VGfloat* aAdjustmentsY, VGbitfield aPaintModes, VGboolean aAllowAutoHinting)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgFontInfo* fontInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.CheckVGFont(aFont, &fontInfo) && TCheck::Chk32bitPtr(*vgContext, aGlyphIndices) &&
+ TCheck::ChkVGPaintModesCombination(*vgContext, aPaintModes) &&
+ TCheck::Chk2xOptional32bitPtr(*vgContext, aAdjustmentsX, aAdjustmentsY) )
+ {
+ fontInfo->DrawGlyphs(*vgContext, aGlyphCount, aGlyphIndices, aAdjustmentsX, aAdjustmentsY, aPaintModes, aAllowAutoHinting);
+ }
+ }
+ }
+
+
+/* Image Filters */
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if either dst or src is not a valid image handle, or is not shared with the
+ current context
+ VG_IMAGE_IN_USE_ERROR
+ – if either dst or src is currently a rendering target
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if src and dst overlap
+ – if matrix is NULL
+ – if matrix is not properly aligned
+ */
+void TGuestOpenVg::vgColorMatrix(VGImage aDst, VGImage aSrc, const VGfloat* aMatrix)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ // **** Desirable: check that neither aDst or aSrc are current rendering targets, or overlapping
+ CVgImageInfo* dstImageInfo = NULL;
+ CVgImageInfo* srcImageInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.Check2VGImages(aDst, &dstImageInfo, aSrc, &srcImageInfo) && TCheck::Chk32bitPtr(*vgContext, aMatrix) )
+ {
+ dstImageInfo->ColorMatrix(*vgContext, *srcImageInfo, aMatrix);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if either dst or src is not a valid image handle, or is not shared with the
+ current context
+ VG_IMAGE_IN_USE_ERROR
+ – if either dst or src is currently a rendering target
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if src and dst overlap
+ – if kernelWidth or kernelHeight is less than or equal to 0 or greater than
+ VG_MAX_KERNEL_SIZE
+ – if kernel is NULL
+ – if kernel is not properly aligned
+ – if tilingMode is not one of the values from the VGTilingMode enumeration
+ */
+void TGuestOpenVg::vgConvolve(VGImage aDst, VGImage aSrc, VGint aKernelWidth, VGint aKernelHeight,
+ VGint aShiftX, VGint aShiftY, const VGshort* aKernel, VGfloat aScale, VGfloat aBias, VGTilingMode aTilingMode)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgImageInfo* dstImageInfo = NULL;
+ CVgImageInfo* srcImageInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.Check2VGImages(aDst, &dstImageInfo, aSrc, &srcImageInfo) && TCheck::Chk16bitPtr(*vgContext, aKernel) &&
+ TCheck::ChkVGTilingMode(*vgContext, aTilingMode) &&
+ vgLock.CheckKernelWidthAndHeight(aKernelHeight, aKernelWidth, VG_MAX_KERNEL_SIZE) )
+ {
+ dstImageInfo->Convolve(*vgContext, *srcImageInfo, aKernelWidth, aKernelHeight,
+ aShiftX, aShiftY, aKernel, aScale, aBias, aTilingMode);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if either dst or src is not a valid image handle, or is not shared with the
+ current context
+ VG_IMAGE_IN_USE_ERROR
+ – if either dst or src is currently a rendering target
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if src and dst overlap
+ – if kernelWidth or kernelHeight is less than or equal to 0 or greater than
+ VG_MAX_SEPARABLE_KERNEL_SIZE
+ – if kernelX or kernelY is NULL
+ – if kernelX or kernelY is not properly aligned
+ – if tilingMode is not one of the values from the VGTilingMode
+ enumeration
+ */
+void TGuestOpenVg::vgSeparableConvolve(VGImage aDst, VGImage aSrc, VGint aKernelWidth, VGint aKernelHeight,
+ VGint aShiftX, VGint aShiftY, const VGshort* aKernelX, const VGshort* aKernelY, VGfloat aScale, VGfloat aBias, VGTilingMode aTilingMode)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgImageInfo* dstImageInfo = NULL;
+ CVgImageInfo* srcImageInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.Check2VGImages(aDst, &dstImageInfo, aSrc, &srcImageInfo) &&
+ TCheck::Chk2x16bitPtr(*vgContext, aKernelX, aKernelY) && TCheck::ChkVGTilingMode(*vgContext, aTilingMode) &&
+ vgLock.CheckKernelWidthAndHeight(aKernelWidth, aKernelHeight, VG_MAX_SEPARABLE_KERNEL_SIZE) )
+ {
+ dstImageInfo->SeparableConvolve(*vgContext, *srcImageInfo, aKernelWidth, aKernelHeight,
+ aShiftX, aShiftY, aKernelX, aKernelY, aScale, aBias, aTilingMode);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if either dst or src is not a valid image handle, or is not shared with the
+ current context
+ VG_IMAGE_IN_USE_ERROR
+ – if either dst or src is currently a rendering target
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if src and dst overlap
+ – if stdDeviationX or stdDeviationY is less than or equal to 0 or greater
+ than VG_MAX_GAUSSIAN_STD_DEVIATION
+ – if tilingMode is not one of the values from the VGTilingMode
+ enumeration
+ */
+void TGuestOpenVg::vgGaussianBlur(VGImage aDst, VGImage aSrc, VGfloat aStdDeviationX, VGfloat aStdDeviationY, VGTilingMode aTilingMode)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgImageInfo* dstImageInfo = NULL;
+ CVgImageInfo* srcImageInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.Check2VGImages(aDst, &dstImageInfo, aSrc, &srcImageInfo) && TCheck::ChkVGTilingMode(*vgContext, aTilingMode) )
+ {
+ // **** Desirable: check against VG_MAX_GAUSSIAN_STD_DEVIATION limit from x86 VG implementation
+ if ( (aStdDeviationX <= KFloatZero) || (aStdDeviationY <= KFloatZero))
+ {
+ vgContext->SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);
+ }
+ else
+ {
+ dstImageInfo->GaussianBlur(*vgContext, *srcImageInfo, aStdDeviationX, aStdDeviationY, aTilingMode);
+ }
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if either dst or src is not a valid image handle, or is not shared with the
+ current context
+ VG_IMAGE_IN_USE_ERROR
+ – if either dst or src is currently a rendering target
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if src and dst overlap
+ – if any pointer parameter is NULL
+ */
+void TGuestOpenVg::vgLookup(VGImage aDst, VGImage aSrc, const VGubyte* aRedLUT, const VGubyte* aGreenLUT,
+ const VGubyte* aBlueLUT, const VGubyte* aAlphaLUT, VGboolean aOutputLinear, VGboolean aOutputPremultiplied)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgImageInfo* dstImageInfo = NULL;
+ CVgImageInfo* srcImageInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.Check2VGImages(aDst, &dstImageInfo, aSrc, &srcImageInfo) )
+ {
+ if ( (aRedLUT == NULL) || (aGreenLUT == NULL) || (aBlueLUT == NULL) || (aAlphaLUT == NULL) )
+ {
+ vgContext->SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);
+ }
+ else
+ {
+ dstImageInfo->Lookup(*vgContext, *srcImageInfo, aRedLUT, aGreenLUT, aBlueLUT, aAlphaLUT, aOutputLinear, aOutputPremultiplied);
+ }
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ – if either dst or src is not a valid image handle, or is not shared with the
+ current context
+ VG_IMAGE_IN_USE_ERROR
+ – if either dst or src is currently a rendering target
+ VG_ILLEGAL_ARGUMENT_ERROR
+ – if src and dst overlap
+ – if src is in an RGB pixel format and sourceChannel is not one of VG_RED,
+ VG_GREEN, VG_BLUE or VG_ALPHA from the VGImageChannel enumeration
+ – if lookupTable is NULL
+ – if lookupTable is not properly aligned
+ */
+void TGuestOpenVg::vgLookupSingle(VGImage aDst, VGImage aSrc, const VGuint* aLookupTable,
+ VGImageChannel aSourceChannel, VGboolean aOutputLinear, VGboolean aOutputPremultiplied)
+ {
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if ( vgContext )
+ {
+ CVgImageInfo* dstImageInfo = NULL;
+ CVgImageInfo* srcImageInfo = NULL;
+ TCleanupVgLocks vgLock(*vgContext); // grab VG State Mutex & automatically release on destruction
+
+ if ( vgLock.Check2VGImages(aDst, &dstImageInfo, aSrc, &srcImageInfo) && TCheck::Chk32bitPtr(*vgContext, aLookupTable) )
+ {
+ dstImageInfo->LookupSingle(*vgContext, *srcImageInfo, aLookupTable,
+ aSourceChannel, aOutputLinear, aOutputPremultiplied);
+ }
+ }
+ }
+
+
+/*
+ ERRORS
+ VG_UNSUPPORTED_IMAGE_FORMAT_ERROR
+ - if the OpenVG implementation is not able to create a VGImage
+ compatible with the provided VGeglImageKHR for an implementation-
+ dependent reason (this could be caused by, but not limited to,
+ reasons such as unsupported pixel formats, anti-aliasing quality,
+ etc.).
+
+ VG_ILLEGAL_ARGUMENT_ERROR
+ - if <image> is not a valid VGeglImageKHR.
+ */
+VGImage TGuestOpenVg::vgCreateEGLImageTargetKHR(VGeglImageKHR aImage)
+ {
+ VGImage imageHandle = VG_INVALID_HANDLE;
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if (vgContext)
+ {
+ TCleanupVgLocks vgLock(*vgContext);
+ imageHandle = vgLock.CreateEGLImageTargetKHR(aImage);
+ }
+ else
+ {
+ OPENVG_TRACE(" TGuestOpenVg::vgCreateEGLImageTargetKHR - no VG context");
+ }
+
+ return imageHandle;
+ }
+
+
+// end of file vgapi.cpp