3  * OpenVG 1.1 Reference Implementation

     3  * OpenVG 1.0.1 Reference Implementation

     6  * Copyright (c) 2008 The Khronos Group Inc.

     6  * Copyright (c) 2007-2009 The Khronos Group Inc.

    29  * \brief	OpenVG 1.1 API.

    29  * \brief	OpenVG 1.0.1 API.

    32 #ifndef __VG_1_1_OPENVG_H

    32 #ifndef __VG_1_0_OPENVG_H

    33 #define __VG_1_1_OPENVG_H

    33 #define __VG_1_0_OPENVG_H

    46 - the addition of __SOFTFP to all function prototypes

    46 - the addition of __SOFTFP in some of the function prototypes

    63 #define OPENVG_VERSION_1_0 1

    66 typedef khronos_float    VGfloat;

    64 #define OPENVG_VERSION_1_1 2

    65 

    66 typedef khronos_float_t  VGfloat;

   179   VG_MATRIX_STROKE_PAINT_TO_USER              = 0x1403,

   172   VG_MATRIX_STROKE_PAINT_TO_USER              = 0x1403

   180   VG_MATRIX_GLYPH_USER_TO_SURFACE             = 0x1404

   456 #define VG_API_CALL IMPORT_C

   441 #   if defined(SYMBIAN_VG_DLL_EXPORTS) 

   442 #       define VG_API_CALL EXPORT_C

   443 #   else

   444 #       define VG_API_CALL IMPORT_C

   445 #   endif //defined(SYMBIAN_VG_DLL_EXPORTS)

   458 #ifndef VG_APIENTRY

   447 

   459 #define VG_APIENTRY /* nothing */

   448 VG_API_CALL VGErrorCode vgGetError(void);

   460 #endif

   449 

   461 #ifndef VG_APIEXIT

   450 VG_API_CALL void vgFlush(void);

   462 #define VG_APIEXIT __SOFTFP

   451 VG_API_CALL void vgFinish(void);

   463 #endif

   464 

   465 VG_API_CALL VGErrorCode VG_APIENTRY

   466     vgGetError(void) VG_APIEXIT;

   467 

   468 VG_API_CALL void VG_APIENTRY

   469     vgFlush(void) VG_APIEXIT;

   470 VG_API_CALL void VG_APIENTRY

   471     vgFinish(void) VG_APIEXIT;

   474 VG_API_CALL void VG_APIENTRY

   454 VG_API_CALL void vgSetf (VGParamType type, VGfloat value) __SOFTFP;

   475    vgSetf (VGParamType type, VGfloat value) VG_APIEXIT;

   455 VG_API_CALL void vgSeti (VGParamType type, VGint value);

   476 VG_API_CALL void VG_APIENTRY

   456 VG_API_CALL void vgSetfv(VGParamType type, VGint count,

   477     vgSeti (VGParamType type, VGint value) VG_APIEXIT;

   457                          const VGfloat * values);

   478 VG_API_CALL void VG_APIENTRY

   458 VG_API_CALL void vgSetiv(VGParamType type, VGint count,

   479     vgSetfv(VGParamType type, VGint count,

   459                          const VGint * values);

   480         const VGfloat * values) VG_APIEXIT;

   460 

   481 VG_API_CALL void VG_APIENTRY

   461 VG_API_CALL VGfloat vgGetf(VGParamType type) __SOFTFP;

   482     vgSetiv(VGParamType type, VGint count,

   462 VG_API_CALL VGint   vgGeti(VGParamType type);

   483         const VGint * values) VG_APIEXIT;

   463 VG_API_CALL VGint   vgGetVectorSize(VGParamType type);

   484 VG_API_CALL VGfloat VG_APIENTRY

   464 VG_API_CALL void    vgGetfv(VGParamType type, VGint count, VGfloat * values);

   485     vgGetf(VGParamType type) VG_APIEXIT;

   465 VG_API_CALL void    vgGetiv(VGParamType type, VGint count, VGint * values);

   486 VG_API_CALL VGint   VG_APIENTRY

   466 

   487     vgGeti(VGParamType type) VG_APIEXIT;

   467 VG_API_CALL void vgSetParameterf(VGHandle object,

   488 VG_API_CALL VGint   VG_APIENTRY

   468                                  VGint paramType,

   489     vgGetVectorSize(VGParamType type) VG_APIEXIT;

   469                                  VGfloat value) __SOFTFP;

   490 VG_API_CALL void    VG_APIENTRY

   470 VG_API_CALL void vgSetParameteri(VGHandle object,

   491     vgGetfv(VGParamType type, VGint count,

   471                                  VGint paramType,

   492         VGfloat * values) VG_APIEXIT;

   472                                  VGint value);

   493 VG_API_CALL void    VG_APIENTRY

   473 VG_API_CALL void vgSetParameterfv(VGHandle object,

   494     vgGetiv(VGParamType type, VGint count,

   474                                   VGint paramType,

   495         VGint * values) VG_APIEXIT;

   475                                   VGint count, const VGfloat * values);

   496 VG_API_CALL void VG_APIENTRY

   476 VG_API_CALL void vgSetParameteriv(VGHandle object,

   497     vgSetParameterf(VGHandle object,

   477                                   VGint paramType,

   498         VGint paramType,

   478                                   VGint count, const VGint * values);

   499         VGfloat value) VG_APIEXIT;

   479 

   500 VG_API_CALL void VG_APIENTRY

   480 VG_API_CALL VGfloat vgGetParameterf(VGHandle object,

   501     vgSetParameteri(VGHandle object,

   481                                     VGint paramType) __SOFTFP;

   502         VGint paramType,

   482 VG_API_CALL VGint vgGetParameteri(VGHandle object,

   503         VGint value) VG_APIEXIT;

   483                                   VGint paramType);

   504 VG_API_CALL void VG_APIENTRY

   484 VG_API_CALL VGint vgGetParameterVectorSize(VGHandle object,

   505     vgSetParameterfv(VGHandle object,

   485                                            VGint paramType);

   506         VGint paramType,

   486 VG_API_CALL void vgGetParameterfv(VGHandle object,

   507         VGint count,

   487                                   VGint paramType,

   508         const VGfloat * values) VG_APIEXIT;

   488                                   VGint count, VGfloat * values);

   509 VG_API_CALL void VG_APIENTRY

   489 VG_API_CALL void vgGetParameteriv(VGHandle object,

   510     vgSetParameteriv(VGHandle object,

   490                                   VGint paramType,

   511         VGint paramType,

   491                                   VGint count, VGint * values);

   512         VGint count,

   513         const VGint * values) VG_APIEXIT;

   514 

   515 VG_API_CALL VGfloat VG_APIENTRY

   516     vgGetParameterf(VGHandle object,

   517         VGint paramType) VG_APIEXIT;

   518 VG_API_CALL VGint VG_APIENTRY

   519     vgGetParameteri(VGHandle object,

   520         VGint paramType) VG_APIEXIT;

   521 VG_API_CALL VGint VG_APIENTRY

   522     vgGetParameterVectorSize(VGHandle object,

   523         VGint paramType) VG_APIEXIT;

   524 VG_API_CALL void VG_APIENTRY

   525     vgGetParameterfv(VGHandle object,

   526         VGint paramType,

   527         VGint count,

   528         VGfloat * values) VG_APIEXIT;

   529 VG_API_CALL void VG_APIENTRY

   530     vgGetParameteriv(VGHandle object,

   531         VGint paramType,

   532         VGint count,

   533         VGint * values) VG_APIEXIT;

   536 VG_API_CALL void VG_APIENTRY

   494 VG_API_CALL void vgLoadIdentity(void);

   537     vgLoadIdentity(void) VG_APIEXIT;

   495 VG_API_CALL void vgLoadMatrix(const VGfloat * m);

   538 VG_API_CALL void VG_APIENTRY

   496 VG_API_CALL void vgGetMatrix(VGfloat * m);

   539     vgLoadMatrix(const VGfloat * m) VG_APIEXIT;

   497 VG_API_CALL void vgMultMatrix(const VGfloat * m);

   540 VG_API_CALL void VG_APIENTRY

   498 VG_API_CALL void vgTranslate(VGfloat tx, VGfloat ty) __SOFTFP;

   541     vgGetMatrix(VGfloat * m) VG_APIEXIT;

   499 VG_API_CALL void vgScale(VGfloat sx, VGfloat sy) __SOFTFP;

   542 VG_API_CALL void VG_APIENTRY

   500 VG_API_CALL void vgShear(VGfloat shx, VGfloat shy) __SOFTFP;

   543     vgMultMatrix(const VGfloat * m) VG_APIEXIT;

   501 VG_API_CALL void vgRotate(VGfloat angle) __SOFTFP;

   544 VG_API_CALL void VG_APIENTRY

   545     vgTranslate(VGfloat tx, VGfloat ty) VG_APIEXIT;

   546 VG_API_CALL void VG_APIENTRY

   547     vgScale(VGfloat sx, VGfloat sy) VG_APIEXIT;

   548 VG_API_CALL void VG_APIENTRY

   549     vgShear(VGfloat shx, VGfloat shy) VG_APIEXIT;

   550 VG_API_CALL void VG_APIENTRY

   551     vgRotate(VGfloat angle) VG_APIEXIT;

   554 typedef VGHandle VGMaskLayer;

   504 VG_API_CALL void vgMask(VGImage mask, VGMaskOperation operation,

   555 

   505                         VGint x, VGint y, VGint width, VGint height);

   556 VG_API_CALL void VG_APIENTRY

   506 VG_API_CALL void vgClear(VGint x, VGint y, VGint width, VGint height);

   557     vgMask(VGHandle mask, VGMaskOperation operation,

   558         VGint x, VGint y,

   559         VGint width, VGint height) VG_APIEXIT;

   560 VG_API_CALL void VG_APIENTRY

   561     vgRenderToMask(VGPath path,

   562         VGbitfield paintModes,

   563         VGMaskOperation operation) VG_APIEXIT;

   564 VG_API_CALL VGMaskLayer VG_APIENTRY

   565     vgCreateMaskLayer(VGint width, VGint height) VG_APIEXIT;

   566 VG_API_CALL void VG_APIENTRY

   567     vgDestroyMaskLayer(VGMaskLayer maskLayer) VG_APIEXIT;

   568 VG_API_CALL void VG_APIENTRY

   569     vgFillMaskLayer(VGMaskLayer maskLayer,

   570         VGint x, VGint y,

   571         VGint width, VGint height,

   572         VGfloat value) VG_APIEXIT;

   573 VG_API_CALL void VG_APIENTRY

   574     vgCopyMask(VGMaskLayer maskLayer,

   575         VGint sx, VGint sy,

   576         VGint dx, VGint dy,

   577         VGint width, VGint height) VG_APIEXIT;

   578 VG_API_CALL void VG_APIENTRY

   579     vgClear(VGint x, VGint y,

   580         VGint width, VGint height) VG_APIEXIT;

   583 VG_API_CALL VGPath VG_APIENTRY

   509 VG_API_CALL VGPath vgCreatePath(VGint pathFormat,

   584     vgCreatePath(VGint pathFormat,

   510                                 VGPathDatatype datatype,

   585         VGPathDatatype datatype,

   511                                 VGfloat scale, VGfloat bias,

   586         VGfloat scale, VGfloat bias,

   512                                 VGint segmentCapacityHint,

   587         VGint segmentCapacityHint,

   513                                 VGint coordCapacityHint,

   588         VGint coordCapacityHint,

   514                                 VGbitfield capabilities) __SOFTFP;

   589         VGbitfield capabilities) VG_APIEXIT;

   515 VG_API_CALL void vgClearPath(VGPath path, VGbitfield capabilities);

   590 VG_API_CALL void VG_APIENTRY

   516 VG_API_CALL void vgDestroyPath(VGPath path);

   591     vgClearPath(VGPath path, VGbitfield capabilities) VG_APIEXIT;

   517 VG_API_CALL void vgRemovePathCapabilities(VGPath path,

   592 VG_API_CALL void VG_APIENTRY

   518                                           VGbitfield capabilities);

   593     vgDestroyPath(VGPath path) VG_APIEXIT;

   519 VG_API_CALL VGbitfield vgGetPathCapabilities(VGPath path);

   594 VG_API_CALL void VG_APIENTRY

   520 VG_API_CALL void vgAppendPath(VGPath dstPath, VGPath srcPath);

   595     vgRemovePathCapabilities(VGPath path,

   521 VG_API_CALL void vgAppendPathData(VGPath dstPath,

   596         VGbitfield capabilities) VG_APIEXIT;

   522                                   VGint numSegments,

   597 VG_API_CALL VGbitfield VG_APIENTRY

   523                                   const VGubyte * pathSegments,

   598     vgGetPathCapabilities(VGPath path) VG_APIEXIT;

   524                                   const void * pathData);

   599 VG_API_CALL void VG_APIENTRY

   525 VG_API_CALL void vgModifyPathCoords(VGPath dstPath, VGint startIndex,

   600     vgAppendPath(VGPath dstPath, VGPath srcPath) VG_APIEXIT;

   526                                     VGint numSegments,

   601 VG_API_CALL void VG_APIENTRY

   527                                     const void * pathData);

   602     vgAppendPathData(VGPath dstPath,

   528 VG_API_CALL void vgTransformPath(VGPath dstPath, VGPath srcPath);

   603         VGint numSegments,

   529 VG_API_CALL VGboolean vgInterpolatePath(VGPath dstPath,

   604         const VGubyte * pathSegments,

   530                                         VGPath startPath,

   605         const void * pathData) VG_APIEXIT;

   531                                         VGPath endPath,

   606 VG_API_CALL void VG_APIENTRY

   532                                         VGfloat amount) __SOFTFP;

   607     vgModifyPathCoords(VGPath dstPath,

   533 VG_API_CALL VGfloat vgPathLength(VGPath path,

   608         VGint startIndex,

   534                                  VGint startSegment, VGint numSegments) __SOFTFP;

   609         VGint numSegments,

   535 VG_API_CALL void vgPointAlongPath(VGPath path,

   610         const void * pathData) VG_APIEXIT;

   536                                   VGint startSegment, VGint numSegments,

   611 VG_API_CALL void VG_APIENTRY

   537                                   VGfloat distance,

   612     vgTransformPath(VGPath dstPath, VGPath srcPath) VG_APIEXIT;

   538                                   VGfloat * x, VGfloat * y,

   613 VG_API_CALL VGboolean VG_APIENTRY

   539                                   VGfloat * tangentX, VGfloat * tangentY) __SOFTFP;

   614     vgInterpolatePath(VGPath dstPath,

   540 VG_API_CALL void vgPathBounds(VGPath path,

   615         VGPath startPath,

   541                               VGfloat * minX, VGfloat * minY,

   616         VGPath endPath,

   542                               VGfloat * width, VGfloat * height);

   617         VGfloat amount) VG_APIEXIT;

   543 VG_API_CALL void vgPathTransformedBounds(VGPath path,

   618 VG_API_CALL VGfloat VG_APIENTRY

   544                                          VGfloat * minX, VGfloat * minY,

   619     vgPathLength(VGPath path,

   545                                          VGfloat * width, VGfloat * height);

   620         VGint startSegment,

   546 VG_API_CALL void vgDrawPath(VGPath path, VGbitfield paintModes);

   621         VGint numSegments) VG_APIEXIT;

   622 VG_API_CALL void VG_APIENTRY

   623     vgPointAlongPath(VGPath path,

   624         VGint startSegment,

   625         VGint numSegments,

   626         VGfloat distance,

   627         VGfloat * x, VGfloat * y,

   628         VGfloat * tangentX,

   629         VGfloat * tangentY) VG_APIEXIT;

   630 VG_API_CALL void VG_APIENTRY

   631     vgPathBounds(VGPath path,

   632         VGfloat * minX,

   633         VGfloat * minY,

   634         VGfloat * width,

   635         VGfloat * height) VG_APIEXIT;

   636 VG_API_CALL void VG_APIENTRY

   637     vgPathTransformedBounds(VGPath path,

   638         VGfloat * minX,

   639         VGfloat * minY,

   640         VGfloat * width,

   641         VGfloat * height) VG_APIEXIT;

   642 VG_API_CALL void VG_APIENTRY

   643     vgDrawPath(VGPath path, VGbitfield paintModes) VG_APIEXIT;

   646 VG_API_CALL VGPaint VG_APIENTRY

   549 VG_API_CALL VGPaint vgCreatePaint(void);

   647     vgCreatePaint(void) VG_APIEXIT;

   550 VG_API_CALL void vgDestroyPaint(VGPaint paint);

   648 VG_API_CALL void VG_APIENTRY

   551 VG_API_CALL void vgSetPaint(VGPaint paint, VGbitfield paintModes);

   649     vgDestroyPaint(VGPaint paint) VG_APIEXIT;

   552 VG_API_CALL VGPaint vgGetPaint(VGPaintMode paintMode);

   650 VG_API_CALL void VG_APIENTRY

   553 VG_API_CALL void vgSetColor(VGPaint paint, VGuint rgba);

   651     vgSetPaint(VGPaint paint, VGbitfield paintModes) VG_APIEXIT;

   554 VG_API_CALL VGuint vgGetColor(VGPaint paint);

   652 VG_API_CALL VGPaint VG_APIENTRY

   555 VG_API_CALL void vgPaintPattern(VGPaint paint, VGImage pattern);

   653     vgGetPaint(VGPaintMode paintMode) VG_APIEXIT;

   654 VG_API_CALL void VG_APIENTRY

   655     vgSetColor(VGPaint paint, VGuint rgba) VG_APIEXIT;

   656 VG_API_CALL VGuint VG_APIENTRY

   657     vgGetColor(VGPaint paint) VG_APIEXIT;

   658 VG_API_CALL void VG_APIENTRY

   659     vgPaintPattern(VGPaint paint, VGImage pattern) VG_APIEXIT;

   662 VG_API_CALL VGImage VG_APIENTRY

   558 VG_API_CALL VGImage vgCreateImage(VGImageFormat format,

   663     vgCreateImage(VGImageFormat format,

   559                                   VGint width, VGint height,

   664         VGint width, VGint height,

   560                                   VGbitfield allowedQuality);

   665         VGbitfield allowedQuality) VG_APIEXIT;

   561 VG_API_CALL void vgDestroyImage(VGImage image);

   666 VG_API_CALL void VG_APIENTRY

   562 VG_API_CALL void vgClearImage(VGImage image,

   667     vgDestroyImage(VGImage image) VG_APIEXIT;

   563                               VGint x, VGint y, VGint width, VGint height);

   668 VG_API_CALL void VG_APIENTRY

   564 VG_API_CALL void vgImageSubData(VGImage image,

   669     vgClearImage(VGImage image,

   565                                 const void * data, VGint dataStride,

   670         VGint x, VGint y,

   566                                 VGImageFormat dataFormat,

   671         VGint width, VGint height) VG_APIEXIT;

   567                                 VGint x, VGint y, VGint width, VGint height);

   672 VG_API_CALL void VG_APIENTRY

   568 VG_API_CALL void vgGetImageSubData(VGImage image,

   673     vgImageSubData(VGImage image,

   569                                    void * data, VGint dataStride,

   674         const void * data,

   570                                    VGImageFormat dataFormat,

   675         VGint dataStride,

   571                                    VGint x, VGint y,

   676         VGImageFormat dataFormat,

   572                                    VGint width, VGint height);

   677         VGint x, VGint y,

   573 VG_API_CALL VGImage vgChildImage(VGImage parent,

   678         VGint width, VGint height) VG_APIEXIT;

   574                                  VGint x, VGint y, VGint width, VGint height);

   679 VG_API_CALL void VG_APIENTRY

   575 VG_API_CALL VGImage vgGetParent(VGImage image); 

   680     vgGetImageSubData(VGImage image,

   576 VG_API_CALL void vgCopyImage(VGImage dst, VGint dx, VGint dy,

   681         void * data,

   577                              VGImage src, VGint sx, VGint sy,

   682         VGint dataStride,

   578                              VGint width, VGint height,

   683         VGImageFormat dataFormat,

   579                              VGboolean dither);

   684         VGint x, VGint y,

   580 VG_API_CALL void vgDrawImage(VGImage image);

   685         VGint width, VGint height) VG_APIEXIT;

   581 VG_API_CALL void vgSetPixels(VGint dx, VGint dy,

   686 VG_API_CALL VGImage VG_APIENTRY

   582                              VGImage src, VGint sx, VGint sy,

   687     vgChildImage(VGImage parent,

   583                              VGint width, VGint height);

   688         VGint x, VGint y,

   584 VG_API_CALL void vgWritePixels(const void * data, VGint dataStride,

   689         VGint width, VGint height) VG_APIEXIT;

   585                                VGImageFormat dataFormat,

   690 VG_API_CALL VGImage VG_APIENTRY

   586                                VGint dx, VGint dy,

   691     vgGetParent(VGImage image) VG_APIEXIT;

   587                                VGint width, VGint height);

   692 VG_API_CALL void VG_APIENTRY

   588 VG_API_CALL void vgGetPixels(VGImage dst, VGint dx, VGint dy,

   693     vgCopyImage(VGImage dst, VGint dx, VGint dy,

   589                              VGint sx, VGint sy,

   694         VGImage src, VGint sx, VGint sy,

   590                              VGint width, VGint height);

   695         VGint width, VGint height,

   591 VG_API_CALL void vgReadPixels(void * data, VGint dataStride,

   696         VGboolean dither) VG_APIEXIT;

   592                               VGImageFormat dataFormat,

   697 VG_API_CALL void VG_APIENTRY

   593                               VGint sx, VGint sy,

   698     vgDrawImage(VGImage image) VG_APIEXIT;

   594                               VGint width, VGint height);

   699 VG_API_CALL void VG_APIENTRY

   595 VG_API_CALL void vgCopyPixels(VGint dx, VGint dy,

   700     vgSetPixels(VGint dx, VGint dy,

   596                               VGint sx, VGint sy,

   701         VGImage src, VGint sx, VGint sy,

   597                               VGint width, VGint height);

   702         VGint width, VGint height) VG_APIEXIT;

   703 VG_API_CALL void VG_APIENTRY

   704     vgWritePixels(const void * data, VGint dataStride,

   705         VGImageFormat dataFormat,

   706         VGint dx, VGint dy,

   707         VGint width, VGint height) VG_APIEXIT;

   708 VG_API_CALL void VG_APIENTRY

   709     vgGetPixels(VGImage dst, VGint dx, VGint dy,

   710         VGint sx, VGint sy,

   711         VGint width, VGint height) VG_APIEXIT;

   712 VG_API_CALL void VG_APIENTRY

   713     vgReadPixels(void * data, VGint dataStride,

   714         VGImageFormat dataFormat,

   715         VGint sx, VGint sy,

   716         VGint width, VGint height) VG_APIEXIT;

   717 VG_API_CALL void VG_APIENTRY

   718     vgCopyPixels(VGint dx, VGint dy,

   719         VGint sx, VGint sy,

   720         VGint width, VGint height) VG_APIEXIT;

   721 

   722 /* Text */

   723 typedef VGHandle VGFont;

   724 

   725 VG_API_CALL VGFont VG_APIENTRY

   726     vgCreateFont(VGint glyphCapacityHint) VG_APIEXIT;

   727 VG_API_CALL void VG_APIENTRY

   728     vgDestroyFont(VGFont font) VG_APIEXIT;

   729 VG_API_CALL void VG_APIENTRY

   730     vgSetGlyphToPath(VGFont font,

   731         VGuint glyphIndex,

   732         VGPath path,

   733         VGboolean isHinted,

   734         const VGfloat glyphOrigin [2],

   735         const VGfloat escapement[2]) VG_APIEXIT;

   736 VG_API_CALL void VG_APIENTRY

   737     vgSetGlyphToImage(VGFont font,

   738         VGuint glyphIndex,

   739         VGImage image,

   740         const VGfloat glyphOrigin [2],

   741         const VGfloat escapement[2]) VG_APIEXIT;

   742 VG_API_CALL void VG_APIENTRY

   743     vgClearGlyph(VGFont font,

   744         VGuint glyphIndex) VG_APIEXIT;

   745 VG_API_CALL void VG_APIENTRY

   746     vgDrawGlyph(VGFont font,

   747         VGuint glyphIndex,

   748         VGbitfield paintModes,

   749         VGboolean allowAutoHinting) VG_APIEXIT;

   750 VG_API_CALL void VG_APIENTRY

   751     vgDrawGlyphs(VGFont font,

   752         VGint glyphCount,

   753         const VGuint * glyphIndices,

   754         const VGfloat * adjustments_x,

   755         const VGfloat * adjustments_y,

   756         VGbitfield paintModes,

   757         VGboolean allowAutoHinting) VG_APIEXIT;

   760 VG_API_CALL void VG_APIENTRY

   600 VG_API_CALL void vgColorMatrix(VGImage dst, VGImage src,

   761     vgColorMatrix(VGImage dst, VGImage src,

   601                                const VGfloat * matrix);

   762         const VGfloat * matrix) VG_APIEXIT;

   602 VG_API_CALL void vgConvolve(VGImage dst, VGImage src,

   763 VG_API_CALL void VG_APIENTRY

   603                             VGint kernelWidth, VGint kernelHeight,

   764     vgConvolve(VGImage dst, VGImage src,

   604                             VGint shiftX, VGint shiftY,

   765         VGint kernelWidth, VGint kernelHeight,

   605                             const VGshort * kernel,

   766         VGint shiftX, VGint shiftY,

   606                             VGfloat scale,

   767         const VGshort * kernel,

   607                             VGfloat bias,

   768         VGfloat scale,

   608                             VGTilingMode tilingMode) __SOFTFP;

   769         VGfloat bias,

   609 VG_API_CALL void vgSeparableConvolve(VGImage dst, VGImage src,

   770         VGTilingMode tilingMode) VG_APIEXIT;

   610                                      VGint kernelWidth,

   771 VG_API_CALL void VG_APIENTRY

   611                                      VGint kernelHeight,

   772     vgSeparableConvolve(VGImage dst, VGImage src,

   612                                      VGint shiftX, VGint shiftY,

   773         VGint kernelWidth,

   613                                      const VGshort * kernelX,

   774         VGint kernelHeight,

   614                                      const VGshort * kernelY,

   775         VGint shiftX, VGint shiftY,

   615                                      VGfloat scale,

   776         const VGshort * kernelX,

   616                                      VGfloat bias,

   777         const VGshort * kernelY,

   617                                      VGTilingMode tilingMode) __SOFTFP;

   778         VGfloat scale,

   618 VG_API_CALL void vgGaussianBlur(VGImage dst, VGImage src,

   779         VGfloat bias,

   619                                 VGfloat stdDeviationX,

   780         VGTilingMode tilingMode) VG_APIEXIT;

   620                                 VGfloat stdDeviationY,

   781 VG_API_CALL void VG_APIENTRY

   621                                 VGTilingMode tilingMode) __SOFTFP;

   782     vgGaussianBlur(VGImage dst, VGImage src,

   622 VG_API_CALL void vgLookup(VGImage dst, VGImage src,

   783         VGfloat stdDeviationX,

   623                           const VGubyte * redLUT,

   784         VGfloat stdDeviationY,

   624                           const VGubyte * greenLUT,

   785         VGTilingMode tilingMode) VG_APIEXIT;

   625                           const VGubyte * blueLUT,

   786 VG_API_CALL void VG_APIENTRY

   626                           const VGubyte * alphaLUT,

   787     vgLookup(VGImage dst, VGImage src,

   627                           VGboolean outputLinear,

   788         const VGubyte * redLUT,

   628                           VGboolean outputPremultiplied);

   789         const VGubyte * greenLUT,

   629 VG_API_CALL void vgLookupSingle(VGImage dst, VGImage src,

   790         const VGubyte * blueLUT,

   630                                 const VGuint * lookupTable,

   791         const VGubyte * alphaLUT,

   631                                 VGImageChannel sourceChannel,

   792         VGboolean outputLinear,

   632                                 VGboolean outputLinear,

   793         VGboolean outputPremultiplied) VG_APIEXIT;

   633                                 VGboolean outputPremultiplied);

   794 VG_API_CALL void VG_APIENTRY

   795     vgLookupSingle(VGImage dst, VGImage src,

   796         const VGuint * lookupTable,

   797         VGImageChannel sourceChannel,

   798         VGboolean outputLinear,

   799         VGboolean outputPremultiplied) VG_APIEXIT;

   802 VG_API_CALL VGHardwareQueryResult VG_APIENTRY

   636 VG_API_CALL VGHardwareQueryResult vgHardwareQuery(VGHardwareQueryType key,

   803     vgHardwareQuery

   637                                                   VGint setting);

   804         (VGHardwareQueryType key,

   805         VGint setting) VG_APIEXIT;

   808 VG_API_CALL const VGubyte * VG_APIENTRY

   640 VG_API_CALL const VGubyte * vgGetString(VGStringID name);

   809     vgGetString(VGStringID name) VG_APIEXIT;

   641 

   810 

   642 #ifdef __cplusplus 

   811 #ifdef __cplusplus

   815 #endif /* __VG_1_1_OPENVG_H */

   646 #endif /*__VG_1_0_OPENVG_H */