--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/guestrendering/guestopenvg/src/vgimage.cpp Wed Sep 08 17:02:34 2010 +0100
@@ -0,0 +1,773 @@
+// 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:
+// Client-side state information for Open VG handle based objects
+
+#include "vgstate.h"
+#include "remotefunctioncall.h"
+#include "openvgrfc.h"
+
+
+const TInt KColorMatrixSize = 20;
+const TInt KLUTLength = 256;
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+// CVgImageInfo
+/////////////////////////////////////////////////////////////////////////////////////////////
+
+CVgImageInfo::CVgImageInfo(VGImageFormat aFormat, VGint aWidth, VGint aHeight, CVgImageInfo* aParent, VGbitfield aAllowedQuality,
+ EGLImageKHR aEglImage, TUint64 aSgImageId) :
+ CVgImageBase(EVgHandleForImage, aWidth, aHeight), iFormat(aFormat), iParent(aParent),
+ iAllowedQuality(aAllowedQuality), iIsEglSibling( aSgImageId ? ETrue : EFalse),
+ iEglImage(aEglImage), iSgImageId(aSgImageId),
+ iChildCount(0)
+ {
+ if (aParent)
+ {
+ aParent->IncChildCount();
+ }
+ }
+
+
+// eglChildImage
+CVgImageInfo* CVgImageInfo::New(VGint aWidth, VGint aHeight, CVgImageInfo* aParent)
+ {
+ VGPANIC_ASSERT_DEBUG(aParent, EVgPanicImageParentIsInvalid);
+ RHeap* clientHeap = CVghwUtils::SwitchToVghwHeap();
+ CVgImageInfo* self = new CVgImageInfo(aParent->iFormat, aWidth, aHeight, aParent, aParent->AllowedQuality(),
+ aParent->EglImage(), aParent->SgImageId());
+ CVghwUtils::SwitchFromVghwHeap(clientHeap);
+ return self;
+ }
+
+
+// vgCreateEGLImageTargetKHR
+CVgImageInfo* CVgImageInfo::New(VGImageFormat aFormat, VGint aWidth, VGint aHeight, EGLImageKHR aEglImage, TUint64& aSgImageId)
+ {
+ RHeap* clientHeap = CVghwUtils::SwitchToVghwHeap();
+ CVgImageInfo* self = new CVgImageInfo(aFormat, aWidth, aHeight, VG_INVALID_HANDLE, 0, aEglImage, aSgImageId);
+ CVghwUtils::SwitchFromVghwHeap(clientHeap);
+ return self;
+ }
+
+
+// eglCreateImage
+CVgImageInfo* CVgImageInfo::New(VGImageFormat aFormat, VGint aWidth, VGint aHeight, VGbitfield aAllowedQuality)
+ {
+ RHeap* clientHeap = CVghwUtils::SwitchToVghwHeap();
+ CVgImageInfo* self = new CVgImageInfo(aFormat, aWidth, aHeight, VG_INVALID_HANDLE, aAllowedQuality, NULL, 0l);
+ CVghwUtils::SwitchFromVghwHeap(clientHeap);
+ return self;
+ }
+
+
+CVgImageInfo::~CVgImageInfo()
+ {
+ VGPANIC_ASSERT(iChildCount == 0, EVgPanicDeleteInUseVgImageInfo);
+ if (iParent)
+ {
+ iParent->DecChildCount();
+ }
+ }
+
+
+CVgImageInfo* CVgImageInfo::Parent() const
+ {
+ return iParent;
+ }
+
+
+TInt CVgImageInfo::ChildCount() const
+ {
+ return iChildCount;
+ }
+
+
+void CVgImageInfo::IncChildCount()
+ {
+ VGPANIC_ASSERT(!iIsDestroyed, EVgPanicParentImageAlreadyDestroyed);
+ User::LockedInc(iChildCount);
+ }
+
+
+void CVgImageInfo::DecChildCount()
+ {
+ User::LockedDec(iChildCount);
+ if ((iChildCount == 0) && iIsDestroyed)
+ {
+ if (iParent == NULL)
+ {
+ if (IsEglSibling())
+ { // close the root EglImage
+ OpenVgState.EglImageClose(iEglImage);
+ }
+ }
+ else
+ {
+ iParent->DecChildCount();
+ }
+ // delete this image & remove it from HandleMap
+ RHeap* clientHeap = CVghwUtils::SwitchToVghwHeap();
+ OpenVgState.UnMapHandle(iClientHandle);
+ delete this;
+ CVghwUtils::SwitchFromVghwHeap(clientHeap);
+ }
+ }
+
+
+VGbitfield CVgImageInfo::AllowedQuality() const
+ {
+ return iAllowedQuality;
+ }
+
+
+TBool CVgImageInfo::IsEglSibling() const
+ {
+ return iIsEglSibling;
+ }
+
+
+EGLImageKHR CVgImageInfo::EglImage() const
+ {
+ return iEglImage;
+ }
+
+
+TUint64 CVgImageInfo::SgImageId() const
+ {
+ return iSgImageId;
+ }
+
+
+TBool CVgImageInfo::DestroyObject(MVgContext& aVgContext)
+ {
+ VGPANIC_ASSERT_DEBUG(iIsDestroyed, EVgPanicTemp);
+ OPENVG_TRACE(" CVgImageInfo::DestroyObject HostHandle=0x%x; ChildCount=%d, Parent=0x%x, IsEglSibling=%d, EglImage=0x%x",
+ iHostHandle, ChildCount(), Parent(), IsEglSibling(), EglImage());
+
+ if (iHostHandle)
+ {
+ // Destroy image, but not for eglImages/SgImages
+ if (!IsEglSibling())
+ {
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgDestroyImage, RemoteFunctionCallData::EOpRequest);
+ vgApiData.AppendParam(iHostHandle);
+ aVgContext.ExecuteVgCommand(vgApiData);
+ }
+ iHostHandle = VG_INVALID_HANDLE;
+ }
+
+ if (iChildCount == 0)
+ {
+ if (iParent == NULL)
+ {
+ if (IsEglSibling())
+ { // close the root EglImage
+ OpenVgState.EglImageClose(iEglImage);
+ }
+ }
+ else
+ {
+ iParent->DecChildCount();
+ }
+ return ETrue;
+ }
+ // don't delete this image until all children have been destroyed
+ return EFalse;
+ }
+
+
+TInt CVgImageInfo::BitsPerPixelForVgImageFormat(VGImageFormat aFormat)
+ {
+ TInt result = -1;
+ if ((aFormat == VG_BW_1) || (aFormat == VG_A_1))
+ {
+ result = 1;
+ }
+ else if (aFormat == VG_A_4)
+ {
+ result = 4;
+ }
+ else if ((aFormat == VG_sL_8) || (aFormat == VG_lL_8) || (aFormat == VG_A_8))
+ {
+ result = 8;
+ }
+ else if ((aFormat >= 0) && (aFormat < 256))
+ { // low bits of format number repeat in a pattern for 16/32 bit per pel
+ TInt format = aFormat & 0x3f;
+ if ((format >= VG_sRGB_565) && (format <= VG_sRGBA_4444))
+ {
+ result = 16;
+ }
+ else if (format <= VG_lRGBA_8888_PRE)
+ {
+ result = 32;
+ }
+ }
+ return result;
+ }
+
+
+void CVgImageInfo::PixmapBlit(TUint8* aDest, const TUint8* aSource, TInt aDestStride, TInt aSourceStride, TInt aRowCount,
+ size_t aRowLength, TInt aLastBits)
+ {
+ VGPANIC_ASSERT_DEBUG(aDest, EVgPanicNullPointer);
+ VGPANIC_ASSERT_DEBUG(aSource, EVgPanicNullPointer);
+ VGPANIC_ASSERT_DEBUG(aDestStride >= aRowLength, EVgPanicStrideSmallerThanRowLength);
+ VGPANIC_ASSERT_DEBUG(aSourceStride >= aRowLength, EVgPanicStrideSmallerThanRowLength);
+ VGPANIC_ASSERT_DEBUG(aRowCount > 0, EVgPanicBadRowCountParam);
+ VGPANIC_ASSERT_DEBUG(aRowLength > 0, EVgPanicBadRowLengthParam);
+ VGPANIC_ASSERT_DEBUG( (aLastBits >= 0) && (aLastBits <= 7), EVgPanicBadLastBitsParam);
+
+ if (aLastBits)
+ { // bits per pixel < 8, only copy lowest <aLastBits> from source to dest
+ TUint8 destMask = 0xFF << aLastBits; // high bits
+ TUint8 srcMask = 0xFF ^ destMask; // low bits
+ aRowLength -= 1;
+ for (VGint row = 0; row < aRowCount; ++row)
+ {
+ memcpy(aDest, aSource, aRowLength);
+ TUint8 byte = (aDest[aRowLength] & destMask) | (aSource[aRowLength] & srcMask);
+ aDest[aRowLength] = byte;
+ aSource += aSourceStride;
+ aDest += aDestStride;
+ }
+ }
+ else
+ {
+ for (VGint row = 0; row < aRowCount; ++row)
+ {
+ memcpy(aDest, aSource, aRowLength);
+ aSource += aSourceStride;
+ aDest += aDestStride;
+ }
+ }
+ }
+
+
+VGint CVgImageInfo::GetParameterVectorSize(MVgContext& aVgContext, VGint aParamType)
+ {
+ switch (aParamType)
+ {
+ case VG_IMAGE_FORMAT:
+ case VG_IMAGE_WIDTH:
+ case VG_IMAGE_HEIGHT:
+ return 1;
+ }
+
+ // invalid ParamType
+ aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);
+ return 0;
+ }
+
+
+VGfloat CVgImageInfo::GetParameterf(MVgContext& aVgContext, VGint aParamType)
+ {
+ switch (aParamType)
+ {
+ case VG_IMAGE_FORMAT:
+ if (iFormat != VG_IMAGE_FORMAT_INVALID)
+ {
+ return (VGfloat)iFormat;
+ }
+ // for EglImage need to get format of underlying VgImage
+ return HostVgGetParameterf(aVgContext, aParamType);
+
+ case VG_IMAGE_WIDTH:
+ return (VGfloat)iWidth;
+
+ case VG_IMAGE_HEIGHT:
+ return (VGfloat)iHeight;
+ }
+
+ // invalid ParamType
+ aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);
+ return 0;
+ }
+
+
+VGint CVgImageInfo::GetParameteri(MVgContext& aVgContext, VGint aParamType)
+ {
+ switch (aParamType)
+ {
+ case VG_IMAGE_FORMAT:
+ if (iFormat != VG_IMAGE_FORMAT_INVALID)
+ {
+ return iFormat;
+ }
+ // for EglImage need to get format of underlying VgImage
+ iFormat = (VGImageFormat) HostVgGetParameteri(aVgContext, aParamType);
+ return iFormat;
+
+ case VG_IMAGE_WIDTH:
+ return iWidth;
+
+ case VG_IMAGE_HEIGHT:
+ return iHeight;
+ }
+
+ // invalid ParamType
+ aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);
+ return 0;
+ }
+
+
+void CVgImageInfo::ClearImage(MVgContext& aVgContext, VGint aX, VGint aY, VGint aWidth, VGint aHeight)
+ {
+ // **** Desirable: check aImage is not rendering target
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgClearImage, RemoteFunctionCallData::EOpRequest);
+ vgApiData.AppendParam(iHostHandle);
+ vgApiData.AppendParam(aX);
+ vgApiData.AppendParam(aY);
+ vgApiData.AppendParam(aWidth);
+ vgApiData.AppendParam(aHeight);
+ TUint64 sgId(0L);
+ if (iIsEglSibling)
+ {
+ sgId = iSgImageId;
+ }
+ vgApiData.AppendTUint64(sgId);
+ aVgContext.ExecuteVgCommand(vgApiData);
+ }
+
+
+void CVgImageInfo::ImageSubData(MVgContext& aVgContext, const void * aData, VGint aDataStride, VGImageFormat aDataFormat, VGint aX, VGint aY,
+ VGint aWidth, VGint aHeight)
+ {
+ // **** Desirable: check image is not a rendering target
+
+ // Limit aWidth & aHeight to the dimensions of aImage
+ if (iWidth < aWidth)
+ {
+ aWidth = iWidth;
+ }
+ if (iHeight < aHeight)
+ {
+ aHeight = iHeight;
+ }
+ OPENVG_TRACE("CVgImageInfo::ImageSubData.1a dest Image: width=%d, height=%d; clipped width=%d, clipped height=%d",
+ iWidth, iHeight, aWidth, aHeight);
+ TInt bitsPerPixel = BitsPerPixelForVgImageFormat(aDataFormat);
+ TUint32 lineLength = ((static_cast<TUint32>(aWidth) * static_cast<TUint32>(bitsPerPixel)) + 7) / 8;
+ OPENVG_TRACE("CVgImageInfo::ImageSubData.1b bitsPerPixel=%d, lineLength=%d", bitsPerPixel, lineLength);
+
+ if (bitsPerPixel <= 0)
+ {
+ aVgContext.SetVgError(VG_UNSUPPORTED_IMAGE_FORMAT_ERROR);
+ }
+ else
+ {
+ if (lineLength == aDataStride)
+ { // use original parameters
+ OPENVG_TRACE("CVgImageInfo::ImageSubData.2a: lineLength == dataStride");
+ HostVgImageSubData(aVgContext, aData, aDataStride * aHeight, aDataStride,
+ aDataFormat, aX, aY, aWidth, aHeight);
+ }
+ else if (0 == aDataStride)
+ { // Fill operation, pixmap size = lineLength
+ OPENVG_TRACE("CVgImageInfo::ImageSubData.2b: 0 == dataStride");
+ HostVgImageSubData(aVgContext, aData, lineLength, aDataStride,
+ aDataFormat, aX, aY, aWidth, aHeight);
+ }
+ else
+ { // try to alloc a translation buffer - datastride maybe negative or simply > lineLength
+ size_t pixmapSize = lineLength * aHeight;
+ TUint8* localBuffer = (TUint8*) CVghwUtils::Alloc(pixmapSize);
+ OPENVG_TRACE("CVgImageInfo::ImageSubData.2c: dataStride not 0 or lineLength, localBuffer=0x%x", localBuffer);
+ if (localBuffer != NULL)
+ { // reformat data into temporary buffer
+ PixmapBlit(localBuffer, static_cast<const TUint8*>(aData), lineLength, aDataStride, aHeight, lineLength);
+ HostVgImageSubData(aVgContext, localBuffer, pixmapSize, lineLength, aDataFormat, aX, aY, 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)
+ {
+ HostVgImageSubData(aVgContext, source, lineLength, lineLength, aDataFormat, aX + row, aY, aWidth, 1);
+ source += aDataStride;
+ }
+ }
+ }
+ }
+ }
+
+
+void CVgImageInfo::HostVgImageSubData(MVgContext& aVgContext, const void* aPixmap, size_t aPixmapSize, VGint aHostDataStride,
+ VGImageFormat aDataFormat, VGint aX, VGint aY, VGint aWidth, VGint aHeight)
+ {
+ VGPANIC_ASSERT(aPixmap != NULL, EVgPanicNullPixmapPointer);
+ VGPANIC_ASSERT(aPixmapSize >= (aHostDataStride * aHeight), EVgPanicPixmapSizeError);
+
+ RemoteFunctionCallData rfcdata; OpenVgRFC vgApiData(rfcdata);
+ vgApiData.Init(OpenVgRFC::EvgImageSubData, RemoteFunctionCallData::EOpRequest);
+ vgApiData.AppendParam(iHostHandle);
+ vgApiData.AppendVector(aPixmap, aPixmapSize);
+ vgApiData.AppendParam(aHostDataStride);
+ vgApiData.AppendParam(aDataFormat);
+ vgApiData.AppendParam(aX);
+ vgApiData.AppendParam(aY);
+ vgApiData.AppendParam(aWidth);
+ vgApiData.AppendParam(aHeight);
+ TUint64 sgId(0L);
+ if (iIsEglSibling)
+ {
+ sgId = iSgImageId;
+ }
+ OPENVG_TRACE("CVgImageInfo::HostVgImageSubData sgId 0x%lx", sgId);
+ vgApiData.AppendTUint64(sgId);
+ aVgContext.ExecuteVgCommand(vgApiData);
+ }
+
+
+void CVgImageInfo::GetImageSubData(MVgContext& aVgContext, void * aData, VGint aDataStride, VGImageFormat aDataFormat, VGint aX, VGint aY, VGint aWidth, VGint aHeight)
+ {
+ // **** Desirable: check VGImage is not currently a rendering target
+
+ // Limit aWidth & aHeight to the dimensions of aImage
+ if (iWidth < aWidth)
+ {
+ aWidth = iWidth;
+ }
+ if (iHeight < aHeight)
+ {
+ aHeight = iHeight;
+ }
+ OPENVG_TRACE("CVgImageInfo::GetImageSubData.1a source Image: width=%d, height=%d; clipped width=%d, clipped height=%d",
+ iWidth, iHeight, aWidth, aHeight);
+ TInt bitsPerPixel = BitsPerPixelForVgImageFormat(aDataFormat);
+ TUint32 lineLength = static_cast<TUint32>(aWidth) * static_cast<TUint32>(bitsPerPixel);
+ TUint32 tailBits = lineLength & 7;
+ lineLength = (lineLength + 7) / 8;
+ OPENVG_TRACE("CVgImageInfo::GetImageSubData.1b bitsPerPixel=%d, lineLength=%d, tailBits=%d", bitsPerPixel, lineLength, tailBits);
+
+ if (bitsPerPixel <= 0)
+ {
+ aVgContext.SetVgError(VG_UNSUPPORTED_IMAGE_FORMAT_ERROR);
+ }
+ else
+ {
+ if (lineLength == aDataStride)
+ { // use original params
+ OPENVG_TRACE("CVgImageInfo::GetImageSubData.2a: lineLength == dataStride");
+ HostVgGetImageSubData(aVgContext, aData, aDataStride * aHeight, aDataStride, aDataFormat, aX, aY, aWidth, aHeight);
+ }
+ else if (0 == aDataStride)
+ { // unlikely unless aHeight = 1, symmetric to fill function for vgGetImageSubData
+ OPENVG_TRACE("CVgImageInfo::GetImageSubData.2b: 0 == dataStride");
+ HostVgGetImageSubData(aVgContext, aData, lineLength, aDataStride, aDataFormat, aX, aY, aWidth, aHeight);
+ }
+ else
+ { // datastride maybe negative or simply > lineLength
+ TInt pixmapSize = lineLength * aHeight;
+ TUint8* localBuffer = (TUint8*) CVghwUtils::Alloc(pixmapSize);
+ OPENVG_TRACE("CVgImageInfo::GetImageSubData.2c: dataStride not 0 or lineLength, localBuffer=0x%x", localBuffer);
+
+ if (localBuffer != NULL)
+ { // read pixels into temporary buffer
+ HostVgGetImageSubData(aVgContext, localBuffer, pixmapSize, lineLength, aDataFormat, aX, aY, aWidth, aHeight);
+ // reformat into client memory
+ 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)
+ {
+ HostVgGetImageSubData(aVgContext, dest, lineLength, lineLength, aDataFormat, aX + row, aY, aWidth, 1);
+ dest += aDataStride;
+ }
+ }
+ }
+ }
+ }
+
+
+void CVgImageInfo::HostVgGetImageSubData(MVgContext& aVgContext, void* aPixmap, size_t aPixmapSize, VGint aHostDataStride,
+ VGImageFormat aDataFormat, VGint aX, VGint aY, VGint aWidth, VGint aHeight)
+ {
+ VGPANIC_ASSERT_DEBUG(aPixmap != NULL, EVgPanicNullPixmapPointer);
+ VGPANIC_ASSERT_DEBUG(aPixmapSize >= (aHostDataStride * aHeight), EVgPanicPixmapSizeError);
+
+ RemoteFunctionCallData rfcdata; OpenVgRFC vgApiData(rfcdata);
+ vgApiData.Init(OpenVgRFC::EvgGetImageSubData);
+ vgApiData.AppendParam(iHostHandle);
+ vgApiData.AppendVector(aPixmap, aPixmapSize, RemoteFunctionCallData::EOut);
+ vgApiData.AppendParam(aHostDataStride);
+ vgApiData.AppendParam(aDataFormat);
+ vgApiData.AppendParam(aX);
+ vgApiData.AppendParam(aY);
+ vgApiData.AppendParam(aWidth);
+ vgApiData.AppendParam(aHeight);
+ vgApiData.AppendParam((VGint)aPixmapSize); // ToDo overload AppendParam for TUint32
+ TUint64 sgId(0L);
+ if (iIsEglSibling)
+ {
+ sgId = iSgImageId;
+ }
+ vgApiData.AppendTUint64(sgId);
+ aVgContext.ExecuteVgCommand(vgApiData);
+ }
+
+
+void CVgImageInfo::CopyImage(MVgContext& aVgContext, VGint aDx, VGint aDy, CVgImageInfo& aSrcImageInfo, VGint aSx, VGint aSy, VGint aWidth,
+ VGint aHeight, VGboolean aDither)
+ {
+ // **** Desirable: verify src & dst are not a rendering target, ...
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgCopyImage, RemoteFunctionCallData::EOpRequest);
+ vgApiData.AppendParam(iHostHandle);
+ vgApiData.AppendParam(aDx);
+ vgApiData.AppendParam(aDy);
+ vgApiData.AppendParam(aSrcImageInfo.HostHandle());
+ vgApiData.AppendParam(aSx);
+ vgApiData.AppendParam(aSy);
+ vgApiData.AppendParam(aWidth);
+ vgApiData.AppendParam(aHeight);
+ vgApiData.AppendParam(aDither);
+ TUint64 dstSgId(0L);
+ TUint64 srcSgId(0L);
+ if (iIsEglSibling)
+ {
+ dstSgId = iSgImageId;
+ }
+ if (aSrcImageInfo.IsEglSibling())
+ {
+ srcSgId = aSrcImageInfo.SgImageId();
+ }
+ vgApiData.AppendTUint64(dstSgId);
+ vgApiData.AppendTUint64(srcSgId);
+ aVgContext.ExecuteVgCommand(vgApiData);
+ }
+
+
+void CVgImageInfo::DrawImage(MVgContext& aVgContext)
+ {
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgDrawImage, RemoteFunctionCallData::EOpRequest);
+ vgApiData.AppendParam(iHostHandle);
+ TUint64 sgId(0L);
+ if (iIsEglSibling)
+ {
+ sgId = iSgImageId;
+ }
+ vgApiData.AppendTUint64(sgId);
+ aVgContext.ExecuteVgCommand(vgApiData);
+ }
+
+
+void CVgImageInfo::SetPixels(MVgContext& aVgContext, VGint aDx, VGint aDy, VGint aSx, VGint aSy, VGint aWidth, VGint aHeight)
+ {
+ // **** Desirable: verify aSrc image is not a rendering target
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgSetPixels, RemoteFunctionCallData::EOpRequest);
+ vgApiData.AppendParam(aDx);
+ vgApiData.AppendParam(aDy);
+ vgApiData.AppendParam(iHostHandle);
+ vgApiData.AppendParam(aSx);
+ vgApiData.AppendParam(aSy);
+ vgApiData.AppendParam(aWidth);
+ vgApiData.AppendParam(aHeight);
+ aVgContext.ExecuteVgCommand(vgApiData);
+ }
+
+
+void CVgImageInfo::GetPixels(MVgContext& aVgContext, VGint aDx, VGint aDy, VGint aSx, VGint aSy, VGint aWidth, VGint aHeight)
+ {
+ // **** Desirable: verify aDst is not currently a rendering target
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgGetPixels, RemoteFunctionCallData::EOpRequest);
+ vgApiData.AppendParam(iHostHandle);
+ vgApiData.AppendParam(aDx);
+ vgApiData.AppendParam(aDy);
+ vgApiData.AppendParam(aSx);
+ vgApiData.AppendParam(aSy);
+ vgApiData.AppendParam(aWidth);
+ vgApiData.AppendParam(aHeight);
+ TUint64 sgId(0L);
+ if (iIsEglSibling)
+ {
+ sgId = iSgImageId;
+ }
+ vgApiData.AppendTUint64(sgId);
+ aVgContext.ExecuteVgCommand(vgApiData);
+ }
+
+
+void CVgImageInfo::ColorMatrix(MVgContext& aVgContext, CVgImageInfo& aSrcImageInfo, const VGfloat * aMatrix)
+ {
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgColorMatrix, RemoteFunctionCallData::EOpRequest);
+ vgApiData.AppendParam(iHostHandle);
+ vgApiData.AppendParam(aSrcImageInfo.HostHandle());
+ vgApiData.AppendVector(aMatrix, KColorMatrixSize);
+ TUint64 dstSgId(0L);
+ TUint64 srcSgId(0L);
+ if (IsEglSibling())
+ {
+ dstSgId = SgImageId();
+ }
+ if (aSrcImageInfo.IsEglSibling())
+ {
+ srcSgId = aSrcImageInfo.SgImageId();
+ }
+ vgApiData.AppendTUint64(dstSgId);
+ vgApiData.AppendTUint64(srcSgId);
+ aVgContext.ExecuteVgCommand(vgApiData);
+ }
+
+
+void CVgImageInfo::Convolve(MVgContext& aVgContext, CVgImageInfo& aSrcImageInfo, VGint aKernelWidth, VGint aKernelHeight,
+ VGint aShiftX, VGint aShiftY, const VGshort * aKernel, VGfloat aScale, VGfloat aBias, VGTilingMode aTilingMode)
+ {
+ // **** Desirable: verify aDst & aSrc are valid and do not overlap
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgConvolve, RemoteFunctionCallData::EOpRequest);
+ vgApiData.AppendParam(iHostHandle);
+ vgApiData.AppendParam(aSrcImageInfo.HostHandle());
+ vgApiData.AppendParam(aKernelWidth);
+ vgApiData.AppendParam(aKernelHeight);
+ vgApiData.AppendParam(aShiftX);
+ vgApiData.AppendParam(aShiftY);
+ vgApiData.AppendVector(aKernel, aKernelWidth*aKernelHeight);
+ vgApiData.AppendParam(aScale);
+ vgApiData.AppendParam(aBias);
+ vgApiData.AppendParam(aTilingMode);
+ aVgContext.ExecuteVgCommand(vgApiData);
+ }
+
+
+void CVgImageInfo::SeparableConvolve(MVgContext& aVgContext, CVgImageInfo& aSrcImageInfo, VGint aKernelWidth, VGint aKernelHeight,
+ VGint aShiftX, VGint aShiftY, const VGshort * aKernelX, const VGshort * aKernelY,
+ VGfloat aScale, VGfloat aBias, VGTilingMode aTilingMode)
+ {
+ // **** Desirable: verify aDst & aSrc are valid and do not overlap
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgSeparableConvolve, RemoteFunctionCallData::EOpRequest);
+ vgApiData.AppendParam(iHostHandle);
+ vgApiData.AppendParam(aSrcImageInfo.HostHandle());
+ vgApiData.AppendParam(aKernelWidth);
+ vgApiData.AppendParam(aKernelHeight);
+ vgApiData.AppendParam(aShiftX);
+ vgApiData.AppendParam(aShiftY);
+ vgApiData.AppendVector(aKernelX, aKernelWidth);
+ vgApiData.AppendVector(aKernelY, aKernelHeight);
+ vgApiData.AppendParam(aScale);
+ vgApiData.AppendParam(aBias);
+ vgApiData.AppendParam(aTilingMode);
+ TUint64 dstSgId(0L);
+ TUint64 srcSgId(0L);
+ if (IsEglSibling())
+ {
+ dstSgId = SgImageId();
+ }
+ if (aSrcImageInfo.IsEglSibling())
+ {
+ srcSgId = aSrcImageInfo.SgImageId();
+ }
+ vgApiData.AppendTUint64(dstSgId);
+ vgApiData.AppendTUint64(srcSgId);
+ aVgContext.ExecuteVgCommand(vgApiData);
+ }
+
+
+void CVgImageInfo::GaussianBlur(MVgContext& aVgContext, CVgImageInfo& aSrcImageInfo, VGfloat aStdDeviationX, VGfloat aStdDeviationY, VGTilingMode aTilingMode)
+ {
+ // **** Desirable: verify aDst & src are not currently a rendering target or overlap
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgGaussianBlur, RemoteFunctionCallData::EOpRequest);
+ vgApiData.AppendParam(iHostHandle);
+ vgApiData.AppendParam(aSrcImageInfo.HostHandle());
+ vgApiData.AppendParam(aStdDeviationX);
+ vgApiData.AppendParam(aStdDeviationY);
+ vgApiData.AppendParam(aTilingMode);
+ TUint64 dstSgId(0L);
+ TUint64 srcSgId(0L);
+ if (IsEglSibling())
+ {
+ dstSgId = SgImageId();
+ }
+ if (aSrcImageInfo.IsEglSibling())
+ {
+ srcSgId = aSrcImageInfo.SgImageId();
+ }
+ vgApiData.AppendTUint64(dstSgId);
+ vgApiData.AppendTUint64(srcSgId);
+ aVgContext.ExecuteVgCommand(vgApiData);
+ }
+
+
+void CVgImageInfo::Lookup(MVgContext& aVgContext, CVgImageInfo& aSrcImageInfo, const VGubyte * aRedLUT, const VGubyte * aGreenLUT, const VGubyte * aBlueLUT,
+ const VGubyte * aAlphaLUT, VGboolean aOutputLinear, VGboolean aOutputPremultiplied)
+ {
+ // **** Desirable: verify aDst & aSrc are not currently a rendering target or overlap
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgLookup, RemoteFunctionCallData::EOpRequest);
+ vgApiData.AppendParam(iHostHandle);
+ vgApiData.AppendParam(aSrcImageInfo.HostHandle());
+ vgApiData.AppendVector(aRedLUT, KLUTLength);
+ vgApiData.AppendVector(aGreenLUT, KLUTLength);
+ vgApiData.AppendVector(aBlueLUT, KLUTLength);
+ vgApiData.AppendVector(aAlphaLUT, KLUTLength);
+ vgApiData.AppendParam(aOutputLinear);
+ vgApiData.AppendParam(aOutputPremultiplied);
+ TUint64 dstSgId(0L);
+ TUint64 srcSgId(0L);
+ if (IsEglSibling())
+ {
+ dstSgId = SgImageId();
+ }
+ if (aSrcImageInfo.IsEglSibling())
+ {
+ srcSgId = aSrcImageInfo.SgImageId();
+ }
+ vgApiData.AppendTUint64(dstSgId);
+ vgApiData.AppendTUint64(srcSgId);
+ aVgContext.ExecuteVgCommand(vgApiData);
+ }
+
+
+void CVgImageInfo::LookupSingle(MVgContext& aVgContext, CVgImageInfo& aSrcImageInfo, const VGuint * aLookupTable, VGImageChannel aSourceChannel,
+ VGboolean aOutputLinear, VGboolean aOutputPremultiplied)
+ {
+ // **** Desirable: check aSrc is in an RGB pixel format, and that aSourceChannel is okay
+ RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+ vgApiData.Init(OpenVgRFC::EvgLookupSingle, RemoteFunctionCallData::EOpRequest);
+ vgApiData.AppendParam(iHostHandle);
+ vgApiData.AppendParam(aSrcImageInfo.HostHandle());
+ vgApiData.AppendVector(aLookupTable, KLUTLength);
+ vgApiData.AppendParam(aSourceChannel);
+ vgApiData.AppendParam(aOutputLinear);
+ vgApiData.AppendParam(aOutputPremultiplied);
+ TUint64 dstSgId(0L);
+ TUint64 srcSgId(0L);
+ if (IsEglSibling())
+ {
+ dstSgId = SgImageId();
+ }
+ if (aSrcImageInfo.IsEglSibling())
+ {
+ srcSgId = aSrcImageInfo.SgImageId();
+ }
+ vgApiData.AppendTUint64(dstSgId);
+ vgApiData.AppendTUint64(srcSgId);
+ aVgContext.ExecuteVgCommand(vgApiData);
+ }
+
+
+// end of file vgimage.cpp