--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/openvg/openvgrefimplementation/sfopenvg/bwins/libvgiu.def	Fri Apr 30 17:15:32 2010 +0100
@@ -0,0 +1,15 @@
+EXPORTS
+   	VGIInitialize @ 1 NONAME
+   	VGICopyToTarget @ 2 NONAME
+   	VGITerminate @ 3 NONAME
+   	VGIResize @ 4 NONAME
+	VGIBindToImage @ 5 NONAME
+	VGIUnBindImage @ 6 NONAME
+	?VGISymbianCopyToBitmap@@YAHPAVCFbsBitmap@@0W4VGICopyToTargetHint@@@Z @ 7 NONAME
+	?VGISymbianInitialize@@YAHVTSize@@W4VGIColorSpace@@@Z @ 8 NONAME
+	?VGISymbianResize@@YAHVTSize@@@Z @ 9 NONAME
+	?VGISymbianTerminate@@YAXXZ @ 10 NONAME
+	?VGISymbianBindToImage@@YAHK@Z @ 11 NONAME
+	?VGISymbianUnBindImage@@YAHXZ @ 12 NONAME
+	?VGISymbianInitializeEx@@YAHVTSize@@W4VGIColorSpace@@HH@Z @ 13  NONAME
+	VGIInitializeEx @ 14  NONAME

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/openvg/openvgrefimplementation/sfopenvg/bwins/sflibopenvgrefimplu.def	Fri Apr 30 17:15:32 2010 +0100
@@ -0,0 +1,134 @@
+EXPORTS
+; NEW:
+	?do_vgImageSubData@@YAXKPBXJW4VGImageFormat@@JJJJ@Z @ 1  NONAME ; void do_vgImageSubData(unsigned long, void const *, long, enum VGImageFormat, long, long, long, long)
+	?do_eglInitialize@@YAHHPAH0@Z @ 2  NONAME ; int do_eglInitialize(int, int *, int *)
+	?do_vgColorMatrix@@YAXKKPBM@Z @ 3  NONAME ; void do_vgColorMatrix(unsigned long, unsigned long, float const *)
+	?do_vgDrawGlyph@@YAXKKKW4VGboolean@@@Z @ 4  NONAME ; void do_vgDrawGlyph(unsigned long, unsigned long, unsigned long, enum VGboolean)
+	?do_vgDestroyPath@@YAXK@Z @ 5  NONAME ; void do_vgDestroyPath(unsigned long)
+	?do_vgDestroyMaskLayer@@YAXK@Z @ 6  NONAME ; void do_vgDestroyMaskLayer(unsigned long)
+	?do_vgCreatePath@@YAKJW4VGPathDatatype@@MMJJK@Z @ 7  NONAME ; unsigned long do_vgCreatePath(long, enum VGPathDatatype, float, float, long, long, unsigned long)
+	?do_vgWritePixels@@YAXPBXJW4VGImageFormat@@JJJJ@Z @ 8  NONAME ; void do_vgWritePixels(void const *, long, enum VGImageFormat, long, long, long, long)
+	?do_vgSetfv@@YAXW4VGParamType@@JPBM@Z @ 9  NONAME ; void do_vgSetfv(enum VGParamType, long, float const *)
+	?do_eglWaitNative@@YAHH@Z @ 10  NONAME ; int do_eglWaitNative(int)
+	?do_vgHardwareQuery@@YA?AW4VGHardwareQueryResult@@W4VGHardwareQueryType@@J@Z @ 11  NONAME ; enum VGHardwareQueryResult do_vgHardwareQuery(enum VGHardwareQueryType, long)
+	?do_eglWaitGL@@YAHXZ @ 12  NONAME ; int do_eglWaitGL(void)
+	?do_vgFinish@@YAXXZ @ 13  NONAME ; void do_vgFinish(void)
+	?do_vgSetPaint@@YAXKK@Z @ 14  NONAME ; void do_vgSetPaint(unsigned long, unsigned long)
+	?do_vgSetParameteriv@@YAXKJJPBJ@Z @ 15  NONAME ; void do_vgSetParameteriv(unsigned long, long, long, long const *)
+	?do_vgPathTransformedBounds@@YAXKPAM000@Z @ 16  NONAME ; void do_vgPathTransformedBounds(unsigned long, float *, float *, float *, float *)
+	?do_eglSwapBuffers@@YAHHH@Z @ 17  NONAME ; int do_eglSwapBuffers(int, int)
+	?do_eglCreatePixmapSurface@@YAHHHPAXPBH@Z @ 18  NONAME ; int do_eglCreatePixmapSurface(int, int, void *, int const *)
+	?do_eglCreatePbufferFromClientBuffer@@YAHHHHHPBH@Z @ 19  NONAME ; int do_eglCreatePbufferFromClientBuffer(int, int, int, int, int const *)
+	?do_vgSeparableConvolve@@YAXKKJJJJPBF0MMW4VGTilingMode@@@Z @ 20  NONAME ; void do_vgSeparableConvolve(unsigned long, unsigned long, long, long, long, long, short const *, short const *, float, float, enum VGTilingMode)
+	?do_vgConvolve@@YAXKKJJJJPBFMMW4VGTilingMode@@@Z @ 21  NONAME ; void do_vgConvolve(unsigned long, unsigned long, long, long, long, long, short const *, float, float, enum VGTilingMode)
+	?do_vgSetParameterf@@YAXKJM@Z @ 22  NONAME ; void do_vgSetParameterf(unsigned long, long, float)
+	?do_vgSetPixels@@YAXJJKJJJJ@Z @ 23  NONAME ; void do_vgSetPixels(long, long, unsigned long, long, long, long, long)
+	?do_vgLookup@@YAXKKPBE000W4VGboolean@@1@Z @ 24  NONAME ; void do_vgLookup(unsigned long, unsigned long, unsigned char const *, unsigned char const *, unsigned char const *, unsigned char const *, enum VGboolean, enum VGboolean)
+	?do_vgGetParameterfv@@YAXKJJPAM@Z @ 25  NONAME ; void do_vgGetParameterfv(unsigned long, long, long, float *)
+	?do_vgSetColor@@YAXKK@Z @ 26  NONAME ; void do_vgSetColor(unsigned long, unsigned long)
+	?do_vgFlush@@YAXXZ @ 27  NONAME ; void do_vgFlush(void)
+	?do_vgPointAlongPath@@YAXKJJMPAM000@Z @ 28  NONAME ; void do_vgPointAlongPath(unsigned long, long, long, float, float *, float *, float *, float *)
+	?do_vgGetiv@@YAXW4VGParamType@@JPAJ@Z @ 29  NONAME ; void do_vgGetiv(enum VGParamType, long, long *)
+	?do_vgGetColor@@YAKK@Z @ 30  NONAME ; unsigned long do_vgGetColor(unsigned long)
+	?do_vgShear@@YAXMM@Z @ 31  NONAME ; void do_vgShear(float, float)
+	?do_vgGetMatrix@@YAXPAM@Z @ 32  NONAME ; void do_vgGetMatrix(float *)
+	?do_vgClearImage@@YAXKJJJJ@Z @ 33  NONAME ; void do_vgClearImage(unsigned long, long, long, long, long)
+	?do_vgGetImageSubData@@YAXKPAXJW4VGImageFormat@@JJJJ@Z @ 34  NONAME ; void do_vgGetImageSubData(unsigned long, void *, long, enum VGImageFormat, long, long, long, long)
+	?do_vgCopyMask@@YAXKJJJJJJ@Z @ 35  NONAME ; void do_vgCopyMask(unsigned long, long, long, long, long, long, long)
+	?do_vgGetVectorSize@@YAJW4VGParamType@@@Z @ 36  NONAME ; long do_vgGetVectorSize(enum VGParamType)
+	?do_eglCreateWindowSurface@@YAHHHPAXPBH@Z @ 37  NONAME ; int do_eglCreateWindowSurface(int, int, void *, int const *)
+	?do_vgGetPathCapabilities@@YAKK@Z @ 38  NONAME ; unsigned long do_vgGetPathCapabilities(unsigned long)
+	?do_vguComputeWarpQuadToSquare@@YA?AW4VGUErrorCode@@MMMMMMMMPAM@Z @ 39  NONAME ; enum VGUErrorCode do_vguComputeWarpQuadToSquare(float, float, float, float, float, float, float, float, float *)
+	?do_eglQueryContext@@YAHHHHPAH@Z @ 40  NONAME ; int do_eglQueryContext(int, int, int, int *)
+	?do_vgGetfv@@YAXW4VGParamType@@JPAM@Z @ 41  NONAME ; void do_vgGetfv(enum VGParamType, long, float *)
+	?do_vgGetPaint@@YAKW4VGPaintMode@@@Z @ 42  NONAME ; unsigned long do_vgGetPaint(enum VGPaintMode)
+	?do_eglCreateContext@@YAHHHHPBH@Z @ 43  NONAME ; int do_eglCreateContext(int, int, int, int const *)
+	?do_vgDestroyImage@@YAXK@Z @ 44  NONAME ; void do_vgDestroyImage(unsigned long)
+	?do_vgDestroyFont@@YAXK@Z @ 45  NONAME ; void do_vgDestroyFont(unsigned long)
+	?do_vgReadPixels@@YAXPAXJW4VGImageFormat@@JJJJ@Z @ 46  NONAME ; void do_vgReadPixels(void *, long, enum VGImageFormat, long, long, long, long)
+	?do_vgDrawImage@@YAXK@Z @ 47  NONAME ; void do_vgDrawImage(unsigned long)
+	?do_eglGetCurrentContext@@YAHXZ @ 48  NONAME ; int do_eglGetCurrentContext(void)
+	?do_vgSetGlyphToImage@@YAXKKKQBM0@Z @ 49  NONAME ; void do_vgSetGlyphToImage(unsigned long, unsigned long, unsigned long, float const * const, float const * const)
+	?do_eglGetDisplay@@YAHH@Z @ 50  NONAME ; int do_eglGetDisplay(int)
+	?do_vgDestroyPaint@@YAXK@Z @ 51  NONAME ; void do_vgDestroyPaint(unsigned long)
+	?do_vguPolygon@@YA?AW4VGUErrorCode@@KPBMJW4VGboolean@@@Z @ 52  NONAME ; enum VGUErrorCode do_vguPolygon(unsigned long, float const *, long, enum VGboolean)
+	?do_vgGeti@@YAJW4VGParamType@@@Z @ 53  NONAME ; long do_vgGeti(enum VGParamType)
+	?do_vgCopyPixels@@YAXJJJJJJ@Z @ 54  NONAME ; void do_vgCopyPixels(long, long, long, long, long, long)
+	?do_eglDestroyContext@@YAHHH@Z @ 55  NONAME ; int do_eglDestroyContext(int, int)
+	?do_eglReleaseTexImage@@YAHHHH@Z @ 56  NONAME ; int do_eglReleaseTexImage(int, int, int)
+	?do_vgPathBounds@@YAXKPAM000@Z @ 57  NONAME ; void do_vgPathBounds(unsigned long, float *, float *, float *, float *)
+	?do_vgSeti@@YAXW4VGParamType@@J@Z @ 58  NONAME ; void do_vgSeti(enum VGParamType, long)
+	?do_vgMask@@YAXKW4VGMaskOperation@@JJJJ@Z @ 59  NONAME ; void do_vgMask(unsigned long, enum VGMaskOperation, long, long, long, long)
+	?do_vgGetPixels@@YAXKJJJJJJ@Z @ 60  NONAME ; void do_vgGetPixels(unsigned long, long, long, long, long, long, long)
+	?do_vgGetParameterf@@YAMKJ@Z @ 61  NONAME ; float do_vgGetParameterf(unsigned long, long)
+	?do_vgDrawGlyphs@@YAXKJPBKPBM1KW4VGboolean@@@Z @ 62  NONAME ; void do_vgDrawGlyphs(unsigned long, long, unsigned long const *, float const *, float const *, unsigned long, enum VGboolean)
+	?do_vgTransformPath@@YAXKK@Z @ 63  NONAME ; void do_vgTransformPath(unsigned long, unsigned long)
+	?do_eglQueryAPI@@YAHXZ @ 64  NONAME ; int do_eglQueryAPI(void)
+	?do_vguEllipse@@YA?AW4VGUErrorCode@@KMMMM@Z @ 65  NONAME ; enum VGUErrorCode do_vguEllipse(unsigned long, float, float, float, float)
+	?do_vgLoadIdentity@@YAXXZ @ 66  NONAME ; void do_vgLoadIdentity(void)
+	?do_vgLookupSingle@@YAXKKPBKW4VGImageChannel@@W4VGboolean@@2@Z @ 67  NONAME ; void do_vgLookupSingle(unsigned long, unsigned long, unsigned long const *, enum VGImageChannel, enum VGboolean, enum VGboolean)
+	?do_eglChooseConfig@@YAHHPBHPAHH1@Z @ 68  NONAME ; int do_eglChooseConfig(int, int const *, int *, int, int *)
+	?do_vgRotate@@YAXM@Z @ 69  NONAME ; void do_vgRotate(float)
+	?do_vgInterpolatePath@@YA?AW4VGboolean@@KKKM@Z @ 70  NONAME ; enum VGboolean do_vgInterpolatePath(unsigned long, unsigned long, unsigned long, float)
+	?do_vgAppendPath@@YAXKK@Z @ 71  NONAME ; void do_vgAppendPath(unsigned long, unsigned long)
+	?do_vgPathLength@@YAMKJJ@Z @ 72  NONAME ; float do_vgPathLength(unsigned long, long, long)
+	?do_eglMakeCurrent@@YAHHHHH@Z @ 73  NONAME ; int do_eglMakeCurrent(int, int, int, int)
+	?do_vguArc@@YA?AW4VGUErrorCode@@KMMMMMMW4VGUArcType@@@Z @ 74  NONAME ; enum VGUErrorCode do_vguArc(unsigned long, float, float, float, float, float, float, enum VGUArcType)
+	?do_vgScale@@YAXMM@Z @ 75  NONAME ; void do_vgScale(float, float)
+	?do_vgCopyImage@@YAXKJJKJJJJW4VGboolean@@@Z @ 76  NONAME ; void do_vgCopyImage(unsigned long, long, long, unsigned long, long, long, long, long, enum VGboolean)
+	?do_vgGetParameteriv@@YAXKJJPAJ@Z @ 77  NONAME ; void do_vgGetParameteriv(unsigned long, long, long, long *)
+	?do_eglQuerySurface@@YAHHHHPAH@Z @ 78  NONAME ; int do_eglQuerySurface(int, int, int, int *)
+	?do_vguRect@@YA?AW4VGUErrorCode@@KMMMM@Z @ 79  NONAME ; enum VGUErrorCode do_vguRect(unsigned long, float, float, float, float)
+	?do_eglCreatePbufferSurface@@YAHHHPBH@Z @ 80  NONAME ; int do_eglCreatePbufferSurface(int, int, int const *)
+	?do_vgChildImage@@YAKKJJJJ@Z @ 81  NONAME ; unsigned long do_vgChildImage(unsigned long, long, long, long, long)
+	?do_vguComputeWarpQuadToQuad@@YA?AW4VGUErrorCode@@MMMMMMMMMMMMMMMMPAM@Z @ 82  NONAME ; enum VGUErrorCode do_vguComputeWarpQuadToQuad(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float *)
+	?do_eglGetConfigAttrib@@YAHHHHPAH@Z @ 83  NONAME ; int do_eglGetConfigAttrib(int, int, int, int *)
+	?do_vgGetParent@@YAKK@Z @ 84  NONAME ; unsigned long do_vgGetParent(unsigned long)
+	?do_eglSurfaceAttrib@@YAHHHHH@Z @ 85  NONAME ; int do_eglSurfaceAttrib(int, int, int, int)
+	?do_vguComputeWarpSquareToQuad@@YA?AW4VGUErrorCode@@MMMMMMMMPAM@Z @ 86  NONAME ; enum VGUErrorCode do_vguComputeWarpSquareToQuad(float, float, float, float, float, float, float, float, float *)
+	?do_eglGetProcAddress@@YAP6AXZZPBD@Z @ 87  NONAME ; void (*)(...) do_eglGetProcAddress(char const *)
+	?do_eglDestroySurface@@YAHHH@Z @ 88  NONAME ; int do_eglDestroySurface(int, int)
+	?do_vgGetString@@YAPBEW4VGStringID@@@Z @ 89  NONAME ; unsigned char const * do_vgGetString(enum VGStringID)
+	?do_vguLine@@YA?AW4VGUErrorCode@@KMMMM@Z @ 90  NONAME ; enum VGUErrorCode do_vguLine(unsigned long, float, float, float, float)
+	?do_vgRemovePathCapabilities@@YAXKK@Z @ 91  NONAME ; void do_vgRemovePathCapabilities(unsigned long, unsigned long)
+	?do_vgMultMatrix@@YAXPBM@Z @ 92  NONAME ; void do_vgMultMatrix(float const *)
+	?do_vgGetParameteri@@YAJKJ@Z @ 93  NONAME ; long do_vgGetParameteri(unsigned long, long)
+	?do_eglGetCurrentSurface@@YAHH@Z @ 94  NONAME ; int do_eglGetCurrentSurface(int)
+	?do_eglBindTexImage@@YAHHHH@Z @ 95  NONAME ; int do_eglBindTexImage(int, int, int)
+	?do_vgModifyPathCoords@@YAXKJJPBX@Z @ 96  NONAME ; void do_vgModifyPathCoords(unsigned long, long, long, void const *)
+	?do_vgSetParameterfv@@YAXKJJPBM@Z @ 97  NONAME ; void do_vgSetParameterfv(unsigned long, long, long, float const *)
+	?do_vgDrawPath@@YAXKK@Z @ 98  NONAME ; void do_vgDrawPath(unsigned long, unsigned long)
+	?do_vgGaussianBlur@@YAXKKMMW4VGTilingMode@@@Z @ 99  NONAME ; void do_vgGaussianBlur(unsigned long, unsigned long, float, float, enum VGTilingMode)
+	?do_vgGetError@@YA?AW4VGErrorCode@@XZ @ 100  NONAME ; enum VGErrorCode do_vgGetError(void)
+	?do_vgFillMaskLayer@@YAXKJJJJM@Z @ 101  NONAME ; void do_vgFillMaskLayer(unsigned long, long, long, long, long, float)
+	?do_eglCopyBuffers@@YAHHHPAX@Z @ 102  NONAME ; int do_eglCopyBuffers(int, int, void *)
+	?do_vgClear@@YAXJJJJ@Z @ 103  NONAME ; void do_vgClear(long, long, long, long)
+	?do_vgSetParameteri@@YAXKJJ@Z @ 104  NONAME ; void do_vgSetParameteri(unsigned long, long, long)
+	?do_vgSetGlyphToPath@@YAXKKKW4VGboolean@@QBM1@Z @ 105  NONAME ; void do_vgSetGlyphToPath(unsigned long, unsigned long, unsigned long, enum VGboolean, float const * const, float const * const)
+	?do_vgCreateFont@@YAKJ@Z @ 106  NONAME ; unsigned long do_vgCreateFont(long)
+	?do_eglSwapInterval@@YAHHH@Z @ 107  NONAME ; int do_eglSwapInterval(int, int)
+	?do_vgClearGlyph@@YAXKK@Z @ 108  NONAME ; void do_vgClearGlyph(unsigned long, unsigned long)
+	?do_eglBindAPI@@YAHH@Z @ 109  NONAME ; int do_eglBindAPI(int)
+	?do_vgAppendPathData@@YAXKJPBEPBX@Z @ 110  NONAME ; void do_vgAppendPathData(unsigned long, long, unsigned char const *, void const *)
+	?do_vgClearPath@@YAXKK@Z @ 111  NONAME ; void do_vgClearPath(unsigned long, unsigned long)
+	?do_vgGetParameterVectorSize@@YAJKJ@Z @ 112  NONAME ; long do_vgGetParameterVectorSize(unsigned long, long)
+	?do_eglGetCurrentDisplay@@YAHXZ @ 113  NONAME ; int do_eglGetCurrentDisplay(void)
+	?do_vgSetf@@YAXW4VGParamType@@M@Z @ 114  NONAME ; void do_vgSetf(enum VGParamType, float)
+	?do_vguRoundRect@@YA?AW4VGUErrorCode@@KMMMMMM@Z @ 115  NONAME ; enum VGUErrorCode do_vguRoundRect(unsigned long, float, float, float, float, float, float)
+	?do_vgTranslate@@YAXMM@Z @ 116  NONAME ; void do_vgTranslate(float, float)
+	?do_eglWaitClient@@YAHXZ @ 117  NONAME ; int do_eglWaitClient(void)
+	?do_vgGetf@@YAMW4VGParamType@@@Z @ 118  NONAME ; float do_vgGetf(enum VGParamType)
+	?do_vgCreateImage@@YAKW4VGImageFormat@@JJK@Z @ 119  NONAME ; unsigned long do_vgCreateImage(enum VGImageFormat, long, long, unsigned long)
+	?do_eglQueryString@@YAPBDHH@Z @ 120  NONAME ; char const * do_eglQueryString(int, int)
+	?do_vgCreatePaint@@YAKXZ @ 121  NONAME ; unsigned long do_vgCreatePaint(void)
+	?do_eglGetError@@YAHXZ @ 122  NONAME ; int do_eglGetError(void)
+	?do_vgLoadMatrix@@YAXPBM@Z @ 123  NONAME ; void do_vgLoadMatrix(float const *)
+	?do_eglTerminate@@YAHH@Z @ 124  NONAME ; int do_eglTerminate(int)
+	?do_eglReleaseThread@@YAHXZ @ 125  NONAME ; int do_eglReleaseThread(void)
+	?do_vgPaintPattern@@YAXKK@Z @ 126  NONAME ; void do_vgPaintPattern(unsigned long, unsigned long)
+	?do_vgSetiv@@YAXW4VGParamType@@JPBJ@Z @ 127  NONAME ; void do_vgSetiv(enum VGParamType, long, long const *)
+	?do_vgRenderToMask@@YAXKKW4VGMaskOperation@@@Z @ 128  NONAME ; void do_vgRenderToMask(unsigned long, unsigned long, enum VGMaskOperation)
+	?do_vgCreateMaskLayer@@YAKJJ@Z @ 129  NONAME ; unsigned long do_vgCreateMaskLayer(long, long)
+	?do_eglGetConfigs@@YAHHPAHH0@Z @ 130  NONAME ; int do_eglGetConfigs(int, int *, int, int *)
+	_E32Dll=__E32Dll	; Entry point for emulation
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/openvg/openvgrefimplementation/sfopenvg/eabi/libvgiu.def	Fri Apr 30 17:15:32 2010 +0100
@@ -0,0 +1,15 @@
+EXPORTS
+   	VGIInitialize @ 1 NONAME
+   	VGICopyToTarget @ 2 NONAME
+   	VGITerminate @ 3 NONAME
+   	VGIResize @ 4 NONAME
+	VGIBindToImage @ 5 NONAME
+	VGIUnBindImage @ 6 NONAME
+	_Z16VGISymbianResize5TSize @ 7 NONAME
+	_Z19VGISymbianTerminatev @ 8 NONAME
+	_Z20VGISymbianInitialize5TSize13VGIColorSpace @ 9 NONAME
+	_Z22VGISymbianCopyToBitmapP10CFbsBitmapS0_19VGICopyToTargetHint @ 10 NONAME
+	_Z21VGISymbianBindToImagem @ 11 NONAME
+	_Z21VGISymbianUnBindImagev @ 12 NONAME
+	VGIInitializeEx @ 13  NONAME
+	_Z22VGISymbianInitializeEx5TSize13VGIColorSpaceii @ 14  NONAME

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/openvg/openvgrefimplementation/sfopenvg/eabi/sflibopenvgrefimplu.def	Fri Apr 30 17:15:32 2010 +0100
@@ -0,0 +1,132 @@
+EXPORTS
+	_Z10do_vgClearllll @ 1 NONAME
+	_Z10do_vgFlushv @ 2 NONAME
+	_Z10do_vgGetfv11VGParamTypelPf @ 3 NONAME
+	_Z10do_vgGetiv11VGParamTypelPl @ 4 NONAME
+	_Z10do_vgScaleff @ 5 NONAME
+	_Z10do_vgSetfv11VGParamTypelPKf @ 6 NONAME
+	_Z10do_vgSetiv11VGParamTypelPKl @ 7 NONAME
+	_Z10do_vgShearff @ 8 NONAME
+	_Z10do_vguLinemffff @ 9 NONAME
+	_Z10do_vguRectmffff @ 10 NONAME
+	_Z11do_vgFinishv @ 11 NONAME
+	_Z11do_vgLookupmmPKhS0_S0_S0_9VGbooleanS1_ @ 12 NONAME
+	_Z11do_vgRotatef @ 13 NONAME
+	_Z12do_eglWaitGLv @ 14 NONAME
+	_Z13do_eglBindAPIi @ 15 NONAME
+	_Z13do_vgConvolvemmllllPKsff12VGTilingMode @ 16 NONAME
+	_Z13do_vgCopyMaskmllllll @ 17 NONAME
+	_Z13do_vgDrawPathmm @ 18 NONAME
+	_Z13do_vgGetColorm @ 19 NONAME
+	_Z13do_vgGetErrorv @ 20 NONAME
+	_Z13do_vgGetPaint11VGPaintMode @ 21 NONAME
+	_Z13do_vgSetColormm @ 22 NONAME
+	_Z13do_vgSetPaintmm @ 23 NONAME
+	_Z13do_vguEllipsemffff @ 24 NONAME
+	_Z13do_vguPolygonmPKfl9VGboolean @ 25 NONAME
+	_Z14do_eglGetErrorv @ 26 NONAME
+	_Z14do_eglQueryAPIv @ 27 NONAME
+	_Z14do_vgClearPathmm @ 28 NONAME
+	_Z14do_vgCopyImagemllmllll9VGboolean @ 29 NONAME
+	_Z14do_vgDrawGlyphmmm9VGboolean @ 30 NONAME
+	_Z14do_vgDrawImagem @ 31 NONAME
+	_Z14do_vgGetMatrixPf @ 32 NONAME
+	_Z14do_vgGetParentm @ 33 NONAME
+	_Z14do_vgGetPixelsmllllll @ 34 NONAME
+	_Z14do_vgGetString10VGStringID @ 35 NONAME
+	_Z14do_vgSetPixelsllmllll @ 36 NONAME
+	_Z14do_vgTranslateff @ 37 NONAME
+	_Z15do_eglTerminatei @ 38 NONAME
+	_Z15do_vgAppendPathmm @ 39 NONAME
+	_Z15do_vgChildImagemllll @ 40 NONAME
+	_Z15do_vgClearGlyphmm @ 41 NONAME
+	_Z15do_vgClearImagemllll @ 42 NONAME
+	_Z15do_vgCopyPixelsllllll @ 43 NONAME
+	_Z15do_vgCreateFontl @ 44 NONAME
+	_Z15do_vgCreatePathl14VGPathDatatypeffllm @ 45 NONAME
+	_Z15do_vgDrawGlyphsmlPKmPKfS2_m9VGboolean @ 46 NONAME
+	_Z15do_vgLoadMatrixPKf @ 47 NONAME
+	_Z15do_vgMultMatrixPKf @ 48 NONAME
+	_Z15do_vgPathBoundsmPfS_S_S_ @ 49 NONAME
+	_Z15do_vgPathLengthmll @ 50 NONAME
+	_Z15do_vgReadPixelsPvl13VGImageFormatllll @ 51 NONAME
+	_Z15do_vguRoundRectmffffff @ 52 NONAME
+	_Z16do_eglGetConfigsiPiiS_ @ 53 NONAME
+	_Z16do_eglGetDisplayi @ 54 NONAME
+	_Z16do_eglInitializeiPiS_ @ 55 NONAME
+	_Z16do_eglWaitClientv @ 56 NONAME
+	_Z16do_eglWaitNativei @ 57 NONAME
+	_Z16do_vgColorMatrixmmPKf @ 58 NONAME
+	_Z16do_vgCreateImage13VGImageFormatllm @ 59 NONAME
+	_Z16do_vgCreatePaintv @ 60 NONAME
+	_Z16do_vgDestroyFontm @ 61 NONAME
+	_Z16do_vgDestroyPathm @ 62 NONAME
+	_Z16do_vgWritePixelsPKvl13VGImageFormatllll @ 63 NONAME
+	_Z17do_eglCopyBuffersiiPv @ 64 NONAME
+	_Z17do_eglMakeCurrentiiii @ 65 NONAME
+	_Z17do_eglQueryStringii @ 66 NONAME
+	_Z17do_eglSwapBuffersii @ 67 NONAME
+	_Z17do_vgDestroyImagem @ 68 NONAME
+	_Z17do_vgDestroyPaintm @ 69 NONAME
+	_Z17do_vgGaussianBlurmmff12VGTilingMode @ 70 NONAME
+	_Z17do_vgImageSubDatamPKvl13VGImageFormatllll @ 71 NONAME
+	_Z17do_vgLoadIdentityv @ 72 NONAME
+	_Z17do_vgLookupSinglemmPKm14VGImageChannel9VGbooleanS2_ @ 73 NONAME
+	_Z17do_vgPaintPatternmm @ 74 NONAME
+	_Z17do_vgRenderToMaskmm15VGMaskOperation @ 75 NONAME
+	_Z18do_eglBindTexImageiii @ 76 NONAME
+	_Z18do_eglChooseConfigiPKiPiiS1_ @ 77 NONAME
+	_Z18do_eglQueryContextiiiPi @ 78 NONAME
+	_Z18do_eglQuerySurfaceiiiPi @ 79 NONAME
+	_Z18do_eglSwapIntervalii @ 80 NONAME
+	_Z18do_vgFillMaskLayermllllf @ 81 NONAME
+	_Z18do_vgGetParameterfml @ 82 NONAME
+	_Z18do_vgGetParameteriml @ 83 NONAME
+	_Z18do_vgGetVectorSize11VGParamType @ 84 NONAME
+	_Z18do_vgHardwareQuery19VGHardwareQueryTypel @ 85 NONAME
+	_Z18do_vgSetParameterfmlf @ 86 NONAME
+	_Z18do_vgSetParameterimll @ 87 NONAME
+	_Z18do_vgTransformPathmm @ 88 NONAME
+	_Z19do_eglCreateContextiiiPKi @ 89 NONAME
+	_Z19do_eglReleaseThreadv @ 90 NONAME
+	_Z19do_eglSurfaceAttribiiii @ 91 NONAME
+	_Z19do_vgAppendPathDatamlPKhPKv @ 92 NONAME
+	_Z19do_vgGetParameterfvmllPf @ 93 NONAME
+	_Z19do_vgGetParameterivmllPl @ 94 NONAME
+	_Z19do_vgPointAlongPathmllfPfS_S_S_ @ 95 NONAME
+	_Z19do_vgSetGlyphToPathmmm9VGbooleanPKfS1_ @ 96 NONAME
+	_Z19do_vgSetParameterfvmllPKf @ 97 NONAME
+	_Z19do_vgSetParameterivmllPKl @ 98 NONAME
+	_Z20do_eglDestroyContextii @ 99 NONAME
+	_Z20do_eglDestroySurfaceii @ 100 NONAME
+	_Z20do_eglGetProcAddressPKc @ 101 NONAME
+	_Z20do_vgCreateMaskLayerll @ 102 NONAME
+	_Z20do_vgGetImageSubDatamPvl13VGImageFormatllll @ 103 NONAME
+	_Z20do_vgInterpolatePathmmmf @ 104 NONAME
+	_Z20do_vgSetGlyphToImagemmmPKfS0_ @ 105 NONAME
+	_Z21do_eglGetConfigAttribiiiPi @ 106 NONAME
+	_Z21do_eglReleaseTexImageiii @ 107 NONAME
+	_Z21do_vgDestroyMaskLayerm @ 108 NONAME
+	_Z21do_vgModifyPathCoordsmllPKv @ 109 NONAME
+	_Z22do_vgSeparableConvolvemmllllPKsS0_ff12VGTilingMode @ 110 NONAME
+	_Z23do_eglGetCurrentContextv @ 111 NONAME
+	_Z23do_eglGetCurrentDisplayv @ 112 NONAME
+	_Z23do_eglGetCurrentSurfacei @ 113 NONAME
+	_Z24do_vgGetPathCapabilitiesm @ 114 NONAME
+	_Z25do_eglCreatePixmapSurfaceiiPvPKi @ 115 NONAME
+	_Z25do_eglCreateWindowSurfaceiiPvPKi @ 116 NONAME
+	_Z26do_eglCreatePbufferSurfaceiiPKi @ 117 NONAME
+	_Z26do_vgPathTransformedBoundsmPfS_S_S_ @ 118 NONAME
+	_Z27do_vgGetParameterVectorSizeml @ 119 NONAME
+	_Z27do_vgRemovePathCapabilitiesmm @ 120 NONAME
+	_Z27do_vguComputeWarpQuadToQuadffffffffffffffffPf @ 121 NONAME
+	_Z29do_vguComputeWarpQuadToSquareffffffffPf @ 122 NONAME
+	_Z29do_vguComputeWarpSquareToQuadffffffffPf @ 123 NONAME
+	_Z35do_eglCreatePbufferFromClientBufferiiiiPKi @ 124 NONAME
+	_Z9do_vgGetf11VGParamType @ 125 NONAME
+	_Z9do_vgGeti11VGParamType @ 126 NONAME
+	_Z9do_vgMaskm15VGMaskOperationllll @ 127 NONAME
+	_Z9do_vgSetf11VGParamTypef @ 128 NONAME
+	_Z9do_vgSeti11VGParamTypel @ 129 NONAME
+	_Z9do_vguArcmffffff10VGUArcType @ 130 NONAME
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/openvg/openvgrefimplementation/sfopenvg/egl/egl.cpp	Fri Apr 30 17:15:32 2010 +0100
@@ -0,0 +1,164 @@
+/*
+* Copyright (c) 2009 Symbian Foundation Ltd
+* This component and the accompanying materials are made available
+* under the terms of the License "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:
+* Symbian Foundation Ltd - initial contribution.
+* 
+* Contributors:
+*
+* Description:
+* Implementation of EGL interface
+*/
+
+#include <egl.h>
+#include "eglinternal.h"
+#include <stdarg.h>
+
+
+extern "C" {
+
+EXPORT_C EGLint eglGetError(void)
+	{
+	return do_eglGetError();
+	}
+EXPORT_C EGLDisplay eglGetDisplay(EGLNativeDisplayType display_id)
+	{
+	return do_eglGetDisplay(display_id);
+	}
+EXPORT_C EGLBoolean eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
+	{
+	return do_eglInitialize(dpy, major, minor);
+	}
+EXPORT_C EGLBoolean eglTerminate(EGLDisplay dpy)
+	{
+	return do_eglTerminate(dpy);
+	}
+EXPORT_C const char* eglQueryString(EGLDisplay dpy, EGLint name)
+	{
+	return do_eglQueryString(dpy, name);
+	}
+EXPORT_C EGLBoolean eglGetConfigs(EGLDisplay dpy, EGLConfig *configs,EGLint config_size, EGLint *num_config)
+	{
+	return do_eglGetConfigs(dpy, configs,config_size, num_config);
+	}
+EXPORT_C EGLBoolean eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list,EGLConfig *configs, EGLint config_size,EGLint *num_config)
+	{
+	return do_eglChooseConfig(dpy, attrib_list,configs, config_size,num_config);
+    }
+EXPORT_C EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config,EGLint attribute, EGLint *value)
+	{
+	return do_eglGetConfigAttrib(dpy, config,attribute, value);
+	}
+EXPORT_C EGLSurface eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config,EGLNativeWindowType win,const EGLint *attrib_list)
+	{
+	return do_eglCreateWindowSurface(dpy, config,win,attrib_list);
+	}
+EXPORT_C EGLSurface eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config,const EGLint *attrib_list)
+	{
+	return do_eglCreatePbufferSurface(dpy, config,attrib_list);
+	}
+EXPORT_C EGLSurface eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config,EGLNativePixmapType pixmap,const EGLint *attrib_list)
+	{
+	return do_eglCreatePixmapSurface(dpy, config,pixmap,attrib_list);
+	}
+EXPORT_C EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
+	{
+	return do_eglDestroySurface(dpy, surface);
+	}
+EXPORT_C EGLBoolean eglQuerySurface(EGLDisplay dpy, EGLSurface surface,EGLint attribute, EGLint *value)
+	{
+	return do_eglQuerySurface(dpy, surface,attribute, value);
+	}
+EXPORT_C EGLBoolean eglBindAPI(EGLenum api)
+	{
+	return do_eglBindAPI(api);
+	}
+EXPORT_C EGLenum eglQueryAPI(void)
+	{
+	return do_eglQueryAPI();
+	}
+EXPORT_C EGLBoolean eglWaitClient(void)
+	{
+	return do_eglWaitClient();
+	}
+EXPORT_C EGLBoolean eglReleaseThread(void)
+	{
+	return do_eglReleaseThread();
+	}
+EXPORT_C EGLSurface eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer,EGLConfig config, const EGLint *attrib_list)
+	{
+	return do_eglCreatePbufferFromClientBuffer(dpy, buftype, buffer,config, attrib_list);
+	}
+EXPORT_C EGLBoolean eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface,EGLint attribute, EGLint value)
+	{
+	return do_eglSurfaceAttrib(dpy, surface,attribute, value);
+	}
+EXPORT_C EGLBoolean eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
+	{
+	return do_eglBindTexImage(dpy, surface, buffer);
+	}
+EXPORT_C EGLBoolean eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
+	{
+	return do_eglReleaseTexImage(dpy, surface, buffer);
+	}
+EXPORT_C EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval)
+	{
+	return do_eglSwapInterval(dpy, interval);
+	}
+EXPORT_C EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config,EGLContext share_context,const EGLint *attrib_list)
+	{
+	return do_eglCreateContext(dpy, config,share_context,attrib_list);
+	}
+EXPORT_C EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
+	{
+	return do_eglDestroyContext(dpy, ctx);
+	}
+EXPORT_C EGLBoolean eglMakeCurrent(EGLDisplay dpy, EGLSurface draw,EGLSurface read, EGLContext ctx)
+	{
+	return do_eglMakeCurrent(dpy, draw,read, ctx);
+	}
+EXPORT_C EGLContext eglGetCurrentContext(void)
+	{
+	return do_eglGetCurrentContext();
+	}
+EXPORT_C EGLSurface eglGetCurrentSurface(EGLint readdraw)
+	{
+	return do_eglGetCurrentSurface(readdraw);
+	}
+EXPORT_C EGLDisplay eglGetCurrentDisplay(void)
+	{
+	return do_eglGetCurrentDisplay();
+	}
+EXPORT_C EGLBoolean eglQueryContext(EGLDisplay dpy, EGLContext ctx,EGLint attribute, EGLint *value)
+	{
+	return do_eglQueryContext(dpy, ctx,attribute, value);
+	}
+EXPORT_C EGLBoolean eglWaitGL(void)
+	{
+	return do_eglWaitGL();
+	}
+EXPORT_C EGLBoolean eglWaitNative(EGLint engine)
+	{
+	return do_eglWaitNative(engine);
+	}
+EXPORT_C EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)
+	{
+	return do_eglSwapBuffers(dpy, surface);
+	}
+EXPORT_C EGLBoolean eglCopyBuffers(EGLDisplay dpy, EGLSurface surface,EGLNativePixmapType target)
+	{
+	return do_eglCopyBuffers(dpy, surface,target);
+	}
+
+typedef void (*eglfPtr)(...);
+EXPORT_C void (*eglGetProcAddress(const char *procname))(...)
+	{
+    eglfPtr pname = do_eglGetProcAddress(procname);
+    return pname;
+	}
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/openvg/openvgrefimplementation/sfopenvg/group/bld.inf	Fri Apr 30 17:15:32 2010 +0100
@@ -0,0 +1,36 @@
+/*
+* Copyright (c) 2009 Symbian Foundation Ltd
+* This component and the accompanying materials are made available
+* under the terms of the License "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:
+* Symbian Foundation Ltd - initial contribution.
+* 
+* Contributors:
+*
+* Description:
+* top level bld.inf for building reference openvg
+*/
+
+PRJ_PLATFORMS
+DEFAULT	
+
+
+PRJ_EXPORTS
+../sfopenvg/symbian/eglosnativewindowtype.h
+sfopenvg.iby /epoc32/rom/include/sfopenvg.iby
+
+PRJ_MMPFILES
+openvg.mmp
+openvgu.mmp
+egl.mmp
+vgi.mmp
+sfopenvg.mmp
+
+// PRJ_TESTMMPFILES
+#include "..\test\group\bld.inf"
+
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/openvg/openvgrefimplementation/sfopenvg/group/egl.mmp	Fri Apr 30 17:15:32 2010 +0100
@@ -0,0 +1,50 @@
+/*
+* Copyright (c) 2009 Symbian Foundation Ltd
+* This component and the accompanying materials are made available
+* under the terms of the License "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:
+* Symbian Foundation Ltd - initial contribution.
+* 
+* Contributors:
+*
+* Description:
+* egl mmp file
+*/
+
+#include <egl\egluids.hrh> // For uids
+
+target          libEGL_sw.dll 		// Destination filename
+
+targettype      dll				// Binary build type
+uid             KUidSharedDllUidValue KUidEGLDllUidValue		// File uids
+VENDORID 0x70000001
+CAPABILITY	ALL -tcb
+//noexportlibrary
+
+userinclude     ..\sfopenvg\include //for internal egl functions e.g. do_eglXXX
+
+OS_LAYER_SYSTEMINCLUDE
+OS_LAYER_LIBC_SYSTEMINCLUDE
+SYSTEMINCLUDE  OS_LAYER_PUBLIC_EXPORT_PATH(egl) // EGL include files
+
+
+
+sourcepath      ..\egl		// Relative path to source files
+
+
+source          egl.cpp
+
+
+library         euser.lib     		// Mandatory
+library			sflibopenvgrefimpl.lib
+
+
+#ifdef WINS
+DEFFILE         \epoc32\include\def\win32\libegl13.def	// WINS/WINSCW def file
+#else
+DEFFILE         \epoc32\include\def\eabi\libegl13.def	// ARM def file
+#endif // WINS
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/openvg/openvgrefimplementation/sfopenvg/group/openvg.mmp	Fri Apr 30 17:15:32 2010 +0100
@@ -0,0 +1,50 @@
+/*
+* Copyright (c) 2009 Symbian Foundation Ltd
+* This component and the accompanying materials are made available
+* under the terms of the License "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:
+* Symbian Foundation Ltd - initial contribution.
+* 
+* Contributors:
+*
+* Description:
+* openvg mmp file
+*/
+#include <vg\openvguids.hrh> // For uids
+
+target          libopenvg_sw.dll		// Destination filename
+
+targettype      dll				// Binary build type
+uid             KUidSharedDllUidValue KUidOpenVGDllUidValue		// File uids
+CAPABILITY      ALL -tcb
+vendorid        0x70000001
+
+//noexportlibrary
+
+MACRO       __OPENVGHEADERS_USE_VG_1_1
+
+userinclude     ..\sfopenvg\include //for internal openvg functions e.g. do_vgXXX
+
+OS_LAYER_SYSTEMINCLUDE
+OS_LAYER_LIBC_SYSTEMINCLUDE
+SYSTEMINCLUDE  OS_LAYER_PUBLIC_EXPORT_PATH(vg) // EGL include files
+
+
+sourcepath      ..\openvg		// Relative path to source files
+
+source openvg.cpp
+
+library         euser.lib     		// Mandatory
+library			sflibopenvgrefimpl.lib
+
+#ifdef WINS
+DEFFILE         \epoc32\include\def\win32\libopenvg11.def	// WINS/WINSCW def file
+#else
+DEFFILE         \epoc32\include\def\eabi\libopenvg11.def	// ARM def file
+#endif // WINS
+
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/openvg/openvgrefimplementation/sfopenvg/group/openvgu.mmp	Fri Apr 30 17:15:32 2010 +0100
@@ -0,0 +1,44 @@
+/*
+* Copyright (c) 2009 Symbian Foundation Ltd
+* This component and the accompanying materials are made available
+* under the terms of the License "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:
+* Symbian Foundation Ltd - initial contribution.
+* 
+* Contributors:
+*
+* Description:
+* openvgu mmp file
+*/
+#include <vg\openvguids.hrh> // For uids
+
+target          libopenvgu_sw.dll		// Destination filename
+targettype      dll				// Binary build type
+uid             KUidSharedDllUidValue KUidVGUDllUidValue		// File uids
+CAPABILITY      CAP_GENERAL_DLL
+vendorid        0x70000001
+//noexportlibrary
+
+userinclude     ..\sfopenvg\include //for internal egl functions e.g. do_eglXXX
+
+OS_LAYER_SYSTEMINCLUDE
+SYSTEMINCLUDE  OS_LAYER_PUBLIC_EXPORT_PATH(vg) // EGL include files
+
+macro __OPENVGHEADERS_USE_VG_1_1
+
+sourcepath      ..\openvgu		// Relative path to source files
+
+source          vgu.cpp
+
+library         euser.lib     		// Mandatory
+library			sflibopenvgrefimpl.lib
+
+#ifdef WINS
+DEFFILE         \epoc32\include\def\win32\libopenvgu11.def	// WINS/WINSCW def file
+#else
+DEFFILE         \epoc32\include\def\eabi\libopenvgu11.def	// ARM def file
+#endif // WINS
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/openvg/openvgrefimplementation/sfopenvg/group/sfopenvg.iby	Fri Apr 30 17:15:32 2010 +0100
@@ -0,0 +1,28 @@
+/*
+* Copyright (c) 2009 Symbian Foundation Ltd
+* This component and the accompanying materials are made available
+* under the terms of the License "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:
+* Symbian Foundation Ltd - initial contribution.
+* 
+* Contributors:
+*
+* Description:  
+* Component IBY file for the SF OpenVG reference implementation.
+*/
+
+#ifndef __SFOPENVG_IBY__
+#define __SFOPENVG_IBY__
+
+file=ABI_DIR\BUILD_DIR\libopenvg.dll           sys\bin\libopenvg.dll
+file=ABI_DIR\BUILD_DIR\libopenvgu.dll          sys\bin\libopenvgu.dll
+file=ABI_DIR\BUILD_DIR\libEGL.dll              sys\bin\libegl.dll
+file=ABI_DIR\BUILD_DIR\sflibopenvgrefimpl.dll  sys\bin\sflibopenvgrefimpl.dll
+
+// VGI included from elsewhere
+// file=ABI_DIR\BUILD_DIR\libvgi.dll              sys\bin\libvgi.dll
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/openvg/openvgrefimplementation/sfopenvg/group/sfopenvg.mmp	Fri Apr 30 17:15:32 2010 +0100
@@ -0,0 +1,83 @@
+/*
+* Copyright (c) 2009 Symbian Foundation Ltd
+* This component and the accompanying materials are made available
+* under the terms of the License "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:
+* Symbian Foundation Ltd - initial contribution.
+* 
+* Contributors:
+*
+* Description:
+* sfopenvg mmp file
+*/
+#include <vg\openvguids.hrh> // For uids
+
+target          sflibopenvgrefimpl.dll		// Destination filename
+
+targettype      dll				// Binary build type
+uid             KUidSharedDllUidValue 0x10281CA6		// File uids
+CAPABILITY      ALL -tcb
+vendorid        0x70000001
+
+
+MACRO       __OPENVGHEADERS_USE_VG_1_1
+
+MACRO 			USE_NEW_ELEAVE //swictch on to use new(ELeave) rather new in alloc's
+					 		   //useful to trap OOM failures
+MACRO  		BUILD_WITH_PRIVATE_EGL //enable this to compile this dll exporting the private form of the EGL functions.
+								   //These are the ones starting do_XX (e.g. do_eglInitialize).
+								   //This should be enabled when you wish to have a separate EGL library (e.g. libegl.dll)
+								   //which will export the ELG APIs.
+								   //If this macro is supressed then this dll will export the true EGL APIs
+								   //see riMiniEgl.cpp
+MACRO 		BUILD_WITH_PRIVATE_VGU //same meaning as macro BUILD_WITH_PRIVATE_EGL except applies to the VGU API.
+								   //see riVGU.cpp
+
+MACRO 		BUILD_WITH_PRIVATE_OPENVG //same meaning as macro BUILD_WITH_PRIVATE_EGL except applies to the OpenVG API.
+								   //see riAPI.cpp
+								   
+userinclude     ..\sfopenvg			// Local include files
+userinclude     ..\sfopenvg\include			// Local include files
+
+OS_LAYER_SYSTEMINCLUDE
+OS_LAYER_LIBC_SYSTEMINCLUDE
+OS_LAYER_STDCPP_SYSTEMINCLUDE
+
+SYSTEMINCLUDE  OS_LAYER_PUBLIC_EXPORT_PATH(vg) // OpenGL ES include files
+SYSTEMINCLUDE  OS_LAYER_PUBLIC_EXPORT_PATH(egl) // EGL include files
+
+
+
+sourcepath      ..\sfopenvg		// Relative path to source files
+
+source riApi.cpp
+source riContext.cpp
+source riFont.cpp
+source riImage.cpp
+source riMath.cpp
+source riMiniEGL.cpp
+source riPath.cpp
+source riPixelPipe.cpp
+source riRasterizer.cpp
+source riVGU.cpp
+
+//for EGL
+SOURCEPATH ..\sfopenvg\symbian
+SOURCE riEGLOS.cpp
+
+library			    libopenvg_sw.lib
+library         euser.lib     		// Mandatory
+library         fbscli.lib    		// For CFbsBitmap, etc
+library         bitgdi.lib    		// For CFbsBitmapDevice, CFbsBitGc, etc
+library         ws32.lib      		// For RWindow, Direct Screen Access, etc
+library         libstdcpp.lib      		// standard lib
+library         libc.lib      		// standard lib
+library         libm.lib      		// standard lib
+
+
+
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/openvg/openvgrefimplementation/sfopenvg/group/vgi.mmp	Fri Apr 30 17:15:32 2010 +0100
@@ -0,0 +1,40 @@
+/*
+* Copyright (c) 2009 Symbian Foundation Ltd
+* This component and the accompanying materials are made available
+* under the terms of the License "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:
+* Symbian Foundation Ltd - initial contribution.
+* 
+* Contributors:
+*
+* Description:
+* vgi mmp file
+*/
+#include <egl\egluids.hrh> // For UID2 uid
+
+target          libvgi.dll		// Destination filename
+targettype      dll				// Binary build type
+//uid             KUidSharedDllUidValue KUidVGUDllUidValue		// File uids
+uid               0x1000008D            0x0ede0f2d 
+CAPABILITY      all -tcb
+vendorid        0x70000001
+
+
+OS_LAYER_SYSTEMINCLUDE
+SYSTEMINCLUDE  OS_LAYER_PUBLIC_EXPORT_PATH(vg) // OpenGL ES include files
+SYSTEMINCLUDE  OS_LAYER_PUBLIC_EXPORT_PATH(egl) // EGL include files
+
+macro __OPENVGHEADERS_USE_VG_1_1
+
+sourcepath      ..\vgi		// Relative path to source files
+
+source          vgi.cpp
+
+library         euser.lib     		// Mandatory
+library			libegl_sw.lib
+library			fbscli.lib
+
+deffile         libvgi.def

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/openvg/openvgrefimplementation/sfopenvg/openvg/openvg.cpp	Fri Apr 30 17:15:32 2010 +0100
@@ -0,0 +1,456 @@
+/*
+* Copyright (c) 2009 Symbian Foundation Ltd
+* This component and the accompanying materials are made available
+* under the terms of the License "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:
+* Symbian Foundation Ltd - initial contribution.
+* 
+* Contributors:
+*
+* Description:
+* Implementation of OpenVG interface
+*/
+#include <openvg.h>
+#include "openvginternal.h"
+
+extern "C" {
+
+EXPORT_C VGErrorCode   vgGetError(void)
+   {
+   return do_vgGetError();
+   }
+
+EXPORT_C void   vgFlush(void)
+   {
+   return do_vgFlush();
+   }
+
+EXPORT_C void   vgFinish(void)
+   {
+   return do_vgFinish();
+   }
+
+EXPORT_C void  vgSetf (VGParamType type, VGfloat value)
+   {
+   return do_vgSetf(type,value);
+   }
+
+EXPORT_C void   vgSeti (VGParamType type, VGint value)
+   {
+   return do_vgSeti(type,value);
+   }
+
+EXPORT_C void   vgSetfv(VGParamType type, VGint count ,const VGfloat* values)
+   {
+   return do_vgSetfv(type,count,values);
+   }
+
+EXPORT_C void   vgSetiv(VGParamType type, VGint count ,const VGint* values)
+   {
+   return do_vgSetiv(type,count,values);
+   }
+
+EXPORT_C VGfloat   vgGetf(VGParamType type)
+   {
+   return do_vgGetf(type);
+   }
+
+EXPORT_C VGint     vgGeti(VGParamType type)
+   {
+   return do_vgGeti(type);
+   }
+
+EXPORT_C VGint     vgGetVectorSize(VGParamType type)
+   {
+   return do_vgGetVectorSize(type);
+   }
+
+EXPORT_C void      vgGetfv(VGParamType type, VGint count ,VGfloat* values)
+   {
+   return do_vgGetfv(type,count,values);
+   }
+
+EXPORT_C void      vgGetiv(VGParamType type, VGint count ,VGint* values)
+   {
+   return do_vgGetiv(type,count,values);
+   }
+
+EXPORT_C void   vgSetParameterf(VGHandle object ,VGint paramType ,VGfloat value)
+   {
+   return do_vgSetParameterf(object,paramType,value);
+   }
+
+EXPORT_C void   vgSetParameteri(VGHandle object ,VGint paramType ,VGint value)
+   {
+   return do_vgSetParameteri(object,paramType,value);
+   }
+
+EXPORT_C void   vgSetParameterfv(VGHandle object ,VGint paramType ,VGint count ,const VGfloat* values)
+   {
+   return do_vgSetParameterfv(object,paramType,count,values);
+   }
+
+EXPORT_C void   vgSetParameteriv(VGHandle object ,VGint paramType ,VGint count ,const VGint* values)
+   {
+   return do_vgSetParameteriv(object,paramType,count,values);
+   }
+
+EXPORT_C VGfloat   vgGetParameterf(VGHandle object ,VGint paramType)
+   {
+   return do_vgGetParameterf(object,paramType);
+   }
+
+EXPORT_C VGint   vgGetParameteri(VGHandle object ,VGint paramType)
+   {
+   return do_vgGetParameteri(object,paramType);
+   }
+
+EXPORT_C VGint   vgGetParameterVectorSize(VGHandle object ,VGint paramType)
+   {
+   return do_vgGetParameterVectorSize(object,paramType);
+   }
+
+EXPORT_C void   vgGetParameterfv(VGHandle object ,VGint paramType ,VGint count ,VGfloat* values)
+   {
+   return do_vgGetParameterfv(object,paramType,count,values);
+   }
+
+EXPORT_C void   vgGetParameteriv(VGHandle object ,VGint paramType ,VGint count ,VGint* values)
+   {
+   return do_vgGetParameteriv(object,paramType,count,values);
+   }
+
+EXPORT_C void   vgLoadIdentity(void)
+   {
+   return do_vgLoadIdentity();
+   }
+
+EXPORT_C void   vgLoadMatrix(const VGfloat* m)
+   {
+   return do_vgLoadMatrix(m);
+   }
+
+EXPORT_C void   vgGetMatrix(VGfloat* m)
+   {
+   return do_vgGetMatrix(m);
+   }
+
+EXPORT_C void   vgMultMatrix(const  VGfloat* m)
+   {
+   return do_vgMultMatrix(m);
+   }
+
+EXPORT_C void   vgTranslate(VGfloat tx, VGfloat ty)
+   {
+   return do_vgTranslate(tx,ty);
+   }
+
+EXPORT_C void   vgScale(VGfloat sx, VGfloat sy)
+   {
+   return do_vgScale(sx,sy);
+   }
+
+EXPORT_C void   vgShear(VGfloat shx, VGfloat shy)
+   {
+   return do_vgShear(shx,shy);
+   }
+
+EXPORT_C void   vgRotate(VGfloat angle)
+   {
+   return do_vgRotate(angle);
+   }
+
+EXPORT_C void   vgMask(VGHandle mask, VGMaskOperation operation ,VGint x, VGint y ,VGint width, VGint height)
+   {
+   return do_vgMask(mask,operation,x,y,width,height);
+   }
+
+EXPORT_C void   vgRenderToMask(VGPath path ,VGbitfield paintModes ,VGMaskOperation operation)
+   {
+   return do_vgRenderToMask(path,paintModes,operation);
+   }
+
+EXPORT_C VGMaskLayer   vgCreateMaskLayer(VGint width, VGint height)
+   {
+   return do_vgCreateMaskLayer(width,height);
+   }
+
+EXPORT_C void   vgDestroyMaskLayer(VGMaskLayer maskLayer)
+   {
+   return do_vgDestroyMaskLayer(maskLayer);
+   }
+
+EXPORT_C void   vgFillMaskLayer(VGMaskLayer maskLayer ,VGint x, VGint y ,VGint width, VGint height ,VGfloat value)
+   {
+   return do_vgFillMaskLayer(maskLayer,x,y,width,height,value);
+   }
+
+EXPORT_C void   vgCopyMask(VGMaskLayer maskLayer ,VGint sx, VGint sy ,VGint dx, VGint dy ,VGint width, VGint height)
+   {
+   return do_vgCopyMask(maskLayer,sx,sy,dx,dy,width,height);
+   }
+
+EXPORT_C void   vgClear(VGint x, VGint y ,VGint width, VGint height)
+   {
+   return do_vgClear(x,y,width,height);
+   }
+
+EXPORT_C VGPath   vgCreatePath(VGint pathFormat ,VGPathDatatype datatype ,VGfloat scale, VGfloat bias ,VGint segmentCapacityHint ,VGint coordCapacityHint ,VGbitfield capabilities)
+   {
+   return do_vgCreatePath(pathFormat,datatype,scale,bias,segmentCapacityHint,coordCapacityHint,capabilities);
+   }
+
+EXPORT_C void   vgClearPath(VGPath path, VGbitfield capabilities)
+   {
+   return do_vgClearPath(path,capabilities);
+   }
+
+EXPORT_C void   vgDestroyPath(VGPath path)
+   {
+   return do_vgDestroyPath(path);
+   }
+
+EXPORT_C void   vgRemovePathCapabilities(VGPath path ,VGbitfield capabilities)
+   {
+   return do_vgRemovePathCapabilities(path,capabilities);
+   }
+
+EXPORT_C VGbitfield   vgGetPathCapabilities(VGPath path)
+   {
+   return do_vgGetPathCapabilities(path);
+   }
+
+EXPORT_C void   vgAppendPath(VGPath dstPath, VGPath srcPath)
+   {
+   return do_vgAppendPath(dstPath,srcPath);
+   }
+
+EXPORT_C void   vgAppendPathData(VGPath dstPath ,VGint numSegments ,const  VGubyte* pathSegments ,const  void* pathData)
+   {
+   return do_vgAppendPathData(dstPath,numSegments,pathSegments,pathData);
+   }
+
+EXPORT_C void   vgModifyPathCoords(VGPath dstPath ,VGint startIndex ,VGint numSegments ,const void* pathData)
+   {
+   return do_vgModifyPathCoords(dstPath,startIndex,numSegments,pathData);
+   }
+
+EXPORT_C void   vgTransformPath(VGPath dstPath, VGPath srcPath)
+   {
+   return do_vgTransformPath(dstPath,srcPath);
+   }
+
+EXPORT_C VGboolean   vgInterpolatePath(VGPath dstPath ,VGPath startPath ,VGPath endPath ,VGfloat amount)
+   {
+   return do_vgInterpolatePath(dstPath,startPath,endPath,amount);
+   }
+
+EXPORT_C VGfloat   vgPathLength(VGPath path ,VGint startSegment ,VGint numSegments)
+   {
+   return do_vgPathLength(path,startSegment,numSegments);
+   }
+
+EXPORT_C void   vgPointAlongPath(VGPath path ,VGint startSegment ,VGint numSegments ,VGfloat distance ,VGfloat* x, VGfloat* y ,VGfloat* tangentX ,VGfloat* tangentY)
+   {
+   return do_vgPointAlongPath(path,startSegment,numSegments,distance,x,y,tangentX,tangentY);
+   }
+
+EXPORT_C void   vgPathBounds(VGPath path ,VGfloat* minX ,VGfloat* minY ,VGfloat* width ,VGfloat* height)
+   {
+   return do_vgPathBounds(path,minX,minY,width,height);
+   }
+
+EXPORT_C void   vgPathTransformedBounds(VGPath path ,VGfloat* minX ,VGfloat* minY ,VGfloat* width ,VGfloat* height)
+   {
+   return do_vgPathTransformedBounds(path,minX,minY,width,height);
+   }
+
+EXPORT_C void   vgDrawPath(VGPath path, VGbitfield paintModes)
+   {
+   return do_vgDrawPath(path,paintModes);
+   }
+
+EXPORT_C VGPaint   vgCreatePaint(void)
+   {
+   return do_vgCreatePaint();
+   }
+
+EXPORT_C void   vgDestroyPaint(VGPaint paint)
+   {
+   return do_vgDestroyPaint(paint);
+   }
+
+EXPORT_C void   vgSetPaint(VGPaint paint, VGbitfield paintModes)
+   {
+   return do_vgSetPaint(paint,paintModes);
+   }
+
+EXPORT_C VGPaint   vgGetPaint(VGPaintMode paintMode)
+   {
+   return do_vgGetPaint(paintMode);
+   }
+
+EXPORT_C void   vgSetColor(VGPaint paint, VGuint rgba)
+   {
+   return do_vgSetColor(paint,rgba);
+   }
+
+EXPORT_C VGuint   vgGetColor(VGPaint paint)
+   {
+   return do_vgGetColor(paint);
+   }
+
+EXPORT_C void   vgPaintPattern(VGPaint paint, VGImage pattern)
+   {
+   return do_vgPaintPattern(paint,pattern);
+   }
+
+EXPORT_C VGImage   vgCreateImage(VGImageFormat format ,VGint width, VGint height ,VGbitfield allowedQuality)
+   {
+   return do_vgCreateImage(format,width,height,allowedQuality);
+   }
+
+EXPORT_C void   vgDestroyImage(VGImage image)
+   {
+   return do_vgDestroyImage(image);
+   }
+
+EXPORT_C void   vgClearImage(VGImage image ,VGint x, VGint y ,VGint width, VGint height)
+   {
+   return do_vgClearImage(image,x,y,width,height);
+   }
+
+EXPORT_C void   vgImageSubData(VGImage image ,const void* data ,VGint dataStride ,VGImageFormat dataFormat ,VGint x, VGint y ,VGint width, VGint height)
+   {
+   return do_vgImageSubData(image,data,dataStride,dataFormat,x,y,width,height);
+   }
+
+EXPORT_C void   vgGetImageSubData(VGImage image ,void* data ,VGint dataStride ,VGImageFormat dataFormat ,VGint x, VGint y ,VGint width, VGint height)
+   {
+   return do_vgGetImageSubData(image,data,dataStride,dataFormat,x,y,width,height);
+   }
+
+EXPORT_C VGImage   vgChildImage(VGImage parent ,VGint x, VGint y ,VGint width, VGint height)
+   {
+   return do_vgChildImage(parent,x,y,width,height);
+   }
+
+EXPORT_C VGImage   vgGetParent(VGImage image)
+   {
+   return do_vgGetParent(image);
+   }
+
+EXPORT_C void   vgCopyImage(VGImage dst, VGint dx, VGint dy ,VGImage src, VGint sx, VGint sy ,VGint width, VGint height ,VGboolean dither)
+   {
+   return do_vgCopyImage(dst,dx,dy,src,sx,sy,width,height,dither);
+   }
+
+EXPORT_C void   vgDrawImage(VGImage image)
+   {
+   return do_vgDrawImage(image);
+   }
+
+EXPORT_C void   vgSetPixels(VGint dx, VGint dy ,VGImage src, VGint sx, VGint sy ,VGint width, VGint height)
+   {
+   return do_vgSetPixels(dx,dy,src,sx,sy,width,height);
+   }
+
+EXPORT_C void   vgWritePixels(const void* data, VGint dataStride ,VGImageFormat dataFormat ,VGint dx, VGint dy ,VGint width, VGint height)
+   {
+   return do_vgWritePixels(data,dataStride,dataFormat,dx,dy,width,height);
+   }
+
+EXPORT_C void   vgGetPixels(VGImage dst, VGint dx, VGint dy ,VGint sx, VGint sy ,VGint width, VGint height)
+   {
+   return do_vgGetPixels(dst,dx,dy,sx,sy,width,height);
+   }
+
+EXPORT_C void   vgReadPixels(void* data, VGint dataStride ,VGImageFormat dataFormat ,VGint sx, VGint sy ,VGint width, VGint height)
+   {
+   return do_vgReadPixels(data,dataStride,dataFormat,sx,sy,width,height);
+   }
+
+EXPORT_C void   vgCopyPixels(VGint dx, VGint dy ,VGint sx, VGint sy ,VGint width, VGint height)
+   {
+   return do_vgCopyPixels(dx,dy,sx,sy,width,height);
+   }
+
+EXPORT_C VGFont   vgCreateFont(VGint glyphCapacityHint)
+   {
+   return do_vgCreateFont(glyphCapacityHint);
+   }
+
+EXPORT_C void   vgDestroyFont(VGFont font)
+   {
+   return do_vgDestroyFont(font);
+   }
+
+EXPORT_C void   vgSetGlyphToPath(VGFont font ,VGuint glyphIndex ,VGPath path ,VGboolean isHinted ,const VGfloat glyphOrigin [2] ,const VGfloat escapement[2])
+   {
+   return do_vgSetGlyphToPath(font,glyphIndex,path,isHinted,glyphOrigin,escapement);
+   }
+
+EXPORT_C void   vgSetGlyphToImage(VGFont font ,VGuint glyphIndex ,VGImage image ,const VGfloat glyphOrigin [2] ,const VGfloat escapement[2])
+   {
+   return do_vgSetGlyphToImage(font,glyphIndex,image,glyphOrigin,escapement);
+   }
+
+EXPORT_C void   vgClearGlyph(VGFont font ,VGuint glyphIndex)
+   {
+   return do_vgClearGlyph(font,glyphIndex);
+   }
+
+EXPORT_C void   vgDrawGlyph(VGFont font ,VGuint glyphIndex ,VGbitfield paintModes ,VGboolean allowAutoHinting)
+   {
+   return do_vgDrawGlyph(font,glyphIndex,paintModes,allowAutoHinting);
+   }
+
+EXPORT_C void   vgDrawGlyphs(VGFont font ,VGint glyphCount ,const VGuint* glyphIndices ,const VGfloat* adjustments_x ,const VGfloat* adjustments_y ,VGbitfield paintModes ,VGboolean allowAutoHinting)
+   {
+   return do_vgDrawGlyphs(font,glyphCount,glyphIndices,adjustments_x,adjustments_y,paintModes,allowAutoHinting);
+   }
+
+EXPORT_C void   vgColorMatrix(VGImage dst, VGImage src ,const VGfloat* matrix)
+   {
+   return do_vgColorMatrix(dst,src,matrix);
+   }
+
+EXPORT_C void   vgConvolve(VGImage dst, VGImage src ,VGint kernelWidth, VGint kernelHeight ,VGint shiftX, VGint shiftY ,const VGshort* kernel ,VGfloat scale ,VGfloat bias ,VGTilingMode tilingMode)
+   {
+   return do_vgConvolve(dst,src,kernelWidth,kernelHeight,shiftX,shiftY,kernel,scale,bias,tilingMode);
+   }
+
+EXPORT_C void   vgSeparableConvolve(VGImage dst, VGImage src ,VGint kernelWidth ,VGint kernelHeight ,VGint shiftX, VGint shiftY ,const VGshort* kernelX ,const VGshort* kernelY ,VGfloat scale ,VGfloat bias ,VGTilingMode tilingMode)
+   {
+   return do_vgSeparableConvolve(dst,src,kernelWidth,kernelHeight,shiftX,shiftY,kernelX,kernelY,scale,bias,tilingMode);
+   }
+
+EXPORT_C void   vgGaussianBlur(VGImage dst, VGImage src ,VGfloat stdDeviationX ,VGfloat stdDeviationY ,VGTilingMode tilingMode)
+   {
+   return do_vgGaussianBlur(dst,src,stdDeviationX,stdDeviationY,tilingMode);
+   }
+
+EXPORT_C void   vgLookup(VGImage dst, VGImage src ,const VGubyte* redLUT ,const VGubyte* greenLUT ,const VGubyte* blueLUT ,const VGubyte* alphaLUT ,VGboolean outputLinear ,VGboolean outputPremultiplied)
+   {
+   return do_vgLookup(dst,src,redLUT,greenLUT,blueLUT,alphaLUT,outputLinear,outputPremultiplied);
+   }
+
+EXPORT_C void   vgLookupSingle(VGImage dst, VGImage src ,const VGuint* lookupTable ,VGImageChannel sourceChannel ,VGboolean outputLinear ,VGboolean outputPremultiplied)
+   {
+   return do_vgLookupSingle(dst,src,lookupTable,sourceChannel,outputLinear,outputPremultiplied);
+   }
+
+EXPORT_C VGHardwareQueryResult   vgHardwareQuery        (VGHardwareQueryType key ,VGint setting)
+   {
+   return do_vgHardwareQuery(key,setting);
+   }
+
+EXPORT_C const VGubyte *   vgGetString(VGStringID name)
+   {
+   return do_vgGetString(name);
+   }
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/openvg/openvgrefimplementation/sfopenvg/openvgu/vgu.cpp	Fri Apr 30 17:15:32 2010 +0100
@@ -0,0 +1,125 @@
+/*
+* Copyright (c) 2009 Symbian Foundation Ltd
+* This component and the accompanying materials are made available
+* under the terms of the License "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:
+* Symbian Foundation Ltd - initial contribution.
+* 
+* Contributors:
+*
+* Description:
+* Implementation of VGU interface
+*/
+
+#include <e32base.h>
+#include <vgu.h>
+
+#include "vguinternal.h" //contains do_vguXX fucntion declarations
+
+extern "C" {
+
+EXPORT_C VGUErrorCode vguLine(VGPath path, VGfloat x0, VGfloat y0, VGfloat x1, VGfloat y1)
+{
+return do_vguLine(path, x0, y0, x1, y1);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+EXPORT_C VGUErrorCode vguPolygon(VGPath path, const VGfloat * points, VGint count, VGboolean closed)
+{
+return do_vguPolygon(path, points, count, closed);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+EXPORT_C VGUErrorCode vguRect(VGPath path, VGfloat x, VGfloat y, VGfloat width, VGfloat height)
+{
+return do_vguRect(path, x, y, width, height);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+EXPORT_C VGUErrorCode vguRoundRect(VGPath path, VGfloat x, VGfloat y, VGfloat width, VGfloat height, VGfloat arcWidth, VGfloat arcHeight)
+{
+return do_vguRoundRect(path, x, y, width, height, arcWidth, arcHeight);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+EXPORT_C VGUErrorCode vguEllipse(VGPath path, VGfloat cx, VGfloat cy, VGfloat width, VGfloat height)
+{
+return do_vguEllipse(path, cx, cy, width, height);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+EXPORT_C VGUErrorCode vguArc(VGPath path, VGfloat x, VGfloat y, VGfloat width, VGfloat height, VGfloat startAngle, VGfloat angleExtent, VGUArcType arcType)
+{
+return do_vguArc(path, x, y, width, height, startAngle, angleExtent, arcType);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+EXPORT_C VGUErrorCode vguComputeWarpQuadToSquare(VGfloat sx0, VGfloat sy0, VGfloat sx1, VGfloat sy1, VGfloat sx2, VGfloat sy2, VGfloat sx3, VGfloat sy3, VGfloat * matrix)
+{
+return do_vguComputeWarpQuadToSquare(sx0, sy0, sx1, sy1, sx2, sy2, sx3, sy3, matrix);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+EXPORT_C VGUErrorCode vguComputeWarpSquareToQuad(VGfloat dx0, VGfloat dy0, VGfloat dx1, VGfloat dy1, VGfloat dx2, VGfloat dy2, VGfloat dx3, VGfloat dy3, VGfloat * matrix)
+{
+return do_vguComputeWarpSquareToQuad(dx0, dy0, dx1, dy1, dx2, dy2, dx3, dy3, matrix);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+EXPORT_C VGUErrorCode vguComputeWarpQuadToQuad(VGfloat dx0, VGfloat dy0, VGfloat dx1, VGfloat dy1, VGfloat dx2, VGfloat dy2, VGfloat dx3, VGfloat dy3, VGfloat sx0, VGfloat sy0, VGfloat sx1, VGfloat sy1, VGfloat sx2, VGfloat sy2, VGfloat sx3, VGfloat sy3, VGfloat * matrix)
+{
+return do_vguComputeWarpQuadToQuad(dx0, dy0, dx1, dy1, dx2, dy2, dx3, dy3, sx0, sy0, sx1, sy1, sx2, sy2, sx3, sy3, matrix);
+}
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/openvg/openvgrefimplementation/sfopenvg/sfopenvg/include/eglinternal.h	Fri Apr 30 17:15:32 2010 +0100
@@ -0,0 +1,68 @@
+/*
+* Copyright (c) 2009 Symbian Foundation Ltd
+* This component and the accompanying materials are made available
+* under the terms of the License "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:
+* Symbian Foundation Ltd - initial contribution.
+* 
+* Contributors:
+*
+* Description:
+* Declaration of EGL like interface . Basically every EGL API names but prefixed with do_ e.g. do_eglInitialize
+*/
+
+#ifndef EGLINTERNAL_H
+#define EGLINTERNAL_H
+
+#include <egl.h>
+
+
+/*
+ * defines set of internal egl functiosn that are 1:1 with the published egl functions.
+ * E.g. eglInitialize -> do_eglInitialize
+ * 
+ * These do_XXX fucntions are called from the libegl.dll (which is a shim) to be processed here
+ */
+
+IMPORT_C EGLint do_eglGetError(void);
+IMPORT_C EGLDisplay do_eglGetDisplay(EGLNativeDisplayType display_id);
+IMPORT_C EGLBoolean do_eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor);
+IMPORT_C EGLBoolean do_eglTerminate(EGLDisplay dpy);
+IMPORT_C const char* do_eglQueryString(EGLDisplay dpy, EGLint name);
+IMPORT_C EGLBoolean do_eglGetConfigs(EGLDisplay dpy, EGLConfig *configs,EGLint config_size, EGLint *num_config);
+IMPORT_C EGLBoolean do_eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list,EGLConfig *configs, EGLint config_size,EGLint *num_config);
+IMPORT_C EGLBoolean do_eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config,EGLint attribute, EGLint *value);
+IMPORT_C EGLSurface do_eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config,EGLNativeWindowType win,const EGLint *attrib_list);
+IMPORT_C EGLSurface do_eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config,const EGLint *attrib_list);
+IMPORT_C EGLSurface do_eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config,EGLNativePixmapType pixmap,const EGLint *attrib_list);
+IMPORT_C EGLBoolean do_eglDestroySurface(EGLDisplay dpy, EGLSurface surface);
+IMPORT_C EGLBoolean do_eglQuerySurface(EGLDisplay dpy, EGLSurface surface,EGLint attribute, EGLint *value);
+IMPORT_C EGLBoolean do_eglBindAPI(EGLenum api);
+IMPORT_C EGLenum do_eglQueryAPI(void);
+IMPORT_C EGLBoolean do_eglWaitClient(void);
+IMPORT_C EGLBoolean do_eglReleaseThread(void);
+IMPORT_C EGLSurface do_eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer,EGLConfig config, const EGLint *attrib_list);
+IMPORT_C EGLBoolean do_eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface,EGLint attribute, EGLint value);
+IMPORT_C EGLBoolean do_eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer);
+IMPORT_C EGLBoolean do_eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer);
+IMPORT_C EGLBoolean do_eglSwapInterval(EGLDisplay dpy, EGLint interval);
+IMPORT_C EGLContext do_eglCreateContext(EGLDisplay dpy, EGLConfig config,EGLContext share_context,const EGLint *attrib_list);
+IMPORT_C EGLBoolean do_eglDestroyContext(EGLDisplay dpy, EGLContext ctx);
+IMPORT_C EGLBoolean do_eglMakeCurrent(EGLDisplay dpy, EGLSurface draw,EGLSurface read, EGLContext ctx);
+IMPORT_C EGLContext do_eglGetCurrentContext(void);
+IMPORT_C EGLSurface do_eglGetCurrentSurface(EGLint readdraw);
+IMPORT_C EGLDisplay do_eglGetCurrentDisplay(void);
+IMPORT_C EGLBoolean do_eglQueryContext(EGLDisplay dpy, EGLContext ctx,EGLint attribute, EGLint *value);
+IMPORT_C EGLBoolean do_eglWaitGL(void);
+IMPORT_C EGLBoolean do_eglWaitNative(EGLint engine);
+IMPORT_C EGLBoolean do_eglSwapBuffers(EGLDisplay dpy, EGLSurface surface);
+IMPORT_C EGLBoolean do_eglCopyBuffers(EGLDisplay dpy, EGLSurface surface,EGLNativePixmapType target);
+IMPORT_C void (* EGLAPIENTRY do_eglGetProcAddress (const char *procname))(...);
+
+
+
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/openvg/openvgrefimplementation/sfopenvg/sfopenvg/include/openvginternal.h	Fri Apr 30 17:15:32 2010 +0100
@@ -0,0 +1,117 @@
+/*
+* Copyright (c) 2009 Symbian Foundation Ltd
+* This component and the accompanying materials are made available
+* under the terms of the License "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:
+* Symbian Foundation Ltd - initial contribution.
+* 
+* Contributors:
+*
+* Description:
+* Implementation of a OpenVG like interface. Basically every OpenVG API names but prefixed with do_ e.g. do_vgSetf
+*/
+
+#ifndef OPENVGINTERNAL_H
+#define OPENVGINTERNAL_H
+
+#include <openvg.h>
+
+/*
+ * defines set of internal vgu functions that are 1:1 with the published openvg functions. 
+ * E.g. vgSetf -> do_vgSetf
+ * 
+ * These do_XXX fucntions are called from the libopenvg.dll (which is a shim) to be processed here
+ */
+
+IMPORT_C VGErrorCode do_vgGetError(void);
+IMPORT_C void do_vgFlush(void);
+IMPORT_C void do_vgFinish(void);
+IMPORT_C void do_vgSetf(VGParamType type, VGfloat value);
+IMPORT_C void do_vgSeti(VGParamType type, VGint value);
+IMPORT_C void do_vgSetfv(VGParamType type, VGint count ,const VGfloat* values);
+IMPORT_C void do_vgSetiv(VGParamType type, VGint count ,const VGint* values);
+IMPORT_C VGfloat do_vgGetf(VGParamType type);
+IMPORT_C VGint do_vgGeti(VGParamType type);
+IMPORT_C VGint do_vgGetVectorSize(VGParamType type);
+IMPORT_C void do_vgGetfv(VGParamType type, VGint count ,VGfloat* values);
+IMPORT_C void do_vgGetiv(VGParamType type, VGint count ,VGint* values);
+IMPORT_C void do_vgSetParameterf(VGHandle object ,VGint paramType ,VGfloat value);
+IMPORT_C void do_vgSetParameteri(VGHandle object ,VGint paramType ,VGint value);
+IMPORT_C void do_vgSetParameterfv(VGHandle object ,VGint paramType ,VGint count ,const VGfloat* values);
+IMPORT_C void do_vgSetParameteriv(VGHandle object ,VGint paramType ,VGint count ,const VGint* values);
+IMPORT_C VGfloat do_vgGetParameterf(VGHandle object ,VGint paramType);
+IMPORT_C VGint do_vgGetParameteri(VGHandle object ,VGint paramType);
+IMPORT_C VGint do_vgGetParameterVectorSize(VGHandle object ,VGint paramType);
+IMPORT_C void do_vgGetParameterfv(VGHandle object ,VGint paramType ,VGint count ,VGfloat* values);
+IMPORT_C void do_vgGetParameteriv(VGHandle object ,VGint paramType ,VGint count ,VGint* values);
+IMPORT_C void do_vgLoadIdentity(void);
+IMPORT_C void do_vgLoadMatrix(const VGfloat* m);
+IMPORT_C void do_vgGetMatrix(VGfloat* m);
+IMPORT_C void do_vgMultMatrix(const  VGfloat* m);
+IMPORT_C void do_vgTranslate(VGfloat tx, VGfloat ty);
+IMPORT_C void do_vgScale(VGfloat sx, VGfloat sy);
+IMPORT_C void do_vgShear(VGfloat shx, VGfloat shy);
+IMPORT_C void do_vgRotate(VGfloat angle);
+IMPORT_C void do_vgMask(VGHandle mask, VGMaskOperation operation ,VGint x, VGint y ,VGint width, VGint height);
+IMPORT_C void do_vgRenderToMask(VGPath path ,VGbitfield paintModes ,VGMaskOperation operation);
+IMPORT_C VGMaskLayer do_vgCreateMaskLayer(VGint width, VGint height);
+IMPORT_C void do_vgDestroyMaskLayer(VGMaskLayer maskLayer);
+IMPORT_C void do_vgFillMaskLayer(VGMaskLayer maskLayer ,VGint x, VGint y ,VGint width, VGint height ,VGfloat value);
+IMPORT_C void do_vgCopyMask(VGMaskLayer maskLayer ,VGint sx, VGint sy ,VGint dx, VGint dy ,VGint width, VGint height);
+IMPORT_C void do_vgClear(VGint x, VGint y ,VGint width, VGint height);
+IMPORT_C VGPath do_vgCreatePath(VGint pathFormat ,VGPathDatatype datatype ,VGfloat scale, VGfloat bias ,VGint segmentCapacityHint ,VGint coordCapacityHint ,VGbitfield capabilities);
+IMPORT_C void do_vgClearPath(VGPath path, VGbitfield capabilities);
+IMPORT_C void do_vgDestroyPath(VGPath path);
+IMPORT_C void do_vgRemovePathCapabilities(VGPath path ,VGbitfield capabilities);
+IMPORT_C VGbitfield do_vgGetPathCapabilities(VGPath path);
+IMPORT_C void do_vgAppendPath(VGPath dstPath, VGPath srcPath);
+IMPORT_C void do_vgAppendPathData(VGPath dstPath ,VGint numSegments ,const  VGubyte* pathSegments ,const  void* pathData);
+IMPORT_C void do_vgModifyPathCoords(VGPath dstPath ,VGint startIndex ,VGint numSegments ,const void* pathData);
+IMPORT_C void do_vgTransformPath(VGPath dstPath, VGPath srcPath);
+IMPORT_C VGboolean do_vgInterpolatePath(VGPath dstPath ,VGPath startPath ,VGPath endPath ,VGfloat amount);
+IMPORT_C VGfloat do_vgPathLength(VGPath path ,VGint startSegment ,VGint numSegments);
+IMPORT_C void do_vgPointAlongPath(VGPath path ,VGint startSegment ,VGint numSegments ,VGfloat distance ,VGfloat* x, VGfloat* y ,VGfloat* tangentX ,VGfloat* tangentY);
+IMPORT_C void do_vgPathBounds(VGPath path ,VGfloat* minX ,VGfloat* minY ,VGfloat* width ,VGfloat* height);
+IMPORT_C void do_vgPathTransformedBounds(VGPath path ,VGfloat* minX ,VGfloat* minY ,VGfloat* width ,VGfloat* height);
+IMPORT_C void do_vgDrawPath(VGPath path, VGbitfield paintModes);
+IMPORT_C VGPaint do_vgCreatePaint(void);
+IMPORT_C void do_vgDestroyPaint(VGPaint paint);
+IMPORT_C void do_vgSetPaint(VGPaint paint, VGbitfield paintModes);
+IMPORT_C VGPaint do_vgGetPaint(VGPaintMode paintMode);
+IMPORT_C void do_vgSetColor(VGPaint paint, VGuint rgba);
+IMPORT_C VGuint do_vgGetColor(VGPaint paint);
+IMPORT_C void do_vgPaintPattern(VGPaint paint, VGImage pattern);
+IMPORT_C VGImage do_vgCreateImage(VGImageFormat format ,VGint width, VGint height ,VGbitfield allowedQuality);
+IMPORT_C void do_vgDestroyImage(VGImage image);
+IMPORT_C void do_vgClearImage(VGImage image ,VGint x, VGint y ,VGint width, VGint height);
+IMPORT_C void do_vgImageSubData(VGImage image ,const void* data ,VGint dataStride ,VGImageFormat dataFormat ,VGint x, VGint y ,VGint width, VGint height);
+IMPORT_C void do_vgGetImageSubData(VGImage image ,void* data ,VGint dataStride ,VGImageFormat dataFormat ,VGint x, VGint y ,VGint width, VGint height);
+IMPORT_C VGImage do_vgChildImage(VGImage parent ,VGint x, VGint y ,VGint width, VGint height);
+IMPORT_C VGImage do_vgGetParent(VGImage image);
+IMPORT_C void do_vgCopyImage(VGImage dst, VGint dx, VGint dy ,VGImage src, VGint sx, VGint sy ,VGint width, VGint height ,VGboolean dither);
+IMPORT_C void do_vgDrawImage(VGImage image);
+IMPORT_C void do_vgSetPixels(VGint dx, VGint dy ,VGImage src, VGint sx, VGint sy ,VGint width, VGint height);
+IMPORT_C void do_vgWritePixels(const void* data, VGint dataStride ,VGImageFormat dataFormat ,VGint dx, VGint dy ,VGint width, VGint height);
+IMPORT_C void do_vgGetPixels(VGImage dst, VGint dx, VGint dy ,VGint sx, VGint sy ,VGint width, VGint height);
+IMPORT_C void do_vgReadPixels(void* data, VGint dataStride ,VGImageFormat dataFormat ,VGint sx, VGint sy ,VGint width, VGint height);
+IMPORT_C void do_vgCopyPixels(VGint dx, VGint dy ,VGint sx, VGint sy ,VGint width, VGint height);
+IMPORT_C VGFont do_vgCreateFont(VGint glyphCapacityHint);
+IMPORT_C void do_vgDestroyFont(VGFont font);
+IMPORT_C void do_vgSetGlyphToPath(VGFont font ,VGuint glyphIndex ,VGPath path ,VGboolean isHinted ,const VGfloat glyphOrigin [2] ,const VGfloat escapement[2]);
+IMPORT_C void do_vgSetGlyphToImage(VGFont font ,VGuint glyphIndex ,VGImage image ,const VGfloat glyphOrigin [2] ,const VGfloat escapement[2]);
+IMPORT_C void do_vgClearGlyph(VGFont font ,VGuint glyphIndex);
+IMPORT_C void do_vgDrawGlyph(VGFont font ,VGuint glyphIndex ,VGbitfield paintModes ,VGboolean allowAutoHinting);
+IMPORT_C void do_vgDrawGlyphs(VGFont font ,VGint glyphCount ,const VGuint* glyphIndices ,const VGfloat* adjustments_x ,const VGfloat* adjustments_y ,VGbitfield paintModes ,VGboolean allowAutoHinting);
+IMPORT_C void do_vgColorMatrix(VGImage dst, VGImage src ,const VGfloat* matrix);
+IMPORT_C void do_vgConvolve(VGImage dst, VGImage src ,VGint kernelWidth, VGint kernelHeight ,VGint shiftX, VGint shiftY ,const VGshort* kernel ,VGfloat scale ,VGfloat bias ,VGTilingMode tilingMode);
+IMPORT_C void do_vgSeparableConvolve(VGImage dst, VGImage src ,VGint kernelWidth ,VGint kernelHeight ,VGint shiftX, VGint shiftY ,const VGshort* kernelX ,const VGshort* kernelY ,VGfloat scale ,VGfloat bias ,VGTilingMode tilingMode);
+IMPORT_C void do_vgGaussianBlur(VGImage dst, VGImage src ,VGfloat stdDeviationX ,VGfloat stdDeviationY ,VGTilingMode tilingMode);
+IMPORT_C void do_vgLookup(VGImage dst, VGImage src ,const VGubyte* redLUT ,const VGubyte* greenLUT ,const VGubyte* blueLUT ,const VGubyte* alphaLUT ,VGboolean outputLinear ,VGboolean outputPremultiplied);
+IMPORT_C void do_vgLookupSingle(VGImage dst, VGImage src ,const VGuint* lookupTable ,VGImageChannel sourceChannel ,VGboolean outputLinear ,VGboolean outputPremultiplied);
+IMPORT_C VGHardwareQueryResult do_vgHardwareQuery(VGHardwareQueryType key ,VGint setting);
+IMPORT_C const VGubyte * do_vgGetString(VGStringID name);
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/openvg/openvgrefimplementation/sfopenvg/sfopenvg/include/vguinternal.h	Fri Apr 30 17:15:32 2010 +0100
@@ -0,0 +1,39 @@
+/*
+* Copyright (c) 2009 Symbian Foundation Ltd
+* This component and the accompanying materials are made available
+* under the terms of the License "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:
+* Symbian Foundation Ltd - initial contribution.
+* 
+* Contributors:
+*
+* Description:
+* Implementation of VGU like interface. Basically every VGU API names but prefixed with do_ e.g. do_vguLine
+*/
+
+#ifndef VGUINTERNAL_H
+#define VGUINTERNAL_H
+
+#include <vgu.h>
+
+/*
+ * defines set of internal vgu functions that are 1:1 with the published vgu functions.
+ * E.g. vguLine -> do_vguLine
+ * 
+ * These do_XXX fucntions are called from the libopenvgu.dll (which is a shim) to be processed here
+ */
+
+IMPORT_C VGUErrorCode do_vguLine(VGPath path, VGfloat x0, VGfloat y0, VGfloat x1, VGfloat y1);
+IMPORT_C VGUErrorCode do_vguPolygon(VGPath path, const VGfloat * points, VGint count, VGboolean closed);
+IMPORT_C VGUErrorCode do_vguRect(VGPath path, VGfloat x, VGfloat y, VGfloat width, VGfloat height);
+IMPORT_C VGUErrorCode do_vguRoundRect(VGPath path, VGfloat x, VGfloat y, VGfloat width, VGfloat height, VGfloat arcWidth, VGfloat arcHeight);
+IMPORT_C VGUErrorCode do_vguEllipse(VGPath path, VGfloat cx, VGfloat cy, VGfloat width, VGfloat height);
+IMPORT_C VGUErrorCode do_vguArc(VGPath path, VGfloat x, VGfloat y, VGfloat width, VGfloat height, VGfloat startAngle, VGfloat angleExtent, VGUArcType arcType);
+IMPORT_C VGUErrorCode do_vguComputeWarpQuadToSquare(VGfloat sx0, VGfloat sy0, VGfloat sx1, VGfloat sy1, VGfloat sx2, VGfloat sy2, VGfloat sx3, VGfloat sy3, VGfloat * matrix);
+IMPORT_C VGUErrorCode do_vguComputeWarpSquareToQuad(VGfloat dx0, VGfloat dy0, VGfloat dx1, VGfloat dy1, VGfloat dx2, VGfloat dy2, VGfloat dx3, VGfloat dy3, VGfloat * matrix);
+IMPORT_C VGUErrorCode do_vguComputeWarpQuadToQuad(VGfloat dx0, VGfloat dy0, VGfloat dx1, VGfloat dy1, VGfloat dx2, VGfloat dy2, VGfloat dx3, VGfloat dy3, VGfloat sx0, VGfloat sy0, VGfloat sx1, VGfloat sy1, VGfloat sx2, VGfloat sy2, VGfloat sx3, VGfloat sy3, VGfloat * matrix);
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/openvg/openvgrefimplementation/sfopenvg/sfopenvg/riApi.cpp	Fri Apr 30 17:15:32 2010 +0100
@@ -0,0 +1,4038 @@
+/*------------------------------------------------------------------------
+ *
+ * OpenVG 1.1 Reference Implementation
+ * -----------------------------------
+ *
+ * Copyright (c) 2007 The Khronos Group Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and /or associated documentation files
+ * (the "Materials "), to deal in the Materials without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Materials,
+ * and to permit persons to whom the Materials are furnished to do so,
+ * subject to the following conditions: 
+ *
+ * The above copyright notice and this permission notice shall be included 
+ * in all copies or substantial portions of the Materials. 
+ *
+ * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR
+ * THE USE OR OTHER DEALINGS IN THE MATERIALS.
+ *
+ *//**
+ * \file
+ * \brief	Implementations of OpenVG API functions.
+ * \note	The actual processing is done in Path, Image, Rasterizer and PixelPipe classes.
+ *//*-------------------------------------------------------------------*/
+
+#include "openvg.h"
+#include "egl.h"
+#include "riContext.h"
+#include "riRasterizer.h"
+#include "riPixelPipe.h"
+#include "riPath.h"
+#include <stdio.h>
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+#include "openvginternal.h"
+#endif
+
+//==============================================================================================
+
+namespace OpenVGRI
+{
+
+/* EGL&OS functions for use in an OpenVG implementation */
+void* eglvgGetCurrentVGContext(void);
+bool  eglvgIsInUse(void* image);
+void  OSAcquireMutex(void);
+void  OSReleaseMutex(void);
+
+
+#define RI_NO_RETVAL
+
+//this must be the first line in an API function
+#define RI_GET_CONTEXT(RETVAL) \
+	OSAcquireMutex(); \
+	VGContext* context = (VGContext*)eglvgGetCurrentVGContext(); \
+	if(!context) \
+	{ \
+		OSReleaseMutex(); \
+		return RETVAL;\
+	}
+
+#define RI_IF_ERROR(COND, ERRORCODE, RETVAL) \
+	if(COND) { context->setError(ERRORCODE); OSReleaseMutex(); return RETVAL; }
+
+//all API functions must call this as their last operation (also functions that don't return values)
+//NOTE: don't evaluate anything or read state in RETVAL (it'll be executed after the mutex has been released)
+#define RI_RETURN(RETVAL) \
+	{ OSReleaseMutex(); \
+	return RETVAL; }
+
+static bool isAligned(const void* ptr, int alignment)
+{
+	RI_ASSERT(alignment == 1 || alignment == 2 || alignment == 4);
+	if(((RIuintptr)ptr) & (alignment-1))
+		return false;
+	return true;
+}
+
+static bool isAligned(const void* ptr, VGImageFormat format)
+{
+	RI_ASSERT(isValidImageFormat(format));
+	int alignment = Color::formatToDescriptor(format).bitsPerPixel >> 3;
+	if(alignment <= 1)
+		return true;	//one bit or byte per pixel
+	return isAligned(ptr, alignment);
+}
+
+bool isValidImageFormat(int f)
+{
+	if(f < VG_sRGBX_8888 || f > VG_lABGR_8888_PRE)
+		return false;
+	return true;
+}
+
+bool isValidImageFormat(EGLNativePixmapType f)
+  {
+#warning TODO: implement isValidImageFormat for EGLNativePixmapType arg
+  return false;
+  }
+
+}	//namespace OpenVGRI
+
+using namespace OpenVGRI;
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgFlush(void)
+#else
+void RI_APIENTRY vgFlush(void)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	//the RI doesn't cache anything, so this is a no-op
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-----
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgFinish(void)
+#else
+void RI_APIENTRY vgFinish(void)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	//the RI doesn't cache anything, so this is a no-op
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+VGErrorCode RI_APIENTRY do_vgGetError(void)
+#else
+VGErrorCode RI_APIENTRY vgGetError(void)
+#endif
+{
+	RI_GET_CONTEXT(VG_NO_CONTEXT_ERROR);
+	VGErrorCode error = context->m_error;
+	context->m_error = VG_NO_ERROR;
+	RI_RETURN(error);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+namespace OpenVGRI
+{
+
+RIfloat inputFloat(VGfloat f)
+{
+	//this function is used for all floating point input values
+	if(RI_ISNAN(f)) return 0.0f;	//convert NaN to zero
+	return RI_CLAMP(f, -RI_FLOAT_MAX, RI_FLOAT_MAX);	//clamp +-inf to +-RIfloat max
+}
+
+Vector2 inputVector2(const Vector2& v)
+{
+    return Vector2(inputFloat(v.x), inputFloat(v.y));
+}
+
+Color inputColor(const Color& c)
+{
+    Color r = c;
+    r.r = inputFloat(r.r);
+    r.g = inputFloat(r.g);
+    r.b = inputFloat(r.b);
+    r.a = inputFloat(r.a);
+    return r;
+}
+
+static int inputFloatToInt(VGfloat value)
+{
+	double v = (double)floor(value);
+	v = v > (double)RI_INT32_MAX ? (double)RI_INT32_MAX : v;
+	v = v < (double)RI_INT32_MIN ? (double)RI_INT32_MIN : v;
+	return (int)v;
+}
+
+static int paramToInt(const void* values, bool floats, int count, int i)
+{
+	RI_ASSERT(i >= 0);
+	if(i >= count || !values)
+		return 0;
+	if(floats)
+		return inputFloatToInt(((const VGfloat*)values)[i]);
+	return (int)((const VGint*)values)[i];
+}
+
+static RIfloat paramToFloat(const void* values, bool floats, int count, int i)
+{
+	RI_ASSERT(i >= 0);
+	if(i >= count || !values)
+		return 0.0f;
+	if(floats)
+		return ((const VGfloat*)values)[i];
+	return (RIfloat)((const VGint*)values)[i];
+}
+
+static void floatToParam(void* output, bool outputFloats, int count, int i, VGfloat value)
+{
+	RI_ASSERT(i >= 0);
+	RI_ASSERT(output);
+	if(i >= count)
+		return;
+	if(outputFloats)
+		((VGfloat*)output)[i] = value;
+	else
+		((VGint*)output)[i] = (VGint)inputFloatToInt(value);
+}
+
+static void intToParam(void* output, bool outputFloats, int count, int i, VGint value)
+{
+	RI_ASSERT(i >= 0);
+	RI_ASSERT(output);
+	if(i >= count)
+		return;
+	if(outputFloats)
+		((VGfloat*)output)[i] = (VGfloat)value;
+	else
+		((VGint*)output)[i] = value;
+}
+
+}	//namespace OpenVGRI
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+static void setifv(VGContext* context, VGParamType type, VGint count, const void* values, bool floats)
+{
+	RI_ASSERT(context);
+	RI_ASSERT(!count || (count && values));
+
+	int ivalue = paramToInt(values, floats, count, 0);
+	RIfloat fvalue = paramToFloat(values, floats, count, 0);
+
+	switch(type)
+	{
+	case VG_MATRIX_MODE:
+		if(count != 1 || ivalue < VG_MATRIX_PATH_USER_TO_SURFACE || ivalue > VG_MATRIX_GLYPH_USER_TO_SURFACE)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		context->m_matrixMode = (VGMatrixMode)ivalue;
+		break;
+
+	case VG_FILL_RULE:
+		if(count != 1 || ivalue < VG_EVEN_ODD || ivalue > VG_NON_ZERO)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		context->m_fillRule = (VGFillRule)ivalue;
+		break;
+
+	case VG_IMAGE_QUALITY:
+		if(count != 1 || ivalue < VG_IMAGE_QUALITY_NONANTIALIASED || ivalue > VG_IMAGE_QUALITY_BETTER)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		context->m_imageQuality = (VGImageQuality)ivalue;
+		break;
+
+	case VG_RENDERING_QUALITY:
+		if(count != 1 || ivalue < VG_RENDERING_QUALITY_NONANTIALIASED || ivalue > VG_RENDERING_QUALITY_BETTER)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		context->m_renderingQuality = (VGRenderingQuality)ivalue;
+		break;
+
+	case VG_BLEND_MODE:
+		if(count != 1 || ivalue < VG_BLEND_SRC || ivalue > VG_BLEND_ADDITIVE)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		context->m_blendMode = (VGBlendMode)ivalue;
+		break;
+
+	case VG_IMAGE_MODE:
+		if(count != 1 || ivalue < VG_DRAW_IMAGE_NORMAL || ivalue > VG_DRAW_IMAGE_STENCIL)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		context->m_imageMode = (VGImageMode)ivalue;
+		break;
+
+	case VG_SCISSOR_RECTS:
+	{
+		if(count & 3)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }	//count must be a multiple of four
+		try
+		{
+			Array<Rectangle> scissor;
+			for(int i=0;i<RI_INT_MIN(count, RI_MAX_SCISSOR_RECTANGLES*4);i+=4)
+			{
+				Rectangle s;
+				s.x = paramToInt(values, floats, count, i+0);
+				s.y = paramToInt(values, floats, count, i+1);
+				s.width = paramToInt(values, floats, count, i+2);
+				s.height = paramToInt(values, floats, count, i+3);
+				scissor.push_back(s);	//throws bad_alloc
+			}
+			context->m_scissor.swap(scissor);	//replace context data
+		}
+		catch(std::bad_alloc)
+		{
+			context->setError(VG_OUT_OF_MEMORY_ERROR);
+		}
+		break;
+	}
+
+	case VG_COLOR_TRANSFORM:
+		if(count != 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		context->m_colorTransform = ivalue ? VG_TRUE : VG_FALSE;
+		break;
+
+	case VG_COLOR_TRANSFORM_VALUES:
+		if(count != 8 || !values) { context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+        {
+            for(int i=0;i<8;i++)
+            {
+                context->m_inputColorTransformValues[i] = paramToFloat(values, floats, count, i);
+                context->m_colorTransformValues[i] = inputFloat(context->m_inputColorTransformValues[i]);
+            }
+        }
+		break;
+
+	case VG_STROKE_LINE_WIDTH:
+		if(count != 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		context->m_inputStrokeLineWidth = fvalue;
+        context->m_strokeLineWidth = inputFloat(fvalue);
+		break;
+
+	case VG_STROKE_CAP_STYLE:
+		if(count != 1 || ivalue < VG_CAP_BUTT || ivalue > VG_CAP_SQUARE)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		context->m_strokeCapStyle = (VGCapStyle)ivalue;
+		break;
+
+	case VG_STROKE_JOIN_STYLE:
+		if(count != 1 || ivalue < VG_JOIN_MITER || ivalue > VG_JOIN_BEVEL)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		context->m_strokeJoinStyle = (VGJoinStyle)ivalue;
+		break;
+
+	case VG_STROKE_MITER_LIMIT:
+		if(count != 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		context->m_inputStrokeMiterLimit = fvalue;
+		context->m_strokeMiterLimit = inputFloat(fvalue);
+		break;
+
+	case VG_STROKE_DASH_PATTERN:
+	{
+		try
+		{
+			Array<RIfloat> inputStrokeDashPattern;
+			Array<RIfloat> strokeDashPattern;
+			for(int i=0;i<RI_INT_MIN(count, RI_MAX_DASH_COUNT);i++)
+            {
+                RIfloat v = paramToFloat(values, floats, count, i);
+				inputStrokeDashPattern.push_back(v);	//throws bad_alloc
+				strokeDashPattern.push_back(inputFloat(v));	//throws bad_alloc
+            }
+			context->m_inputStrokeDashPattern.swap(inputStrokeDashPattern);	//replace context data
+			context->m_strokeDashPattern.swap(strokeDashPattern);	//replace context data
+		}
+		catch(std::bad_alloc)
+		{
+			context->setError(VG_OUT_OF_MEMORY_ERROR);
+		}
+		break;
+	}
+
+	case VG_STROKE_DASH_PHASE:
+		if(count != 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		context->m_inputStrokeDashPhase = fvalue;
+		context->m_strokeDashPhase = inputFloat(fvalue);
+		break;
+
+	case VG_STROKE_DASH_PHASE_RESET:
+		if(count != 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		context->m_strokeDashPhaseReset = ivalue ? VG_TRUE : VG_FALSE;
+		break;
+
+	case VG_TILE_FILL_COLOR:
+		if(count != 4 || !values) { context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		context->m_inputTileFillColor.set(paramToFloat(values, floats, count, 0),
+									 paramToFloat(values, floats, count, 1),
+									 paramToFloat(values, floats, count, 2),
+									 paramToFloat(values, floats, count, 3),
+									 Color::sRGBA);
+        context->m_tileFillColor = inputColor(context->m_inputTileFillColor);
+		break;
+
+	case VG_GLYPH_ORIGIN:
+		if(count != 2 || !values) { context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		context->m_inputGlyphOrigin.x = paramToFloat(values, floats, count, 0);
+		context->m_inputGlyphOrigin.y = paramToFloat(values, floats, count, 1);
+		context->m_glyphOrigin = inputVector2(context->m_inputGlyphOrigin);
+		break;
+
+	case VG_CLEAR_COLOR:
+		if(count != 4 || !values) { context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		context->m_inputClearColor.set(paramToFloat(values, floats, count, 0),
+								  paramToFloat(values, floats, count, 1),
+								  paramToFloat(values, floats, count, 2),
+								  paramToFloat(values, floats, count, 3),
+								  Color::sRGBA);
+        context->m_clearColor = inputColor(context->m_inputClearColor);
+		break;
+
+	case VG_MASKING:
+		if(count != 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		context->m_masking = ivalue ? VG_TRUE : VG_FALSE;
+		break;
+
+	case VG_SCISSORING:
+		if(count != 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		context->m_scissoring = ivalue ? VG_TRUE : VG_FALSE;
+		break;
+
+	case VG_PIXEL_LAYOUT:
+		if(count != 1 || ivalue < VG_PIXEL_LAYOUT_UNKNOWN || ivalue > VG_PIXEL_LAYOUT_BGR_HORIZONTAL)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		context->m_pixelLayout = (VGPixelLayout)ivalue;
+		break;
+
+	case VG_SCREEN_LAYOUT:
+		if(count != 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		break;	//setting read-only values has no effect
+
+	case VG_FILTER_FORMAT_LINEAR:
+		if(count != 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		context->m_filterFormatLinear = ivalue ? VG_TRUE : VG_FALSE;
+		break;
+
+	case VG_FILTER_FORMAT_PREMULTIPLIED:
+		if(count != 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		context->m_filterFormatPremultiplied = ivalue ? VG_TRUE : VG_FALSE;
+		break;
+
+	case VG_FILTER_CHANNEL_MASK:
+		if(count != 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		//undefined bits are ignored
+		context->m_filterChannelMask = (VGbitfield)ivalue;
+		break;
+
+	case VG_MAX_SCISSOR_RECTS:
+	case VG_MAX_DASH_COUNT:
+	case VG_MAX_KERNEL_SIZE:
+	case VG_MAX_SEPARABLE_KERNEL_SIZE:
+	case VG_MAX_COLOR_RAMP_STOPS:
+	case VG_MAX_IMAGE_WIDTH:
+	case VG_MAX_IMAGE_HEIGHT:
+	case VG_MAX_IMAGE_PIXELS:
+	case VG_MAX_IMAGE_BYTES:
+	case VG_MAX_FLOAT:
+	case VG_MAX_GAUSSIAN_STD_DEVIATION:
+		if(count != 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		break;	//setting read-only values has no effect
+
+	default:
+		context->setError(VG_ILLEGAL_ARGUMENT_ERROR);	//invalid VGParamType
+		break;
+	}
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgSetf(VGParamType type, VGfloat value)
+#else
+void RI_APIENTRY vgSetf(VGParamType type, VGfloat value)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(type == VG_SCISSOR_RECTS || type == VG_STROKE_DASH_PATTERN || type == VG_TILE_FILL_COLOR ||
+				type == VG_CLEAR_COLOR, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);	//vector type value
+	VGfloat values[1] = {value};
+	setifv(context, type, 1, values, true);
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgSeti(VGParamType type, VGint value)
+#else
+void RI_APIENTRY vgSeti(VGParamType type, VGint value)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(type == VG_SCISSOR_RECTS || type == VG_STROKE_DASH_PATTERN || type == VG_TILE_FILL_COLOR ||
+				type == VG_CLEAR_COLOR, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);	//vector type value
+	VGint values[1] = {value};
+	setifv(context, type, 1, values, false);
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgSetiv(VGParamType type, VGint count, const VGint * values)
+#else 
+void RI_APIENTRY vgSetiv(VGParamType type, VGint count, const VGint * values)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(count < 0, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR((!values && count > 0) || (values && !isAligned(values,4)), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	setifv(context, type, count, values, false);
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgSetfv(VGParamType type, VGint count, const VGfloat * values)
+#else
+void RI_APIENTRY vgSetfv(VGParamType type, VGint count, const VGfloat * values)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(count < 0, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR((!values && count > 0) || (values && !isAligned(values,4)), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	setifv(context, type, count, values, true);
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+static void getifv(VGContext* context, VGParamType type, VGint count, void* values, bool floats)
+{
+	switch(type)
+	{
+	case VG_MATRIX_MODE:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, context->m_matrixMode);
+		break;
+
+	case VG_FILL_RULE:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, context->m_fillRule);
+		break;
+
+	case VG_IMAGE_QUALITY:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, context->m_imageQuality);
+		break;
+
+	case VG_RENDERING_QUALITY:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, context->m_renderingQuality);
+		break;
+
+	case VG_BLEND_MODE:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, context->m_blendMode);
+		break;
+
+	case VG_IMAGE_MODE:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, context->m_imageMode);
+		break;
+
+	case VG_SCISSOR_RECTS:
+	{
+		if(count > context->m_scissor.size()*4)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		for(int i=0;i<context->m_scissor.size();i++)
+		{
+			intToParam(values, floats, count, i*4+0, context->m_scissor[i].x);
+			intToParam(values, floats, count, i*4+1, context->m_scissor[i].y);
+			intToParam(values, floats, count, i*4+2, context->m_scissor[i].width);
+			intToParam(values, floats, count, i*4+3, context->m_scissor[i].height);
+		}
+		break;
+	}
+
+	case VG_COLOR_TRANSFORM:
+		if(count != 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, context->m_colorTransform);
+		break;
+
+	case VG_COLOR_TRANSFORM_VALUES:
+		if(count > 8) { context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+        {
+            for(int i=0;i<count;i++)
+            {
+                floatToParam(values, floats, count, i, context->m_inputColorTransformValues[i]);
+            }
+        }
+		break;
+
+	case VG_STROKE_LINE_WIDTH:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		floatToParam(values, floats, count, 0, context->m_inputStrokeLineWidth);
+		break;
+
+	case VG_STROKE_CAP_STYLE:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, context->m_strokeCapStyle);
+		break;
+
+	case VG_STROKE_JOIN_STYLE:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, context->m_strokeJoinStyle);
+		break;
+
+	case VG_STROKE_MITER_LIMIT:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		floatToParam(values, floats, count, 0, context->m_inputStrokeMiterLimit);
+		break;
+
+	case VG_STROKE_DASH_PATTERN:
+	{
+		if(count > context->m_inputStrokeDashPattern.size())	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		for(int i=0;i<context->m_inputStrokeDashPattern.size();i++)
+			floatToParam(values, floats, count, i, context->m_inputStrokeDashPattern[i]);
+		break;
+	}
+
+	case VG_STROKE_DASH_PHASE:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		floatToParam(values, floats, count, 0, context->m_inputStrokeDashPhase);
+		break;
+
+	case VG_STROKE_DASH_PHASE_RESET:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, context->m_strokeDashPhaseReset);
+		break;
+
+	case VG_TILE_FILL_COLOR:
+		if(count > 4)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		floatToParam(values, floats, count, 0, context->m_inputTileFillColor.r);
+		floatToParam(values, floats, count, 1, context->m_inputTileFillColor.g);
+		floatToParam(values, floats, count, 2, context->m_inputTileFillColor.b);
+		floatToParam(values, floats, count, 3, context->m_inputTileFillColor.a);
+		break;
+
+	case VG_CLEAR_COLOR:
+		if(count > 4)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		floatToParam(values, floats, count, 0, context->m_inputClearColor.r);
+		floatToParam(values, floats, count, 1, context->m_inputClearColor.g);
+		floatToParam(values, floats, count, 2, context->m_inputClearColor.b);
+		floatToParam(values, floats, count, 3, context->m_inputClearColor.a);
+		break;
+
+	case VG_GLYPH_ORIGIN:
+		if(count > 2)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		floatToParam(values, floats, count, 0, context->m_inputGlyphOrigin.x);
+		floatToParam(values, floats, count, 1, context->m_inputGlyphOrigin.y);
+		break;
+
+	case VG_MASKING:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, context->m_masking);
+		break;
+
+	case VG_SCISSORING:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, context->m_scissoring);
+		break;
+
+	case VG_PIXEL_LAYOUT:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, context->m_pixelLayout);
+		break;
+
+	case VG_SCREEN_LAYOUT:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, VG_PIXEL_LAYOUT_UNKNOWN);
+		break;
+
+	case VG_FILTER_FORMAT_LINEAR:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, context->m_filterFormatLinear);
+		break;
+
+	case VG_FILTER_FORMAT_PREMULTIPLIED:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, context->m_filterFormatPremultiplied);
+		break;
+
+	case VG_FILTER_CHANNEL_MASK:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, context->m_filterChannelMask);
+		break;
+
+	case VG_MAX_SCISSOR_RECTS:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, RI_MAX_SCISSOR_RECTANGLES);
+		break;
+
+	case VG_MAX_DASH_COUNT:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, RI_MAX_DASH_COUNT);
+		break;
+
+	case VG_MAX_KERNEL_SIZE:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, RI_MAX_KERNEL_SIZE);
+		break;
+
+	case VG_MAX_SEPARABLE_KERNEL_SIZE:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, RI_MAX_SEPARABLE_KERNEL_SIZE);
+		break;
+
+	case VG_MAX_COLOR_RAMP_STOPS:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, RI_MAX_COLOR_RAMP_STOPS);
+		break;
+
+	case VG_MAX_IMAGE_WIDTH:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, RI_MAX_IMAGE_WIDTH);
+		break;
+
+	case VG_MAX_IMAGE_HEIGHT:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, RI_MAX_IMAGE_HEIGHT);
+		break;
+
+	case VG_MAX_IMAGE_PIXELS:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, RI_MAX_IMAGE_PIXELS);
+		break;
+
+	case VG_MAX_IMAGE_BYTES:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, RI_MAX_IMAGE_BYTES);
+		break;
+
+	case VG_MAX_FLOAT:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		floatToParam(values, floats, count, 0, RI_FLOAT_MAX);
+		break;
+
+	case VG_MAX_GAUSSIAN_STD_DEVIATION:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		floatToParam(values, floats, count, 0, RI_MAX_GAUSSIAN_STD_DEVIATION);
+		break;
+
+	default:
+		context->setError(VG_ILLEGAL_ARGUMENT_ERROR);	//invalid VGParamType
+		break;
+	}
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+VGfloat RI_APIENTRY do_vgGetf(VGParamType type)
+#else
+VGfloat RI_APIENTRY vgGetf(VGParamType type)
+#endif
+{
+	RI_GET_CONTEXT(0.0f);
+	RI_IF_ERROR(type == VG_SCISSOR_RECTS || type == VG_STROKE_DASH_PATTERN || type == VG_TILE_FILL_COLOR ||
+				type == VG_CLEAR_COLOR, VG_ILLEGAL_ARGUMENT_ERROR, 0.0f);	//vector type value
+	RIfloat ret = 0.0f;
+	getifv(context, type, 1, &ret, true);
+	RI_RETURN(ret);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+VGint RI_APIENTRY do_vgGeti(VGParamType type)
+#else
+VGint RI_APIENTRY vgGeti(VGParamType type)
+#endif
+{
+	RI_GET_CONTEXT(0);
+	RI_IF_ERROR(type == VG_SCISSOR_RECTS || type == VG_STROKE_DASH_PATTERN || type == VG_TILE_FILL_COLOR ||
+				type == VG_CLEAR_COLOR, VG_ILLEGAL_ARGUMENT_ERROR, 0);	//vector type value
+	VGint ret = 0;
+	getifv(context, type, 1, &ret, false);
+	RI_RETURN(ret);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgGetiv(VGParamType type, VGint count, VGint * values)
+#else
+void RI_APIENTRY vgGetiv(VGParamType type, VGint count, VGint * values)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(count <= 0, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(!values || !isAligned(values,4), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	getifv(context, type, count, values, false);
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgGetfv(VGParamType type, VGint count, VGfloat * values)
+#else
+void RI_APIENTRY vgGetfv(VGParamType type, VGint count, VGfloat * values)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(count <= 0, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(!values || !isAligned(values,4), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	getifv(context, type, count, values, true);
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+VGint RI_APIENTRY do_vgGetVectorSize(VGParamType type)
+#else
+VGint RI_APIENTRY vgGetVectorSize(VGParamType type)
+#endif
+{
+	RI_GET_CONTEXT(0);
+	VGint ret = 0;
+	switch(type)
+	{
+	case VG_MATRIX_MODE:
+	case VG_FILL_RULE:
+	case VG_IMAGE_QUALITY:
+	case VG_RENDERING_QUALITY:
+	case VG_BLEND_MODE:
+	case VG_IMAGE_MODE:
+		ret = 1;
+		break;
+
+	case VG_SCISSOR_RECTS:
+		ret = 4*context->m_scissor.size();
+		break;
+
+    case VG_COLOR_TRANSFORM:
+        ret = 1;
+        break;
+
+    case VG_COLOR_TRANSFORM_VALUES:
+        ret = 8;
+        break;
+
+	case VG_STROKE_LINE_WIDTH:
+	case VG_STROKE_CAP_STYLE:
+	case VG_STROKE_JOIN_STYLE:
+	case VG_STROKE_MITER_LIMIT:
+		ret = 1;
+		break;
+
+	case VG_STROKE_DASH_PATTERN:
+		ret = context->m_inputStrokeDashPattern.size();
+		break;
+
+	case VG_STROKE_DASH_PHASE:
+	case VG_STROKE_DASH_PHASE_RESET:
+		ret = 1;
+		break;
+
+	case VG_TILE_FILL_COLOR:
+	case VG_CLEAR_COLOR:
+		ret = 4;
+		break;
+
+	case VG_GLYPH_ORIGIN:
+		ret = 2;
+		break;
+
+	case VG_MASKING:
+	case VG_SCISSORING:
+	case VG_PIXEL_LAYOUT:
+	case VG_SCREEN_LAYOUT:
+	case VG_FILTER_FORMAT_LINEAR:
+	case VG_FILTER_FORMAT_PREMULTIPLIED:
+	case VG_FILTER_CHANNEL_MASK:
+	case VG_MAX_SCISSOR_RECTS:
+	case VG_MAX_DASH_COUNT:
+	case VG_MAX_KERNEL_SIZE:
+	case VG_MAX_SEPARABLE_KERNEL_SIZE:
+	case VG_MAX_COLOR_RAMP_STOPS:
+	case VG_MAX_IMAGE_WIDTH:
+	case VG_MAX_IMAGE_HEIGHT:
+	case VG_MAX_IMAGE_PIXELS:
+	case VG_MAX_IMAGE_BYTES:
+	case VG_MAX_FLOAT:
+	case VG_MAX_GAUSSIAN_STD_DEVIATION:
+		ret = 1;
+		break;
+
+	default:
+		context->setError(VG_ILLEGAL_ARGUMENT_ERROR);	//invalid VGParamType
+		break;
+	}
+	RI_RETURN(ret);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+static void setPaintParameterifv(VGContext* context, Paint* paint, VGPaintParamType paramType, VGint count, const void* values, bool floats)
+{
+	RI_ASSERT(context);
+	RI_ASSERT(paint);
+
+	int ivalue = paramToInt(values, floats, count, 0);
+
+	switch(paramType)
+	{
+	case VG_PAINT_TYPE:
+		if(count != 1 || ivalue < VG_PAINT_TYPE_COLOR || ivalue > VG_PAINT_TYPE_PATTERN)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		paint->m_paintType = (VGPaintType)ivalue;
+		break;
+
+	case VG_PAINT_COLOR:
+		if(count != 4)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		paint->m_inputPaintColor.set(paramToFloat(values, floats, count, 0),
+									 paramToFloat(values, floats, count, 1),
+									 paramToFloat(values, floats, count, 2),
+									 paramToFloat(values, floats, count, 3),
+									 Color::sRGBA);
+		paint->m_paintColor = inputColor(paint->m_inputPaintColor);
+		paint->m_paintColor.clamp();
+		paint->m_paintColor.premultiply();
+		break;
+
+	case VG_PAINT_COLOR_RAMP_SPREAD_MODE:
+		if(count != 1 || ivalue < VG_COLOR_RAMP_SPREAD_PAD || ivalue > VG_COLOR_RAMP_SPREAD_REFLECT)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		paint->m_colorRampSpreadMode = (VGColorRampSpreadMode)ivalue;
+		break;
+
+	case VG_PAINT_COLOR_RAMP_STOPS:
+	{
+		int numStops = count/5;
+		if(count != numStops*5)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }	//count must be a multiple of five
+		try
+		{
+			Array<Paint::GradientStop> colorRampStops;
+			Array<Paint::GradientStop> inputColorRampStops;
+			RIfloat prevOffset = -RI_FLOAT_MAX;
+			bool valid = true;
+			for(int i=0;i<RI_INT_MIN(numStops, RI_MAX_COLOR_RAMP_STOPS);i++)	//NOTE: ignores the final stop if there is not enough parameters
+			{
+				Paint::GradientStop gs;
+				gs.offset = paramToFloat(values, floats, count, i*5);
+				gs.color.set(paramToFloat(values, floats, count, i*5+1),
+							 paramToFloat(values, floats, count, i*5+2),
+							 paramToFloat(values, floats, count, i*5+3),
+							 paramToFloat(values, floats, count, i*5+4),
+							 Color::sRGBA);
+				inputColorRampStops.push_back(gs);
+
+				if(gs.offset < prevOffset)
+					valid = false;	//decreasing sequence, ignore it
+
+				if(gs.offset >= 0.0f && gs.offset <= 1.0f)
+				{
+					gs.color.clamp();
+
+					if(!colorRampStops.size() && gs.offset > 0.0f)
+					{	//the first valid stop is not at 0, replicate the first one
+						RIfloat tmp = gs.offset;
+						gs.offset = 0.0f;
+						colorRampStops.push_back(gs);	//throws bad_alloc
+						gs.offset = tmp;
+					}
+					colorRampStops.push_back(gs);	//throws bad_alloc
+				}
+				prevOffset = gs.offset;
+			}
+			if(valid && colorRampStops.size() && colorRampStops[colorRampStops.size()-1].offset < 1.0f)
+			{	//there is at least one stop, but the last one is not at 1, replicate the last one
+				Paint::GradientStop gs = colorRampStops[colorRampStops.size()-1];
+				gs.offset = 1.0f;
+				colorRampStops.push_back(gs);	//throws bad_alloc
+			}
+			if(!valid || !colorRampStops.size())
+			{	//there are no valid stops, add implicit stops
+				colorRampStops.clear();
+				Paint::GradientStop gs;
+				gs.offset = 0.0f;
+				gs.color.set(0,0,0,1,Color::sRGBA);
+				colorRampStops.push_back(gs);	//throws bad_alloc
+				gs.offset = 1.0f;
+				gs.color.set(1,1,1,1,Color::sRGBA);
+				colorRampStops.push_back(gs);	//throws bad_alloc
+			}
+			RI_ASSERT(colorRampStops.size() >= 2 && colorRampStops.size() <= RI_MAX_COLOR_RAMP_STOPS);
+			paint->m_colorRampStops.swap(colorRampStops);	//set paint array
+			paint->m_inputColorRampStops.swap(inputColorRampStops);	//set paint array
+		}
+		catch(std::bad_alloc)
+		{
+			context->setError(VG_OUT_OF_MEMORY_ERROR);
+		}
+		break;
+	}
+
+	case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:
+		if(count != 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		paint->m_colorRampPremultiplied = ivalue ? VG_TRUE : VG_FALSE;
+		break;
+
+	case VG_PAINT_LINEAR_GRADIENT:
+		if(count != 4)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		paint->m_inputLinearGradientPoint0.set(paramToFloat(values, floats, count, 0),
+										  paramToFloat(values, floats, count, 1));
+		paint->m_inputLinearGradientPoint1.set(paramToFloat(values, floats, count, 2),
+										  paramToFloat(values, floats, count, 3));
+        paint->m_linearGradientPoint0 = inputVector2(paint->m_inputLinearGradientPoint0);
+        paint->m_linearGradientPoint1 = inputVector2(paint->m_inputLinearGradientPoint1);
+		break;
+
+	case VG_PAINT_RADIAL_GRADIENT:
+		if(count != 5)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		paint->m_inputRadialGradientCenter.set(paramToFloat(values, floats, count, 0),
+										  paramToFloat(values, floats, count, 1));
+		paint->m_inputRadialGradientFocalPoint.set(paramToFloat(values, floats, count, 2),
+											  paramToFloat(values, floats, count, 3));
+		paint->m_inputRadialGradientRadius = paramToFloat(values, floats, count, 4);
+        paint->m_radialGradientCenter = inputVector2(paint->m_inputRadialGradientCenter);
+        paint->m_radialGradientFocalPoint = inputVector2(paint->m_inputRadialGradientFocalPoint);
+        paint->m_radialGradientRadius = inputFloat(paint->m_inputRadialGradientRadius);
+		break;
+
+	case VG_PAINT_PATTERN_TILING_MODE:
+		if(count != 1 || ivalue < VG_TILE_FILL || ivalue > VG_TILE_REFLECT)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		paint->m_patternTilingMode = (VGTilingMode)ivalue;
+		break;
+
+	default:
+		context->setError(VG_ILLEGAL_ARGUMENT_ERROR);	//invalid VGParamType
+		break;
+	}
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgSetParameterf(VGHandle object, VGint paramType, VGfloat value)
+#else
+void RI_APIENTRY vgSetParameterf(VGHandle object, VGint paramType, VGfloat value)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	bool isImage = context->isValidImage(object);
+	bool isPath = context->isValidPath(object);
+	bool isPaint = context->isValidPaint(object);
+	bool isMaskLayer = context->isValidMaskLayer(object);
+	bool isFont = context->isValidFont(object);
+	RI_IF_ERROR(!isImage && !isPath && !isPaint && !isMaskLayer && !isFont, VG_BAD_HANDLE_ERROR, RI_NO_RETVAL); //invalid object handle
+	RI_IF_ERROR(paramType == VG_PAINT_COLOR || paramType == VG_PAINT_COLOR_RAMP_STOPS || paramType == VG_PAINT_LINEAR_GRADIENT ||
+				paramType == VG_PAINT_RADIAL_GRADIENT, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL); //vector valued parameter
+	VGfloat values[1] = {value};
+	if(isImage)
+	{	//read only, the function does nothing
+		RI_ASSERT(!isPath && !isPaint && !isMaskLayer && !isFont);
+		if(paramType < VG_IMAGE_FORMAT || paramType > VG_IMAGE_HEIGHT)
+			context->setError(VG_ILLEGAL_ARGUMENT_ERROR);	//invalid VGParamType
+	}
+	else if(isPath)
+	{	//read only, the function does nothing
+		RI_ASSERT(!isImage && !isPaint && !isMaskLayer && !isFont);
+		if(paramType < VG_PATH_FORMAT || paramType > VG_PATH_NUM_COORDS)
+			context->setError(VG_ILLEGAL_ARGUMENT_ERROR);	//invalid VGParamType
+	}
+	else if(isPaint)
+	{
+		RI_ASSERT(!isImage && !isPath && !isMaskLayer && !isFont);
+		setPaintParameterifv(context, (Paint*)object, (VGPaintParamType)paramType, 1, values, true);
+	}
+	else if(isMaskLayer)
+	{
+		RI_ASSERT(!isImage && !isPath && !isPaint && !isFont);
+		context->setError(VG_ILLEGAL_ARGUMENT_ERROR);	//invalid VGParamType
+	}
+    else
+	{	//read only, the function does nothing
+		RI_ASSERT(!isImage && !isPath && !isPaint && !isMaskLayer && isFont);
+        if (paramType != VG_FONT_NUM_GLYPHS)
+    		context->setError(VG_ILLEGAL_ARGUMENT_ERROR);	//invalid VGParamType
+    }
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgSetParameteri(VGHandle object, VGint paramType, VGint value)
+#else
+void RI_APIENTRY vgSetParameteri(VGHandle object, VGint paramType, VGint value)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	bool isImage = context->isValidImage(object);
+	bool isPath = context->isValidPath(object);
+	bool isPaint = context->isValidPaint(object);
+	bool isMaskLayer = context->isValidMaskLayer(object);
+	bool isFont = context->isValidFont(object);
+	RI_IF_ERROR(!isImage && !isPath && !isPaint && !isMaskLayer && !isFont, VG_BAD_HANDLE_ERROR, RI_NO_RETVAL); //invalid object handle
+	RI_IF_ERROR(paramType == VG_PAINT_COLOR || paramType == VG_PAINT_COLOR_RAMP_STOPS || paramType == VG_PAINT_LINEAR_GRADIENT ||
+				paramType == VG_PAINT_RADIAL_GRADIENT, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);	//vector valued parameter
+	VGint values[1] = {value};
+	if(isImage)
+	{	//read only, the function does nothing
+		RI_ASSERT(!isPath && !isPaint && !isMaskLayer && !isFont);
+		if(paramType < VG_IMAGE_FORMAT || paramType > VG_IMAGE_HEIGHT)
+			context->setError(VG_ILLEGAL_ARGUMENT_ERROR);	//invalid VGParamType
+	}
+	else if(isPath)
+	{	//read only, the function does nothing
+		RI_ASSERT(!isImage && !isPaint && !isMaskLayer && !isFont);
+		if(paramType < VG_PATH_FORMAT || paramType > VG_PATH_NUM_COORDS)
+			context->setError(VG_ILLEGAL_ARGUMENT_ERROR);	//invalid VGParamType
+	}
+	else if(isPaint)
+	{
+		RI_ASSERT(!isImage && !isPath && !isMaskLayer && !isFont);
+		setPaintParameterifv(context, (Paint*)object, (VGPaintParamType)paramType, 1, values, false);
+	}
+	else if(isMaskLayer)
+	{
+		RI_ASSERT(!isImage && !isPath && !isPaint && !isFont);
+		context->setError(VG_ILLEGAL_ARGUMENT_ERROR);	//invalid VGParamType
+	}
+    else
+	{	//read only, the function does nothing
+		RI_ASSERT(!isImage && !isPath && !isPaint && !isMaskLayer && isFont);
+        if (paramType != VG_FONT_NUM_GLYPHS)
+    		context->setError(VG_ILLEGAL_ARGUMENT_ERROR);	//invalid VGParamType
+    }
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgSetParameterfv(VGHandle object, VGint paramType, VGint count, const VGfloat * values)
+#else
+void RI_APIENTRY vgSetParameterfv(VGHandle object, VGint paramType, VGint count, const VGfloat * values)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(count < 0 || (!values && count > 0) || (values && !isAligned(values,4)), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	bool isImage = context->isValidImage(object);
+	bool isPath = context->isValidPath(object);
+	bool isPaint = context->isValidPaint(object);
+	bool isMaskLayer = context->isValidMaskLayer(object);
+	bool isFont = context->isValidFont(object);
+	RI_IF_ERROR(!isImage && !isPath && !isPaint && !isMaskLayer && !isFont, VG_BAD_HANDLE_ERROR, RI_NO_RETVAL); //invalid object handle
+	if(isImage)
+	{	//read only, the function does nothing
+		RI_ASSERT(!isPath && !isPaint && !isMaskLayer && !isFont);
+		if(paramType < VG_IMAGE_FORMAT || paramType > VG_IMAGE_HEIGHT)
+			context->setError(VG_ILLEGAL_ARGUMENT_ERROR);	//invalid VGParamType
+	}
+	else if(isPath)
+	{	//read only, the function does nothing
+		RI_ASSERT(!isImage && !isPaint && !isMaskLayer && !isFont);
+		if(paramType < VG_PATH_FORMAT || paramType > VG_PATH_NUM_COORDS)
+			context->setError(VG_ILLEGAL_ARGUMENT_ERROR);	//invalid VGParamType
+	}
+	else if(isPaint)
+	{
+		RI_ASSERT(!isImage && !isPath && !isMaskLayer && !isFont);
+		setPaintParameterifv(context, (Paint*)object, (VGPaintParamType)paramType, count, values, true);
+	}
+	else if(isMaskLayer)
+	{
+		RI_ASSERT(!isImage && !isPath && !isPaint && !isFont);
+		context->setError(VG_ILLEGAL_ARGUMENT_ERROR);	//invalid VGParamType
+	}
+    else
+	{	//read only, the function does nothing
+		RI_ASSERT(!isImage && !isPath && !isPaint && !isMaskLayer && isFont);
+        if (paramType != VG_FONT_NUM_GLYPHS)
+    		context->setError(VG_ILLEGAL_ARGUMENT_ERROR);	//invalid VGParamType
+    }
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgSetParameteriv(VGHandle object, VGint paramType, VGint count, const VGint * values)
+#else
+void RI_APIENTRY vgSetParameteriv(VGHandle object, VGint paramType, VGint count, const VGint * values)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(count < 0 || (!values && count > 0) || (values && !isAligned(values,4)), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	bool isImage = context->isValidImage(object);
+	bool isPath = context->isValidPath(object);
+	bool isPaint = context->isValidPaint(object);
+	bool isMaskLayer = context->isValidMaskLayer(object);
+	bool isFont = context->isValidFont(object);
+	RI_IF_ERROR(!isImage && !isPath && !isPaint && !isMaskLayer && !isFont, VG_BAD_HANDLE_ERROR, RI_NO_RETVAL); //invalid object handle
+	if(isImage)
+	{	//read only, the function does nothing
+		RI_ASSERT(!isPath && !isPaint && !isMaskLayer && !isFont);
+		if(paramType < VG_IMAGE_FORMAT || paramType > VG_IMAGE_HEIGHT)
+			context->setError(VG_ILLEGAL_ARGUMENT_ERROR);	//invalid VGParamType
+	}
+	else if(isPath)
+	{	//read only, the function does nothing
+		RI_ASSERT(!isImage && !isPaint && !isMaskLayer && !isFont);
+		if(paramType < VG_PATH_FORMAT || paramType > VG_PATH_NUM_COORDS)
+			context->setError(VG_ILLEGAL_ARGUMENT_ERROR);	//invalid VGParamType
+	}
+	else if(isPaint)
+	{
+		RI_ASSERT(!isImage && !isPath && !isMaskLayer && !isFont);
+		setPaintParameterifv(context, (Paint*)object, (VGPaintParamType)paramType, count, values, false);
+	}
+	else if(isMaskLayer)
+	{
+		RI_ASSERT(!isImage && !isPath && !isPaint && !isFont);
+		context->setError(VG_ILLEGAL_ARGUMENT_ERROR);	//invalid VGParamType
+	}
+    else
+	{	//read only, the function does nothing
+		RI_ASSERT(!isImage && !isPath && !isPaint && !isMaskLayer && isFont);
+        if (paramType != VG_FONT_NUM_GLYPHS)
+    		context->setError(VG_ILLEGAL_ARGUMENT_ERROR);	//invalid VGParamType
+    }
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+static void getPaintParameterifv(VGContext* context, Paint* paint, VGPaintParamType type, VGint count, void* values, bool floats)
+{
+	switch(type)
+	{
+	case VG_PAINT_TYPE:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, paint->m_paintType);
+		break;
+
+	case VG_PAINT_COLOR:
+		if(count > 4)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		floatToParam(values, floats, count, 0, paint->m_inputPaintColor.r);
+		floatToParam(values, floats, count, 1, paint->m_inputPaintColor.g);
+		floatToParam(values, floats, count, 2, paint->m_inputPaintColor.b);
+		floatToParam(values, floats, count, 3, paint->m_inputPaintColor.a);
+		break;
+
+	case VG_PAINT_COLOR_RAMP_SPREAD_MODE:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, paint->m_colorRampSpreadMode);
+		break;
+
+	case VG_PAINT_COLOR_RAMP_STOPS:
+		{
+			if(count > paint->m_inputColorRampStops.size()*5)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+			int j = 0;
+			for(int i=0;i<paint->m_inputColorRampStops.size();i++)
+			{
+				floatToParam(values, floats, count, j++, paint->m_inputColorRampStops[i].offset);
+				floatToParam(values, floats, count, j++, paint->m_inputColorRampStops[i].color.r);
+				floatToParam(values, floats, count, j++, paint->m_inputColorRampStops[i].color.g);
+				floatToParam(values, floats, count, j++, paint->m_inputColorRampStops[i].color.b);
+				floatToParam(values, floats, count, j++, paint->m_inputColorRampStops[i].color.a);
+			}
+			break;
+		}
+
+	case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, paint->m_colorRampPremultiplied);
+		break;
+
+	case VG_PAINT_LINEAR_GRADIENT:
+		if(count > 4)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		floatToParam(values, floats, count, 0, paint->m_inputLinearGradientPoint0.x);
+		floatToParam(values, floats, count, 1, paint->m_inputLinearGradientPoint0.y);
+		floatToParam(values, floats, count, 2, paint->m_inputLinearGradientPoint1.x);
+		floatToParam(values, floats, count, 3, paint->m_inputLinearGradientPoint1.y);
+		break;
+
+	case VG_PAINT_RADIAL_GRADIENT:
+		if(count > 5)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		floatToParam(values, floats, count, 0, paint->m_inputRadialGradientCenter.x);
+		floatToParam(values, floats, count, 1, paint->m_inputRadialGradientCenter.y);
+		floatToParam(values, floats, count, 2, paint->m_inputRadialGradientFocalPoint.x);
+		floatToParam(values, floats, count, 3, paint->m_inputRadialGradientFocalPoint.y);
+		floatToParam(values, floats, count, 4, paint->m_inputRadialGradientRadius);
+		break;
+
+	case VG_PAINT_PATTERN_TILING_MODE:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, paint->m_patternTilingMode);
+		break;
+
+	default:
+		context->setError(VG_ILLEGAL_ARGUMENT_ERROR);	//invalid VGParamType
+		break;
+	}
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+static void getPathParameterifv(VGContext* context, Path* path, VGPathParamType type, VGint count, void* values, bool floats)
+{
+	switch(type)
+	{
+	case VG_PATH_FORMAT:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, path->getFormat());
+		break;
+
+	case VG_PATH_DATATYPE:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, path->getDatatype());
+		break;
+
+	case VG_PATH_SCALE:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		floatToParam(values, floats, count, 0, path->getScale());
+		break;
+
+	case VG_PATH_BIAS:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		floatToParam(values, floats, count, 0, path->getBias());
+		break;
+
+	case VG_PATH_NUM_SEGMENTS:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, path->getNumSegments());
+		break;
+
+	case VG_PATH_NUM_COORDS:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, path->getNumCoordinates());
+		break;
+
+	default:
+		context->setError(VG_ILLEGAL_ARGUMENT_ERROR);	//invalid VGParamType
+		break;
+	}
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+static void getImageParameterifv(VGContext* context, Image* image, VGImageParamType type, VGint count, void* values, bool floats)
+{
+	switch(type)
+	{
+	case VG_IMAGE_FORMAT:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		RI_ASSERT(isValidImageFormat(image->getDescriptor().format));
+		intToParam(values, floats, count, 0, image->getDescriptor().format);
+		break;
+
+	case VG_IMAGE_WIDTH:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, image->getWidth());
+		break;
+
+	case VG_IMAGE_HEIGHT:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, image->getHeight());
+		break;
+
+	default:
+		context->setError(VG_ILLEGAL_ARGUMENT_ERROR);	//invalid VGParamType
+		break;
+	}
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+static void getFontParameterifv(VGContext* context, Font* font, VGFontParamType type, VGint count, void* values, bool floats)
+{
+	switch(type)
+	{
+	case VG_FONT_NUM_GLYPHS:
+		if(count > 1)	{ context->setError(VG_ILLEGAL_ARGUMENT_ERROR); return; }
+		intToParam(values, floats, count, 0, font->getNumGlyphs());
+		break;
+
+	default:
+		context->setError(VG_ILLEGAL_ARGUMENT_ERROR);	//invalid VGParamType
+		break;
+	}
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+VGfloat RI_APIENTRY do_vgGetParameterf(VGHandle object, VGint paramType)
+#else
+VGfloat RI_APIENTRY vgGetParameterf(VGHandle object, VGint paramType)
+#endif
+{
+	RI_GET_CONTEXT(0.0f);
+	RI_IF_ERROR(paramType == VG_PAINT_COLOR || paramType == VG_PAINT_COLOR_RAMP_STOPS || paramType == VG_PAINT_LINEAR_GRADIENT ||
+				paramType == VG_PAINT_RADIAL_GRADIENT, VG_ILLEGAL_ARGUMENT_ERROR, 0.0f);	//vector valued parameter
+	bool isImage = context->isValidImage(object);
+	bool isPath = context->isValidPath(object);
+	bool isPaint = context->isValidPaint(object);
+	bool isFont = context->isValidFont(object);
+	RI_IF_ERROR(!isImage && !isPath && !isPaint && !isFont, VG_BAD_HANDLE_ERROR, 0.0f);	//invalid object handle
+	VGfloat ret = 0.0f;
+	if(isImage)
+	{
+		RI_ASSERT(!isPath && !isPaint && !isFont);
+		getImageParameterifv(context, (Image*)object, (VGImageParamType)paramType, 1, &ret, true);
+	}
+	else if(isPath)
+	{
+		RI_ASSERT(!isImage && !isPaint && !isFont);
+		getPathParameterifv(context, (Path*)object, (VGPathParamType)paramType, 1, &ret, true);
+	}
+	else if(isPaint)
+	{
+		RI_ASSERT(!isImage && !isPath && !isFont);
+		getPaintParameterifv(context, (Paint*)object, (VGPaintParamType)paramType, 1, &ret, true);
+	}
+	else
+	{
+		RI_ASSERT(!isImage && !isPath && !isPaint && isFont);
+		getFontParameterifv(context, (Font*)object, (VGFontParamType)paramType, 1, &ret, true);
+	}
+	RI_RETURN(ret);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+VGint RI_APIENTRY do_vgGetParameteri(VGHandle object, VGint paramType)
+#else
+VGint RI_APIENTRY vgGetParameteri(VGHandle object, VGint paramType)
+#endif
+{
+	RI_GET_CONTEXT(0);
+	RI_IF_ERROR(paramType == VG_PAINT_COLOR || paramType == VG_PAINT_COLOR_RAMP_STOPS || paramType == VG_PAINT_LINEAR_GRADIENT ||
+				paramType == VG_PAINT_RADIAL_GRADIENT, VG_ILLEGAL_ARGUMENT_ERROR, 0);	//vector valued parameter
+	bool isImage = context->isValidImage(object);
+	bool isPath = context->isValidPath(object);
+	bool isPaint = context->isValidPaint(object);
+	bool isFont = context->isValidFont(object);
+	RI_IF_ERROR(!isImage && !isPath && !isPaint && !isFont, VG_BAD_HANDLE_ERROR, 0);	//invalid object handle
+	VGint ret = 0;
+	if(isImage)
+	{
+		RI_ASSERT(!isPath && !isPaint && !isFont);
+		getImageParameterifv(context, (Image*)object, (VGImageParamType)paramType, 1, &ret, false);
+	}
+	else if(isPath)
+	{
+		RI_ASSERT(!isImage && !isPaint && !isFont);
+		getPathParameterifv(context, (Path*)object, (VGPathParamType)paramType, 1, &ret, false);
+	}
+	else if(isPaint)
+	{
+		RI_ASSERT(!isImage && !isPath && !isFont);
+		getPaintParameterifv(context, (Paint*)object, (VGPaintParamType)paramType, 1, &ret, false);
+	}
+	else
+	{
+		RI_ASSERT(!isImage && !isPath && !isPaint && isFont);
+		getFontParameterifv(context, (Font*)object, (VGFontParamType)paramType, 1, &ret, false);
+	}
+	RI_RETURN(ret);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgGetParameterfv(VGHandle object, VGint paramType, VGint count, VGfloat * values)
+#else
+void RI_APIENTRY vgGetParameterfv(VGHandle object, VGint paramType, VGint count, VGfloat * values)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(count <= 0 || !values || !isAligned(values,4), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	bool isImage = context->isValidImage(object);
+	bool isPath = context->isValidPath(object);
+	bool isPaint = context->isValidPaint(object);
+	bool isFont = context->isValidFont(object);
+	RI_IF_ERROR(!isImage && !isPath && !isPaint && !isFont, VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);	//invalid object handle
+	if(isImage)
+	{
+		RI_ASSERT(!isPath && !isPaint && !isFont);
+		getImageParameterifv(context, (Image*)object, (VGImageParamType)paramType, count, values, true);
+	}
+	else if(isPath)
+	{
+		RI_ASSERT(!isImage && !isPaint && !isFont);
+		getPathParameterifv(context, (Path*)object, (VGPathParamType)paramType, count, values, true);
+	}
+	else if(isPaint)
+	{
+		RI_ASSERT(!isImage && !isPath && !isFont);
+		getPaintParameterifv(context, (Paint*)object, (VGPaintParamType)paramType, count, values, true);
+	}
+	else
+	{
+		RI_ASSERT(!isImage && !isPath && !isPaint && isFont);
+		getFontParameterifv(context, (Font*)object, (VGFontParamType)paramType, count, values, true);
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgGetParameteriv(VGHandle object, VGint paramType, VGint count, VGint * values)
+#else
+void RI_APIENTRY vgGetParameteriv(VGHandle object, VGint paramType, VGint count, VGint * values)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(count <= 0 || !values || !isAligned(values,4), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	bool isImage = context->isValidImage(object);
+	bool isPath = context->isValidPath(object);
+	bool isPaint = context->isValidPaint(object);
+	bool isFont = context->isValidFont(object);
+	RI_IF_ERROR(!isImage && !isPath && !isPaint && !isFont, VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);	//invalid object handle
+	if(isImage)
+	{
+		RI_ASSERT(!isPath && !isPaint && !isFont);
+		getImageParameterifv(context, (Image*)object, (VGImageParamType)paramType, count, values, false);
+	}
+	else if(isPath)
+	{
+		RI_ASSERT(!isImage && !isPaint && !isFont);
+		getPathParameterifv(context, (Path*)object, (VGPathParamType)paramType, count, values, false);
+	}
+	else if(isPaint)
+	{
+		RI_ASSERT(!isImage && !isPath && !isFont);
+		getPaintParameterifv(context, (Paint*)object, (VGPaintParamType)paramType, count, values, false);
+	}
+	else
+	{
+		RI_ASSERT(!isImage && !isPath && !isPaint && isFont);
+		getFontParameterifv(context, (Font*)object, (VGFontParamType)paramType, count, values, false);
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+VGint RI_APIENTRY do_vgGetParameterVectorSize(VGHandle object, VGint paramType)
+#else
+VGint RI_APIENTRY vgGetParameterVectorSize(VGHandle object, VGint paramType)
+#endif
+{
+	RI_GET_CONTEXT(0);
+	bool isImage = context->isValidImage(object);
+	bool isPath = context->isValidPath(object);
+	bool isPaint = context->isValidPaint(object);
+	bool isFont = context->isValidFont(object);
+	RI_IF_ERROR(!isImage && !isPath && !isPaint && !isFont, VG_BAD_HANDLE_ERROR, 0);	//invalid object handle
+	int ret = 0;
+	if(isImage)
+	{
+		RI_ASSERT(!isPath && !isPaint && !isFont);
+		switch(paramType)
+		{
+		case VG_IMAGE_FORMAT:
+		case VG_IMAGE_WIDTH:
+		case VG_IMAGE_HEIGHT:
+			ret = 1;
+			break;
+
+		default:
+			context->setError(VG_ILLEGAL_ARGUMENT_ERROR);	//invalid paramType
+			break;
+		}
+	}
+	else if(isPath)
+	{
+		RI_ASSERT(!isImage && !isPaint && !isFont);
+		switch(paramType)
+		{
+		case VG_PATH_FORMAT:
+		case VG_PATH_DATATYPE:
+		case VG_PATH_SCALE:
+		case VG_PATH_BIAS:
+		case VG_PATH_NUM_SEGMENTS:
+		case VG_PATH_NUM_COORDS:
+			ret = 1;
+			break;
+
+		default:
+			context->setError(VG_ILLEGAL_ARGUMENT_ERROR);	//invalid paramType
+			break;
+		}
+	}
+	else if(isPaint)
+	{
+		RI_ASSERT(!isImage && !isPath && !isFont);
+		switch(paramType)
+		{
+		case VG_PAINT_TYPE:
+		case VG_PAINT_COLOR_RAMP_SPREAD_MODE:
+		case VG_PAINT_PATTERN_TILING_MODE:
+			ret = 1;
+			break;
+
+		case VG_PAINT_COLOR:
+		case VG_PAINT_LINEAR_GRADIENT:
+			ret = 4;
+			break;
+
+		case VG_PAINT_COLOR_RAMP_STOPS:
+			ret = ((Paint*)object)->m_inputColorRampStops.size() * 5;
+			break;
+
+		case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:
+			ret = 1;
+			break;
+
+		case VG_PAINT_RADIAL_GRADIENT:
+			ret = 5;
+			break;
+			
+		default:
+			context->setError(VG_ILLEGAL_ARGUMENT_ERROR);	//invalid paramType
+			break;
+		}
+	}
+	else
+	{
+		RI_ASSERT(!isImage && !isPath && !isPaint && isFont);
+		switch(paramType)
+		{
+		case VG_FONT_NUM_GLYPHS:
+			ret = 1;
+			break;
+
+		default:
+			context->setError(VG_ILLEGAL_ARGUMENT_ERROR);	//invalid paramType
+			break;
+		}
+	}
+	RI_RETURN(ret);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+static Matrix3x3* getCurrentMatrix(VGContext* context)
+{
+	RI_ASSERT(context);
+	switch(context->m_matrixMode)
+	{
+	case VG_MATRIX_PATH_USER_TO_SURFACE:
+		return &context->m_pathUserToSurface;
+
+	case VG_MATRIX_IMAGE_USER_TO_SURFACE:
+		return &context->m_imageUserToSurface;
+
+	case VG_MATRIX_FILL_PAINT_TO_USER:
+		return &context->m_fillPaintToUser;
+
+	case VG_MATRIX_STROKE_PAINT_TO_USER:
+		return &context->m_strokePaintToUser;
+
+	default:
+		RI_ASSERT(context->m_matrixMode == VG_MATRIX_GLYPH_USER_TO_SURFACE);
+		return &context->m_glyphUserToSurface;
+	}
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgLoadIdentity(void)
+#else
+void RI_APIENTRY vgLoadIdentity(void)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	Matrix3x3* d = getCurrentMatrix(context);
+	d->identity();
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgLoadMatrix(const VGfloat * m)
+#else
+void RI_APIENTRY vgLoadMatrix(const VGfloat * m)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!m || !isAligned(m,4), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	Matrix3x3* d = getCurrentMatrix(context);
+	d->set(inputFloat(m[0]), inputFloat(m[3]), inputFloat(m[6]),
+		   inputFloat(m[1]), inputFloat(m[4]), inputFloat(m[7]),
+		   inputFloat(m[2]), inputFloat(m[5]), inputFloat(m[8]));
+	if(context->m_matrixMode != VG_MATRIX_IMAGE_USER_TO_SURFACE)
+	{
+		(*d)[2].set(0,0,1);
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgGetMatrix(VGfloat * m)
+#else
+void RI_APIENTRY vgGetMatrix(VGfloat * m)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!m || !isAligned(m,4), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	Matrix3x3* d = getCurrentMatrix(context);
+	m[0] = (*d)[0][0];
+	m[1] = (*d)[1][0];
+	m[2] = (*d)[2][0];
+	m[3] = (*d)[0][1];
+	m[4] = (*d)[1][1];
+	m[5] = (*d)[2][1];
+	m[6] = (*d)[0][2];
+	m[7] = (*d)[1][2];
+	m[8] = (*d)[2][2];
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgMultMatrix(const VGfloat * m)
+#else
+void RI_APIENTRY vgMultMatrix(const VGfloat * m)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!m || !isAligned(m,4), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	Matrix3x3 n(inputFloat(m[0]), inputFloat(m[3]), inputFloat(m[6]),
+				inputFloat(m[1]), inputFloat(m[4]), inputFloat(m[7]),
+				inputFloat(m[2]), inputFloat(m[5]), inputFloat(m[8]));
+	if(context->m_matrixMode != VG_MATRIX_IMAGE_USER_TO_SURFACE)
+		n[2].set(0,0,1);
+
+	Matrix3x3* d = getCurrentMatrix(context);
+	*d *= n;
+	if(context->m_matrixMode != VG_MATRIX_IMAGE_USER_TO_SURFACE)
+	{
+		(*d)[2].set(0,0,1);	//force affinity
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgTranslate(VGfloat tx, VGfloat ty)
+#else
+void RI_APIENTRY vgTranslate(VGfloat tx, VGfloat ty)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	Matrix3x3 n(1, 0, inputFloat(tx),
+				0, 1, inputFloat(ty),
+				0, 0, 1 );
+	Matrix3x3* d = getCurrentMatrix(context);
+	*d *= n;
+	if(context->m_matrixMode != VG_MATRIX_IMAGE_USER_TO_SURFACE)
+	{
+		(*d)[2].set(0,0,1);	//force affinity
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgScale(VGfloat sx, VGfloat sy)
+#else
+void RI_APIENTRY vgScale(VGfloat sx, VGfloat sy)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	Matrix3x3 n(inputFloat(sx), 0,              0,
+				0,              inputFloat(sy), 0,
+				0,              0,              1 );
+	Matrix3x3* d = getCurrentMatrix(context);
+	*d *= n;
+	if(context->m_matrixMode != VG_MATRIX_IMAGE_USER_TO_SURFACE)
+	{
+		(*d)[2].set(0,0,1);	//force affinity
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgShear(VGfloat shx, VGfloat shy)
+#else
+void RI_APIENTRY vgShear(VGfloat shx, VGfloat shy)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	Matrix3x3 n(1,               inputFloat(shx), 0,
+				inputFloat(shy), 1,               0,
+				0,               0,               1);
+	Matrix3x3* d = getCurrentMatrix(context);
+	*d *= n;
+	if(context->m_matrixMode != VG_MATRIX_IMAGE_USER_TO_SURFACE)
+	{
+		(*d)[2].set(0,0,1);	//force affinity
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgRotate(VGfloat angle)
+#else
+void RI_APIENTRY vgRotate(VGfloat angle)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RIfloat a = RI_DEG_TO_RAD(inputFloat(angle));
+	Matrix3x3 n((RIfloat)cos(a), -(RIfloat)sin(a), 0,
+				(RIfloat)sin(a),  (RIfloat)cos(a), 0,
+				0,              0,             1 );
+	Matrix3x3* d = getCurrentMatrix(context);
+	*d *= n;
+	if(context->m_matrixMode != VG_MATRIX_IMAGE_USER_TO_SURFACE)
+	{
+		(*d)[2].set(0,0,1);	//force affinity
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgMask(VGHandle mask, VGMaskOperation operation, VGint x, VGint y, VGint width, VGint height)
+#else
+void RI_APIENTRY vgMask(VGHandle mask, VGMaskOperation operation, VGint x, VGint y, VGint width, VGint height)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+    bool isImage = context->isValidImage(mask);
+    bool isMaskLayer = context->isValidMaskLayer(mask);
+	RI_IF_ERROR(operation != VG_CLEAR_MASK && operation != VG_FILL_MASK && !isImage && !isMaskLayer, VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(operation != VG_CLEAR_MASK && operation != VG_FILL_MASK && isImage && eglvgIsInUse((Image*)mask), VG_IMAGE_IN_USE_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(operation < VG_CLEAR_MASK || operation > VG_SUBTRACT_MASK, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(width <= 0 || height <= 0, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+    Drawable* drawable = context->getCurrentDrawable();
+	RI_IF_ERROR(isMaskLayer && drawable->getNumSamples() != ((Surface*)mask)->getNumSamples(), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+    if(!drawable || !drawable->getMaskBuffer())
+    {
+        RI_RETURN(RI_NO_RETVAL);	//no EGL surface is current at the moment or context has no mask buffer
+    }
+    if(isImage)
+        drawable->getMaskBuffer()->mask((Image*)mask, operation, x, y, width, height);
+    else
+        drawable->getMaskBuffer()->mask((Surface*)mask, operation, x, y, width, height);
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+static void renderStroke(const VGContext* context, int w, int h, int numSamples, Path* path, Rasterizer& rasterizer, const PixelPipe* pixelPipe, const Matrix3x3& userToSurface)
+{
+    RI_ASSERT(context);
+    RI_ASSERT(w > 0 && h > 0 && numSamples >= 1 && numSamples <= 32);
+
+    RIuint32* covBuffer = RI_NEW_ARRAY(RIuint32, w*h);
+    memset(covBuffer, 0, w*h*sizeof(RIuint32));
+
+    rasterizer.setup(0, 0, w, h, VG_NON_ZERO, NULL, covBuffer);
+    path->stroke(userToSurface, rasterizer, context->m_strokeDashPattern, context->m_strokeDashPhase, context->m_strokeDashPhaseReset ? true : false,
+                 context->m_strokeLineWidth, context->m_strokeCapStyle, context->m_strokeJoinStyle, RI_MAX(context->m_strokeMiterLimit, 1.0f));	//throws bad_alloc
+
+    int sx,sy,ex,ey;
+    rasterizer.getBBox(sx,sy,ex,ey);
+    RI_ASSERT(sx >= 0 && sx <= w);
+    RI_ASSERT(sy >= 0 && sy <= h);
+    RI_ASSERT(ex >= 0 && ex <= w);
+    RI_ASSERT(ey >= 0 && ey <= h);
+
+    for(int j=sy;j<ey;j++)
+    {
+        for(int i=sx;i<ex;i++)
+        {
+            unsigned int c = covBuffer[j*w+i];
+            if(c)
+            {
+                int coverage = 0;
+                for(int k=0;k<numSamples;k++)
+                {
+                    if(c & (1<<k))
+                        coverage++;
+                }
+                pixelPipe->pixelPipe(i, j, (RIfloat)coverage/(RIfloat)numSamples, c);
+            }
+        }
+    }
+    RI_DELETE_ARRAY(covBuffer);
+}
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgRenderToMask(VGPath path, VGbitfield paintModes, VGMaskOperation operation)
+#else
+void RI_APIENTRY vgRenderToMask(VGPath path, VGbitfield paintModes, VGMaskOperation operation)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidPath(path), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);	//invalid path handle
+	RI_IF_ERROR(!paintModes || (paintModes & ~(VG_FILL_PATH | VG_STROKE_PATH)), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);	//invalid paint mode
+	RI_IF_ERROR(operation < VG_CLEAR_MASK || operation > VG_SUBTRACT_MASK, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+    Drawable* curr = context->getCurrentDrawable();
+    if(!curr || !curr->getMaskBuffer())
+    {
+        RI_RETURN(RI_NO_RETVAL);	//no EGL surface is current at the moment or context has no mask buffer
+    }
+
+    if(operation == VG_CLEAR_MASK || operation == VG_FILL_MASK)
+    {
+        Surface* dummy = NULL;
+        curr->getMaskBuffer()->mask(dummy, operation, 0, 0, curr->getWidth(), curr->getHeight());
+        RI_RETURN(RI_NO_RETVAL);
+    }
+
+	try
+	{
+        Drawable drawable(Color::formatToDescriptor(VG_A_8), curr->getWidth(), curr->getHeight(), curr->getNumSamples(), 1);    //TODO 0 mask bits (mask buffer is not used)
+
+        Rasterizer rasterizer;
+        if(context->m_scissoring)
+            rasterizer.setScissor(context->m_scissor);	//throws bad_alloc
+        int numSamples = rasterizer.setupSamplingPattern(context->m_renderingQuality, drawable.getNumSamples());
+
+        PixelPipe pixelPipe;
+        pixelPipe.setDrawable(&drawable);
+        pixelPipe.setMask(false);
+        pixelPipe.setPaint(NULL);   //use default paint (solid color alpha = 1)
+        pixelPipe.setBlendMode(VG_BLEND_SRC);   //write solid color * coverage to dest
+
+        Matrix3x3 userToSurface = context->m_pathUserToSurface;
+        userToSurface[2].set(0,0,1);	//force affinity
+
+        if(paintModes & VG_FILL_PATH)
+        {
+            drawable.getColorBuffer()->clear(Color(0,0,0,0,drawable.getColorBuffer()->getDescriptor().internalFormat), 0, 0, drawable.getWidth(), drawable.getHeight());
+            ((Path*)path)->fill(userToSurface, rasterizer);	//throws bad_alloc
+            rasterizer.setup(0, 0, drawable.getWidth(), drawable.getHeight(), context->m_fillRule, &pixelPipe, NULL);
+            rasterizer.fill();	//throws bad_alloc
+            curr->getMaskBuffer()->mask(drawable.getColorBuffer(), operation, 0, 0, drawable.getWidth(), drawable.getHeight());
+        }
+
+        if(paintModes & VG_STROKE_PATH && context->m_strokeLineWidth > 0.0f)
+        {
+            drawable.getColorBuffer()->clear(Color(0,0,0,0,drawable.getColorBuffer()->getDescriptor().internalFormat), 0, 0, drawable.getWidth(), drawable.getHeight());
+            renderStroke(context, drawable.getWidth(), drawable.getHeight(), numSamples, (Path*)path, rasterizer, &pixelPipe, userToSurface);
+            curr->getMaskBuffer()->mask(drawable.getColorBuffer(), operation, 0, 0, drawable.getWidth(), drawable.getHeight());
+        }
+	}
+	catch(std::bad_alloc)
+	{
+		context->setError(VG_OUT_OF_MEMORY_ERROR);
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+VGMaskLayer RI_APIENTRY do_vgCreateMaskLayer(VGint width, VGint height)
+#else
+VGMaskLayer RI_APIENTRY vgCreateMaskLayer(VGint width, VGint height)
+#endif
+{
+	RI_GET_CONTEXT(VG_INVALID_HANDLE);
+	RI_IF_ERROR(width <= 0 || height <= 0, VG_ILLEGAL_ARGUMENT_ERROR, VG_INVALID_HANDLE);
+	RI_IF_ERROR(width > RI_MAX_IMAGE_WIDTH || height > RI_MAX_IMAGE_HEIGHT || width*height > RI_MAX_IMAGE_PIXELS ||
+				width*height > RI_MAX_IMAGE_BYTES, VG_ILLEGAL_ARGUMENT_ERROR, VG_INVALID_HANDLE);
+    Drawable* curr = context->getCurrentDrawable();
+    if(!curr || !curr->getMaskBuffer())
+        RI_RETURN(VG_INVALID_HANDLE);   //no current drawing surface
+
+	Surface* layer = NULL;
+	try
+	{
+		layer = RI_NEW(Surface, (Color::formatToDescriptor(VG_A_8), width, height, curr->getNumSamples()));	//throws bad_alloc
+		RI_ASSERT(layer);
+		context->m_maskLayerManager->addResource(layer, context);	//throws bad_alloc
+        layer->clear(Color(1,1,1,1,Color::sRGBA), 0, 0, width, height);
+		RI_RETURN((VGMaskLayer)layer);
+	}
+	catch(std::bad_alloc)
+	{
+		RI_DELETE(layer);
+		context->setError(VG_OUT_OF_MEMORY_ERROR);
+		RI_RETURN(VG_INVALID_HANDLE);
+	}
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgDestroyMaskLayer(VGMaskLayer maskLayer)
+#else
+void RI_APIENTRY vgDestroyMaskLayer(VGMaskLayer maskLayer)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidMaskLayer(maskLayer), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);	//invalid handle
+
+	context->m_maskLayerManager->removeResource((Surface*)maskLayer);
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgFillMaskLayer(VGMaskLayer maskLayer, VGint x, VGint y, VGint width, VGint height, VGfloat value)
+#else
+void RI_APIENTRY vgFillMaskLayer(VGMaskLayer maskLayer, VGint x, VGint y, VGint width, VGint height, VGfloat value)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidMaskLayer(maskLayer), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);	//invalid handle
+    RI_IF_ERROR(value < 0.0f || value > 1.0f, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+    Surface* layer = (Surface*)maskLayer;
+    RI_IF_ERROR(width <= 0 || height <= 0 || x < 0 || y < 0 || x > layer->getWidth()-width || y > layer->getHeight()-height, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+    layer->clear(Color(1,1,1,value,Color::sRGBA), x, y, width, height);
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgCopyMask(VGMaskLayer maskLayer, VGint dx, VGint dy, VGint sx, VGint sy, VGint width, VGint height)
+#else
+void RI_APIENTRY vgCopyMask(VGMaskLayer maskLayer, VGint dx, VGint dy, VGint sx, VGint sy, VGint width, VGint height)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidMaskLayer(maskLayer), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);	//invalid handle
+    Drawable* drawable = context->getCurrentDrawable();
+    if(!drawable || !drawable->getMaskBuffer())
+    {
+        RI_RETURN(RI_NO_RETVAL);	//no EGL surface is current at the moment or context has no mask buffer
+    }
+    Surface* layer = (Surface*)maskLayer;
+    RI_IF_ERROR(width <= 0 || height <= 0 || drawable->getNumSamples() != layer->getNumSamples(), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+    try
+    {   //copy drawing surface mask to mask layer
+        layer->blit(drawable->getMaskBuffer(), sx, sy, dx, dy, width, height);	//throws bad_alloc
+    }
+	catch(std::bad_alloc)
+	{
+		context->setError(VG_OUT_OF_MEMORY_ERROR);
+	}
+    RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgClear(VGint x, VGint y, VGint width, VGint height)
+#else
+void RI_APIENTRY vgClear(VGint x, VGint y, VGint width, VGint height)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(width <= 0 || height <= 0, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+    Drawable* drawable = context->getCurrentDrawable();
+    if(!drawable)
+    {
+        RI_RETURN(RI_NO_RETVAL);	//no EGL surface is current at the moment
+    }
+
+	try
+	{
+		if(context->m_scissoring)
+			drawable->getColorBuffer()->clear(context->m_clearColor, x, y, width, height, context->m_scissor);	//throws bad_alloc
+		else
+			drawable->getColorBuffer()->clear(context->m_clearColor, x, y, width, height);
+	}
+	catch(std::bad_alloc)
+	{
+		context->setError(VG_OUT_OF_MEMORY_ERROR);
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+VGPath RI_APIENTRY do_vgCreatePath(VGint pathFormat, VGPathDatatype datatype, VGfloat scale, VGfloat bias, VGint segmentCapacityHint, VGint coordCapacityHint, VGbitfield capabilities)
+#else
+VGPath RI_APIENTRY vgCreatePath(VGint pathFormat, VGPathDatatype datatype, VGfloat scale, VGfloat bias, VGint segmentCapacityHint, VGint coordCapacityHint, VGbitfield capabilities)
+#endif
+{
+	RI_GET_CONTEXT(VG_INVALID_HANDLE);
+	RI_IF_ERROR(pathFormat != VG_PATH_FORMAT_STANDARD, VG_UNSUPPORTED_PATH_FORMAT_ERROR, VG_INVALID_HANDLE);
+	RI_IF_ERROR(datatype < VG_PATH_DATATYPE_S_8 || datatype > VG_PATH_DATATYPE_F, VG_ILLEGAL_ARGUMENT_ERROR, VG_INVALID_HANDLE);
+	RIfloat s = inputFloat(scale);
+	RIfloat b = inputFloat(bias);
+	RI_IF_ERROR(s == 0.0f, VG_ILLEGAL_ARGUMENT_ERROR, VG_INVALID_HANDLE);
+	capabilities &= VG_PATH_CAPABILITY_ALL;	//undefined bits are ignored
+
+	Path* path = NULL;
+	try
+	{
+		path = RI_NEW(Path, (pathFormat, datatype, s, b, segmentCapacityHint, coordCapacityHint, capabilities));	//throws bad_alloc
+		RI_ASSERT(path);
+		context->m_pathManager->addResource(path, context);	//throws bad_alloc
+		RI_RETURN((VGPath)path);
+	}
+	catch(std::bad_alloc)
+	{
+		RI_DELETE(path);
+		context->setError(VG_OUT_OF_MEMORY_ERROR);
+		RI_RETURN(VG_INVALID_HANDLE);
+	}
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgClearPath(VGPath path, VGbitfield capabilities)
+#else
+void RI_APIENTRY vgClearPath(VGPath path, VGbitfield capabilities)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidPath(path), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);	//invalid path handle
+	capabilities &= VG_PATH_CAPABILITY_ALL;	//undefined bits are ignored
+	((Path*)path)->clear(capabilities);
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgDestroyPath(VGPath path)
+#else
+void RI_APIENTRY vgDestroyPath(VGPath path)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidPath(path), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);	//invalid path handle
+
+	context->m_pathManager->removeResource((Path*)path);
+
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgRemovePathCapabilities(VGPath path, VGbitfield capabilities)
+#else
+void RI_APIENTRY vgRemovePathCapabilities(VGPath path, VGbitfield capabilities)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidPath(path), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);	//invalid path handle
+	capabilities &= VG_PATH_CAPABILITY_ALL;	//undefined bits are ignored
+
+	VGbitfield caps = ((Path*)path)->getCapabilities();
+	caps &= ~capabilities;
+	((Path*)path)->setCapabilities(caps);
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+VGbitfield RI_APIENTRY do_vgGetPathCapabilities(VGPath path)
+#else
+VGbitfield RI_APIENTRY vgGetPathCapabilities(VGPath path)
+#endif
+{
+	RI_GET_CONTEXT(0);
+	RI_IF_ERROR(!context->isValidPath(path), VG_BAD_HANDLE_ERROR, 0);	//invalid path handle
+	VGbitfield ret = ((Path*)path)->getCapabilities();
+	RI_RETURN(ret);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgAppendPathData(VGPath dstPath, VGint numSegments, const VGubyte * pathSegments, const void * pathData)
+#else
+void RI_APIENTRY vgAppendPathData(VGPath dstPath, VGint numSegments, const VGubyte * pathSegments, const void * pathData)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidPath(dstPath), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);	//invalid path handle
+	Path* p = (Path*)dstPath;
+	RI_IF_ERROR(!(p->getCapabilities() & VG_PATH_CAPABILITY_APPEND_TO), VG_PATH_CAPABILITY_ERROR, RI_NO_RETVAL);	//no append cap
+	RI_IF_ERROR(numSegments <= 0 || !pathSegments || !pathData, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);	//no segments or data
+	RI_IF_ERROR((p->getDatatype() == VG_PATH_DATATYPE_S_16 && !isAligned(pathData,2)) ||
+				((p->getDatatype() == VG_PATH_DATATYPE_S_32 || p->getDatatype() == VG_PATH_DATATYPE_F) && !isAligned(pathData,4)),
+				VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);	//invalid alignment
+	for(int i=0;i<numSegments;i++)
+	{
+		VGPathSegment c = (VGPathSegment)(pathSegments[i] & 0x1e);
+		RI_IF_ERROR(c < VG_CLOSE_PATH || c > VG_LCWARC_TO, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);	//invalid segment
+		RI_IF_ERROR(c & ~0x1f, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);	//reserved bits are nonzero
+	}
+
+	try
+	{
+		p->appendData((const RIuint8*)pathSegments, numSegments, (const RIuint8*)pathData);	//throws bad_alloc
+	}
+	catch(std::bad_alloc)
+	{
+		context->setError(VG_OUT_OF_MEMORY_ERROR);
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgModifyPathCoords(VGPath dstPath, VGint startIndex, VGint numSegments, const void * pathData)
+#else
+void RI_APIENTRY vgModifyPathCoords(VGPath dstPath, VGint startIndex, VGint numSegments, const void * pathData)
+#endif
+
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidPath(dstPath), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);	//invalid path handle
+	Path* p = (Path*)dstPath;
+	RI_IF_ERROR(!(p->getCapabilities() & VG_PATH_CAPABILITY_MODIFY), VG_PATH_CAPABILITY_ERROR, RI_NO_RETVAL);	//no modify cap
+	RI_IF_ERROR(!pathData || startIndex < 0 || numSegments <= 0 || RI_INT_ADDSATURATE(startIndex, numSegments) > p->getNumSegments(), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);	//no segments
+	RI_IF_ERROR((p->getDatatype() == VG_PATH_DATATYPE_S_16 && !isAligned(pathData,2)) ||
+				((p->getDatatype() == VG_PATH_DATATYPE_S_32 || p->getDatatype() == VG_PATH_DATATYPE_F) && !isAligned(pathData,4)),
+				VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);	//invalid alignment
+	p->modifyCoords(startIndex, numSegments, (const RIuint8*)pathData);
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgAppendPath(VGPath dstPath, VGPath srcPath)
+#else
+void RI_APIENTRY vgAppendPath(VGPath dstPath, VGPath srcPath)
+#endif
+
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidPath(dstPath) || !context->isValidPath(srcPath), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);	//invalid path handle
+	RI_IF_ERROR(!(((Path*)dstPath)->getCapabilities() & VG_PATH_CAPABILITY_APPEND_TO) ||
+				!(((Path*)srcPath)->getCapabilities() & VG_PATH_CAPABILITY_APPEND_FROM), VG_PATH_CAPABILITY_ERROR, RI_NO_RETVAL);	//invalid caps
+
+	try
+	{
+		((Path*)dstPath)->append((Path*)srcPath);	//throws bad_alloc
+	}
+	catch(std::bad_alloc)
+	{
+		context->setError(VG_OUT_OF_MEMORY_ERROR);
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgTransformPath(VGPath dstPath, VGPath srcPath)
+#else
+void RI_APIENTRY vgTransformPath(VGPath dstPath, VGPath srcPath)
+#endif
+
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidPath(dstPath) || !context->isValidPath(srcPath), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);	//invalid path handle
+	RI_IF_ERROR(!(((Path*)dstPath)->getCapabilities() & VG_PATH_CAPABILITY_TRANSFORM_TO) ||
+				!(((Path*)srcPath)->getCapabilities() & VG_PATH_CAPABILITY_TRANSFORM_FROM), VG_PATH_CAPABILITY_ERROR, RI_NO_RETVAL);	//invalid caps
+	try
+	{
+		((Path*)dstPath)->transform((Path*)srcPath, context->m_pathUserToSurface);	//throws bad_alloc
+	}
+	catch(std::bad_alloc)
+	{
+		context->setError(VG_OUT_OF_MEMORY_ERROR);
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+static bool drawPath(VGContext* context, VGPath path, const Matrix3x3& userToSurfaceMatrix, VGbitfield paintModes)
+{
+	//set up rendering surface and mask buffer
+    Drawable* drawable = context->getCurrentDrawable();
+    if(!drawable)
+        return false;   //no EGL surface is current at the moment
+
+	Rasterizer rasterizer;
+	if(context->m_scissoring)
+		rasterizer.setScissor(context->m_scissor);	//throws bad_alloc
+	int numSamples = rasterizer.setupSamplingPattern(context->m_renderingQuality, drawable->getNumSamples());
+
+	PixelPipe pixelPipe;
+	pixelPipe.setDrawable(drawable);
+	pixelPipe.setMask(context->m_masking ? true : false);
+	pixelPipe.setBlendMode(context->m_blendMode);
+	pixelPipe.setTileFillColor(context->m_tileFillColor);
+	pixelPipe.setImageQuality(context->m_imageQuality);
+    pixelPipe.setColorTransform(context->m_colorTransform ? true : false, context->m_colorTransformValues);
+
+	Matrix3x3 userToSurface = userToSurfaceMatrix;
+	userToSurface[2].set(0,0,1);	//force affinity
+
+	if(paintModes & VG_FILL_PATH)
+	{
+		pixelPipe.setPaint((Paint*)context->m_fillPaint);
+
+		Matrix3x3 surfaceToPaintMatrix = userToSurface * context->m_fillPaintToUser;
+		if(surfaceToPaintMatrix.invert())
+		{
+			surfaceToPaintMatrix[2].set(0,0,1);		//force affinity
+			pixelPipe.setSurfaceToPaintMatrix(surfaceToPaintMatrix);
+
+            rasterizer.setup(0, 0, drawable->getWidth(), drawable->getHeight(), context->m_fillRule, &pixelPipe, NULL);
+			((Path*)path)->fill(userToSurface, rasterizer);	//throws bad_alloc
+			rasterizer.fill();	//throws bad_alloc
+		}
+	}
+
+	if(paintModes & VG_STROKE_PATH && context->m_strokeLineWidth > 0.0f)
+	{
+		pixelPipe.setPaint((Paint*)context->m_strokePaint);
+
+		Matrix3x3 surfaceToPaintMatrix = userToSurface * context->m_strokePaintToUser;
+		if(surfaceToPaintMatrix.invert())
+		{
+			surfaceToPaintMatrix[2].set(0,0,1);		//force affinity
+			pixelPipe.setSurfaceToPaintMatrix(surfaceToPaintMatrix);
+
+            renderStroke(context, drawable->getWidth(), drawable->getHeight(), numSamples, (Path*)path, rasterizer, &pixelPipe, userToSurface);
+		}
+	}
+	return true;
+}
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgDrawPath(VGPath path, VGbitfield paintModes)
+#else
+void RI_APIENTRY vgDrawPath(VGPath path, VGbitfield paintModes)
+#endif
+
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidPath(path), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);	//invalid path handle
+	RI_IF_ERROR(!paintModes || (paintModes & ~(VG_FILL_PATH | VG_STROKE_PATH)), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);	//invalid paint mode
+
+	try
+	{
+		if(!drawPath(context, path, context->m_pathUserToSurface, paintModes))
+		{
+			RI_RETURN(RI_NO_RETVAL);
+		}
+	}
+	catch(std::bad_alloc)
+	{
+		context->setError(VG_OUT_OF_MEMORY_ERROR);
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+VGfloat RI_APIENTRY do_vgPathLength(VGPath path, VGint startSegment, VGint numSegments)
+#else
+VGfloat RI_APIENTRY vgPathLength(VGPath path, VGint startSegment, VGint numSegments)
+#endif
+
+{
+	RI_GET_CONTEXT(-1.0f);
+	RI_IF_ERROR(!context->isValidPath(path), VG_BAD_HANDLE_ERROR, -1.0f);	//invalid path handle
+	Path* p = (Path*)path;
+	RI_IF_ERROR(!(p->getCapabilities() & VG_PATH_CAPABILITY_PATH_LENGTH), VG_PATH_CAPABILITY_ERROR, -1.0f);	//invalid caps
+	RI_IF_ERROR(startSegment < 0 || numSegments <= 0 || RI_INT_ADDSATURATE(startSegment, numSegments) > p->getNumSegments(), VG_ILLEGAL_ARGUMENT_ERROR, -1.0f);
+	RIfloat pathLength = -1.0f;
+	try
+	{
+		pathLength = p->getPathLength(startSegment, numSegments);	//throws bad_alloc
+	}
+	catch(std::bad_alloc)
+	{
+		context->setError(VG_OUT_OF_MEMORY_ERROR);
+	}
+	RI_RETURN(pathLength);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgPointAlongPath(VGPath path, VGint startSegment, VGint numSegments, VGfloat distance, VGfloat * x, VGfloat * y, VGfloat * tangentX, VGfloat * tangentY)
+#else
+void RI_APIENTRY vgPointAlongPath(VGPath path, VGint startSegment, VGint numSegments, VGfloat distance, VGfloat * x, VGfloat * y, VGfloat * tangentX, VGfloat * tangentY)
+#endif
+
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidPath(path), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);	//invalid path handle
+	Path* p = (Path*)path;
+	RI_IF_ERROR((x && y && !(p->getCapabilities() & VG_PATH_CAPABILITY_POINT_ALONG_PATH)) ||
+				(tangentX && tangentY && !(p->getCapabilities() & VG_PATH_CAPABILITY_TANGENT_ALONG_PATH)), VG_PATH_CAPABILITY_ERROR, RI_NO_RETVAL);	//invalid caps
+	RI_IF_ERROR(startSegment < 0 || numSegments <= 0 || RI_INT_ADDSATURATE(startSegment, numSegments) > p->getNumSegments(), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(!isAligned(x,4) || !isAligned(y,4) || !isAligned(tangentX,4) || !isAligned(tangentY,4), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	try
+	{
+		Vector2 point, tangent;
+		p->getPointAlong(startSegment, numSegments, distance, point, tangent);	//throws bad_alloc
+		if(x && y)
+		{
+			*x = point.x;
+			*y = point.y;
+		}
+		if(tangentX && tangentY)
+		{
+			tangent.normalize();
+			*tangentX = tangent.x;
+			*tangentY = tangent.y;
+		}
+	}
+	catch(std::bad_alloc)
+	{
+		context->setError(VG_OUT_OF_MEMORY_ERROR);
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgPathBounds(VGPath path, VGfloat * minx, VGfloat * miny, VGfloat * width, VGfloat * height)
+#else
+void RI_APIENTRY vgPathBounds(VGPath path, VGfloat * minx, VGfloat * miny, VGfloat * width, VGfloat * height)
+#endif
+
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidPath(path), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);	//invalid path handle
+	RI_IF_ERROR(!(((Path*)path)->getCapabilities() & VG_PATH_CAPABILITY_PATH_BOUNDS), VG_PATH_CAPABILITY_ERROR, RI_NO_RETVAL);	//invalid caps
+	RI_IF_ERROR(!minx || !miny || !width || !height, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(!isAligned(minx,4) || !isAligned(miny,4) || !isAligned(width,4) || !isAligned(height,4), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	try
+	{
+		RIfloat pminx,pminy,pmaxx,pmaxy;
+		((Path*)path)->getPathBounds(pminx, pminy, pmaxx, pmaxy);	//throws bad_alloc
+		*minx = pminx;
+		*miny = pminy;
+		*width = pmaxx - pminx;
+		*height = pmaxy - pminy;
+	}
+	catch(std::bad_alloc)
+	{
+		context->setError(VG_OUT_OF_MEMORY_ERROR);
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgPathTransformedBounds(VGPath path, VGfloat * minx, VGfloat * miny, VGfloat * width, VGfloat * height)
+#else
+void RI_APIENTRY vgPathTransformedBounds(VGPath path, VGfloat * minx, VGfloat * miny, VGfloat * width, VGfloat * height)
+#endif
+
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidPath(path), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);	//invalid path handle
+	RI_IF_ERROR(!(((Path*)path)->getCapabilities() & VG_PATH_CAPABILITY_PATH_TRANSFORMED_BOUNDS), VG_PATH_CAPABILITY_ERROR, RI_NO_RETVAL);	//invalid caps
+	RI_IF_ERROR(!minx || !miny || !width || !height, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(!isAligned(minx,4) || !isAligned(miny,4) || !isAligned(width,4) || !isAligned(height,4), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	try
+	{
+		RIfloat pminx, pminy, pmaxx, pmaxy;
+		((Path*)path)->getPathTransformedBounds(context->m_pathUserToSurface, pminx, pminy, pmaxx, pmaxy);	//throws bad_alloc
+		*minx = pminx;
+		*miny = pminy;
+		*width = pmaxx - pminx;
+		*height = pmaxy - pminy;
+	}
+	catch(std::bad_alloc)
+	{
+		context->setError(VG_OUT_OF_MEMORY_ERROR);
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+VGboolean RI_APIENTRY do_vgInterpolatePath(VGPath dstPath, VGPath startPath, VGPath endPath, VGfloat amount)
+#else
+VGboolean RI_APIENTRY vgInterpolatePath(VGPath dstPath, VGPath startPath, VGPath endPath, VGfloat amount)
+#endif
+
+{
+	RI_GET_CONTEXT(VG_FALSE);
+	RI_IF_ERROR(!context->isValidPath(dstPath) || !context->isValidPath(startPath) || !context->isValidPath(endPath), VG_BAD_HANDLE_ERROR, VG_FALSE);	//invalid path handle
+	RI_IF_ERROR(!(((Path*)dstPath)->getCapabilities() & VG_PATH_CAPABILITY_INTERPOLATE_TO) ||
+				!(((Path*)startPath)->getCapabilities() & VG_PATH_CAPABILITY_INTERPOLATE_FROM) ||
+				!(((Path*)endPath)->getCapabilities() & VG_PATH_CAPABILITY_INTERPOLATE_FROM), VG_PATH_CAPABILITY_ERROR, VG_FALSE);	//invalid caps
+	VGboolean ret = VG_FALSE;
+	try
+	{
+		if(((Path*)dstPath)->interpolate((const Path*)startPath, (const Path*)endPath, inputFloat(amount)))	//throws bad_alloc
+			ret = VG_TRUE;
+	}
+	catch(std::bad_alloc)
+	{
+		context->setError(VG_OUT_OF_MEMORY_ERROR);
+	}
+	RI_RETURN(ret);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+VGPaint RI_APIENTRY do_vgCreatePaint(void)
+#else
+VGPaint RI_APIENTRY vgCreatePaint(void)
+#endif
+
+{
+	RI_GET_CONTEXT(VG_INVALID_HANDLE);
+	Paint* paint = NULL;
+	try
+	{
+		paint = RI_NEW(Paint, ());	//throws bad_alloc
+		RI_ASSERT(paint);
+		context->m_paintManager->addResource(paint, context);	//throws bad_alloc
+		RI_RETURN((VGPaint)paint);
+	}
+	catch(std::bad_alloc)
+	{
+		RI_DELETE(paint);
+		context->setError(VG_OUT_OF_MEMORY_ERROR);
+		RI_RETURN(VG_INVALID_HANDLE);
+	}
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgDestroyPaint(VGPaint paint)
+#else
+void RI_APIENTRY vgDestroyPaint(VGPaint paint)
+#endif
+
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidPaint(paint), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);	//invalid paint handle
+
+	context->m_paintManager->removeResource((Paint*)paint);
+
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgSetPaint(VGPaint paint, VGbitfield paintModes)
+#else
+void RI_APIENTRY vgSetPaint(VGPaint paint, VGbitfield paintModes)
+#endif
+
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(paint && !context->isValidPaint(paint), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);	//invalid paint handle
+	RI_IF_ERROR(!paintModes || paintModes & ~(VG_FILL_PATH | VG_STROKE_PATH), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);	//invalid paint mode
+
+	context->releasePaint(paintModes);
+
+	if(paintModes & VG_FILL_PATH)
+	{
+		if(paint)
+			((Paint*)paint)->addReference();
+		context->m_fillPaint = paint;
+	}
+	if(paintModes & VG_STROKE_PATH)
+	{
+		if(paint)
+			((Paint*)paint)->addReference();
+		context->m_strokePaint = paint;
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgSetColor(VGPaint paint, VGuint rgba)
+#else
+void RI_APIENTRY vgSetColor(VGPaint paint, VGuint rgba)
+#endif
+
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidPaint(paint), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);	//invalid paint handle
+	Paint* p = (Paint*)paint;
+	p->m_inputPaintColor.unpack(rgba, Color::formatToDescriptor(VG_sRGBA_8888));
+	p->m_paintColor = inputColor(p->m_inputPaintColor);
+	p->m_paintColor.clamp();
+	p->m_paintColor.premultiply();
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+VGuint RI_APIENTRY do_vgGetColor(VGPaint paint)
+#else
+VGuint RI_APIENTRY vgGetColor(VGPaint paint)
+#endif
+
+{
+	RI_GET_CONTEXT(0);
+	RI_IF_ERROR(!context->isValidPaint(paint), VG_BAD_HANDLE_ERROR, 0);	//invalid paint handle
+	unsigned int ret = ((Paint*)paint)->m_inputPaintColor.pack(Color::formatToDescriptor(VG_sRGBA_8888));
+	RI_RETURN(ret);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+VGPaint RI_APIENTRY do_vgGetPaint(VGPaintMode paintMode)
+#else
+VGPaint RI_APIENTRY vgGetPaint(VGPaintMode paintMode)
+#endif
+
+{
+	RI_GET_CONTEXT(VG_INVALID_HANDLE);
+	RI_IF_ERROR(paintMode != VG_FILL_PATH && paintMode != VG_STROKE_PATH, VG_ILLEGAL_ARGUMENT_ERROR, VG_INVALID_HANDLE);	//invalid paint mode
+
+	if(paintMode == VG_FILL_PATH)
+	{
+		RI_RETURN(context->m_fillPaint);
+	}
+	RI_RETURN(context->m_strokePaint);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgPaintPattern(VGPaint paint, VGImage image)
+#else
+void RI_APIENTRY vgPaintPattern(VGPaint paint, VGImage image)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidPaint(paint) || (image != VG_INVALID_HANDLE && !context->isValidImage(image)), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);	//invalid handle
+	Image* img = (Image*)image;
+	Paint* pnt = (Paint*)paint;
+	RI_IF_ERROR(image != VG_INVALID_HANDLE && eglvgIsInUse(img), VG_IMAGE_IN_USE_ERROR, RI_NO_RETVAL);
+	Image* pattern = pnt->m_pattern;
+	if(pattern)
+	{
+		pattern->removeInUse();
+		if(!pattern->removeReference())
+			RI_DELETE(pattern);
+	}
+	pnt->m_pattern = img;
+	if(img)
+	{
+		img->addReference();
+		img->addInUse();
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+VGImage RI_APIENTRY do_vgCreateImage(VGImageFormat format, VGint width, VGint height, VGbitfield allowedQuality)
+#else
+VGImage RI_APIENTRY vgCreateImage(VGImageFormat format, VGint width, VGint height, VGbitfield allowedQuality)
+#endif
+{
+	RI_GET_CONTEXT(VG_INVALID_HANDLE);
+	RI_IF_ERROR(!isValidImageFormat(format), VG_UNSUPPORTED_IMAGE_FORMAT_ERROR, VG_INVALID_HANDLE);
+	RI_IF_ERROR(width <= 0 || height <= 0 || !allowedQuality ||
+				(allowedQuality & ~(VG_IMAGE_QUALITY_NONANTIALIASED | VG_IMAGE_QUALITY_FASTER | VG_IMAGE_QUALITY_BETTER)), VG_ILLEGAL_ARGUMENT_ERROR, VG_INVALID_HANDLE);
+	RI_IF_ERROR(width > RI_MAX_IMAGE_WIDTH || height > RI_MAX_IMAGE_HEIGHT || width*height > RI_MAX_IMAGE_PIXELS ||
+				((width*Color::formatToDescriptor(format).bitsPerPixel+7)/8)*height > RI_MAX_IMAGE_BYTES, VG_ILLEGAL_ARGUMENT_ERROR, VG_INVALID_HANDLE);
+
+	Image* image = NULL;
+	try
+	{
+		image = RI_NEW(Image, (Color::formatToDescriptor(format), width, height, allowedQuality));	//throws bad_alloc
+		RI_ASSERT(image);
+		context->m_imageManager->addResource(image, context);	//throws bad_alloc
+		RI_RETURN((VGImage)image);
+	}
+	catch(std::bad_alloc)
+	{
+		RI_DELETE(image);
+		context->setError(VG_OUT_OF_MEMORY_ERROR);
+		RI_RETURN(VG_INVALID_HANDLE);
+	}
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgDestroyImage(VGImage image)
+#else
+void RI_APIENTRY vgDestroyImage(VGImage image)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidImage(image), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);	//invalid image handle
+
+	context->m_imageManager->removeResource((Image*)image);
+
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgClearImage(VGImage image, VGint x, VGint y, VGint width, VGint height)
+#else
+void RI_APIENTRY vgClearImage(VGImage image, VGint x, VGint y, VGint width, VGint height)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidImage(image), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);
+	Image* img = (Image*)image;
+	RI_IF_ERROR(eglvgIsInUse(img), VG_IMAGE_IN_USE_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(width <= 0 || height <= 0, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	img->clear(context->m_clearColor, x, y, width, height);
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgImageSubData(VGImage image, const void * data, VGint dataStride, VGImageFormat dataFormat, VGint x, VGint y, VGint width, VGint height)
+#else
+void RI_APIENTRY vgImageSubData(VGImage image, const void * data, VGint dataStride, VGImageFormat dataFormat, VGint x, VGint y, VGint width, VGint height)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidImage(image), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);
+	Image* img = (Image*)image;
+	RI_IF_ERROR(eglvgIsInUse(img), VG_IMAGE_IN_USE_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(!isValidImageFormat(dataFormat), VG_UNSUPPORTED_IMAGE_FORMAT_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(!data || !isAligned(data, dataFormat) || width <= 0 || height <= 0, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	{
+		Image input(Color::formatToDescriptor(dataFormat), width, height, dataStride, const_cast<RIuint8*>((const RIuint8*)data));
+		input.addReference();
+		try
+		{
+			img->blit(input, 0, 0, x, y, width, height, false);	//throws bad_alloc
+		}
+		catch(std::bad_alloc)
+		{
+		}
+		input.removeReference();
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgGetImageSubData(VGImage image, void * data, VGint dataStride, VGImageFormat dataFormat, VGint x, VGint y, VGint width, VGint height)
+#else
+void RI_APIENTRY vgGetImageSubData(VGImage image, void * data, VGint dataStride, VGImageFormat dataFormat, VGint x, VGint y, VGint width, VGint height)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidImage(image), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);
+	Image* img = (Image*)image;
+	RI_IF_ERROR(eglvgIsInUse(img), VG_IMAGE_IN_USE_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(!isValidImageFormat(dataFormat), VG_UNSUPPORTED_IMAGE_FORMAT_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(!data || !isAligned(data, dataFormat) || width <= 0 || height <= 0, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	{
+		Image output(Color::formatToDescriptor(dataFormat), width, height, dataStride, (RIuint8*)data);
+		output.addReference();
+		try
+		{
+			output.blit(*img, x, y, 0, 0, width, height, false);	//throws bad_alloc
+		}
+		catch(std::bad_alloc)
+		{
+		}
+		output.removeReference();
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+VGImage RI_APIENTRY do_vgChildImage(VGImage parent, VGint x, VGint y, VGint width, VGint height)
+#else
+VGImage RI_APIENTRY vgChildImage(VGImage parent, VGint x, VGint y, VGint width, VGint height)
+#endif
+{
+	RI_GET_CONTEXT(VG_INVALID_HANDLE);
+	RI_IF_ERROR(!context->isValidImage(parent), VG_BAD_HANDLE_ERROR, VG_INVALID_HANDLE);
+	Image* p = (Image*)parent;
+	RI_IF_ERROR(eglvgIsInUse((Image*)parent), VG_IMAGE_IN_USE_ERROR, VG_INVALID_HANDLE);
+	RI_IF_ERROR(x < 0 || x >= p->getWidth() || y < 0 || y >= p->getHeight() ||
+				width <= 0 || height <= 0 || RI_INT_ADDSATURATE(x, width) > p->getWidth() || RI_INT_ADDSATURATE(y, height) > p->getHeight(), VG_ILLEGAL_ARGUMENT_ERROR, VG_INVALID_HANDLE);
+
+	Image* child = NULL;
+	try
+	{
+		child = RI_NEW(Image, (p, x, y, width, height));	//throws bad_alloc
+		RI_ASSERT(child);
+		context->m_imageManager->addResource(child, context);	//throws bad_alloc
+		RI_RETURN((VGImage)child);
+	}
+	catch(std::bad_alloc)
+	{
+		RI_DELETE(child);
+		context->setError(VG_OUT_OF_MEMORY_ERROR);
+		RI_RETURN(VG_INVALID_HANDLE);
+	}
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+VGImage RI_APIENTRY do_vgGetParent(VGImage image)
+#else
+VGImage RI_APIENTRY vgGetParent(VGImage image)
+#endif
+{
+	RI_GET_CONTEXT(VG_INVALID_HANDLE);
+	RI_IF_ERROR(!context->isValidImage(image), VG_BAD_HANDLE_ERROR, VG_INVALID_HANDLE);
+	VGImage ret = image;	//if image has no ancestors, image is returned.
+
+    //The vgGetParent function returns the closest valid ancestor (i.e., one that has not been the target of a vgDestroyImage call)
+    // of the given image.
+	Image* im = ((Image*)image)->getParent();
+    for(;im;im = im->getParent())
+    {
+		if(context->isValidImage((VGImage)im))
+		{	//the parent is valid and alive
+			ret = (VGImage)im;
+            break;
+		}
+	}
+	RI_RETURN(ret);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgCopyImage(VGImage dst, VGint dx, VGint dy, VGImage src, VGint sx, VGint sy, VGint width, VGint height, VGboolean dither)
+#else
+void RI_APIENTRY vgCopyImage(VGImage dst, VGint dx, VGint dy, VGImage src, VGint sx, VGint sy, VGint width, VGint height, VGboolean dither)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidImage(dst) || !context->isValidImage(src), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(eglvgIsInUse((Image*)dst) || eglvgIsInUse((Image*)src), VG_IMAGE_IN_USE_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(width <= 0 || height <= 0, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	try
+	{
+		((Image*)dst)->blit(*(Image*)src, sx, sy, dx, dy, width, height, dither ? true : false);	//throws bad_alloc
+	}
+	catch(std::bad_alloc)
+	{
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+static bool drawImage(VGContext* context, VGImage image, const Matrix3x3& userToSurfaceMatrix)
+{
+    Drawable* drawable = context->getCurrentDrawable();
+    if(!drawable)
+        return false;   //no EGL surface is current at the moment
+
+	Image* img = (Image*)image;
+	//transform image corners into the surface space
+	Vector3 p0(0, 0, 1);
+	Vector3 p1(0, (RIfloat)img->getHeight(), 1);
+	Vector3 p2((RIfloat)img->getWidth(), (RIfloat)img->getHeight(), 1);
+	Vector3 p3((RIfloat)img->getWidth(), 0, 1);
+	p0 = userToSurfaceMatrix * p0;
+	p1 = userToSurfaceMatrix * p1;
+	p2 = userToSurfaceMatrix * p2;
+	p3 = userToSurfaceMatrix * p3;
+	if(p0.z <= 0.0f || p1.z <= 0.0f || p2.z <= 0.0f || p3.z <= 0.0f)
+		return false;
+
+	//projection
+	p0 *= 1.0f/p0.z;
+	p1 *= 1.0f/p1.z;
+	p2 *= 1.0f/p2.z;
+	p3 *= 1.0f/p3.z;
+
+	Rasterizer rasterizer;
+	if(context->m_scissoring)
+		rasterizer.setScissor(context->m_scissor);	//throws bad_alloc
+	rasterizer.setupSamplingPattern(context->m_renderingQuality, drawable->getNumSamples());
+
+	PixelPipe pixelPipe;
+	pixelPipe.setTileFillColor(context->m_tileFillColor);
+	pixelPipe.setPaint((Paint*)context->m_fillPaint);
+	pixelPipe.setImageQuality(context->m_imageQuality);
+	pixelPipe.setBlendMode(context->m_blendMode);
+	pixelPipe.setDrawable(drawable);
+	pixelPipe.setMask(context->m_masking ? true : false);
+    pixelPipe.setColorTransform(context->m_colorTransform ? true : false, context->m_colorTransformValues);
+
+	Matrix3x3 surfaceToImageMatrix = userToSurfaceMatrix;
+	Matrix3x3 surfaceToPaintMatrix = userToSurfaceMatrix * context->m_fillPaintToUser;
+	if(surfaceToImageMatrix.invert() && surfaceToPaintMatrix.invert())
+	{
+		VGImageMode imode = context->m_imageMode;
+		if(!surfaceToPaintMatrix.isAffine())
+			imode = VG_DRAW_IMAGE_NORMAL;	//if paint matrix is not affine, always use normal image mode
+		surfaceToPaintMatrix[2].set(0,0,1);	//force affine
+
+		pixelPipe.setImage(img, imode);
+		pixelPipe.setSurfaceToPaintMatrix(surfaceToPaintMatrix);
+		pixelPipe.setSurfaceToImageMatrix(surfaceToImageMatrix);
+
+		rasterizer.addEdge(Vector2(p0.x,p0.y), Vector2(p1.x,p1.y));	//throws bad_alloc
+		rasterizer.addEdge(Vector2(p1.x,p1.y), Vector2(p2.x,p2.y));	//throws bad_alloc
+		rasterizer.addEdge(Vector2(p2.x,p2.y), Vector2(p3.x,p3.y));	//throws bad_alloc
+		rasterizer.addEdge(Vector2(p3.x,p3.y), Vector2(p0.x,p0.y));	//throws bad_alloc
+        rasterizer.setup(0, 0, drawable->getWidth(), drawable->getHeight(), VG_EVEN_ODD, &pixelPipe, NULL);
+		rasterizer.fill();	//throws bad_alloc
+	}
+	return true;
+}
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgDrawImage(VGImage image)
+#else
+void RI_APIENTRY vgDrawImage(VGImage image)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidImage(image), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);
+	Image* img = (Image*)image;
+	RI_IF_ERROR(eglvgIsInUse(img), VG_IMAGE_IN_USE_ERROR, RI_NO_RETVAL);
+
+	try
+	{
+		if(!drawImage(context, image, context->m_imageUserToSurface))
+		{
+			RI_RETURN(RI_NO_RETVAL);
+		}
+	}
+	catch(std::bad_alloc)
+	{
+		context->setError(VG_OUT_OF_MEMORY_ERROR);
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgSetPixels(VGint dx, VGint dy, VGImage src, VGint sx, VGint sy, VGint width, VGint height)
+#else
+void RI_APIENTRY vgSetPixels(VGint dx, VGint dy, VGImage src, VGint sx, VGint sy, VGint width, VGint height)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidImage(src), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(eglvgIsInUse((Image*)src), VG_IMAGE_IN_USE_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(width <= 0 || height <= 0, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+    Drawable* drawable = context->getCurrentDrawable();
+    if(!drawable)
+    {
+        RI_RETURN(RI_NO_RETVAL);	//no EGL surface is current at the moment
+    }
+	try
+	{
+		if(context->m_scissoring)
+			drawable->getColorBuffer()->blit(*(Image*)src, sx, sy, dx, dy, width, height, context->m_scissor);	//throws bad_alloc
+		else
+			drawable->getColorBuffer()->blit(*(Image*)src, sx, sy, dx, dy, width, height);	//throws bad_alloc
+	}
+	catch(std::bad_alloc)
+	{
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgWritePixels(const void * data, VGint dataStride, VGImageFormat dataFormat, VGint dx, VGint dy, VGint width, VGint height)
+#else
+void RI_APIENTRY vgWritePixels(const void * data, VGint dataStride, VGImageFormat dataFormat, VGint dx, VGint dy, VGint width, VGint height)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!isValidImageFormat(dataFormat), VG_UNSUPPORTED_IMAGE_FORMAT_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(!data || !isAligned(data, dataFormat) || width <= 0 || height <= 0, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+    Drawable* drawable = context->getCurrentDrawable();
+    if(!drawable)
+    {
+        RI_RETURN(RI_NO_RETVAL);	//no EGL surface is current at the moment
+    }
+	{
+		Image input(Color::formatToDescriptor(dataFormat), width, height, dataStride, const_cast<RIuint8*>((const RIuint8*)data));
+		input.addReference();
+		try
+		{
+			if(context->m_scissoring)
+				drawable->getColorBuffer()->blit(input, 0, 0, dx, dy, width, height, context->m_scissor);	//throws bad_alloc
+			else
+				drawable->getColorBuffer()->blit(input, 0, 0, dx, dy, width, height);	//throws bad_alloc
+		}
+		catch(std::bad_alloc)
+		{
+		}
+		input.removeReference();
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgGetPixels(VGImage dst, VGint dx, VGint dy, VGint sx, VGint sy, VGint width, VGint height)
+#else
+void RI_APIENTRY vgGetPixels(VGImage dst, VGint dx, VGint dy, VGint sx, VGint sy, VGint width, VGint height)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidImage(dst), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(eglvgIsInUse((Image*)dst), VG_IMAGE_IN_USE_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(width <= 0 || height <= 0, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+    Drawable* drawable = context->getCurrentDrawable();
+    if(!drawable)
+    {
+        RI_RETURN(RI_NO_RETVAL);	//no EGL surface is current at the moment
+    }
+	try
+	{
+		((Image*)dst)->blit(drawable->getColorBuffer(), sx, sy, dx, dy, width, height);	//throws bad_alloc
+	}
+	catch(std::bad_alloc)
+	{
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgReadPixels(void* data, VGint dataStride, VGImageFormat dataFormat, VGint sx, VGint sy, VGint width, VGint height)
+#else
+void RI_APIENTRY vgReadPixels(void* data, VGint dataStride, VGImageFormat dataFormat, VGint sx, VGint sy, VGint width, VGint height)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!isValidImageFormat(dataFormat), VG_UNSUPPORTED_IMAGE_FORMAT_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(!data || !isAligned(data, dataFormat) || width <= 0 || height <= 0, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+    Drawable* drawable = context->getCurrentDrawable();
+    if(!drawable)
+    {
+        RI_RETURN(RI_NO_RETVAL);	//no EGL surface is current at the moment
+    }
+	{
+		Image output(Color::formatToDescriptor(dataFormat), width, height, dataStride, (RIuint8*)data);
+		output.addReference();
+		try
+		{
+			output.blit(drawable->getColorBuffer(), sx, sy, 0, 0, width, height);	//throws bad_alloc
+		}
+		catch(std::bad_alloc)
+		{
+		}
+		output.removeReference();
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgCopyPixels(VGint dx, VGint dy, VGint sx, VGint sy, VGint width, VGint height)
+#else
+void RI_APIENTRY vgCopyPixels(VGint dx, VGint dy, VGint sx, VGint sy, VGint width, VGint height)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(width <= 0 || height <= 0, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+    Drawable* drawable = context->getCurrentDrawable();
+    if(!drawable)
+    {
+        RI_RETURN(RI_NO_RETVAL);	//no EGL surface is current at the moment
+    }
+	try
+	{
+		if(context->m_scissoring)
+			drawable->getColorBuffer()->blit(drawable->getColorBuffer(), sx, sy, dx, dy, width, height, context->m_scissor);	//throws bad_alloc
+		else
+			drawable->getColorBuffer()->blit(drawable->getColorBuffer(), sx, sy, dx, dy, width, height);	//throws bad_alloc
+	}
+	catch(std::bad_alloc)
+	{
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgColorMatrix(VGImage dst, VGImage src, const VGfloat * matrix)
+#else
+void RI_APIENTRY vgColorMatrix(VGImage dst, VGImage src, const VGfloat * matrix)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidImage(dst) || !context->isValidImage(src), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);
+	Image* d = (Image*)dst;
+	Image* s = (Image*)src;
+	RI_IF_ERROR(eglvgIsInUse(d) || eglvgIsInUse(s), VG_IMAGE_IN_USE_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(d->overlaps(s), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(!matrix || !isAligned(matrix,4), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	unsigned int channelMask = context->m_filterChannelMask & (VG_RED|VG_GREEN|VG_BLUE|VG_ALPHA);	//undefined bits are ignored
+
+	RIfloat m[20];
+	for(int i=0;i<20;i++)
+	{
+		m[i] = inputFloat(matrix[i]);
+	}
+	try
+	{
+		d->colorMatrix(*s, m, context->m_filterFormatLinear ? true : false, context->m_filterFormatPremultiplied ? true : false, channelMask);
+	}
+	catch(std::bad_alloc)
+	{
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgConvolve(VGImage dst, VGImage src, VGint kernelWidth, VGint kernelHeight, VGint shiftX, VGint shiftY, const VGshort * kernel, VGfloat scale, VGfloat bias, VGTilingMode tilingMode)
+#else
+void RI_APIENTRY vgConvolve(VGImage dst, VGImage src, VGint kernelWidth, VGint kernelHeight, VGint shiftX, VGint shiftY, const VGshort * kernel, VGfloat scale, VGfloat bias, VGTilingMode tilingMode)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidImage(dst) || !context->isValidImage(src), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);
+	Image* d = (Image*)dst;
+	Image* s = (Image*)src;
+	RI_IF_ERROR(eglvgIsInUse(d) || eglvgIsInUse(s), VG_IMAGE_IN_USE_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(d->overlaps(s), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(!kernel || !isAligned(kernel,2) || kernelWidth <= 0 || kernelHeight <= 0 || kernelWidth > RI_MAX_KERNEL_SIZE || kernelHeight > RI_MAX_KERNEL_SIZE, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(tilingMode < VG_TILE_FILL || tilingMode > VG_TILE_REFLECT, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	unsigned int channelMask = context->m_filterChannelMask & (VG_RED|VG_GREEN|VG_BLUE|VG_ALPHA);	//undefined bits are ignored
+	try
+	{
+		d->convolve(*s, kernelWidth, kernelHeight, shiftX, shiftY, (const RIint16*)kernel, inputFloat(scale), inputFloat(bias), tilingMode, context->m_tileFillColor, context->m_filterFormatLinear ? true : false, context->m_filterFormatPremultiplied ? true : false, channelMask);
+	}
+	catch(std::bad_alloc)
+	{
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgSeparableConvolve(VGImage dst, VGImage src, VGint kernelWidth, VGint kernelHeight, VGint shiftX, VGint shiftY, const VGshort * kernelX, const VGshort * kernelY, VGfloat scale, VGfloat bias, VGTilingMode tilingMode)
+#else
+void RI_APIENTRY vgSeparableConvolve(VGImage dst, VGImage src, VGint kernelWidth, VGint kernelHeight, VGint shiftX, VGint shiftY, const VGshort * kernelX, const VGshort * kernelY, VGfloat scale, VGfloat bias, VGTilingMode tilingMode)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidImage(dst) || !context->isValidImage(src), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);
+	Image* d = (Image*)dst;
+	Image* s = (Image*)src;
+	RI_IF_ERROR(eglvgIsInUse(d) || eglvgIsInUse(s), VG_IMAGE_IN_USE_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(d->overlaps(s), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(!kernelX || !kernelY || !isAligned(kernelX,2) || !isAligned(kernelY,2) || kernelWidth <= 0 || kernelHeight <= 0 || kernelWidth > RI_MAX_SEPARABLE_KERNEL_SIZE || kernelHeight > RI_MAX_SEPARABLE_KERNEL_SIZE, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(tilingMode < VG_TILE_FILL || tilingMode > VG_TILE_REFLECT, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	unsigned int channelMask = context->m_filterChannelMask & (VG_RED|VG_GREEN|VG_BLUE|VG_ALPHA);	//undefined bits are ignored
+	try
+	{
+		d->separableConvolve(*s, kernelWidth, kernelHeight, shiftX, shiftY, (const RIint16*)kernelX, (const RIint16*)kernelY,
+										 inputFloat(scale), inputFloat(bias), tilingMode, context->m_tileFillColor, context->m_filterFormatLinear ? true : false,
+										 context->m_filterFormatPremultiplied ? true : false, channelMask);
+	}
+	catch(std::bad_alloc)
+	{
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgGaussianBlur(VGImage dst, VGImage src, VGfloat stdDeviationX, VGfloat stdDeviationY, VGTilingMode tilingMode)
+#else
+void RI_APIENTRY vgGaussianBlur(VGImage dst, VGImage src, VGfloat stdDeviationX, VGfloat stdDeviationY, VGTilingMode tilingMode)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidImage(dst) || !context->isValidImage(src), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);
+	Image* d = (Image*)dst;
+	Image* s = (Image*)src;
+	RI_IF_ERROR(eglvgIsInUse(d) || eglvgIsInUse(s), VG_IMAGE_IN_USE_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(d->overlaps(s), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	RIfloat sx = inputFloat(stdDeviationX);
+	RIfloat sy = inputFloat(stdDeviationY);
+	RI_IF_ERROR(sx <= 0.0f || sy <= 0.0f || sx > (RIfloat)RI_MAX_GAUSSIAN_STD_DEVIATION || sy > (RIfloat)RI_MAX_GAUSSIAN_STD_DEVIATION, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(tilingMode < VG_TILE_FILL || tilingMode > VG_TILE_REFLECT, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	unsigned int channelMask = context->m_filterChannelMask & (VG_RED|VG_GREEN|VG_BLUE|VG_ALPHA);	//undefined bits are ignored
+	try
+	{
+		d->gaussianBlur(*s, sx, sy, tilingMode, context->m_tileFillColor, context->m_filterFormatLinear ? true : false,
+						context->m_filterFormatPremultiplied ? true : false, channelMask);
+	}
+	catch(std::bad_alloc)
+	{
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgLookup(VGImage dst, VGImage src, const VGubyte * redLUT, const VGubyte * greenLUT, const VGubyte * blueLUT, const VGubyte * alphaLUT, VGboolean outputLinear, VGboolean outputPremultiplied)
+#else
+void RI_APIENTRY vgLookup(VGImage dst, VGImage src, const VGubyte * redLUT, const VGubyte * greenLUT, const VGubyte * blueLUT, const VGubyte * alphaLUT, VGboolean outputLinear, VGboolean outputPremultiplied)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidImage(dst) || !context->isValidImage(src), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);
+	Image* d = (Image*)dst;
+	Image* s = (Image*)src;
+	RI_IF_ERROR(eglvgIsInUse(d) || eglvgIsInUse(s), VG_IMAGE_IN_USE_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(d->overlaps(s), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(!redLUT || !greenLUT || !blueLUT || !alphaLUT, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	unsigned int channelMask = context->m_filterChannelMask & (VG_RED|VG_GREEN|VG_BLUE|VG_ALPHA);	//undefined bits are ignored
+	try
+	{
+		d->lookup(*s, (const RIuint8*)redLUT, (const RIuint8*)greenLUT, (const RIuint8*)blueLUT, (const RIuint8*)alphaLUT,
+				  outputLinear ? true : false, outputPremultiplied ? true : false, context->m_filterFormatLinear ? true : false,
+				  context->m_filterFormatPremultiplied ? true : false, channelMask);
+	}
+	catch(std::bad_alloc)
+	{
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgLookupSingle(VGImage dst, VGImage src, const VGuint * lookupTable, VGImageChannel sourceChannel, VGboolean outputLinear, VGboolean outputPremultiplied)
+#else
+void RI_APIENTRY vgLookupSingle(VGImage dst, VGImage src, const VGuint * lookupTable, VGImageChannel sourceChannel, VGboolean outputLinear, VGboolean outputPremultiplied)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidImage(dst) || !context->isValidImage(src), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);
+	Image* d = (Image*)dst;
+	Image* s = (Image*)src;
+	RI_IF_ERROR(eglvgIsInUse(d) || eglvgIsInUse(s), VG_IMAGE_IN_USE_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(d->overlaps(s), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(!lookupTable || !isAligned(lookupTable,4), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	const Color::Descriptor& desc = s->getDescriptor();
+	RI_ASSERT(Color::isValidDescriptor(desc));
+	//give an error if src is in rgb format and the source channel is not valid
+	RI_IF_ERROR((!desc.isLuminance() && !desc.isAlphaOnly()) && (sourceChannel != VG_RED && sourceChannel != VG_GREEN && sourceChannel != VG_BLUE && sourceChannel != VG_ALPHA), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	unsigned int channelMask = context->m_filterChannelMask & (VG_RED|VG_GREEN|VG_BLUE|VG_ALPHA);	//undefined bits are ignored
+	try
+	{
+		d->lookupSingle(*s, (const RIuint32*)lookupTable, sourceChannel, outputLinear ? true : false, outputPremultiplied ? true : false,
+						context->m_filterFormatLinear ? true : false, context->m_filterFormatPremultiplied ? true : false, channelMask);
+	}
+	catch(std::bad_alloc)
+	{
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+VGHardwareQueryResult RI_APIENTRY do_vgHardwareQuery(VGHardwareQueryType key, VGint setting)
+#else
+VGHardwareQueryResult RI_APIENTRY vgHardwareQuery(VGHardwareQueryType key, VGint setting)
+#endif
+{
+	RI_GET_CONTEXT(VG_HARDWARE_UNACCELERATED);
+	RI_IF_ERROR(key != VG_IMAGE_FORMAT_QUERY && key != VG_PATH_DATATYPE_QUERY, VG_ILLEGAL_ARGUMENT_ERROR, VG_HARDWARE_UNACCELERATED);
+	RI_IF_ERROR(key == VG_IMAGE_FORMAT_QUERY && !isValidImageFormat(setting), VG_ILLEGAL_ARGUMENT_ERROR, VG_HARDWARE_UNACCELERATED);
+	RI_IF_ERROR(key == VG_PATH_DATATYPE_QUERY && (setting < VG_PATH_DATATYPE_S_8 || setting > VG_PATH_DATATYPE_F), VG_ILLEGAL_ARGUMENT_ERROR, VG_HARDWARE_UNACCELERATED);
+	RI_RETURN(VG_HARDWARE_UNACCELERATED);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+RI_APIENTRY const VGubyte * do_vgGetString(VGStringID name)
+#else
+RI_APIENTRY const VGubyte * vgGetString(VGStringID name)
+#endif
+{
+	static const VGubyte vendor[] = "Khronos Group";
+	static const VGubyte renderer[] = {"OpenVG 1.1 Reference Implementation May 13 2008"};
+	static const VGubyte version[] = "1.1";
+	static const VGubyte extensions[] = "";
+	const VGubyte* r = NULL;
+	RI_GET_CONTEXT(NULL);
+	switch(name)
+	{
+	case VG_VENDOR:
+		r = vendor;
+		break;
+	case VG_RENDERER:
+		r = renderer;
+		break;
+	case VG_VERSION:
+		r = version;
+		break;
+	case VG_EXTENSIONS:
+		r = extensions;
+		break;
+	default:
+		break;
+	}
+	RI_RETURN(r);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+VGFont RI_APIENTRY do_vgCreateFont(VGint glyphCapacityHint)
+#else
+VGFont RI_APIENTRY vgCreateFont(VGint glyphCapacityHint)
+#endif
+{
+	RI_GET_CONTEXT(VG_INVALID_HANDLE);
+	RI_IF_ERROR(glyphCapacityHint < 0, VG_ILLEGAL_ARGUMENT_ERROR, VG_INVALID_HANDLE);
+
+	Font* font = NULL;
+	try
+	{
+		font = RI_NEW(Font, (glyphCapacityHint));	//throws bad_alloc
+		RI_ASSERT(font);
+		context->m_fontManager->addResource(font, context);	//throws bad_alloc
+		RI_RETURN((VGFont)font);
+	}
+	catch(std::bad_alloc)
+	{
+		RI_DELETE(font);
+		context->setError(VG_OUT_OF_MEMORY_ERROR);
+		RI_RETURN(VG_INVALID_HANDLE);
+	}
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgDestroyFont(VGFont font)
+#else
+void RI_APIENTRY vgDestroyFont(VGFont font)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidFont(font), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);	//invalid font handle
+
+	context->m_fontManager->removeResource((Font*)font);
+
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgSetGlyphToPath(VGFont font, VGuint glyphIndex, VGPath path, VGboolean isHinted, const VGfloat glyphOrigin[2], const VGfloat escapement[2])
+#else
+void RI_APIENTRY vgSetGlyphToPath(VGFont font, VGuint glyphIndex, VGPath path, VGboolean isHinted, const VGfloat glyphOrigin[2], const VGfloat escapement[2])
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidFont(font), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);	//invalid font handle
+	RI_IF_ERROR(path != VG_INVALID_HANDLE && !context->isValidPath(path), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);	//invalid path handle
+    RI_IF_ERROR(!glyphOrigin || !escapement || !isAligned(glyphOrigin,sizeof(VGfloat)) || !isAligned(escapement,sizeof(VGfloat)), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	Font* f = (Font*)font;
+
+	try
+	{
+        f->setGlyphToPath(glyphIndex, path, isHinted ? true : false, Vector2(inputFloat(glyphOrigin[0]), inputFloat(glyphOrigin[1])), Vector2(inputFloat(escapement[0]), inputFloat(escapement[1])));
+	}
+	catch(std::bad_alloc)
+	{
+		context->setError(VG_OUT_OF_MEMORY_ERROR);
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgSetGlyphToImage(VGFont font, VGuint glyphIndex, VGImage image, const VGfloat glyphOrigin[2], const VGfloat escapement[2])
+#else
+void RI_APIENTRY vgSetGlyphToImage(VGFont font, VGuint glyphIndex, VGImage image, const VGfloat glyphOrigin[2], const VGfloat escapement[2])
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidFont(font), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);	//invalid font handle
+    if(image != VG_INVALID_HANDLE)
+    {
+        RI_IF_ERROR(!context->isValidImage(image), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);	//invalid image handle
+        RI_IF_ERROR(eglvgIsInUse((Image*)image), VG_IMAGE_IN_USE_ERROR, RI_NO_RETVAL); //image in use
+    }
+    RI_IF_ERROR(!glyphOrigin || !escapement || !isAligned(glyphOrigin,sizeof(VGfloat)) || !isAligned(escapement,sizeof(VGfloat)), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	Font* f = (Font*)font;
+
+	try
+	{
+        f->setGlyphToImage(glyphIndex, image, Vector2(inputFloat(glyphOrigin[0]), inputFloat(glyphOrigin[1])), Vector2(inputFloat(escapement[0]), inputFloat(escapement[1])));
+	}
+	catch(std::bad_alloc)
+	{
+		context->setError(VG_OUT_OF_MEMORY_ERROR);
+	}
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgClearGlyph(VGFont font, VGuint glyphIndex)
+#else
+void RI_APIENTRY vgClearGlyph(VGFont font, VGuint glyphIndex)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidFont(font), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);	//invalid font handle
+	Font* f = (Font*)font;
+    Font::Glyph* g = f->findGlyph(glyphIndex);
+    RI_IF_ERROR(!g, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);   //glyphIndex not defined
+
+	f->clearGlyph(g);
+
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgDrawGlyph(VGFont font, VGuint glyphIndex, VGbitfield paintModes, VGboolean allowAutoHinting)
+#else
+void RI_APIENTRY vgDrawGlyph(VGFont font, VGuint glyphIndex, VGbitfield paintModes, VGboolean allowAutoHinting)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidFont(font), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);	//invalid font handle
+	RI_IF_ERROR(paintModes & ~(VG_FILL_PATH | VG_STROKE_PATH), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);	//invalid paint mode
+	Font* f = (Font*)font;
+    Font::Glyph* g = f->findGlyph(glyphIndex);
+    RI_IF_ERROR(!g, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);   //glyphIndex not defined
+    RI_UNREF(allowAutoHinting); //RI doesn't implement autohinting
+
+	try
+	{
+        if(paintModes)
+        {
+            Matrix3x3 userToSurfaceMatrix = context->m_glyphUserToSurface;
+            Vector2 t = context->m_glyphOrigin - g->m_origin;
+            Matrix3x3 n(1, 0, t.x,
+                        0, 1, t.y,
+                        0, 0, 1 );
+            userToSurfaceMatrix *= n;
+            userToSurfaceMatrix[2].set(0,0,1);		//force affinity
+
+            bool ret = true;
+            if(g->m_image != VG_INVALID_HANDLE)
+                ret = drawImage(context, g->m_image, userToSurfaceMatrix);
+            else if(g->m_path != VG_INVALID_HANDLE)
+                ret = drawPath(context, g->m_path, userToSurfaceMatrix, paintModes);
+            if(!ret)
+            {
+                RI_RETURN(RI_NO_RETVAL);
+            }
+        }
+
+        context->m_glyphOrigin += g->m_escapement;
+        context->m_inputGlyphOrigin = context->m_glyphOrigin;
+	}
+	catch(std::bad_alloc)
+	{
+		context->setError(VG_OUT_OF_MEMORY_ERROR);
+	}
+
+	RI_RETURN(RI_NO_RETVAL);
+}
+
+/*-------------------------------------------------------------------*//*!
+* \brief	
+* \param	
+* \return	
+* \note		
+*//*-------------------------------------------------------------------*/
+
+#ifdef BUILD_WITH_PRIVATE_OPENVG
+void RI_APIENTRY do_vgDrawGlyphs(VGFont font, VGint glyphCount, const VGuint *glyphIndices, const VGfloat *adjustments_x, const VGfloat *adjustments_y, VGbitfield paintModes, VGboolean allowAutoHinting)
+#else
+void RI_APIENTRY vgDrawGlyphs(VGFont font, VGint glyphCount, const VGuint *glyphIndices, const VGfloat *adjustments_x, const VGfloat *adjustments_y, VGbitfield paintModes, VGboolean allowAutoHinting)
+#endif
+{
+	RI_GET_CONTEXT(RI_NO_RETVAL);
+	RI_IF_ERROR(!context->isValidFont(font), VG_BAD_HANDLE_ERROR, RI_NO_RETVAL);	//invalid font handle
+	RI_IF_ERROR(!glyphIndices || !isAligned(glyphIndices, sizeof(VGuint)) || glyphCount <= 0, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR((adjustments_x && !isAligned(adjustments_x, sizeof(VGfloat))) || (adjustments_y && !isAligned(adjustments_y, sizeof(VGfloat))), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);
+	RI_IF_ERROR(paintModes & ~(VG_FILL_PATH | VG_STROKE_PATH), VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);	//invalid paint mode
+	Font* f = (Font*)font;
+	for(int i=0;i<glyphCount;i++)
+	{
+        Font::Glyph* g = f->findGlyph(glyphIndices[i]);
+        RI_IF_ERROR(!g, VG_ILLEGAL_ARGUMENT_ERROR, RI_NO_RETVAL);   //glyphIndex not defined
+    }
+    RI_UNREF(allowAutoHinting); //RI doesn't implement autohinting
+
+	try
+	{
+		for(int i=0;i<glyphCount;i++)
+		{
+            Font::Glyph* g = f->findGlyph(glyphIndices[i]);
+
+            if(paintModes)
+            {
+                Matrix3x3 userToSurfaceMatrix = context->m_glyphUserToSurface;
+                Vector2 t = context->m_glyphOrigin - g->m_origin;
+                Matrix3x3 n(1, 0, t.x,
+                            0, 1, t.y,
+                            0, 0, 1 );
+                userToSurfaceMatrix *= n;
+                userToSurfaceMatrix[2].set(0,0,1);		//force affinity
+
+                bool ret = true;
+                if(g->m_image != VG_INVALID_HANDLE)
+                    ret = drawImage(context, g->m_image, userToSurfaceMatrix);
+                else if(g->m_path != VG_INVALID_HANDLE)
+                    ret = drawPath(context, g->m_path, userToSurfaceMatrix, paintModes);
+                if(!ret)
+                {
+                    RI_RETURN(RI_NO_RETVAL);
+                }
+            }
+
+            context->m_glyphOrigin += g->m_escapement;
+            if(adjustments_x)
+                context->m_glyphOrigin.x += inputFloat(adjustments_x[i]);
+            if(adjustments_y)
+                context->m_glyphOrigin.y += inputFloat(adjustments_y[i]);
+            context->m_inputGlyphOrigin = context->m_glyphOrigin;
+		}
+	}
+	catch(std::bad_alloc)
+	{
+		context->setError(VG_OUT_OF_MEMORY_ERROR);
+	}
+
+	RI_RETURN(RI_NO_RETVAL);
+}
+