// Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// OpenVG C API for Symbian DLL
#include "vgstate.h"
extern "C" {
/*
Note: Comments at the start of each Open VG api are adapted from the Open VG 1.1 specification.
The text has been chosen/adapted to give a helpful overview of the function, and the errors
(other than VG_NO_CONTEXT_ERROR) that it may generate. For more details and diagrams see the
full Open VG specification.
*/
/*
The vgGetParameter functions return the value of a parameter on a given VGHandlebased
object.
The original value passed to vgSetParameter (provided the call to
vgSetParameter completed without error) should be returned by
vgGetParameter (except where specifically noted), even if the implementation
makes use of a truncated or quantized value internally.
ERRORS
VG_BAD_HANDLE_ERROR
if object is not a valid handle, or is not shared with the current context
VG_ILLEGAL_ARGUMENT_ERROR
if paramType is not a valid value from the appropriate enumeration
if paramType refers to a vector parameter in vgGetParameterf or
vgGetParameteri
*/
EXPORT_C VGint
vgGetParameteri(VGHandle object,
VGint paramType)
{
OPENVG_TRACE("vgGetParameteri object=0x%x, paramType=0x%x -->", object, paramType);
VGint value = TGuestOpenVg::vgGetParameteri(object, paramType);
OPENVG_TRACE("vgGetParameteri value=0x%x <--", value);
return value;
}
////////////////////////////////////////////////////////////////////////////////////////////
//Functions returning value
////////////////////////////////////////////////////////////////////////////////////////////
/*
Returns the oldest error code provided by an API call on the current context since the
previous call to vgGetError on that context (or since the creation of the context). No
error is indicated by a return value of 0 (VG_NO_ERROR). After the call, the error code is
cleared to 0. The possible errors that may be generated by each OpenVG function (apart from
VG_OUT_OF_MEMORY_ERROR) are shown below the definition of the function.
If no context is current at the time vgGetError is called, the error code
VG_NO_CONTEXT_ERROR is returned. Pending error codes on existing contexts are not affected
by the call.
*/
EXPORT_C VGErrorCode
vgGetError(void)
{
OPENVG_TRACE("vgGetError");
MVgContext* vgContext = CVghwUtils::VgContext();
VGErrorCode error = VG_NO_CONTEXT_ERROR;
if (vgContext)
{ // thread state already exists - get client or Host VG error
error = vgContext->VgError();
}
return error;
}
/*
Returns the paint object currently set for the given paintMode, or VG_INVALID_HANDLE
if an error occurs or if no paint object is set (i.e., the default paint is present) on
the given context with the given paintMode.
ERRORS
VG_ILLEGAL_ARGUMENT_ERROR
if paintMode is not a valid value from the VGPaintMode enumeration
*/
EXPORT_C VGPaint
vgGetPaint(VGPaintMode paintMode)
{
OPENVG_TRACE("vgGetPaint paintMode=0x%x -->", paintMode);
VGPaint paintHandle = TGuestOpenVg::vgGetPaint(paintMode);
OPENVG_TRACE("vgGetPaint handle=0x%x <--", paintHandle);
return paintHandle;
}
/*
Creates a new paint object that is initialized to a set of default values and returns
a VGPaint handle to it. If insufficient memory is available to allocate a new object,
VG_INVALID_HANDLE is returned.
*/
EXPORT_C VGPaint
vgCreatePaint(void)
{
OPENVG_TRACE("vgCreatePaint -->");
VGPaint paintHandle = TGuestOpenVg::vgCreatePaint();
OPENVG_TRACE("vgCreatePaint handle=0x%x <--", paintHandle);
return paintHandle;
}
/*
Appends a path, defined by interpolation (or extrapolation) between the paths
startPath and endPath by the given amount, to the path dstPath. It returns
VG_TRUE if interpolation was successful (i.e., the paths had compatible segment
types after normalization), and VG_FALSE otherwise. If interpolation is
unsuccessful, dstPath is left unchanged. It is legal for dstPath to be a handle
to the same path object as either startPath or endPath or both, in which case
the contents of the source path or paths referenced by dstPath will have the
interpolated path appended. If dstPath is not the a handle to the same path
object as either startPath or endPath, the contents of startPath and endPath
will not be affected by the call.
ERRORS
VG_BAD_HANDLE_ERROR
if any of dstPath, startPath, or endPath is not a valid path handle, or is
not shared with the current context
VG_PATH_CAPABILITY_ERROR
if VG_PATH_CAPABILITY_INTERPOLATE_TO is not enabled for dstPath
if VG_PATH_CAPABILITY_INTERPOLATE_FROM is not enabled for startPath or endPath
*/
EXPORT_C VGboolean
vgInterpolatePath(VGPath dstPath,
VGPath startPath,
VGPath endPath,
VGfloat amount)
{
OPENVG_TRACE("vgInterpolatePath dstPath=0x%x, startPath=0x%x, endPath=0x%x, amount=%f",
dstPath, startPath, endPath, amount);
return TGuestOpenVg::vgInterpolatePath(dstPath, startPath, endPath, amount);
}
/*
Returns the length of a given portion of a path in the user coordinate system
(that is, in the paths own coordinate system, disregarding any matrix
settings). Only the subpath consisting of the numSegments path segments beginning
with startSegment (where the initial path segment has index 0) is used. If an
error occurs, -1.0f is returned.
ERRORS
VG_BAD_HANDLE_ERROR
if path is not a valid path handle, or is not shared with the current context
VG_PATH_CAPABILITY_ERROR
if VG_PATH_CAPABILITY_PATH_LENGTH is not enabled for path
VG_ILLEGAL_ARGUMENT_ERROR
if startSegment is less than 0 or greater than the index of the final path
segment
if numSegments is less than or equal to 0
if (startSegment + numSegments 1) is greater than the index of the final
path segment
*/
EXPORT_C VGfloat
vgPathLength(VGPath path,
VGint startSegment,
VGint numSegments)
{
OPENVG_TRACE("vgPathLength path=0x%x, startSegment=%d, numSegments=%d", path, startSegment, numSegments);
return TGuestOpenVg::vgPathLength(path, startSegment, numSegments);
}
/*
Returns the current capabilities of the path, as a bitwise OR of
VGPathCapabilities constants. If an error occurs, 0 is returned.
ERRORS
VG_BAD_HANDLE_ERROR
if path is not a valid path handle, or is not shared with the current context
*/
EXPORT_C VGbitfield
vgGetPathCapabilities(VGPath path)
{
OPENVG_TRACE("vgGetPathCapabilities path=0x%x", path);
return TGuestOpenVg::vgGetPathCapabilities(path);
}
/*
Create a new path that is ready to accept segment data and return a VGPath handle
to it. The path data will be formatted in the format given by pathFormat, typically
VG_PATH_FORMAT_STANDARD. The datatype parameter contains a value from the
VGPathDatatype enumeration indicating the datatype that will be used for coordinate
data. The capabilities argument is a bitwise OR of the desired VGPathCapabilities
values. Bits of capabilities that do not correspond to values from VGPathCapabilities
have no effect.
If an error occurs, VG_INVALID_HANDLE is returned.
ERRORS
VG_UNSUPPORTED_PATH_FORMAT_ERROR
if pathFormat is not a supported format
VG_ILLEGAL_ARGUMENT_ERROR
if datatype is not a valid value from the VGPathDatatype enumeration
if scale is equal to 0
*/
EXPORT_C VGPath
vgCreatePath(VGint pathFormat,
VGPathDatatype datatype,
VGfloat scale, VGfloat bias,
VGint segmentCapacityHint,
VGint coordCapacityHint,
VGbitfield capabilities)
{
OPENVG_TRACE("vgCreatePath pathFormat=%d, datatype=0x%x, scale=%f, bias=%f, segCapHint=%d, coordCapHint=%d, caps=0x%x -->",
pathFormat, datatype, scale, bias, segmentCapacityHint, coordCapacityHint, capabilities);
VGPath pathHandle = TGuestOpenVg::vgCreatePath(pathFormat, datatype, scale, bias, segmentCapacityHint, coordCapacityHint, capabilities);
OPENVG_TRACE("vgCreatePath handle=0x%x <--", pathHandle);
return pathHandle;
}
/*
The vgGet functions return the value of a parameter on the current context.
The original value passed to vgSet (except as specifically noted, and provided the call to
vgSet completed without error) is returned by vgGet, even if the implementation makes
use of a truncated or quantized value internally. This rule ensures that OpenVG state may
be saved and restored without degradation.
If an error occurs during a call to vgGetf, vgGeti, or vgGetVectorSize, the return value
is undefined.
ERRORS
VG_ILLEGAL_ARGUMENT_ERROR
if paramType is not a valid value from the VGParamType enumeration
if paramType refers to a vector parameter in vgGetf or vgGeti
*/
EXPORT_C VGfloat
vgGetf(VGParamType type)
{
OPENVG_TRACE("vgGetf type=0x%x", type);
return TGuestOpenVg::vgGetf(type);
}
/*
The vgGet functions return the value of a parameter on the current context.
The original value passed to vgSet (except as specifically noted, and provided the call to
vgSet completed without error) is returned by vgGet, even if the implementation makes
use of a truncated or quantized value internally. This rule ensures that OpenVG state may
be saved and restored without degradation.
If an error occurs during a call to vgGetf, vgGeti, or vgGetVectorSize, the return value
is undefined.
ERRORS
VG_ILLEGAL_ARGUMENT_ERROR
if paramType is not a valid value from the VGParamType enumeration
if paramType refers to a vector parameter in vgGetf or vgGeti
*/
EXPORT_C VGint
vgGeti(VGParamType type)
{
OPENVG_TRACE("vgGeti type=0x%x", type);
return TGuestOpenVg::vgGeti(type);
}
/*
The vgGetVectorSize function returns the maximum number of elements in the vector
that will be retrieved by the vgGetiv or vgGetfv functions if called with the given
paramType argument. For scalar values, 1 is returned. If vgGetiv or vgGetfv is
called with a smaller value for count than that returned by vgGetVectorSize,
only the first count elements of the vector are retrieved. Use of a greater value
for count will result in an error.
The original value passed to vgSet (except as specifically noted, and provided the call to
vgSet completed without error) is returned by vgGet, even if the implementation makes
use of a truncated or quantized value internally. This rule ensures that OpenVG state may
be saved and restored without degradation.
If an error occurs during a call to vgGetf, vgGeti, or vgGetVectorSize, the return value
is undefined.
ERRORS
VG_ILLEGAL_ARGUMENT_ERROR
if paramType is not a valid value from the VGParamType enumeration
*/
EXPORT_C VGint
vgGetVectorSize(VGParamType type)
{
OPENVG_TRACE("vgGetVectorSize type=0x%x", type);
return TGuestOpenVg::vgGetVectorSize(type);
}
/*
The vgGetParameter functions return the value of a parameter on a given VGHandlebased
object.
The original value passed to vgSetParameter (provided the call to
vgSetParameter completed without error) should be returned by
vgGetParameter (except where specifically noted), even if the implementation
makes use of a truncated or quantized value internally.
ERRORS
VG_BAD_HANDLE_ERROR
if object is not a valid handle, or is not shared with the current context
VG_ILLEGAL_ARGUMENT_ERROR
if paramType is not a valid value from the appropriate enumeration
if paramType refers to a vector parameter in vgGetParameterf or
vgGetParameteri
*/
EXPORT_C VGfloat
vgGetParameterf(VGHandle object,
VGint paramType)
{
OPENVG_TRACE("vgGetParameterf object=0x%x, paramType=0x%x -->", object, paramType);
VGfloat value = TGuestOpenVg::vgGetParameterf(object, paramType);
OPENVG_TRACE("vgGetParameterf value=%f <--", value);
return value;
}
/*
The vgGetParameterVectorSize function returns the number of elements in the vector
that will be returned by the vgGetParameteriv or vgGetParameterfv functions if called
with the given paramType argument. For scalar values, 1 is returned.
ERRORS
VG_BAD_HANDLE_ERROR
if object is not a valid handle, or is not shared with the current context
VG_ILLEGAL_ARGUMENT_ERROR
if paramType is not a valid value from the appropriate enumeration
*/
EXPORT_C VGint
vgGetParameterVectorSize(VGHandle object,
VGint paramType)
{
OPENVG_TRACE("vgGetParameterVectorSize object=0x%x, paramType=0x%x -->", object, paramType);
VGint size = TGuestOpenVg::vgGetParameterVectorSize(object, paramType);
OPENVG_TRACE("vgGetParameterVectorSize size=%i <--", size);
return size;
}
/*
Creates an object capable of storing a mask layer with the given width and
height and returns a VGMaskLayer handle to it. The mask layer is defined to
be compatible with the format and multisampling properties of the current
drawing surface. If there is no current drawing surface, no mask is
configured for the current drawing surface, or an error occurs,
VG_INVALID_HANDLE is returned. All mask layer values are initially set to one.
ERRORS
VG_ILLEGAL_ARGUMENT_ERROR
if width or height are less than or equal to 0
if width is greater than VG_MAX_IMAGE_WIDTH
if height is greater than VG_MAX_IMAGE_HEIGHT
if width*height is greater than VG_MAX_IMAGE_PIXELS
*/
EXPORT_C VGMaskLayer
vgCreateMaskLayer(VGint width, VGint height)
{
OPENVG_TRACE("vgCreateMaskLayer width=%d, height=%d -->", width, height);
VGMaskLayer maskHandle = TGuestOpenVg::vgCreateMaskLayer(width, height);
OPENVG_TRACE("vgCreateMaskLayer handle=0x%x <--", maskHandle);
return maskHandle;
}
/*
The current setting of the VG_PAINT_COLOR parameter on a given paint object may
be queried as a 32-bit non-premultiplied sRGBA_8888 value. Each color channel or
alpha value is clamped to the range [0, 1] , multiplied by 255, and rounded to obtain an
8-bit integer; the resulting values are packed into a 32-bit value in the same format as for
vgSetColor.
ERRORS
VG_BAD_HANDLE_ERROR
if paint is not a valid paint handle, or is not shared with the current context
*/
EXPORT_C VGuint
vgGetColor(VGPaint paint)
{
OPENVG_TRACE("vgGetColor paint=0x%x", paint);
return TGuestOpenVg::vgGetColor(paint);
}
/*
Creates an image with the given width, height, and pixel format and returns a
VGImage handle to it. If an error occurs, VG_INVALID_HANDLE is returned. All
color and alpha channel values are initially set to zero. The format parameter
must contain a value from the VGImageFormat enumeration.
The allowedQuality parameter is a bitwise OR of values from the
VGImageQuality enumeration, indicating which levels of resampling quality may be
used to draw the image. It is always possible to draw an image using the
VG_IMAGE_QUALITY_NONANTIALIASED quality setting even if it is not explicitly
specified.
ERRORS
VG_UNSUPPORTED_IMAGE_FORMAT_ERROR
if format is not a valid value from the VGImageFormat enumeration
VG_ILLEGAL_ARGUMENT_ERROR
if width or height are less than or equal to 0
if width is greater than VG_MAX_IMAGE_WIDTH
if height is greater than VG_MAX_IMAGE_HEIGHT
if width*height is greater than VG_MAX_IMAGE_PIXELS
if width*height*(pixel size of format) is greater than
VG_MAX_IMAGE_BYTES
if allowedQuality is not a bitwise OR of values from the
VGImageQuality enumeration
*/
EXPORT_C VGImage
vgCreateImage(VGImageFormat format,
VGint width, VGint height,
VGbitfield allowedQuality)
{
OPENVG_TRACE("vgCreateImage format=0x%x, width=%d, height=%d, allowedQuality=0x%x -->",
format, width, height, allowedQuality);
VGImage imageHandle = TGuestOpenVg::vgCreateImage(format, width, height, allowedQuality);
OPENVG_TRACE("vgCreateImage handle=0x%x <--", imageHandle);
return imageHandle;
}
/*
Returns a new VGImage handle that refers to a portion of the parent image. The
region is given by the intersection of the bounds of the parent image with the
rectangle beginning at pixel (x, y) with dimensions width and height, which
must define a positive region contained entirely within parent.
ERRORS
VG_BAD_HANDLE_ERROR
if parent is not a valid image handle, or is not shared with the current
context
VG_IMAGE_IN_USE_ERROR
if parent is currently a rendering target
VG_ILLEGAL_ARGUMENT_ERROR
if x is less than 0 or greater than or equal to the parent width
if y is less than 0 or greater than or equal to the parent height
if width or height is less than or equal to 0
if x + width is greater than the parent width
if y + height is greater than the parent height
*/
EXPORT_C VGImage
vgChildImage(VGImage parent,
VGint x, VGint y,
VGint width, VGint height)
{
OPENVG_TRACE("vgChildImage parent=oc%x, x=%d, y=%d, width=%d, height=%d -->",
parent, x, y, width, height);
VGImage imageHandle = TGuestOpenVg::vgChildImage(parent, x, y, width, height);
OPENVG_TRACE("vgChildImage handle=0x%x <--", imageHandle);
return imageHandle;
}
/*
Returns the closest valid ancestor (i.e., one that has not been the target of
a vgDestroyImage call) of the given image. If image has no ancestors, image is
returned.
ERRORS
VG_BAD_HANDLE_ERROR
if image is not a valid image handle, or is not shared with the current
context
VG_IMAGE_IN_USE_ERROR
if image is currently a rendering target
*/
EXPORT_C VGImage vgGetParent(VGImage image)
{
OPENVG_TRACE("vgGetParent image=0x%x", image);
return TGuestOpenVg::vgGetParent(image);
}
/*
Creates a new font object and returns a VGFont handle to it. The glyphCapacityHint
argument provides a hint as to the capacity of a VGFont, i.e., the total number of
glyphs that this VGFont object will be required to accept. A value of 0 indicates that
the value is unknown. If an error occurs during execution, VG_INVALID_HANDLE is returned.
ERRORS
VG_ILLEGAL_ARGUMENT_ERROR
if glyphCapacityHint is negative
*/
EXPORT_C VGFont vgCreateFont(VGint glyphCapacityHint)
{
OPENVG_TRACE("vgCreateFont glyphCapacityHint=%d -->", glyphCapacityHint);
VGFont fontHandle = TGuestOpenVg::vgCreateFont(glyphCapacityHint);
OPENVG_TRACE("vgCreateFont handle=0x%x <--", fontHandle);
return fontHandle;
}
/* Hardware Queries */
/*
Returns a value indicating whether a given setting of a property of a type given
by key is generally accelerated in hardware on the currently running OpenVG
implementation.
ERRORS
VG_ILLEGAL_ARGUMENT_ERROR
if key is not one of the values from the VGHardwareQueryType enumeration
if setting is not one of the values from the enumeration associated with
key
*/
EXPORT_C VGHardwareQueryResult
vgHardwareQuery
(VGHardwareQueryType key,
VGint setting)
{
OPENVG_TRACE("vgHardwareQuery key=0x%x, setting=%d", key, setting);
return TGuestOpenVg::vgHardwareQuery(key, setting);
}
/*
The vgGetString function returns information about the OpenVG implementation,
including extension information. The values returned may vary according to
the display (e.g., the EGLDisplay when using EGL) associated with the current
context.
Returns NULL if no context is current.
*/
EXPORT_C const VGubyte *
vgGetString(VGStringID name)
{
OPENVG_TRACE("vgGetString name=0x%x", name);
switch (name)
{
case VG_VENDOR:
return (const VGubyte *)"Nokia";
case VG_RENDERER:
return (const VGubyte *)"Guest 1.0";
case VG_VERSION:
return (const VGubyte *)"1.1";
case VG_EXTENSIONS: // supported VG extensions, (associated function addresses are fetched with eglGetProcAddress)
return (const VGubyte *)"VG_KHR_EGL_image";
}
return (const VGubyte *)NULL;
}
/*
The vgGetParameter functions return the value of a parameter on a given VGHandlebased
object.
If vgGetParameteriv or vgGetParameterfv is called with a smaller value for
count than that returned by vgGetParameterVectorSize, only the first count
elements of the vector are retrieved. Use of a greater value for count will result
in an error.
The original value passed to vgSetParameter (provided the call to
vgSetParameter completed without error) should be returned by
vgGetParameter (except where specifically noted), even if the implementation
makes use of a truncated or quantized value internally.
ERRORS
VG_BAD_HANDLE_ERROR
if object is not a valid handle, or is not shared with the current context
VG_ILLEGAL_ARGUMENT_ERROR
if paramType is not a valid value from the appropriate enumeration
if values is NULL in vgGetParameterfv or vgGetParameteriv
if values is not properly aligned in vgGetParameterfv or vgGetParameteriv
if count is less than or equal to 0 in vgGetParameterfv or vgGetParameteriv
if count is greater than the value returned by vgGetParameterVectorSize for
the given parameter in vgGetParameterfv or vgGetParameteriv
*/
EXPORT_C void
vgGetParameterfv(VGHandle object,
VGint paramType,
VGint count,
VGfloat * values)
{
OPENVG_TRACE("vgGetParameterfv object=0x%x, paramType=0x%x, count=%d, values=0x%x",
object, paramType, count, values);
TGuestOpenVg::vgGetParameterfv(object, paramType, count, values);
}
EXPORT_C void
vgGetParameteriv(VGHandle object,
VGint paramType,
VGint count,
VGint * values)
{
OPENVG_TRACE("vgGetParameteriv object=0x%x, paramType=0x%x, count=%d, values=0x%x",
object, paramType, count, values);
TGuestOpenVg::vgGetParameteriv(object, paramType, count, values);
}
/* Renderer and Extension Information */
/*
The vgGetVectorSize function returns the maximum number of elements in the vector
that will be retrieved by the vgGetiv or vgGetfv functions if called with the given
paramType argument. For scalar values, 1 is returned. If vgGetiv or vgGetfv is
called with a smaller value for count than that returned by vgGetVectorSize,
only the first count elements of the vector are retrieved. Use of a greater value
for count will result in an error.
The original value passed to vgSet (except as specifically noted, and provided the call to
vgSet completed without error) is returned by vgGet, even if the implementation makes
use of a truncated or quantized value internally. This rule ensures that OpenVG state may
be saved and restored without degradation.
If an error occurs during a call to vgGetfv or vgGetiv, nothing is
written to values.
ERRORS
VG_ILLEGAL_ARGUMENT_ERROR
if paramType is not a valid value from the VGParamType enumeration
if values is NULL in vgGetfv or vgGetiv
if values is not properly aligned in vgGetfv or vgGetiv
if count is less than or equal to 0 in vgGetfv or vgGetiv
if count is greater than the value returned by vgGetVectorSize for the
given parameter in vgGetfv or vgGetiv
*/
EXPORT_C void
vgGetfv(VGParamType type, VGint count,
VGfloat * values)
{
OPENVG_TRACE("vgGetfv type=0x%x, count=%d, values=0x%x", type, count, values);
TGuestOpenVg::vgGetfv(type, count, values);
}
EXPORT_C void
vgGetiv(VGParamType type, VGint count,
VGint * values)
{
OPENVG_TRACE("vgGetiv type=0x%x, count=%d, values=0x%x", type, count, values);
TGuestOpenVg::vgGetiv(type, count, values);
}
/*
Retrieve the value of the current transformation.
Nine values are written to m in the order:
{ sx, shy, w0, shx, sy, w1, tx, ty, w2 }
For an affine matrix, w0 and w1 will always be 0 and w2 will always be 1.
ERRORS
VG_ILLEGAL_ARGUMENT_ERROR
if m is NULL
if m is not properly aligned
*/
EXPORT_C void
vgGetMatrix(VGfloat * m)
{
OPENVG_TRACE("vgGetMatrix m=0x%x", m);
TGuestOpenVg::vgGetMatrix(m);
}
/*
Read pixel values from a rectangular portion of an image, performs format conversion
if necessary, and stores the resulting pixels into memory.
Pixel values are written starting at the address given by the pointer data; adjacent
scanlines are separated by dataStride bytes. Negative or zero values of
dataStride are allowed. The region to be read is given by x, y, width, and
height, which must define a positive region. Pixels that fall outside the bounds
of the image are ignored.
Pixel values in memory are formatted according to the dataFormat parameter, which
must contain a value from the VGImageFormat enumeration. If dataFormat
specifies a premultiplied format (VG_sRGBA_8888_PRE or VG_lRGBA_8888_PRE),
color channel values of a pixel that are greater than their corresponding alpha value are
clamped to the range [0, alpha]. The data pointer alignment and the pixel layout in
memory are as described in the vgImageSubData section.
ERRORS
VG_BAD_HANDLE_ERROR
if image is not a valid image handle, or is not shared with the current context
VG_IMAGE_IN_USE_ERROR
if image is currently a rendering target
VG_UNSUPPORTED_IMAGE_FORMAT_ERROR
if dataFormat is not a valid value from the VGImageFormat enumeration
VG_ILLEGAL_ARGUMENT_ERROR
if width or height is less than or equal to 0
if data is NULL
if data is not properly aligned
*/
EXPORT_C void
vgGetImageSubData(VGImage image,
void * data,
VGint dataStride,
VGImageFormat dataFormat,
VGint x, VGint y,
VGint width, VGint height)
{
OPENVG_TRACE("vgGetImageSubData image=0x%x, data=0x%x, dataStride=%d, dataFormat=0x%x, x=%d, y=%d, width=%d, height=%d",
image, data, dataStride, dataFormat, x, y, width, height);
TGuestOpenVg::vgGetImageSubData(image, data, dataStride, dataFormat, x, y, width, height);
}
/*
Copy pixel data from the drawing surface without the creation of a VGImage object.
Pixel values are written starting at the address given by the pointer data; adjacent
scanlines are separated by dataStride bytes. Negative or zero values of
dataStride are allowed. The region to be read is given by x, y, width, and
height, which must define a positive region.
Pixel values in memory are formatted according to the dataFormat parameter, which
must contain a value from the VGImageFormat enumeration. The data pointer
alignment and the pixel layout in memory is as described for vgImageSubData.
Pixels whose source lies outside of the bounds of the drawing surface are
ignored. Pixel format conversion is applied as needed. The scissoring region
does not affect the reading of pixels.
ERRORS
VG_UNSUPPORTED_IMAGE_FORMAT_ERROR
if dataFormat is not a valid value from the VGImageFormat enumeration
VG_ILLEGAL_ARGUMENT_ERROR
if width or height is less than or equal to 0
if data is NULL
if data is not properly aligned
*/
EXPORT_C void
vgReadPixels(void * data, VGint dataStride,
VGImageFormat dataFormat,
VGint sx, VGint sy,
VGint width, VGint height)
{
OPENVG_TRACE("vgReadPixels data=0x%x, dataStride=%d, dataFormat=0x%x, sx=%d, sy=%d, width=%d, height=%d",
data, dataStride, dataFormat, sx, sy, width, height);
TGuestOpenVg::vgReadPixels(data, dataStride, dataFormat, sx, sy, width, height);
}
/*
Returns an axis-aligned bounding box that tightly bounds the interior of the given
path. Stroking parameters are ignored. If path is empty, minX and minY are set to 0
and width and height are set to -1. If path contains a single point, minX and minY
are set to the coordinates of the point and width and height are set to 0.
The VG_PATH_CAPABILITY_PATH_BOUNDS capability must be enabled for path.
ERRORS
VG_BAD_HANDLE_ERROR
if path is not a valid path handle, or is not shared with the current context
VG_ILLEGAL_ARGUMENT_ERROR
if minX, minY, width, or height is NULL
if minX, minY, width, or height is not properly aligned
VG_PATH_CAPABILITY_ERROR
if VG_PATH_CAPABILITY_PATH_BOUNDS is not enabled for path
*/
EXPORT_C void
vgPathBounds(VGPath path,
VGfloat * minX,
VGfloat * minY,
VGfloat * width,
VGfloat * height)
{
OPENVG_TRACE("vgPathBounds path=0x%x, minX=0x%x, minY=0x%x, width=0x%x, height=0x%x",
path, minX, minY, width, height);
TGuestOpenVg::vgPathBounds(path, minX, minY, width, height);
}
/*
The vgPathTransformedBounds function returns an axis-aligned bounding box
that is guaranteed to enclose the geometry of the given path following
transformation by the current path-user-to-surface transform. The returned
bounding box is not guaranteed to fit tightly around the path geometry. If path
is empty, minX and minY are set to 0 and width and height are set to -1. If
path contains a single point, minX and minY are set to the transformed
coordinates of the point and width and height are set to 0.
The VG_PATH_CAPABILITY_PATH_TRANSFORMED_BOUNDS capability must be
enabled for path.
ERRORS
VG_BAD_HANDLE_ERROR
if path is not a valid path handle, or is not shared with the current context
VG_ILLEGAL_ARGUMENT_ERROR
if minX, minY, width, or height is NULL
if minX, minY, width, or height is not properly aligned
VG_PATH_CAPABILITY_ERROR
if VG_PATH_CAPABILITY_PATH_TRANSFORMED_BOUNDS is not enabled
for path
*/
EXPORT_C void
vgPathTransformedBounds(VGPath path,
VGfloat * minX,
VGfloat * minY,
VGfloat * width,
VGfloat * height)
{
OPENVG_TRACE("vgPathTransformedBounds path=0x%x, minX=0x%x, minY=0x%x, width=0x%x, height=0x%x",
path, minX, minY, width, height);
TGuestOpenVg::vgPathTransformedBounds(path, minX, minY, width, height);
}
////////////////////////////////////////////////////////////////////////////////////////////
//Syncing methods
////////////////////////////////////////////////////////////////////////////////////////////
/*
Ensures that all outstanding requests on the current context will complete in finite time.
vgFlush may return prior to the actual completion of all requests.
*/
EXPORT_C void
vgFlush(void)
{
// ToDo comment
OPENVG_TRACE("vgFlush");
MVgContext* vgContext = CVghwUtils::VgContext();
if (vgContext)
{
vgContext->ExecuteVgFlushCommand();
}
}
/*
The vgFinish function forces all outstanding requests on the current context to
complete, returning only when the last request has completed.
*/
EXPORT_C void
vgFinish(void)
{
// ToDo comment
OPENVG_TRACE("vgFinish");
MVgContext* vgContext = CVghwUtils::VgContext();
if (vgContext)
{
vgContext->ExecuteVgFinishCommand();
}
}
////////////////////////////////////////////////////////////////////////////////////////////
//Functions not returning value (possible to buffer)
////////////////////////////////////////////////////////////////////////////////////////////
/* Getters and Setters */
/*
The vgSet functions set the value of a parameter on the current context.
ERRORS
VG_ILLEGAL_ARGUMENT_ERROR
if paramType is not a valid value from the VGParamType enumeration
if paramType refers to a vector parameter in vgSetf or vgSeti
if value is not a legal enumerated value for the given parameter in vgSetf or
vgSeti
*/
EXPORT_C void
vgSetf (VGParamType type, VGfloat value)
{
OPENVG_TRACE("vgSetf type=0x%x, value=%f", type, value);
TGuestOpenVg::vgSetf(type, value);
}
EXPORT_C void
vgSeti (VGParamType type, VGint value)
{
OPENVG_TRACE("vgSeti type=0x%x, value=%d", type, value);
TGuestOpenVg::vgSeti(type, value);
}
/*
The vgSet functions set the value of a parameter on the current context.
ERRORS
VG_ILLEGAL_ARGUMENT_ERROR
if paramType is not a valid value from the VGParamType enumeration
if paramType refers to a scalar parameter in vgSetfv or vgSetiv and count is
not equal to 1
if values[i] is not a legal enumerated value for the given parameter in vgSetfv
or vgSetiv for 0 <= i < count
if values is NULL in vgSetfv or vgSetiv and count is greater than 0
if values is not properly aligned in vgSetfv or vgSetiv
if count is less than 0 in vgSetfv or vgSetiv
if count is not a valid value for the given parameter
*/
EXPORT_C void
vgSetfv(VGParamType type, VGint count,
const VGfloat * values)
{
OPENVG_TRACE("vgSetfv type=0x%x, count=%d, values=0x%x", type, count, values);
TGuestOpenVg::vgSetfv(type, count, values);
}
EXPORT_C void
vgSetiv(VGParamType type, VGint count,
const VGint * values)
{
OPENVG_TRACE("vgSetiv type=0x%x, count=%d, values=0x%x", type, count, values);
TGuestOpenVg::vgSetiv(type, count, values);
}
/*
For vgSetParameterf and vgSetParameteri.
The vgSetParameter functions set the value of a parameter on a given VGHandlebased
object.
ERRORS
VG_BAD_HANDLE_ERROR
if object is not a valid handle, or is not shared with the current context
VG_ILLEGAL_ARGUMENT_ERROR
if paramType is not a valid value from the appropriate enumeration
if paramType refers to a vector parameter in vgSetParameterf or
vgSetParameteri
if value is not a legal enumerated value for the given parameter in
vgSetParameterf or vgSetParameteri
*/
EXPORT_C void
vgSetParameterf(VGHandle object,
VGint paramType,
VGfloat value)
{
OPENVG_TRACE("vgSetParameterf object=0x%x, paramType=0x%x, value=%f -->", object, paramType, value);
TGuestOpenVg::vgSetParameterf(object, paramType, value);
}
EXPORT_C void
vgSetParameteri(VGHandle object,
VGint paramType,
VGint value)
{
OPENVG_TRACE("vgSetParameteri object=0x%x, paramType=0x%x, value=0x%x", object, paramType, value);
TGuestOpenVg::vgSetParameteri(object, paramType, value);
}
/*
For vgSetParameterfv and vgSetParameteriv.
The vgSetParameter functions set the value of a parameter on a given VGHandlebased
object.
ERRORS
VG_BAD_HANDLE_ERROR
if object is not a valid handle, or is not shared with the current context
VG_ILLEGAL_ARGUMENT_ERROR
if paramType is not a valid value from the appropriate enumeration
if paramType refers to a scalar parameter in vgSetParameterfv or
vgSetParameteriv and count is not equal to 1
if values[i] is not a legal enumerated value for the given parameter
in vgSetParameterfv or vgSetParameteriv for 0 <= i < count
if values is NULL in vgSetParameterfv or vgSetParameteriv and count is
greater than 0
if values is not properly aligned in vgSetParameterfv or vgSetParameteriv
if count is less than 0 in vgSetParameterfv or vgSetParameteriv
if count is not a valid value for the given parameter
*/
EXPORT_C void
vgSetParameterfv(VGHandle object,
VGint paramType,
VGint count,
const VGfloat * values)
{
OPENVG_TRACE("vgSetParameterfv object=0x%x, paramType=%d, count=%d, values=0x%x", object, paramType, count, values);
TGuestOpenVg::vgSetParameterfv(object, paramType, count, values);
}
EXPORT_C void
vgSetParameteriv(VGHandle object,
VGint paramType,
VGint count,
const VGint * values)
{
OPENVG_TRACE("vgSetParameteriv object=0x%x, paramType=%d, count=%d, values=0x%x", object, paramType, count, values);
TGuestOpenVg::vgSetParameteriv(object, paramType, count, values);
}
/* Matrix Manipulation */
/*
Sets the current matrix M to the identity matrix:
*/
EXPORT_C void
vgLoadIdentity(void)
{
OPENVG_TRACE("vgLoadIdentity");
TGuestOpenVg::vgLoadIdentity();
}
/*
Loads an arbitrary set of matrix values into the current
matrix. Nine matrix values are read from m, in the order:
{ sx, shy, w0, shx, sy, w1, tx, ty, w2 }
However, if the targeted matrix is affine (i.e., the matrix mode is not
VG_MATRIX_IMAGE_USER_TO_SURFACE), the values { w0, w1, w2 } are ignored and
replaced by the values { 0, 0, 1 }.
ERRORS
VG_ILLEGAL_ARGUMENT_ERROR
if m is NULL
if m is not properly aligned
*/
EXPORT_C void
vgLoadMatrix(const VGfloat * m)
{
OPENVG_TRACE("vgLoadMatrix m=0x%x", m);
TGuestOpenVg::vgLoadMatrix(m);
}
/*
Right-multiplies the current matrix M by a given matrix:
Nine matrix values are read from m in the order:
{ sx, shy, w0, shx, sy, w1, tx, ty, w2 }
and the current matrix is multiplied by the resulting matrix. However, if the
targeted matrix is affine (i.e., the matrix mode is not
VG_MATRIX_IMAGE_USER_TO_SURFACE), the values { w0, w1, w2 } are ignored
and replaced by the values { 0, 0, 1 } prior to multiplication.
ERRORS
VG_ILLEGAL_ARGUMENT_ERROR
if m is NULL
if m is not properly aligned
*/
EXPORT_C void
vgMultMatrix(const VGfloat * m)
{
OPENVG_TRACE("vgMultMatrix m=0x%x", m);
TGuestOpenVg::vgMultMatrix(m);
}
/*
Modifies the current transformation by appending a translation. This is equivalent
to right-multiplying the current matrix M by a translation matrix:
[ 1 0 tx ]
[ 0 1 ty ]
[ 0 0 1 ]
*/
EXPORT_C void
vgTranslate(VGfloat tx, VGfloat ty)
{
OPENVG_TRACE("vgTranslate tx=%f, ty=%f", tx, ty);
TGuestOpenVg::vgTranslate(tx, ty);
}
/*
Modifies the current transformation by appending a scale. This is equivalent to
right-multiplying the current matrix M by a scale matrix:
[ sx 0 0 ]
[ 0 sy 0 ]
[ 0 0 1 ]
*/
EXPORT_C void
vgScale(VGfloat sx, VGfloat sy)
{
OPENVG_TRACE("vgScale sx=%f, sy=%f", sx, sy);
TGuestOpenVg::vgScale(sx, sy);
}
/*
Modifies the current transformation by appending a shear. This is equivalent to
right-multiplying the current matrix M by a shear matrix:
[ 1 shx 0 ]
[ shy 1 0 ]
[ 0 0 1 ]
*/
EXPORT_C void
vgShear(VGfloat shx, VGfloat shy)
{
OPENVG_TRACE("vgShear shx=%f, shy=%f", shx, shy);
TGuestOpenVg::vgShear(shx, shy);
}
/*
Modifies the current transformation by appending a counterclockwise rotation by a given
angle (expressed in degrees) about the origin. This is equivalent to right-multiplying
the current matrix M by the following matrix (using the symbol a to represent the value
of the angle parameter):
[ cos(a) -sin(a) 0 ]
[ sin(a) cos(a) 0 ]
[ 0 0 1 ]
*/
EXPORT_C void
vgRotate(VGfloat angle)
{
OPENVG_TRACE("vgRotate angle=%f");
TGuestOpenVg::vgRotate(angle);
}
/*
Modifies the drawing surface mask values according to a given operation, possibly
using coverage values taken from a mask layer or bitmap image given by the mask
parameter. If no mask is configured for the current drawing surface, vgMask has
no effect.
ERRORS
VG_BAD_HANDLE_ERROR
if operation is not VG_CLEAR_MASK or VG_FILL_MASK, and mask is not a
valid mask layer or image handle, or is not shared with the current context
VG_IMAGE_IN_USE_ERROR
if mask is a VGImage that is currently a rendering target
VG_ILLEGAL_ARGUMENT_ERROR
if operation is not a valid value from the VGMaskOperation
enumeration
if width or height is less than or equal to 0
if mask is a VGMaskLayer and is not compatible with the current surface
mask
*/
EXPORT_C void
vgMask(VGHandle mask, VGMaskOperation operation,
VGint x, VGint y,
VGint width, VGint height)
{
OPENVG_TRACE("vgMask mask=0x%x, operation=0x%x, x=%d, y=%d, width=%d, height=%d",
mask, operation, x, y, width, height);
TGuestOpenVg::vgMask(mask, operation, x, y, width, height);
}
/*
Modifies the current surface mask by applying the given operation to the set of
coverage values associated with the rendering of the given path. If paintModes
contains VG_FILL_PATH, the path is filled; if it contains VG_STROKE_PATH, the path
is stroked. If both are present, the mask operation is performed in two passes,
first on the filled path geometry, then on the stroked path geometry.
ERRORS
VG_BAD_HANDLE_ERROR
if path is not a valid path handle
VG_ILLEGAL_ARGUMENT_ERROR
if paintModes is not a valid bitwise OR of values from the VGPaintMode
enumeration
if operation is not a valid value from the VGMaskOperation enumeration
*/
EXPORT_C void
vgRenderToMask(VGPath path,
VGbitfield paintModes,
VGMaskOperation operation)
{
OPENVG_TRACE("vgRenderToMask path=0x%x, paintModes=0x%x, operation=0x%x", path, paintModes, operation);
TGuestOpenVg::vgRenderToMask(path, paintModes, operation);
}
/*
Deallocate the resources associated with a mask layer. Following the call,
the maskLayer handle is no longer valid in the current context.
ERRORS
VG_BAD_HANDLE_ERROR
if maskLayer is not a valid mask handle
*/
EXPORT_C void vgDestroyMaskLayer(VGMaskLayer maskLayer)
{
OPENVG_TRACE("vgDestroyMaskLayer maskLayer=0x%x", maskLayer);
TGuestOpenVg::vgDestroyMaskLayer(maskLayer);
}
/*
Set the values of a given maskLayer within a given rectangular region to a given
value. The floating-point value value must be between 0 and 1. The value is rounded
to the closest available value supported by the mask layer. If two values are equally
close, the larger value is used.
ERRORS
VG_BAD_HANDLE_ERROR
if maskLayer is not a valid mask layer handle, or is not shared with the
current context
VG_ILLEGAL_ARGUMENT_ERROR
if value is less than 0 or greater than 1
if width or height is less than or equal to 0
if x or y is less than 0
if x + width is greater than the width of the mask
if y + height is greater than the height of the mask
*/
EXPORT_C void
vgFillMaskLayer(VGMaskLayer maskLayer,
VGint x, VGint y,
VGint width, VGint height,
VGfloat value)
{
OPENVG_TRACE("vgFillMaskLayer maskLayer=0x%x, x=%d, y=%d, width=%d, height=%d, value=%f",
maskLayer, x, y, width, height, value);
TGuestOpenVg::vgFillMaskLayer(maskLayer, x, y, width, height, value);
}
/*
Copies a portion of the current surface mask into a VGMaskLayer object. The source
region starts at (sx, sy) in the surface mask, and the destination region starts
at (dx, dy) in the destination maskLayer. The copied region is clipped to the given
width and height and the bounds of the source and destination. If the current context
does not contain a surface mask, vgCopyMask does nothing.
ERRORS
VG_BAD_HANDLE_ERROR
if maskLayer is not a valid mask layer handle
VG_ILLEGAL_ARGUMENT_ERROR
if width or height are less than or equal to 0
if maskLayer is not compatible with the current surface mask
*/
EXPORT_C void
vgCopyMask(VGMaskLayer maskLayer,
VGint sx, VGint sy,
VGint dx, VGint dy,
VGint width, VGint height)
{
OPENVG_TRACE("vgCopyMask maskLayer=0x%x, sx=%d, sy=%d, dx=%d, dy=%d, width=%d, height=%d",
maskLayer, sx, sy, dx, dy, width, height);
TGuestOpenVg::vgCopyMask(maskLayer, sx, sy, dx, dy, width, height);
}
/*
Fills the portion of the drawing surface intersecting the rectangle extending from
pixel (x, y) and having the given width and height with a constant color value, taken
from the VG_CLEAR_COLOR parameter. The color value is expressed in non-premultiplied
sRGBA (sRGB color plus alpha)format. Values outside the [0, 1] range are interpreted
as the nearest endpoint of the range. The color is converted to the destination color
space in the same manner as if a rectangular path were being filled. Clipping and
scissoring take place in the usual fashion, but antialiasing, masking, and blending
do not occur.
ERRORS
VG_ILLEGAL_ARGUMENT_ERROR
if width or height is less than or equal to 0
*/
EXPORT_C void
vgClear(VGint x, VGint y,
VGint width, VGint height)
{
OPENVG_TRACE("vgClear x=%d, y=%d, width=%d, height=%d", x, y, width, height);
TGuestOpenVg::vgClear(x, y, width, height);
}
/* Paths */
/*
Remove all segment command and coordinate data associated with a path. The handle
continues to be valid for use in the future, and the path format and datatype retain
their existing values. The capabilities argument is a bitwise OR of the desired
VGPathCapabilities values. Bits of capabilities that do not correspond to values from
VGPathCapabilities have no effect. Using vgClearPath may be more efficient than
destroying and re-creating a path for short-lived paths.
ERRORS
VG_BAD_HANDLE_ERROR
if path is not a valid path handle, or is not shared with the current context
*/
EXPORT_C void
vgClearPath(VGPath path, VGbitfield capabilities)
{
OPENVG_TRACE("vgClearPath path=0x%x, capabilities=0x%x", path, capabilities);
TGuestOpenVg::vgClearPath(path, capabilities);
}
/*
Release any resources associated with path, and makes the handle invalid in all
contexts that shared it.
ERRORS
VG_BAD_HANDLE_ERROR
if path is not a valid path handle, or is not shared with the current context
*/
EXPORT_C void vgDestroyPath(VGPath path)
{
OPENVG_TRACE("vgDestroyPath path=0x%x", path);
TGuestOpenVg::vgDestroyPath(path);
}
/*
Requests the set of capabilities specified in the capabilities argument to
be disabled for the given path. The capabilities argument is a bitwise OR of
the VGPathCapabilities values whose removal is requested. Attempting to
remove a capability that is already disabled has no effect. Bits of
capabilities that do not correspond to values from VGPathCapabilities have
no effect.
ERRORS
VG_BAD_HANDLE_ERROR
if path is not a valid path handle, or is not shared with the current context
*/
EXPORT_C void
vgRemovePathCapabilities(VGPath path,
VGbitfield capabilities)
{
OPENVG_TRACE("vgRemovePathCapabilities path=0x%x, capabilities=0x%x", path, capabilities);
TGuestOpenVg::vgRemovePathCapabilities(path, capabilities);
}
/*
Appends a copy of all path segments from srcPath onto the end of the existing
data in dstPath. It is legal for srcPath and dstPath to be handles to the same
path object, in which case the contents of the path are duplicated. If srcPath
and dstPath are handles to distinct path objects, the contents of srcPath will
not be affected by the call.
ERRORS
VG_BAD_HANDLE_ERROR
if either dstPath or srcPath is not a valid path handle, or is not shared
with the current context
VG_PATH_CAPABILITY_ERROR
if VG_PATH_CAPABILITY_APPEND_FROM is not enabled for srcPath
if VG_PATH_CAPABILITY_APPEND_TO is not enabled for dstPath
*/
EXPORT_C void
vgAppendPath(VGPath dstPath, VGPath srcPath)
{
OPENVG_TRACE("vgAppendPath dstPath=0x%x, srcPath=0x%x", dstPath, srcPath);
TGuestOpenVg::vgAppendPath(dstPath, srcPath);
}
/*
Appends data taken from pathData to the given path dstPath. The data are formatted
using the path format of dstPath (as returned by querying the paths VG_PATH_FORMAT
parameter using vgGetParameteri). The numSegments parameter gives the total number
of entries in the pathSegments array, and must be greater than 0. Legal values for
the pathSegments array are the values from the VGPathCommand enumeration as well as
VG_CLOSE_PATH and (VG_CLOSE_PATH | VG_RELATIVE) (which are synonymous).
The pathData pointer must be aligned on a 1-, 2-, or 4-byte boundary (as defined in
the Bytes column of Open VG spec Table 7) depending on the size of the coordinate
datatype (as returned by querying the paths VG_PATH_DATATYPE parameter using
vgGetParameteri). The VG_PATH_CAPABILITY_APPEND_TO capability must be enabled for
path.
ERRORS
VG_BAD_HANDLE_ERROR
if dstPath is not a valid path handle, or is not shared with the current
context
VG_PATH_CAPABILITY_ERROR
if VG_PATH_CAPABILITY_APPEND_TO is not enabled for dstPath
VG_ILLEGAL_ARGUMENT_ERROR
if pathSegments or pathData is NULL
if pathData is not properly aligned
if numSegments is less than or equal to 0
if pathSegments contains an illegal command
*/
EXPORT_C void
vgAppendPathData(VGPath dstPath,
VGint numSegments,
const VGubyte * pathSegments,
const void * pathData)
{
OPENVG_TRACE("vgAppendPathData dstPath=0x%x, numSegments=%d, pathSegments=0x%x, pathData=0x%x",
dstPath, numSegments, pathSegments, pathData);
TGuestOpenVg::vgAppendPathData(dstPath, numSegments, pathSegments, pathData);
}
/*
Modifies the coordinate data for a contiguous range of segments of dstPath, starting
at startIndex (where 0 is the index of the first path segment) and having length
numSegments. The data in pathData must be formatted in exactly the same manner as the
original coordinate data for the given segment range, unless the path has been
transformed using vgTransformPath or interpolated using vgInterpolatePath. In these
cases, the path will have been subject to the segment promotion rules specified in
those functions.
The pathData pointer must be aligned on a 1-, 2-, or 4-byte boundary
depending on the size of the coordinate datatype (as returned by querying the
paths VG_PATH_DATATYPE parameter using vgGetParameteri). The
VG_PATH_CAPABILITY_MODIFY capability must be enabled for path.
ERRORS
VG_BAD_HANDLE_ERROR
if dstPath is not a valid path handle, or is not shared with the current
context
VG_PATH_CAPABILITY_ERROR
if VG_PATH_CAPABILITY_MODIFY is not enabled for dstPath
VG_ILLEGAL_ARGUMENT_ERROR
if pathData is NULL
if pathData is not properly aligned
if startIndex is less than 0
if numSegments is less than or equal to 0
if startIndex + numSegments is greater than the number of segments in the path
*/
EXPORT_C void
vgModifyPathCoords(VGPath dstPath,
VGint startIndex,
VGint numSegments,
const void * pathData)
{
OPENVG_TRACE("vgModifyPathCoords dstPath=0x%x, startIndex=%d, numSegments=%d, pathData=0x%x",
dstPath, startIndex, numSegments, pathData);
TGuestOpenVg::vgModifyPathCoords(dstPath, startIndex, numSegments, pathData);
}
/*
Appends a transformed copy of srcPath to the current contents of dstPath.
The appended path is equivalent to the results of applying the current
pathuser-to-surface transformation (VG_MATRIX_PATH_USER_TO_SURFACE) to srcPath.
It is legal for srcPath and dstPath to be handles to the same path object, in
which case the transformed path will be appended to the existing path. If
srcPath and dstPath are handles to distinct path objects, the contents of
srcPath will not be affected by the call.
ERRORS
VG_BAD_HANDLE_ERROR
if either dstPath or srcPath is not a valid path handle, or is not shared with
the current context
VG_PATH_CAPABILITY_ERROR
if VG_PATH_CAPABILITY_TRANSFORM_FROM is not enabled for srcPath
if VG_PATH_CAPABILITY_TRANSFORM_TO is not enabled for dstPath
*/
EXPORT_C void
vgTransformPath(VGPath dstPath, VGPath srcPath)
{
OPENVG_TRACE("vgTransformPath dstPath=0x%x, srcPath=0x%x", dstPath, srcPath);
TGuestOpenVg::vgTransformPath(dstPath, srcPath);
}
/*
Returns the point lying a given distance along a given portion of a path and
the unit-length tangent vector at that point. Only the subpath consisting of the
numSegments path segments beginning with startSegment (where the initial path
segment has index 0) is used. For the remainder of this section we refer only to
this subpath when discussing paths.
ERRORS
VG_BAD_HANDLE_ERROR
if path is not a valid path handle, or is not shared with the current context
VG_PATH_CAPABILITY_ERROR
If x and y are both non-NULL, and the VG_PATH_CAPABILITY_POINT_ALONG_PATH is
not enabled for path
If tangentX and tangentY are both non-NULL, and the
VG_PATH_CAPABILITY_TANGENT_ALONG_PATH capability is not enabled for path
VG_ILLEGAL_ARGUMENT_ERROR
if startSegment is less than 0 or greater than the index of the final path
segment
if numSegments is less than or equal to 0
if (startSegment + numSegments 1) is less than 0 or greater than the index
of the final path segment
if x, y, tangentX or tangentY is not properly aligned
*/
EXPORT_C void
vgPointAlongPath(VGPath path,
VGint startSegment,
VGint numSegments,
VGfloat distance,
VGfloat * x, VGfloat * y,
VGfloat * tangentX,
VGfloat * tangentY)
{
OPENVG_TRACE("vgPointAlongPath path=0x%x, startSeg=%d, numSegs=%d, distance=%f, x=0x%x, y=0x%x, tangentX=0x%x, tangentY=0x%x",
path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
TGuestOpenVg::vgPointAlongPath(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
}
/*
Performs filling and stroking. The paintModes argument is a bitwise OR of
values from the VGPaintMode enumeration, determining whether the path is to be
filled (VG_FILL_PATH), stroked (VG_STROKE_PATH), or both (VG_FILL_PATH |
VG_STROKE_PATH). If both filling and stroking are to be performed, the path is
first filled, then stroked.
ERRORS
VG_BAD_HANDLE_ERROR
if path is not a valid path handle, or is not shared with the current context
VG_ILLEGAL_ARGUMENT_ERROR
if paintModes is not a valid bitwise OR of values from the VGPaintMode
enumeration
*/
EXPORT_C void
vgDrawPath(VGPath path, VGbitfield paintModes)
{
OPENVG_TRACE("vgDrawPath path=0x%x paintModes=0x%x", path, paintModes);
TGuestOpenVg::vgDrawPath(path, paintModes);
}
/* Paint */
/*
Deallocates the resources associated with a paint object. Following the call, the
paint handle is no longer valid in any of the contexts that shared it. If the paint
object is currently active in a drawing context, the context continues to access it
until it is replaced or the context is destroyed.
ERRORS
VG_BAD_HANDLE_ERROR
if paint is not a valid paint handle, or is not shared with the current context
*/
EXPORT_C void vgDestroyPaint(VGPaint paint)
{
OPENVG_TRACE("vgDestroyPaint paint=0x%x", paint);
TGuestOpenVg::vgDestroyPaint(paint);
}
/*
Set paint definitions on the current context. The paintModes argument is a
bitwise OR of values from the VGPaintMode enumeration, determining whether
the paint object is to be used for filling (VG_FILL_PATH), stroking
(VG_STROKE_PATH), or both (VG_FILL_PATH | VG_STROKE_PATH). The current paint
replaces the previously set paint object, if any, for the given paint mode
or modes. If paint is equal to VG_INVALID_HANDLE, the previously set paint
object for the given mode (if present) is removed and the paint settings are
restored to their default values.
ERRORS
VG_BAD_HANDLE_ERROR
if paint is neither a valid paint handle nor equal to VG_INVALID_HANDLE,
or is not shared with the current context
VG_ILLEGAL_ARGUMENT_ERROR
if paintModes is not a valid bitwise OR of values from the VGPaintMode
enumeration
*/
EXPORT_C void
vgSetPaint(VGPaint paint, VGbitfield paintModes)
{
OPENVG_TRACE("vgSetPaint paint=0x%x, paintModes=0x%x", paint, paintModes);
TGuestOpenVg::vgSetPaint(paint, paintModes);
}
/*
As a shorthand, the vgSetColor function allows the VG_PAINT_COLOR parameter of a
given paint object to be set using a 32-bit non-premultiplied sRGBA_8888
representation. The rgba parameter is a VGuint with 8 bits of red starting at the
most significant bit, followed by 8 bits each of green, blue, and alpha. Each color
or alpha channel value is conceptually divided by 255. So as to obtain a value
between 0 and 1.
ERRORS
VG_BAD_HANDLE_ERROR
if paint is not a valid paint handle, or is not shared with the current context
*/
EXPORT_C void
vgSetColor(VGPaint paint, VGuint rgba)
{
OPENVG_TRACE("vgSetColor paint=0x%x, rgba=0x%x", paint, rgba);
TGuestOpenVg::vgSetColor(paint, rgba);
}
/*
Replaces any previous pattern image defined on the given paint object for the given
set of paint modes with a new pattern image. A value of VG_INVALID_HANDLE for the
pattern parameter removes the current pattern image from the paint object.
If the current paint object has its VG_PAINT_TYPE parameter set to VG_PAINT_TYPE_PATTERN,
but no pattern image is set, the paint object behaves as if VG_PAINT_TYPE were set to
VG_PAINT_TYPE_COLOR. While an image is set as the paint pattern for any paint object, it
may not be used as a rendering target. Conversely, an image that is currently a rendering
target may not be set as a paint pattern.
ERRORS
VG_BAD_HANDLE_ERROR
if paint is not a valid paint handle, or is not shared with the current context
if pattern is neither a valid image handle nor equal to VG_INVALID_HANDLE, or is not
shared with the current context
VG_IMAGE_IN_USE_ERROR
if pattern is currently a rendering target
*/
EXPORT_C void
vgPaintPattern(VGPaint paint, VGImage pattern)
{
OPENVG_TRACE("vgPaintPattern paint=0x%x, pattern=0x%x", paint, pattern);
TGuestOpenVg::vgPaintPattern(paint, pattern);
}
/* Images */
/*
Deallocates the resources associated with an image. Following the call, the image
handle is no longer valid in any context that shared it. If the image is currently
in use as a rendering target, is the ancestor of another image (see vgChildImage),
is set as a paint pattern image on a VGPaint object, or is set as a glyph an a
VGFont object, its definition remains available to those consumers as long as they
remain valid, but the handle may no longer be used. When those uses cease, the
images resources will automatically be deallocated.
ERRORS
VG_BAD_HANDLE_ERROR
if image is not a valid image handle, or is not shared with the current
context
*/
EXPORT_C void vgDestroyImage(VGImage image)
{
OPENVG_TRACE("vgDestroyImage image=0x%x -->", image);
TGuestOpenVg::vgDestroyImage(image);
OPENVG_TRACE("vgDestroyImage <--");
}
/*
Fills a given rectangle of an image with the color specified by the VG_CLEAR_COLOR parameter.
The rectangle to be cleared is given by x, y, width, and height, which must define a positive
region. The rectangle is clipped to the bounds of the image.
ERRORS
VG_BAD_HANDLE_ERROR
if image is not a valid image handle, or is not shared with the current
context
VG_IMAGE_IN_USE_ERROR
if image is currently a rendering target
VG_ILLEGAL_ARGUMENT_ERROR
if width or height is less than or equal to 0
*/
EXPORT_C void
vgClearImage(VGImage image,
VGint x, VGint y,
VGint width, VGint height)
{
OPENVG_TRACE("vgClearImage image=0x%x, x=%d, y=%d, width=%d, height=%d",
image, x, y, width, height);
TGuestOpenVg::vgClearImage(image, x, y, width, height);
}
/*
Read pixel values from memory, perform format conversion if necessary, and store
the resulting pixels into a rectangular portion of an image.
Pixel values are read starting at the address given by the pointer data; adjacent
scanlines are separated by dataStride bytes. Negative or zero values of
dataStride are allowed. The region to be written is given by x, y, width, and
height, which must define a positive region. Pixels that fall outside the bounds
of the image are ignored.
Pixel values in memory are formatted according to the dataFormat parameter, which
must contain a value from the VGImageFormat enumeration. The data pointer must
be aligned according to the number of bytes of the pixel format specified by
dataFormat, unless dataFormat is equal to VG_BW_1, VG_A_1, or VG_A_4, in
which case 1 byte alignment is sufficient. Each pixel is converted into the format of
the destination image as it is written.
ERRORS
VG_BAD_HANDLE_ERROR
if image is not a valid image handle, or is not shared with the current
context
VG_IMAGE_IN_USE_ERROR
if image is currently a rendering target
VG_UNSUPPORTED_IMAGE_FORMAT_ERROR
if dataFormat is not a valid value from the VGImageFormat enumeration
VG_ILLEGAL_ARGUMENT_ERROR
if width or height is less than or equal to 0
if data is NULL
if data is not properly aligned
*/
EXPORT_C void
vgImageSubData(VGImage image,
const void * data,
VGint dataStride,
VGImageFormat dataFormat,
VGint x, VGint y,
VGint width, VGint height)
{
OPENVG_TRACE("vgImageSubData image=0x%x, data=0x%x, dataStride=%d, dataFormat=0x%x, x=%d, y=%d, width=%d, height=%d",
image, data, dataStride, dataFormat, x, y, width, height);
TGuestOpenVg::vgImageSubData(image, data, dataStride, dataFormat, x, y, width, height);
}
/*
Copies pixels between images. The source image pixel (sx + i, sy + j) is copied
to the destination image pixel (dx + i, dy + j), for 0 <= i < width and
0 <= j < height. Pixels whose source or destination lie outside of the bounds
of the respective image are ignored. Pixel format conversion is applied as needed.
ERRORS
VG_BAD_HANDLE_ERROR
if either dst or src is not a valid image handle, or is not shared with the
current context
VG_IMAGE_IN_USE_ERROR
if either dst or src is currently a rendering target
VG_ILLEGAL_ARGUMENT_ERROR
if width or height is less than or equal to 0
*/
EXPORT_C void
vgCopyImage(VGImage dst, VGint dx, VGint dy,
VGImage src, VGint sx, VGint sy,
VGint width, VGint height,
VGboolean dither)
{
OPENVG_TRACE("vgCopyImage dst=0x%x, dx=%d, dy=%d, src=0x%x, sx=%d, sy=%d, width=%d, height=%d, dither=%d",
dst, dx, dy, src, sx, sy, width, height, dither);
TGuestOpenVg::vgCopyImage(dst, dx, dy, src, sx, sy, width, height, dither);
}
/*
Draw an image to the current drawing surface. The current image-user-to-surface
transformation Ti is applied to the image, so that the image pixel centered at
(px + 0.5, py + 0.5) is mapped to the point (Ti)(px + 0.5, py + 0.5). In practice,
backwards mapping may be used. That is, a sample located at (x, y) in the surface
coordinate system is colored according to an interpolated image pixel value at the
point (Ti)-1(x, y) in the image coordinate system. If Ti is non-invertible (or nearly
so, within the limits of numerical accuracy), no drawing occurs.
ERRORS
VG_BAD_HANDLE_ERROR
if image is not a valid image handle, or is not shared with the current
context
VG_IMAGE_IN_USE_ERROR
if image is currently a rendering target
*/
EXPORT_C void
vgDrawImage(VGImage image)
{
OPENVG_TRACE("vgDrawImage image=0x%x", image);
TGuestOpenVg::vgDrawImage(image);
}
/*
Copies pixel data from the image src onto the drawing surface. The image pixel
(sx + i, sy + j) is copied to the drawing surface pixel (dx + i, dy + j), for
0 <= i < width and 0 <= j < height. Pixels whose source lies outside of the
bounds of src or whose destination lies outside the bounds of the drawing surface
are ignored. Pixel format conversion is applied as needed. Scissoring takes place
normally. Transformations, masking, and blending are not applied.
ERRORS
VG_BAD_HANDLE_ERROR
if src is not a valid image handle, or is not shared with the current context
VG_IMAGE_IN_USE_ERROR
if src is currently a rendering target
VG_ILLEGAL_ARGUMENT_ERROR
if width or height is less than or equal to 0
*/
EXPORT_C void
vgSetPixels(VGint dx, VGint dy,
VGImage src, VGint sx, VGint sy,
VGint width, VGint height)
{
OPENVG_TRACE("vgSetPixels dx=%d, dy=%d, src==0x%x, sx=%d, sy=%d, width=%d, height=%d",
dx, dy, src, sx, sy, width, height);
TGuestOpenVg::vgSetPixels(dx, dy, src, sx, sy, width, height);
}
/*
Copy pixel data to the drawing surface without the creation of a VGImage object. The pixel
values to be drawn are taken from the data pointer at the time of the vgWritePixels call,
so future changes to the data have no effect. The effects of changes to the data by another
thread at the time of the call to vgWritePixels are undefined.
ERRORS
VG_UNSUPPORTED_IMAGE_FORMAT_ERROR
if dataFormat is not a valid value from the VGImageFormat enumeration
VG_ILLEGAL_ARGUMENT_ERROR
if width or height is less than or equal to 0
if data is NULL
if data is not properly aligned
*/
EXPORT_C void
vgWritePixels(const void * data, VGint dataStride,
VGImageFormat dataFormat,
VGint dx, VGint dy,
VGint width, VGint height)
{
OPENVG_TRACE("vgWritePixels data=0x%x, dataStride=%d, dataFormat=0x%x, dx=%d, dy=%d, width=%d, height=%d",
data, dataStride, dataFormat, dx, dy, width, height);
TGuestOpenVg::vgWritePixels(data, dataStride, dataFormat, dx, dy, width, height);
}
/*
Retrieves pixel data from the drawing surface into the image dst. The drawing surface
pixel (sx + i, sy + j) is copied to pixel (dx + i, dy + j) of the image dst, for
0 <= i < width and 0 <= j < height. Pixels whose source lies outside of the bounds of
the drawing surface or whose destination lies outside the bounds of dst are ignored.
Pixel format conversion is applied as needed. The scissoring region does not affect
the reading of pixels.
ERRORS
VG_BAD_HANDLE_ERROR
if dst is not a valid image handle, or is not shared with the current context
VG_IMAGE_IN_USE_ERROR
if dst is currently a rendering target
VG_ILLEGAL_ARGUMENT_ERROR
if width or height is less than or equal to 0
*/
EXPORT_C void
vgGetPixels(VGImage dst, VGint dx, VGint dy,
VGint sx, VGint sy,
VGint width, VGint height)
{
OPENVG_TRACE("vgGetPixels dst=0x%x, dx=%d, dy=%d, sx=%d, sy=%d, width=%d, height=%d",
dst, dx, dy, sx, sy, width, height);
TGuestOpenVg::vgGetPixels(dst, dx, dy, sx, sy, width, height);
}
/*
Copy pixels from one region of the drawing surface to another. Copies between
overlapping regions are allowed and always produce consistent results identical to
copying the entire source region to a scratch buffer followed by copying the scratch
buffer into the destination region. The drawing surface pixel (sx + i, sy + j) is
copied to pixel (dx + i, dy + j) for 0 <= i < width and 0 <= j < height. Pixels whose
source or destination lies outside of the bounds of the drawing surface are ignored.
Transformations, masking, and blending are not applied. Scissoring is applied to the
destination, but does not affect the reading of pixels.
ERRORS
VG_ILLEGAL_ARGUMENT_ERROR
if width or height is less than or equal to 0
*/
EXPORT_C void
vgCopyPixels(VGint dx, VGint dy,
VGint sx, VGint sy,
VGint width, VGint height)
{
OPENVG_TRACE("vgCopyPixels dx=%d, dy=%d, sx=%d, sy=%d, width=%d, height=%d",
dx, dy, sx, sy, width, height);
TGuestOpenVg::vgCopyPixels(dx, dy, sx, sy, width, height);
}
/*
Destroys the VGFont object pointed to by the font argument.
Note that vgDestroyFont will not destroy underlying objects that were used to
define glyphs in the font. It is the responsibility of an application to destroy all
VGPath or VGImage objects that were used in a VGFont, if they are no longer in
use.
ERRORS
VG_BAD_HANDLE_ERROR
if font is not a valid font handle, or is not shared with the current context
*/
EXPORT_C void
vgDestroyFont(VGFont font)
{
OPENVG_TRACE("vgDestroyFont font=0x%x", font);
TGuestOpenVg::vgDestroyFont(font);
}
/*
Creates a new glyph and assigns the given path to a glyph associated with the
glyphIndex in a font object. The glyphOrigin argument defines the coordinates of
the glyph origin within the path, and the escapement parameter determines the
advance width for this glyph. Both glyphOrigin and escapement coordinates are
defined in the same coordinate system as the path. For glyphs that have no
visual representation (e.g., the <space> character), a value of VG_INVALID_HANDLE
is used for path. The reference count for the path is incremented.
The path object may define either an original glyph outline, or an outline that
has been scaled and hinted to a particular size (in surface coordinate units); this
is defined by the isHinted parameter, which can be used by implementation
for text-specific optimizations (e.g., heuristic auto-hinting of unhinted outlines).
When isHinted is equal to VG_TRUE, the implementation will never apply
auto-hinting; otherwise, auto hinting will be applied at the implementation's
discretion.
ERRORS
VG_BAD_HANDLE_ERROR
if font is not a valid font handle, or is not shared with the current context
if path is not a valid font handle or VG_INVALID_HANDLE, or is not shared
with the current context
VG_ILLEGAL_ARGUMENT_ERROR
if the pointer to glyphOrigin or escapement is NULL or is not properly
aligned
*/
EXPORT_C void
vgSetGlyphToPath(VGFont font,
VGuint glyphIndex,
VGPath path,
VGboolean isHinted,
const VGfloat glyphOrigin [2],
const VGfloat escapement[2])
{
OPENVG_TRACE("vgSetGlyphToPath font=0x%x, glyphIndex=%u, path=0x%x, isHinted=%d, glyphOrigin=0x%x, escapement=0x%x",
font, glyphIndex, path, isHinted, glyphOrigin, escapement);
TGuestOpenVg::vgSetGlyphToPath(font, glyphIndex, path, isHinted, glyphOrigin, escapement);
}
/*
Creates a new glyph and assigns the given image into a glyph associated with
the glyphIndex in a font object. The glyphOrigin argument defines the
coordinates of the glyph origin within the image, and the escapement parameter
determines the advance width for this glyph. Both glyphOrigin and escapement
coordinates are defined in the image coordinate system. Applying transformations
to an image (other than translations mapped to pixel grid in surface coordinate
system) should be avoided as much as possible. For glyphs that have no visual
representation (e.g., the <space> character), a value of VG_INVALID_HANDLE is
used for image. The reference count for the image is incremented.
ERRORS
VG_BAD_HANDLE_ERROR
if font is not a valid font handle, or is not shared with the current context
if image is not a valid image handle or VG_INVALID_HANDLE, or is not
shared with the current context
VG_ILLEGAL_ARGUMENT_ERROR
if the pointer to glyphOrigin or escapement is NULL or is not properly
aligned
VG_IMAGE_IN_USE_ERROR
if image is currently a rendering target
*/
EXPORT_C void
vgSetGlyphToImage(VGFont font,
VGuint glyphIndex,
VGImage image,
const VGfloat glyphOrigin [2],
const VGfloat escapement[2])
{
OPENVG_TRACE("vgSetGlyphToImage font=0x%x, glyphIndex=%d, image=0x%x, glyphOrigin=0x%x, escapement=0x%x",
font, glyphIndex, image, (void*)glyphOrigin, (void*)escapement);
TGuestOpenVg::vgSetGlyphToImage(font, glyphIndex, image, glyphOrigin, escapement);
}
/*
Deletes the glyph defined by a glyphIndex parameter from a font. The reference count
for the VGPath or VGImage object to which the glyph was previously set is decremented,
and the object's resources are released if the count has fallen to 0.
ERRORS
VG_BAD_HANDLE_ERROR
if font is not a valid font handle, or is not shared with the current context
VG_ILLEGAL_ARGUMENT_ERROR
if glyphIndex is not defined for the font
*/
EXPORT_C void
vgClearGlyph(VGFont font,
VGuint glyphIndex)
{
OPENVG_TRACE("vgClearGlyph font=0x%x, glyphIndex=%u", font, glyphIndex);
TGuestOpenVg::vgClearGlyph(font, glyphIndex);
}
/*
Renders a glyph defined by the glyphIndex using the given font object. The
user space position of the glyph (the point where the glyph origin will be
placed) is determined by value of VG_GLYPH_ORIGIN. vgDrawGlyph calculates the
new text origin by translating the glyph origin by the escapement vector of
the glyph defined by glyphIndex. Following the call, the VG_GLYPH_ORIGIN
parameter will be updated with the new origin.
ERRORS
VG_BAD_HANDLE_ERROR
if font is not a valid font handle, or is not shared with the current context
VG_ILLEGAL_ARGUMENT_ERROR
if glyphIndex has not been defined for a given font object
if paintModes is not a valid bitwise OR of values from the VGPaintMode
enumeration, or 0
*/
EXPORT_C void
vgDrawGlyph(VGFont font,
VGuint glyphIndex,
VGbitfield paintModes,
VGboolean allowAutoHinting)
{
OPENVG_TRACE("vgDrawGlyph font=0x%x, glyphIndex=%u, paintModes=0x%x, allowAutoHinting=%d",
font, glyphIndex, paintModes, allowAutoHinting);
TGuestOpenVg::vgDrawGlyph(font, glyphIndex, paintModes, allowAutoHinting);
}
/*
Renders a sequence of glyphs defined by the array pointed to by glyphIndices
using the given font object. The values in the adjustments_x and adjustments_y
arrays define positional adjustment values for each pair of glyphs defined by
the glyphIndices array. The glyphCount parameter defines the number of elements
in the glyphIndices and adjustments_x and adjustments_y arrays. The adjustment
values defined in these arrays may represent kerning or other positional adjustments
required for each pair of glyphs. If no adjustments for glyph positioning in a
particular axis are required (all horizontal and/or vertical adjustments are zero),
NULL pointers may be passed for either or both of adjustment_x and
adjustment_y. The adjustments values should be defined in the same
coordinate system as the font glyphs; if the glyphs are defined by path objects
with path data scaled (e.g., by a factor of 1/units-per-EM), the values in the
adjustment_x and adjustment_y arrays are scaled using the same scale factor.
ERRORS
VG_BAD_HANDLE_ERROR
if font is not a valid font handle, or is not shared with the current context
VG_ILLEGAL_ARGUMENT_ERROR
if glyphCount is zero or a negative value
if the pointer to the glyphIndices array is NULL or is not properly
aligned
if a pointer to either of the adjustments_x or adjustments_y arrays are
non-NULL and are not properly aligned
if any of the glyphIndices has not been defined in a given font object
if paintModes is not a valid bitwise OR of values from the VGPaintMode
enumeration, or 0
*/
EXPORT_C void
vgDrawGlyphs(VGFont font,
VGint glyphCount,
const VGuint * glyphIndices,
const VGfloat * adjustments_x,
const VGfloat * adjustments_y,
VGbitfield paintModes,
VGboolean allowAutoHinting)
{
OPENVG_TRACE("vgDrawGlyphs font=0x%x, glyphCount=%d, glyphIndices=0x%x, adjustments_y=0x%x, "
"adjustments_x=0x%x, paintModes=0x%x, allowAutoHinting=%d",
font, glyphCount, (void*)glyphIndices, (void*)adjustments_x, (void*)adjustments_y, paintModes, allowAutoHinting);
TGuestOpenVg::vgDrawGlyphs(font, glyphCount, glyphIndices, adjustments_x, adjustments_y, paintModes, allowAutoHinting);
}
/* Image Filters */
/*
Computes a linear combination of color and alpha values (Rsrc, Gsrc, Bsrc,
ALPHAsrc) from the normalized source image src at each pixel.
ERRORS
VG_BAD_HANDLE_ERROR
if either dst or src is not a valid image handle, or is not shared with the
current context
VG_IMAGE_IN_USE_ERROR
if either dst or src is currently a rendering target
VG_ILLEGAL_ARGUMENT_ERROR
if src and dst overlap
if matrix is NULL
if matrix is not properly aligned
*/
EXPORT_C void
vgColorMatrix(VGImage dst, VGImage src,
const VGfloat * matrix)
{
OPENVG_TRACE("vgColorMatrix dst=0x%x, src=0x%x, matrix=0x%x", dst, src, matrix);
TGuestOpenVg::vgColorMatrix(dst, src, matrix);
}
/*
Applies a user-supplied convolution kernel to a normalized source image src. The
dimensions of the kernel are given by kernelWidth and kernelHeight; the kernel values
are specified as kernelWidth*kernelHeight VGshorts in column-major order. That is,
the kernel entry (i, j) is located at position i*kernelHeight + j in the input sequence.
The shiftX and shiftY parameters specify a translation between the source and
destination images. The result of the convolution is multiplied by a scale factor, and
a bias is added.
ERRORS
VG_BAD_HANDLE_ERROR
if either dst or src is not a valid image handle, or is not shared with the
current context
VG_IMAGE_IN_USE_ERROR
if either dst or src is currently a rendering target
VG_ILLEGAL_ARGUMENT_ERROR
if src and dst overlap
if kernelWidth or kernelHeight is less than or equal to 0 or greater than
VG_MAX_KERNEL_SIZE
if kernel is NULL
if kernel is not properly aligned
if tilingMode is not one of the values from the VGTilingMode enumeration
*/
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)
{
OPENVG_TRACE("vgConvolve dst=0x%x, src=0x%x, kW=%d, kH=%d, shX=%d, shY=%d, kernel=0x%x, scale=%f, bias=%f, tiling=0x%x",
dst, src, kernelWidth, kernelHeight, shiftX, shiftY, kernel, scale, bias, tilingMode);
TGuestOpenVg::vgConvolve(dst, src, kernelWidth, kernelHeight, shiftX, shiftY, kernel, scale, bias, tilingMode);
}
/*
Applies a user-supplied separable convolution kernel to a normalized source image src.
A separable kernel is a two-dimensional kernel in which each entry kij is equal to a
product kxi * kyj of elements from two one dimensional kernels, one horizontal and one
vertical.
ERRORS
VG_BAD_HANDLE_ERROR
if either dst or src is not a valid image handle, or is not shared with the
current context
VG_IMAGE_IN_USE_ERROR
if either dst or src is currently a rendering target
VG_ILLEGAL_ARGUMENT_ERROR
if src and dst overlap
if kernelWidth or kernelHeight is less than or equal to 0 or greater than
VG_MAX_SEPARABLE_KERNEL_SIZE
if kernelX or kernelY is NULL
if kernelX or kernelY is not properly aligned
if tilingMode is not one of the values from the VGTilingMode
enumeration
*/
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)
{
OPENVG_TRACE("vgSeparableConvolve dst=0x%x, src=0x%x, kW=%d, kH=%d, shX=%d, shY=%d, kX=0x%x, kY=0x%x, scale=%f, bias=%f, tiling=0x%x",
dst, src, kernelWidth, kernelHeight, shiftX, shiftY, kernelX, kernelY, scale, bias, tilingMode);
TGuestOpenVg::vgSeparableConvolve(dst, src, kernelWidth, kernelHeight, shiftX, shiftY, kernelX, kernelY, scale, bias, tilingMode);
}
/*
Computes the convolution of a normalized source image src with a separable kernel
defined in each dimension by the Gaussian function G(x, s).
ERRORS
VG_BAD_HANDLE_ERROR
if either dst or src is not a valid image handle, or is not shared with the
current context
VG_IMAGE_IN_USE_ERROR
if either dst or src is currently a rendering target
VG_ILLEGAL_ARGUMENT_ERROR
if src and dst overlap
if stdDeviationX or stdDeviationY is less than or equal to 0 or greater
than VG_MAX_GAUSSIAN_STD_DEVIATION
if tilingMode is not one of the values from the VGTilingMode
enumeration
*/
EXPORT_C void
vgGaussianBlur(VGImage dst, VGImage src,
VGfloat stdDeviationX,
VGfloat stdDeviationY,
VGTilingMode tilingMode)
{
OPENVG_TRACE("vgGaussianBlur dst=0x%x, src=0x%x, stdDeviationX=%f, stdDeviationY=%f, tilingMode=%d",
dst, src, stdDeviationX, stdDeviationY, tilingMode);
TGuestOpenVg::vgGaussianBlur(dst, src, stdDeviationX, stdDeviationY, tilingMode);
}
/*
Passes each image channel of the normalized source image src through a separate lookup
table.
Each channel of the normalized source pixel is used as an index into the lookup table for
that channel by multiplying the normalized value by 255 and rounding to obtain an 8-bit
integral value. Each LUT parameter should contain 256 VGubyte entries. The
outputs of the lookup tables are concatenated to form an RGBA_8888 pixel
value, which is interpreted as lRGBA_8888, lRGBA_8888_PRE, sRGBA_8888,
or sRGBA_8888_PRE, depending on the values of outputLinear and outputPremultiplied.
The resulting pixels are converted into the destination format using the normal
pixel format conversion rules.
ERRORS
VG_BAD_HANDLE_ERROR
if either dst or src is not a valid image handle, or is not shared with the
current context
VG_IMAGE_IN_USE_ERROR
if either dst or src is currently a rendering target
VG_ILLEGAL_ARGUMENT_ERROR
if src and dst overlap
if any pointer parameter is NULL
*/
EXPORT_C void
vgLookup(VGImage dst, VGImage src,
const VGubyte * redLUT,
const VGubyte * greenLUT,
const VGubyte * blueLUT,
const VGubyte * alphaLUT,
VGboolean outputLinear,
VGboolean outputPremultiplied)
{
OPENVG_TRACE("vgLookup dst=0x%x, src=0x%x, redLUT=0x%x, greenLUT=0x%x, blueLUT=0x%x, alphaLUT=0x%x, opLin=%d, opPremul=%d",
dst, src, redLUT, greenLUT, blueLUT, alphaLUT, outputLinear, outputPremultiplied);
TGuestOpenVg::vgLookup(dst, src, redLUT, greenLUT, blueLUT, alphaLUT, outputLinear, outputPremultiplied);
}
/*
Passes a single image channel of the normalized source image src, selected by the
sourceChannel parameter, through a combined lookup table that produces whole pixel
values. Each normalized source channel value is multiplied by 255 and rounded to
obtain an 8 bit integral value.
ERRORS
VG_BAD_HANDLE_ERROR
if either dst or src is not a valid image handle, or is not shared with the
current context
VG_IMAGE_IN_USE_ERROR
if either dst or src is currently a rendering target
VG_ILLEGAL_ARGUMENT_ERROR
if src and dst overlap
if src is in an RGB pixel format and sourceChannel is not one of VG_RED,
VG_GREEN, VG_BLUE or VG_ALPHA from the VGImageChannel enumeration
if lookupTable is NULL
if lookupTable is not properly aligned
*/
EXPORT_C void
vgLookupSingle(VGImage dst, VGImage src,
const VGuint * lookupTable,
VGImageChannel sourceChannel,
VGboolean outputLinear,
VGboolean outputPremultiplied)
{
OPENVG_TRACE("vgLookupSingle dst=0x%x, src=0x%x, lookupTable=0x%x, sourceChannel=0x%x, opLin=%d, opPremul=%d",
dst, src, lookupTable, sourceChannel, outputLinear, outputPremultiplied);
TGuestOpenVg::vgLookupSingle(dst, src, lookupTable, sourceChannel, outputLinear, outputPremultiplied);
}
// guest support for OpenVG extension #4, KHR_EGL_image - vgCreateEGLImageTargetKHR(VGeglImageKHR image)
/*
Creates an EGLImage target VGImage object from the provided EGLImage
<image>. <image> should be of type EGLImageKHR, cast into the type
VGeglImageKHR. Assuming no errors are generated in this function,
the resulting VGImage will be an EGLImage target of the specified
EGLImage <image>. As a side-effect of the referencing operation,
all of the pixel data in the <buffer> used as the EGLImage source
resource (i.e., the <buffer> parameter passed to the CreateImageKHR
command that returned <image>) will become undefined.
ERRORS
VG_UNSUPPORTED_IMAGE_FORMAT_ERROR
- if the OpenVG implementation is not able to create a VGImage
compatible with the provided VGeglImageKHR for an implementation-
dependent reason (this could be caused by, but not limited to,
reasons such as unsupported pixel formats, anti-aliasing quality,
etc.).
VG_ILLEGAL_ARGUMENT_ERROR
- if <image> is not a valid VGeglImageKHR.
*/
VGImage vgCreateEGLImageTargetKHR(VGeglImageKHR image)
{
OPENVG_TRACE("vgCreateEGLImageTargetKHR image=0x%x -->", image);
VGImage imageHandle = TGuestOpenVg::vgCreateEGLImageTargetKHR(image);
OPENVG_TRACE("vgCreateEGLImageTargetKHR imageHandle=0x%x <--", imageHandle);
return imageHandle;
}
} /* extern "C" */
// end of file openvg.cpp