12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060 |
- /****************************************************************************
- *
- * The MIT License (MIT)
- *
- * Copyright 2012 - 2020 Vivante Corporation, Santa Clara, California.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * 'Software'), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject
- * to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VIVANTE AND/OR ITS SUPPLIERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- *****************************************************************************/
- #ifndef _vg_lite_h_
- #define _vg_lite_h_
- #ifdef __cplusplus
- extern "C" {
- #endif
- #if defined(_MSC_VER)
- #define inline __inline
- #endif
- #include <stddef.h>
- #include <stdint.h>
- #define VGLITE_RELEASE_VERSION 0x03000f
- #define VGLITE_HEADER_VERSION 6
- #ifndef VGLITE_VERSION_2_0
- #define VGLITE_VERSION_2_0 1
- #define VGLITE_MAKE_VERSION(major, minor, patch) (((major) << 16) | ((minor) << 8) | (patch))
- #define VGLITE_VERSION_MAJOR(version) (((uint32_t)(version) >> 16) & 0xff)
- #define VGLITE_VERSION_MINOR(version) (((uint32_t)(version) >> 8) & 0xff)
- #define VGLITE_VERSION_PATCH(version) ((uint32_t)(version) & 0xff)
- #define VGLITE_API_VERSION_2_0 VGLITE_MAKE_VERSION(2, 0, 0)
- #/* Macros *********************************************************************************************************************/
- /* Path command (op code). */
- #define VLC_OP_END 0x00
- #define VLC_OP_CLOSE 0x01
- #define VLC_OP_MOVE 0x02
- #define VLC_OP_MOVE_REL 0x03
- #define VLC_OP_LINE 0x04
- #define VLC_OP_LINE_REL 0x05
- #define VLC_OP_QUAD 0x06
- #define VLC_OP_QUAD_REL 0x07
- #define VLC_OP_CUBIC 0x08
- #define VLC_OP_CUBIC_REL 0x09
- #define VLC_OP_SCCWARC 0x0A
- #define VLC_OP_SCCWARC_REL 0x0B
- #define VLC_OP_SCWARC 0x0C
- #define VLC_OP_SCWARC_REL 0x0D
- #define VLC_OP_LCCWARC 0x0E
- #define VLC_OP_LCCWARC_REL 0x0F
- #define VLC_OP_LCWARC 0x10
- #define VLC_OP_LCWARC_REL 0x11
- /* Macros for path manipulating: See path definitions. "VLM" means "VGLite Macros" */
- #define VLM_PATH_ENABLE_UPLOAD(path) (path).uploaded.property |= 1
- #define VLM_PATH_DISABLE_UPLOAD(path) (path).uploaded.property &= (~1)
- #define VLM_PATH_GET_UPLOAD_BIT(path) ((path).uploaded.property & 1)
- /* Types ***********************************************************************************************************************/
- #ifndef VG_LITE_ERROR
- #define VG_LITE_ERROR 1
- /*!
- @abstract Error codes that the vg_lite functions can return.
- @discussion
- All API functions return a status code. On success, <code>VG_LITE_SUCCESS</code> will be returned when a function is
- successful. This value is set to zero, so if any function returns a non-zero value, an error has occured.
- */
- typedef enum vg_lite_error
- {
- VG_LITE_SUCCESS = 0, /*! Success. */
- VG_LITE_INVALID_ARGUMENT, /*! An invalid argument was specified. */
- VG_LITE_OUT_OF_MEMORY, /*! Out of memory. */
- VG_LITE_NO_CONTEXT, /*! No context or an unintialized context specified. */
- VG_LITE_TIMEOUT, /*! A timeout has occured during a wait. */
- VG_LITE_OUT_OF_RESOURCES, /*! Out of system resources. */
- VG_LITE_GENERIC_IO, /*! Cannot communicate with the kernel driver. */
- VG_LITE_NOT_SUPPORT, /*! Function call not supported. */
- VG_LITE_MULTI_THREAD_FAIL, /*! Multi-thread/tasks fail. */
- VG_LITE_ALREADY_EXISTS, /*! Object already exists */
- VG_LITE_NOT_ALIGNED, /*! Data alignment error */
- }
- vg_lite_error_t;
- #endif
- /*!
- @abstract The floating point type used by the VGLite API.
- */
- typedef float vg_lite_float_t;
- /*!
- @abstract A 32-bit color value used by the VGLite API.
- @discussion
- The color value specifies the color used in various functions. The color is formed using 8-bit RGBA channels. The red channel
- is in the lower 8-bit of the color value, followed by the green and blue channels. The alpha channel is in the upper 8-bit of
- the color value.
- For L8 target formats, the RGB color is converted to L8 by using the default ITU-R BT.709 conversion rules.
- */
- typedef uint32_t vg_lite_color_t;
- /* Enumerations ***********************************************************************************************************************/
- /*!
- @abstract Quality enumeration for a given path.
- @discussion
- Each path should specify a quality hint for the hardware. The path generation tool will generate the quality hint based on the
- complexity of the path.
- */
- typedef enum vg_lite_quality {
- VG_LITE_HIGH, /*! High quality 16x anti-aliasing path. */
- VG_LITE_UPPER, /*! Upper quality 8x anti-aliasing path. */
- VG_LITE_MEDIUM, /*! Medium quality 4x anti-aliasing path. */
- VG_LITE_LOW, /*! Low quality pat without any anti-aliasing. */
- } vg_lite_quality_t;
- /*!
- @abstract Format of path coordinates.
- @discussion
- Each path can have a separate coordinate system. The path generation tool will find the most optimal coordinate system for any
- given path based on its dimensions and input coordinates.
- */
- typedef enum vg_lite_format {
- VG_LITE_S8, /*! Signed 8-bit coordinates. */
- VG_LITE_S16, /*! Signed 16-bit coordinates. */
- VG_LITE_S32, /*! Signed 32-bit coordinates. */
- VG_LITE_FP32, /*! 32-bit floating point coordinates. */
- } vg_lite_format_t;
- /*!
- @abstract Format of a buffer.
- @discussion
- The pixel type for a <code>vg_lite_buffer_t</code> structure.
- */
- typedef enum vg_lite_buffer_format {
- VG_LITE_RGBA8888, /*! 32-bit RGBA format with 8 bits per color channel. Red is in bits 7:0, green in bits 15:8, blue in
- bits 23:16, and the alpha channel is in bits 31:24. */
- VG_LITE_BGRA8888, /*! 32-bit RGBA format with 8 bits per color channel. Red is in bits 23:16, green in bits 15:8, blue in
- bits 7:0, and the alpha channel is in bits 31:24. */
- VG_LITE_RGBX8888, /*! 32-bit RGBX format with 8 bits per color channel. Red is in bits 7:0, green in bits 15:8, blue in
- bits 23:16, and the x channel is in bits 31:24. */
- VG_LITE_BGRX8888, /*! 32-bit RGBX format with 8 bits per color channel. Red is in bits 23:16, green in bits 15:8, blue in
- bits 7:0, and the x channel is in bits 31:24. */
- VG_LITE_RGB565, /*! 16-bit RGB format with 5 and 6 bits per color channel. Red is in bits 4:0, green in bits 10:5, and
- the blue color channel is in bits 15:11. */
- VG_LITE_BGR565, /*! 16-bit RGB format with 5 and 6 bits per color channel. Red is in bits 15:11, green in bits 10:5,
- and the blue color channel is in bits 4:0. */
- VG_LITE_RGBA4444, /*! 16-bit RGBA format with 4 bits per color channel. Red is in bits 3:0, green in bits 7:4, blue in
- bits 11:8 and the alpha channel is in bits 15:12. */
- VG_LITE_BGRA4444, /*! 16-bit RGBA format with 4 bits per color channel. Red is in bits 11:8, green in bits 7:4, blue in
- bits 3:0 and the alpha channel is in bits 15:12. */
- VG_LITE_BGRA5551, /*! 16-bit RGBA format with 4 bits per color channel. Red is in bits 14:10, green in bits 9:5, blue in
- bits 4:0 and the alpha channel is in bit 15:15. */
- VG_LITE_A4, /*! 4-bit alpha format. There are no RGB values. */
- VG_LITE_A8, /*! 8-bit alpha format. There are no RGB values. */
- VG_LITE_L8, /*! 8-bit luminance value. There is no alpha value. */
- VG_LITE_YUYV, /*! Packed YUV format, 32-bit for 2 pixels. Y0 is in bits 7:0 and V is in bits 31:23. */
- VG_LITE_YUY2, /*! New formats. */
- VG_LITE_NV12,
- VG_LITE_ANV12,
- VG_LITE_AYUY2,
- VG_LITE_YV12,
- VG_LITE_YV24,
- VG_LITE_YV16,
- VG_LITE_NV16,
- VG_LITE_YUY2_TILED, /*! Tiled YUV formats. */
- VG_LITE_NV12_TILED,
- VG_LITE_ANV12_TILED,
- VG_LITE_AYUY2_TILED,
- VG_LITE_INDEX_1 = 100, /*! Indexed format. */
- VG_LITE_INDEX_2,
- VG_LITE_INDEX_4,
- VG_LITE_INDEX_8,
- VG_LITE_RGBA2222, /*! 8-bit RGBA format with 2 bits per color channel.Red is in bits 1:0,green in bits 3:2,blue in
- bits 5:4 and the alpha channel is in bits 7:6*/
- VG_LITE_BGRA2222, /*! 8-bit RGBA format with 2 bits per color channel.Blue is in bits 1:0,green in bits 3:2,red in
- bits 5:4 and the alpha channel is in bits 7:6*/
- VG_LITE_ABGR2222, /*! 8-bit RGBA format with 2 bits per color channel.Alpha is in bits 1:0,blue in bits 3:2,green in
- bits 5:4 and the red channel is in bits 7:6*/
- VG_LITE_ARGB2222, /*! 8-bit RGBA format with 2 bits per color channel.Alpha is in bits 1:0,red in bits 3:2,green in
- bits 5:4 and the blue channel is in bits 7:6*/
- VG_LITE_ABGR4444, /*! 16-bit RGBA format with 4 bits per color channel. Alpha is in bits 3:0, blue in bits 7:4, green in
- bits 11:8 and the red channel is in bits 15:12. */
- VG_LITE_ARGB4444, /*! 16-bit RGBA format with 4 bits per color channel. Alpha is in bits 3:0, red in bits 7:4, green in
- bits 11:8 and the blue channel is in bits 15:12. */
- VG_LITE_ABGR8888, /*! 32-bit RGBA format with 8 bits per color channel. Alpha is in bits 7:0, blue in bits 15:8, green in
- bits 23:16, and the red channel is in bits 31:24. */
- VG_LITE_ARGB8888, /*! 32-bit RGBA format with 8 bits per color channel. Alpha is in bits 7:0, red in bits 15:8, green in
- bits 23:16, and the blue channel is in bits 31:24. */
- VG_LITE_ABGR1555, /*! 16-bit RGBA format with 4 bits per color channel. Red is in bits 15:11, green in bits 10:6, blue in
- bits 5:1 and the alpha channel is in bit 0:0. */
- VG_LITE_RGBA5551, /*! 16-bit RGBA format with 4 bits per color channel. Blue is in bits 14:10, green in bits 9:5, red in
- bits 4:0 and the alpha channel is in bit 15:15. */
- VG_LITE_ARGB1555, /*! 16-bit RGBA format with 4 bits per color channel. Blue is in bits 15:11, green in bits 10:6, red in
- bits 5:1 and the alpha channel is in bit 0:0. */
- VG_LITE_XBGR8888, /*! 32-bit RGBX format with 8 bits per color channel. X channel is in bits 7:0, blue in bits 15:8, green in
- bits 23:16, and the red is in bits 31:24. */
- VG_LITE_XRGB8888 /*! 32-bit RGBX format with 8 bits per color channel. X channel is in bits 7:0, red in bits 15:8, green in
- bits 23:16, and the blue is in bits 31:24. */
- } vg_lite_buffer_format_t;
- /*!
- @abstract Swizzle of packed YUV format UV channels.
- @discussion
- The swizzle of packed YUV format UV channels.
- */
- typedef enum vg_lite_swizzle {
- VG_LITE_SWIZZLE_UV,
- VG_LITE_SWIZZLE_VU,
- } vg_lite_swizzle_t;
- /*!
- @abstract The YUV<->RGB conversion rule.
- @discussion
- Indicate the rule how to convert rgb and yuv colors.
- */
- typedef enum vg_lite_yuv2rgb {
- VG_LITE_YUV601,
- VG_LITE_YUV709,
- } vg_lite_yuv2rgb_t;
- /*!
- @abstract The pixel layout in a buffer.
- @discussion
- Pixels in a buffer may be tiled or linear.
- */
- typedef enum vg_lite_buffer_layout {
- VG_LITE_LINEAR,
- VG_LITE_TILED,
- } vg_lite_buffer_layout_t;
- /*!
- @abstract The image (buffer) rendering mode.
- @discussion
- This defines how an image are rendered onto a buffer. There are 3 modes.
- */
- typedef enum vg_lite_buffer_image_mode {
- VG_LITE_NORMAL_IMAGE_MODE,
- VG_LITE_NONE_IMAGE_MODE,
- VG_LITE_MULTIPLY_IMAGE_MODE
- } vg_lite_buffer_image_mode_t;
- /*!
- @abstract The image (buffer) transparency mode.
- OPAQUE, All image pixels are copied to the VGPE for rasterization;
- TRANSPARENT,Only the non-transparent image pixels are copied to the VGPE.
- Note: This mode is valid when IMAGE_MODE(vg_lite_buffer_image_mode_t) isn't NONE.
- */
- typedef enum vg_lite_buffer_transparency_mode {
- VG_LITE_IMAGE_OPAQUE,
- VG_LITE_IMAGE_TRANSPARENT
- } vg_lite_buffer_transparency_mode_t;
- typedef struct vg_lite_yuvinfo {
- vg_lite_swizzle_t swizzle; /* UV swizzle. */
- vg_lite_yuv2rgb_t yuv2rgb; /* 601 or 709 conversion standard. */
- uint32_t uv_planar; /* UV(U) planar address. */
- uint32_t v_planar; /* V planar address. */
- uint32_t alpha_planar; /* Alpha planar address. */
- uint32_t uv_stride; /* UV(U) stride. */
- uint32_t v_stride; /* V stride. */
- uint32_t alpha_stride; /* Alpha stride. */
- uint32_t uv_height; /* UV(U) height. */
- uint32_t v_height; /* V height. */
- void * uv_memory; /* The logical pointer to the UV(U) planar memory. */
- void * v_memory; /* The logical pointer to the V planar memory. */
- void * uv_handle; /* The memory handle of the UV(U) planar. */
- void * v_handle; /* The memory handle of the V planar. */
- } vg_lite_yuvinfo_t;
- /*!
- @abstract Blending modes.
- @discussion
- Some of the VGLite API functions calls support blending. S and D represent source and destination color channels and Sa and Da
- represent the source and destination alpha channels.
- */
- typedef enum vg_lite_blend {
- VG_LITE_BLEND_NONE, /*! S, i.e. no blending. */
- VG_LITE_BLEND_SRC_OVER, /*! S + (1 - Sa) * D */
- VG_LITE_BLEND_DST_OVER, /*! (1 - Da) * S + D */
- VG_LITE_BLEND_SRC_IN, /*! Da * S */
- VG_LITE_BLEND_DST_IN, /*! Sa * D */
- VG_LITE_BLEND_SCREEN, /*! S + D - S * D */
- VG_LITE_BLEND_MULTIPLY, /*! S * (1 - Da) + D * (1 - Sa) + S * D */
- VG_LITE_BLEND_ADDITIVE, /*! S + D */
- VG_LITE_BLEND_SUBTRACT, /*! D * (1 - S) */
- } vg_lite_blend_t;
- /*!
- @abstract Fill rules.
- @discussion
- For drawing any path, the hardware supports both non-zero and odd-even fill rules.
- To determine whether any point is contained inside an object, imagine drawing a line from that point out to infinity in any
- direction such that the line does not cross any vertex of the path. For each edge that is crossed by the line, add 1 to the
- counter if the edge crosses from left to right, as seen by an observer walking across the line towards infinity, and subtract 1
- if the edge crosses from right to left. In this way, each region of the plane will receive an integer value.
- The non-zero fill rule says that a point is inside the shape if the resulting sum is not equal to zero. The even/odd rule says
- that a point is inside the shape if the resulting sum is odd, regardless of sign.
- */
- typedef enum vg_lite_fill {
- VG_LITE_FILL_NON_ZERO, /*! Non-zero fill rule. A pixel is drawn if it crosses at least one path pixel. */
- VG_LITE_FILL_EVEN_ODD, /*! Even-odd fill rule. A pixel is drawn it it crosses an odd number of path pixels. */
- } vg_lite_fill_t;
- /* Chip features. */
- typedef enum vg_lite_feature
- {
- gcFEATURE_BIT_VG_IM_INDEX_FORMAT,
- gcFEATURE_BIT_VG_PE_PREMULTIPLY,
- gcFEATURE_BIT_VG_BORDER_CULLING,
- gcFEATURE_BIT_VG_RGBA2_FORMAT,
- gcFEATURE_BIT_VG_QUALITY_8X,
- gcFEATURE_BIT_VG_RADIAL_GRADIENT,
- gcFEATURE_BIT_VG_LINEAR_GRADIENT_EXT,
- gcFEATURE_BIT_VG_COLOR_KEY,
- gcFEATURE_BIT_VG_DITHER,
- /* Insert features above this comment only. */
- gcFEATURE_COUNT /* Not a feature. */
- }
- vg_lite_feature_t;
- /* Filter modes. */
- typedef enum vg_lite_filter
- {
- VG_LITE_FILTER_POINT = 0, /* Only the nearest image pixel is fetched. */
- VG_LITE_FILTER_LINEAR = 0x10000, /* Used for linear paint. */
- VG_LITE_FILTER_BI_LINEAR = 0x20000, /* Use a 2x2 box around the image pixel and perform an interpolation. */
- } vg_lite_filter_t;
- /* Pattern padding mode. */
- typedef enum vg_lite_pattern_mode
- {
- VG_LITE_PATTERN_COLOR = 0,
- VG_LITE_PATTERN_PAD,
- } vg_lite_pattern_mode_t;
- /* radial gradient padding mode. */
- typedef enum {
- VG_LITE_RADIAL_GRADIENT_SPREAD_FILL = 0,
- VG_LITE_RADIAL_GRADIENT_SPREAD_PAD,
- VG_LITE_RADIAL_GRADIENT_SPREAD_REPEAT,
- VG_LITE_RADIAL_GRADIENT_SPREAD_REFLECT,
- } vg_lite_radial_gradient_spreadmode_t;
- /* draw path type. */
- typedef enum vg_lite_draw_path_type{
- VG_LITE_DRAW_FILL_PATH = 0, /*! draw fill path. */
- VG_LITE_DRAW_STROKE_PATH, /*! draw stroke path. */
- VG_LITE_DRAW_FILL_STROKE_PATH, /*! draw both fill and stroke path. */
- } vg_lite_draw_path_type_t;
- /* End cap style. */
- typedef enum vg_lite_cap_style
- {
- VG_LITE_CAP_BUTT, /*! The Butt end cap style terminates each segment with a line perpendicular to the tangent at each endpoint. */
- VG_LITE_CAP_ROUND, /*! The Round end cap style appends a semicircle with a diameter equal to the line width centered around each endpoint. */
- VG_LITE_CAP_SQUARE /*! The Square end cap style appends a rectangle with two sides of length equal to the line width
- perpendicular to the tangent, and two sides of length equal to half the line width parallel
- to the tangent, at each endpoint. */
- }
- vg_lite_cap_style_t;
- /* Line join styles. */
- typedef enum vg_lite_join_style
- {
- VG_LITE_JOIN_MITER,/*! The Miter join style appends a trapezoid with one vertex at the intersection point of the two original
- lines, two adjacent vertices at the outer endpoints of the two “fattened” lines and a fourth vertex at
- the extrapolated intersection point of the outer perimeters of the two “fattened” lines. */
- VG_LITE_JOIN_ROUND,/*! The Round join style appends a wedge-shaped portion of a circle,centered at the intersection point
- of the two original lines, having a radius equal to half the line width. */
- VG_LITE_JOIN_BEVEL /*! The Bevel join style appends a triangle with two vertices at the outer endpoints of the two "fattened"
- lines and a third vertex at the intersection point of the two original lines. */
- }
- vg_lite_join_style_t;
- /* Structures *******************************************************************************************************************/
- typedef struct vg_lite_path_point * vg_lite_path_point_ptr;
- typedef struct vg_lite_path_point
- {
- /* X coordinate. */
- vg_lite_float_t x;
- /* Y coordinate. */
- vg_lite_float_t y;
- /* Flatten flag for flattened path. */
- uint8_t flatten_flag;
- /* Curve type for stroke path. */
- uint8_t curve_type;
- /* X tangent. */
- vg_lite_float_t tangentX;
- /* Y tangent. */
- vg_lite_float_t tangentY;
- /* Length of the line. */
- vg_lite_float_t length;
- /* Pointer to next point node. */
- vg_lite_path_point_ptr next;
- /* Pointer to previous point node. */
- vg_lite_path_point_ptr prev;
- }vg_lite_path_point_t;
- typedef struct vg_lite_sub_path * vg_lite_sub_path_ptr;
- typedef struct vg_lite_sub_path
- {
- /* Pointer to next sub path. */
- vg_lite_sub_path_ptr next;
- /* Number of points. */
- uint32_t point_count;
- /* Point list. */
- vg_lite_path_point_ptr point_list;
- /* Last point. */
- vg_lite_path_point_ptr last_point;
- /* Whether is path is closed. */
- uint8_t closed;
- /* Sub path length. */
- vg_lite_float_t length;
- }
- vg_lite_sub_path_t;
- typedef struct vg_lite_stroke_conversion
- {
- /* Stroke parameters */
- vg_lite_cap_style_t stroke_cap_style;
- vg_lite_join_style_t stroke_join_style;
- vg_lite_float_t stroke_line_width;
- vg_lite_float_t stroke_miter_limit;
- vg_lite_float_t * stroke_dash_pattern;
- uint32_t stroke_dash_pattern_count;
- vg_lite_float_t stroke_dash_phase;
- vg_lite_float_t stroke_dash_initial_length;
- uint32_t stroke_dash_initial_index;
- vg_lite_float_t half_line_width;
- /* Total length of stroke dash patterns. */
- vg_lite_float_t stroke_dash_pattern_length;
- /* For fast checking. */
- vg_lite_float_t stroke_miter_limit_square;
- /* Temp storage of stroke subPath. */
- vg_lite_path_point_ptr path_point_list;
- vg_lite_path_point_ptr path_last_point;
- uint32_t point_count;
- vg_lite_path_point_ptr left_stroke_point;
- vg_lite_path_point_ptr last_right_stroke_point;
- vg_lite_path_point_ptr stroke_point_list;
- vg_lite_path_point_ptr stroke_last_point;
- uint32_t stroke_point_count;
- /* Sub path list. */
- vg_lite_sub_path_ptr stroke_sub_path_list;
- /* Last sub path. */
- vg_lite_sub_path_ptr last_stroke_sub_path;
- /* Swing area handling. */
- uint8_t swing_need_to_handle;
- uint32_t swing_handling;
- uint8_t swing_counter_clockwise;
- vg_lite_float_t swing_stroke_deltax;
- vg_lite_float_t swing_stroke_deltay;
- vg_lite_path_point_ptr swing_start_point;
- vg_lite_path_point_ptr swing_start_stroke_point;
- vg_lite_float_t swing_accu_length;
- vg_lite_float_t swing_center_length;
- uint32_t swing_count;
- vg_lite_float_t stroke_path_length;
- uint32_t stroke_path_size;
- /* The stroke line is fat line. */
- uint8_t is_fat;
- uint8_t closed;
- }
- vg_lite_stroke_conversion_t;
- /* A 2D Point definition. */
- typedef struct vg_lite_point {
- int x;
- int y;
- }
- vg_lite_point_t;
- /* Four 2D Point that form a polygon */
- typedef vg_lite_point_t vg_lite_point4_t[4];
- /* This structure is used to query VGLite driver information */
- typedef struct vg_lite_info {
- uint32_t api_version; /*! VGLite API version. */
- uint32_t header_version; /*! VGLite API header version. */
- uint32_t release_version; /*! VGLite release version. */
- uint32_t reserved; /*! Reserved for future use. */
- } vg_lite_info_t;
- /*!
- @abstract A 3x3 matrix.
- @discussion
- For those functions that need a matrix, this is the structure that defines it. The contents are a simple 3x3 matrix
- consisting of floating pointer numbers.
- */
- typedef struct vg_lite_matrix {
- vg_lite_float_t m[3][3]; /*! The 3x3 matrix itself, in [row][column] order. */
- } vg_lite_matrix_t;
- /*!
- @abstract A wrapper structure for any image or render target.
- @discussion
- Each piece of memory, whether it is an image used as a source or a buffer used as a target, requires a structure to define it.
- This structure contains all the information the VGLite API requires to access the buffer's memory by the hardware.
- */
- typedef struct vg_lite_buffer {
- int32_t width; /*! Width of the buffer in pixels. */
- int32_t height; /*! Height of the buffer in pixels. */
- int32_t stride; /*! The number of bytes to move from one line in the buffer to the next line. */
- vg_lite_buffer_layout_t tiled; /*! Indicating the buffer memory layout is linear or tiled. */
- vg_lite_buffer_format_t format; /*! The pixel format of the buffer. */
- void * handle; /*! The memory handle of the buffer's memory as allocated by the VGLite kernel. */
- void * memory; /*! The logical pointer to the buffer's memory for the CPU. */
- uint32_t address; /*! The address to the buffer's memory for the hardware. */
- vg_lite_yuvinfo_t yuv; /*! The yuv format details. */
- vg_lite_buffer_image_mode_t image_mode; /*! The blit image mode. */
- vg_lite_buffer_transparency_mode_t transparency_mode; /*image transparency mode*/
- } vg_lite_buffer_t;
- /* This structure simply records the memory allocation info by kernel. */
- typedef struct vg_lite_hw_memory {
- void * handle; /*! gpu memory object handle. */
- void * memory; /*! logical memory address. */
- uint32_t address; /*! GPU memory address. */
- uint32_t bytes; /*! Size of memory. */
- uint32_t property; /*! Currently bit0 is used for path upload:
- 1 to enable auto path data uploading;
- 0 to disable path data uploading (always embedded into command buffer).
- */
- } vg_lite_hw_memory_t;
- /*!
- @abstract A path used by the drawing command.
- @discussion
- Each path needs a few parameters. This structure defines those parameters, so the VGLite driver knows the detail of a path.
- */
- typedef struct vg_lite_path {
- vg_lite_float_t bounding_box[4]; /*! Bounding box specified as left, top, right, and bottom. */
- vg_lite_quality_t quality; /*! Quality hint for the path. */
- vg_lite_format_t format; /*! Coordinate format. */
- vg_lite_hw_memory_t uploaded; /*! Path data that has been upload into GPU addressable memory. */
- int32_t path_length; /*! Number of bytes in the path data. */
- void *path; /*! Pointer to the physical description of the path. */
- int8_t path_changed; /* Indicate whether path data is synced with command buffer (uploaded) or not. */
- int8_t pdata_internal; /*! Indicate whether path data memory is allocated by driver. */
- vg_lite_stroke_conversion_t *stroke_conversion; /*! Refer to the definition by <code>vg_lite_stroke_conversion_t</code>.*/
- vg_lite_draw_path_type_t path_type; /*! Refer to the definition by <code>vg_lite_draw_path_type_t</code>. */
- void *stroke_path_data; /*! Pointer to the physical description of the stroke path. */
- int32_t stroke_path_size; /*! Number of bytes in the stroke path data. */
- vg_lite_color_t stroke_color; /*! The stroke path fill color.Refer to the definition by <code>vg_lite_color_t</code>.*/
- } vg_lite_path_t;
- /*!
- @abstract A rectangle.
- @discussion
- A rectangle defines a rectangular definition of the screen.
- */
- typedef struct vg_lite_rectangle {
- int32_t x; /*! Left coordinate of the rectangle. */
- int32_t y; /*! Top coordinate of the rectangle. */
- int32_t width; /*! Width of the rectangle. */
- int32_t height; /*! Height of the rectangle. */
- } vg_lite_rectangle_t;
- /*!
- @abstract Tessellation buffer information.
- @discussion
- The tessellation buffer information for access.
- */
- typedef struct vg_lite_tsbuffer_info {
- uint32_t tessellation_buffer_gpu[3]; /*! HW physical address. */
- uint8_t *tessellation_buffer_logic[3]; /*! Logical address. */
- uint32_t tessellation_buffer_size[3]; /*! Buffer size for tessellation buffer, l1, l2. */
- uint32_t tessellation_stride; /*! Buffer stride. */
- uint32_t tessellation_width_height; /*! Combination of buffer width and height. */
- uint32_t tessellation_shift; /*! Tessellation config: shift. */
- uint32_t tessellation_origin[2];
- } vg_lite_tsbuffer_info_t;
- /* Linear Gradient definitions. */
- #define VLC_MAX_GRAD 16 /*! The max number of gradient stops. */
- #define VLC_GRADBUFFER_WIDTH 256 /*! The internal buffer width.*/
- /*!
- @abstract Linear gradient definition.
- @discussion
- Linear gradient is applied to filling a path. It will generate a 256x1 image according the settings.
- */
- typedef struct vg_lite_linear_gradient {
- uint32_t colors[VLC_MAX_GRAD]; /*! Colors for stops. */
- uint32_t count; /*! Count of colors, up to 16. */
- uint32_t stops[VLC_MAX_GRAD]; /*! Color stops, value from 0 to 255. */
- vg_lite_matrix_t matrix; /*! The matrix to transform the gradient. */
- vg_lite_buffer_t image; /*! The image for rendering as gradient pattern. */
- } vg_lite_linear_gradient_t;
- /* radial Gradient definitions. */
- #define MAX_COLOR_RAMP_STOPS 256 /*! The max number of radial gradient stops. */
- /*!
- @abstract color ramp definition.
- @discussion
- This is the stop for the radial gradient.The number of parameters is 5,and give the offset and
- color of the stop.Each stop is defined by a floating-point offset value and four floating-point values
- containing the sRGBA color and alpha value associated with each stop, in the form of a non-premultiplied
- (R, G, B, alpha) quad.And the range of all parameters in it is [0,1].[0,1] of the color channel value is
- mapped to [0,255].
- */
- typedef struct vg_lite_color_ramp
- {
- vg_lite_float_t stop; /* Value for the color stop. */
- vg_lite_float_t red; /* Red color channel value for the color stop. */
- vg_lite_float_t green; /* Green color channel value for the color stop. */
- vg_lite_float_t blue; /* Blue color channel value for the color stop. */
- vg_lite_float_t alpha; /* Alpha color channel value for the color stop. */
- }
- vg_lite_color_ramp_t, *vg_lite_color_ramp_ptr;
- typedef struct vg_lite_radial_gradient_parameter
- {
- vg_lite_float_t cx; /* the x coordinate of the center point. */
- vg_lite_float_t cy; /* the y coordinate of the center point. */
- vg_lite_float_t r; /* the radius. */
- vg_lite_float_t fx; /* the x coordinate of the focal point. */
- vg_lite_float_t fy; /* the y coordinate of the focal point. */
- }
- vg_lite_radial_gradient_parameter_t;
- /*!
- @abstract radial gradient definition.
- @discussion
- radial gradient is applied to filling a path.
- */
- typedef struct vg_lite_radial_gradient {
- uint32_t count; /*! Count of colors, up to 256. */
- vg_lite_matrix_t matrix; /*! The matrix to transform the gradient. */
- vg_lite_buffer_t image; /*! The image for rendering as gradient pattern. */
- vg_lite_radial_gradient_parameter_t radialGradient; /* include center point,focal point and radius.*/
- vg_lite_radial_gradient_spreadmode_t SpreadMode; /* The tiling mode that applied to the pixels out of the image after transformed. */
- uint32_t vgColorRampLength; /* Color ramp parameters for gradient paints provided to the driver. */
- vg_lite_color_ramp_t vgColorRamp[MAX_COLOR_RAMP_STOPS];
- uint32_t intColorRampLength; /* Converted internal color ramp. */
- vg_lite_color_ramp_t intColorRamp[MAX_COLOR_RAMP_STOPS + 2];
- uint8_t colorRampPremultiplied; /* if this value is set to 1,the color value of vgColorRamp will multiply by alpha value of vgColorRamp.*/
- } vg_lite_radial_gradient_t;
- /*!
- @abstract linear gradient parameter definition.
- @discussion
- The line connecting point (X0,Y0) to point (X1,Y1) is the radial direction of the linear gradient.
- This radial direction line called line0,the line perpendicular to line0 and passing through the point (X0,Y0)
- called line1,the line perpendicular to line0 and passing through the point (X1,Y1) called line2,the linear gradient
- starts form line1 and end to line2.
- */
- typedef struct vg_lite_linear_gradient_parameter
- {
- vg_lite_float_t X0;
- vg_lite_float_t Y0;
- vg_lite_float_t X1;
- vg_lite_float_t Y1;
- }
- vg_lite_linear_gradient_parameter_t;
- /*!
- @abstract linear gradient definition.
- @discussion
- linear gradient is applied to filling a path.vg_lite_linear_gradient_ext and vg_lite_linear_gradient for hardware and software implementation
- of linear gradient respectively.
- */
- typedef struct vg_lite_linear_gradient_ext {
- uint32_t count; /*! Count of colors, up to 256. */
- vg_lite_matrix_t matrix; /*! The matrix to transform the gradient. */
- vg_lite_buffer_t image; /*! The image for rendering as gradient pattern. */
- vg_lite_linear_gradient_parameter_t linear_gradient; /* Refer to the definition by <code>vg_lite_linear_gradient_parameter_t</code>.*/
- uint32_t vg_color_ramp_length; /* Color ramp parameters for gradient paints provided to the driver. */
- vg_lite_color_ramp_t vg_color_ramp[MAX_COLOR_RAMP_STOPS];
- uint32_t int_color_ramp_length; /* Converted internal color ramp. */
- vg_lite_color_ramp_t int_color_ramp[MAX_COLOR_RAMP_STOPS + 2];
- uint8_t color_ramp_premultiplied; /* if this value is set to 1,the color value of vgColorRamp will multiply by alpha value of vgColorRamp.*/
- vg_lite_radial_gradient_spreadmode_t spread_mode; /* Use tge same spread mode enumeration type as radial gradient. */
- } vg_lite_linear_gradient_ext_t;
- /*!
- @abstract color key definition.
- @discussion
- The colorkey have two sections,each section contain R,G,B chanels.Debited as hign_rgb and low_rgb respectively.
- Can be used for blit operation or draw_pattern operation.when enable is ture,the alpha value is used to replace
- the alpha channel of destination pixel when its RGB channels in range [low_rgb,hign_rgb].After use color key this
- frame,and if the color key is not need in the next frame,disable the color key before next frame.
- */
- typedef struct vg_lite_color_key
- {
- uint8_t enable; /* when enable is ture,this color key is effective. */
- uint8_t low_r; /* The R chanel of low_rgb. */
- uint8_t low_g; /* The G chanel of low_rgb. */
- uint8_t low_b; /* The B chanel of low_rgb. */
- uint8_t alpha; /* The alpha channel to replace destination pixel alpha channel.*/
- uint8_t hign_r; /* The R chanel of hign_rgb. */
- uint8_t hign_g; /* The G chanel of hign_rgb. */
- uint8_t hign_b; /* The B chanel of hign_rgb. */
- } vg_lite_color_key_t;
- /*!
- @abstract colorkey definition.
- @discussion
- There are 4 groups of color key states.
- rgb_hi_0, rgb_lo_0, alpha_0, enable_0;
- rgb_hi_1, rgb_lo_1, alpha_1, enable_1;
- rgb_hi_2, rgb_lo_2, alpha_2, enable_2;
- rgb_hi_3, rgb_lo_3, alpha_3, enable_3;
- Priority order:color_key_0 > color_key_1 > color_key_2 > color_key_3.
- */
- typedef vg_lite_color_key_t vg_lite_color_key4_t[4];
- /* API Function prototypes *****************************************************************************************************/
- /*!
- @abstract Get a 3*3 homogenous transform matrix by source coordinates and target coordinates.
- @param src
- Pointer to the four 2D points that form a source polygon.
- @param dst
- Pointer to the four 2D points that form a destination polygon.
- @param mat
- Output parameter,pointer to 3*3 homogenous matrix that transform source polygon to destination polygon.
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.
- */
- vg_lite_error_t vg_lite_get_transform_matrix(vg_lite_point4_t src, vg_lite_point4_t dst,vg_lite_matrix_t *mat);
- /*!
- @abstract Allocate a buffer from hardware accessible memory.
- @discussion
- In order for the hardware to access some memory, like a source image or a target buffer, it needs to be allocated first. The
- supplied <code>vg_lite_buffer_t</code> structure needs to be initialized with the size (width and height) and format of the
- requested buffer. If the stride is set to zero, this function will fill it in.
- This function will call the kernel to actually allocate the memory and the memory handle and logical and hardware addresses
- will be filled in by the kernel.
- @param buffer
- Pointer to the buffer that holds the size and format of the buffer being allocated.
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.
- */
- vg_lite_error_t vg_lite_allocate(vg_lite_buffer_t *buffer);
- /*!
- @abstract Free a buffer that was previously allocated by {@link vg_lite_allocate}.
- @discussion
- Free any memory resources allocated by a previous call to {@link vg_lite_allocate}.
- @param buffer
- Pointer to a buffer structure that was filled in by {@link vg_lite_allocate}.
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.
- */
- vg_lite_error_t vg_lite_free(vg_lite_buffer_t *buffer);
- /*!
- @abstract Upload the pixel data to the buffer object.
- @discussion
- The function uploads the pixel data to the buffer object. According to the
- buffer format, there are 3 planes' data at most (for YUV planars). Note that
- the format of the data (pixel) to upload must be the same as described in
- the buffer object. The input data memory pointers should be big enough to
- hold all the data needed by the buffer.
- @param buffer
- The image buffer object.
- @param data
- Pixel data. For YUV format, it may be up to 3 pointers.
- @param stride
- Stride for pixel data.
- @result
- Any error status during uploading.
- */
- vg_lite_error_t vg_lite_buffer_upload(vg_lite_buffer_t *buffer, uint8_t *data[3], uint32_t stride[3]);
- /*!
- @abstract Map a buffer into hardware accessible address space.
- @discussion
- If you want the use a frame buffer directly as an target buffer, you need to wrap a <code>vg_lite_buffer_t</code> structure
- around it and call the kernel to map the supplied logical or physical address into hardware accessible memory.
- For example, if you know the logical address of the frame buffer, set the memory field of the vg_lite_buffer_t structure
- with that address and call this function. If you know the physical address, set the memory field to <code>NULL</code> and
- program the address field with the physical address.
- @param buffer
- Pointer to the buffer that holds the size and format of the buffer being allocated. Either the memory or address field
- needs to be set to a non-zero value to map either a logical or physical address into hardware accessible memory.
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.
- */
- vg_lite_error_t vg_lite_map(vg_lite_buffer_t *buffer);
- /*!
- @abstract Unmap a buffer that was previously mapped by {@link vg_lite_map}.
- @discussion
- Free any memory resources allocated by a previous call to {@link vg_lite_map}.
- @param buffer
- Pointer to a buffer structure that was filled in by {@link vg_lite_map}.
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.
- */
- vg_lite_error_t vg_lite_unmap(vg_lite_buffer_t *buffer);
- /*!
- @abstract Fill a (partial) buffer with a specified color.
- @discussion
- Either an entire buffer or a partial rectangle of a buffer will be filled with a specific color.
- This function will wait until the hardware is complete, i.e. it is synchronous.
- @param target
- Pointer to a <code>vg_lite_buffer_t</code> structure that describes the buffer to be filled.
- @param rectangle
- Pointer to a rectangle that specifies the area to be filled. If <code>rectangle</code> is <code>NULL</code>, the entire target
- buffer will be filled with the specified color.
- @param color
- The color value to use for filling the buffer. If the buffer is in L8 format, the RGBA color will be converted into a
- luminance value.
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.
- */
- vg_lite_error_t vg_lite_clear(vg_lite_buffer_t *target,
- vg_lite_rectangle_t *rectangle,
- vg_lite_color_t color);
- /*!
- @abstract Copy a source image to the the destination window with a specified matrix that can include translation, rotation,
- scaling, and perspective correction.
- @discussion
- A source image is copied to the target using the specified matrix. If the specified matrix is <code>NULL</code>, an identity
- matrix is assumed, meaning the source will be copied directly on the target at 0,0 location.
- An optional blend mode can be specified that defines the blending of the source onto the target.
- Also, an optional mix color can be specified. The mix color will be multiplied by the source color. If you don't need a mix
- color, set the <code>color</code> parameter to 0.
- Note that on hardware that doesn't support border scissoring (GC355) the blend mode will be forced to
- <code>VG_LITE_BLEND_SRC_OVER</code> if rotation or perspective is involved.
- @param target
- Pointer to a <code>vg_lite_buffer_t</code> structure that describes the target of the blit.
- @param source
- Pointer to a <code>vg_lite_buffer_t</code> structure that describes the source of the blit.
- @param matrix
- Pointer to a 3x3 matrix that defines the transformation matrix of source pixels into the target. If matrix is
- <code>NULL</code>, an identity matrix is assumed.
- @param blend
- The blending mode to be applied to each image pixel. If no blending is required, set this value to
- <code>VG_LITE_BLEND_NONE</code> (0).
- @param color
- If non-zero, this color value will be used as a mix color. The mix color gets multiplied with each source pixel before
- blending happens.
- @param filter
- The filter mode to be applied. If no filter mode is required, set this value to
- <code>VG_LITE_FILTER_BI_LINEAR</code> (0x20000).
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.
- */
- vg_lite_error_t vg_lite_blit(vg_lite_buffer_t *target,
- vg_lite_buffer_t *source,
- vg_lite_matrix_t *matrix,
- vg_lite_blend_t blend,
- vg_lite_color_t color,
- vg_lite_filter_t filter);
- /* In additional to vg_lite_blit:
- @brief
- This API draws a porting of the image to the screen.
- @param
- rect The source rectangle to blit. rect[0]/[1]/[2]/[3] are x, y, width and height of the source rectangle. */
- vg_lite_error_t vg_lite_blit_rect(vg_lite_buffer_t *target,
- vg_lite_buffer_t *source,
- uint32_t *rect,
- vg_lite_matrix_t *matrix,
- vg_lite_blend_t blend,
- vg_lite_color_t color,
- vg_lite_filter_t filter);
- /*!
- @abstract Initialize a vglite context.
- @discussion
- The {@link vg_lite_draw} function requires a draw context to be initialized. There is only one draw context per process, so
- this function has be called once in your application if any draw command will be used. If this would be the first context that
- accesses the hardware, the hardware will be turned on and initialized.
- The difference between a blit and draw context is that the draw context has a larger command buffer and allocates a
- tessellation buffer for the hardware. The size of the tessellation buffer can be specified, and that size will be aligned to
- the minimum required alignment of the hardware by the kernel. If you make the tessellation buffer smaller, less memory will
- be allocated, but a path might be sent down to the hardware multiple times because the hardware will walk the target with the
- provided tessellation window size, so performance might go down. It is good practice to set the tessellation buffer size to the
- most common path size. For example, if all you do is render up to 24-pt fonts, you can set the tessellation buffer to be
- 24x24.
- @param tessellation_width
- The width of the tessellation window.
- @param tessellation_height
- The height of the tessellation window.
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.
- */
- vg_lite_error_t vg_lite_init(int32_t tessellation_width, int32_t tessellation_height);
- /*!
- @abstract Destroy a vglite context.
- @discussion
- Destroy a draw context that was previously initialized by {@link vg_lite_draw_init}.
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.
- */
- vg_lite_error_t vg_lite_close(void);
- /*!
- @abstract This api explicitly submits the command buffer to GPU and waits for it to complete.
- @param none.
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.
- */
- vg_lite_error_t vg_lite_finish(void);
- /*!
- @abstract This api explicitly submits the command buffer to GPU without waiting for it to complete.
- @param none.
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.
- */
- vg_lite_error_t vg_lite_flush(void);
- /*!
- @abstract Draw a path to a target buffer.
- @discussion
- The specified path will be transformed by the given matrix and drawn into the specified target buffer using the supplied color.
- Blending can be specified.
- @param target
- Pointer to a <code>vg_lite_buffer_t</code> structure that describes the target of the draw.
- @param path
- Pointer to a <code>vg_lite_path_t</code> structure that describes the path to draw.
- @param fill_rule
- Specified fill rule for the path.
- @param matrix
- Pointer to a 3x3 matrix that defines the transformation matrix of the path. If <code>matrix</code> is <code>NULL</code>, an
- identity matrix is assumed which is usually a bad idea since the path can be anything.
- @param blend
- The blending mode to be applied to each drawn pixel. If no blending is required, set this value to
- <code>VG_LITE_BLEND_NONE</code> (0).
- @param color
- The color applied to each pixel drawn by the path.
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.
- */
- vg_lite_error_t vg_lite_draw(vg_lite_buffer_t *target,
- vg_lite_path_t *path,
- vg_lite_fill_t fill_rule,
- vg_lite_matrix_t *matrix,
- vg_lite_blend_t blend,
- vg_lite_color_t color);
- /*!
- @abstract Set stroke path's attributes.
- @discussion
- This function use the input parameters to set stroke attributes.
- @param path
- Pointer to a <code>vg_lite_path_t</code> structure that describes the path.
- @param stroke_cap_style
- The end cap style defined by <code>vg_lite_cap_style_t</code>.
- @param stroke_join_style
- The line join style defined by <code>vg_lite_join_style_t</code>.
- @param stroke_line_width
- The line width of stroke path.A line width less than or equal to 0 prevents stroking from taking place.
- @param stroke_miter_limit
- When stroking using the Miter join style, the miter length (i.e., the length between the
- intersection points of the inner and outer perimeters of the two “fattened” lines) is compared
- to the product of the user-set miter limit and the line width. If the miter length exceeds this
- product, the Miter join is not drawn and a Bevel join is substituted.Miter limit values less
- than 1 are silently clamped to 1.
- @param stroke_dash_pattern
- The dash pattern consists of a sequence of lengths of alternating "on" and "off" dash
- segments. The first value of the dash array defines the length, in user coordinates, of the
- first "on" dash segment. The second value defines the length of the following "off"
- segment. Each subsequent pair of values defines one "on" and one "off" segment.If the dash
- pattern has an odd number of elements, the final element is ignored.
- @param stroke_dash_pattern_count
- The count of dash on/off segments.
- @param stroke_dash_phase
- The dash phase defines the starting point in the dash pattern that is associated with the
- start of the first segment of the path. For example, if the dash pattern is [10 20 30 40]
- and the dash phase is 35, the path will be stroked with an "on" segment of length 25
- (skipping the first "on" segment of length 10, the following "off" segment of length 20,
- and the first 5 units of the next "on" segment), followed by an "off" segment of length
- 40. The pattern will then repeat from the beginning, with an “on” segment of length 10,
- an "off" segment of length 20, an "on" segment of length 30.
- @param stroke_color
- The color fill in stroke path.
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.
- */
- vg_lite_error_t vg_lite_set_stroke(vg_lite_path_t *path,
- vg_lite_cap_style_t stroke_cap_style,
- vg_lite_join_style_t stroke_join_style,
- vg_lite_float_t stroke_line_width,
- vg_lite_float_t stroke_miter_limit,
- vg_lite_float_t *stroke_dash_pattern,
- uint32_t stroke_dash_pattern_count,
- vg_lite_float_t stroke_dash_phase,
- vg_lite_color_t stroke_color);
- /*!
- @abstract Update stroke path.
- @discussion
- This function use the given path and stroke attributes given by function vg_lite_set_stroke
- to update stroke path's parameters and generate stroke path data.
- @param path
- Pointer to a <code>vg_lite_path_t</code> structure that describes the path.
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.
- */
- vg_lite_error_t vg_lite_update_stroke(vg_lite_path_t *path);
- /*!
- @abstract Set path type.
- @discussion
- This function set the path type.It can be VG_LITE_DRAW_FILL_PATH ,VG_LITE_DRAW_STROKE_PATH or
- VG_LITE_DRAW_FILL_PATH | VG_LITE_DRAW_STROKE_PATH.
- @param path
- Pointer to a <code>vg_lite_path_t</code> structure that describes the path.
- @param path_type
- Pointer to a <code>vg_lite_draw_path_type_t</code> structure that describes the path.
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.
- */
- vg_lite_error_t vg_lite_set_draw_path_type(vg_lite_path_t * path,vg_lite_draw_path_type_t path_type);
- /*!
- @abstract Get the value of register from register's address.
- @discussion
- This address will be the AHB Byte address of the register whose value you want to dump.
- Refer to the Vivante AHB Register Specification document for register descriptions.
- The valid range for VGLite cores is usually 0x0 to 0x1FF and 0xA00 to 0xA7F.
- @param address
- Address of register which is needed to get its value.
- @param result
- The register's value.
- */
- vg_lite_error_t vg_lite_get_register(uint32_t address, uint32_t *result);
- /*
- @abstract Get the VGLite driver information.
- @param info
- Pointer to vg_lite_info_t structure.
- */
- void vg_lite_get_info(vg_lite_info_t *info);
- /*
- @abstract Get the name of the VGLite Product.
- @param name
- Character array to store the name of the chip.
- @param chip_id
- Store the chip id.
- @param chip_rev
- Store the chip revision number.
- @return
- Length of the name string, including the ending '\0'.
- */
- uint32_t vg_lite_get_product_info(char *name, uint32_t *chip_id, uint32_t *chip_rev);
- /*!
- @abstract Queried whether the specified feature is available.
- @param feature
- Feature to be verified.
- @return
- The feature is supported (1) or not (0).
- */
- uint32_t vg_lite_query_feature(vg_lite_feature_t feature);
- /*!
- @abstract This api initializes a path object by given member values.
- @param path
- The path object.
- @param data_format
- The coordinate data format of the path. One of S8, S16, S32 and FP32.
- @param quality
- The rendering quality (AA level) of the path.
- @param path_length
- The memory length of the path data.
- @param path_data
- The path data.
- @param min_x
- The min x of the bounding box.
- @param min_y
- The min y of the bounding box.
- @param max_x
- The max x of the bounding box.
- @param max_y
- The max y of the bounding box.
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.
- */
- vg_lite_error_t vg_lite_init_path(vg_lite_path_t *path,
- vg_lite_format_t data_format,
- vg_lite_quality_t quality,
- uint32_t path_length,
- void *path_data,
- vg_lite_float_t min_x, vg_lite_float_t min_y,
- vg_lite_float_t max_x, vg_lite_float_t max_y);
- /*!
- @abstract This api initializes a path object which include arc command by given member values.
- @param path
- The path object.
- @param data_format
- The coordinate data format of the path. Should be FP32.
- @param quality
- The rendering quality (AA level) of the path.
- @param path_length
- The memory length of the path data.
- @param path_data
- The given path data which inlcude arc command.
- @param min_x
- The min x of the bounding box.
- @param min_y
- The min y of the bounding box.
- @param max_x
- The max x of the bounding box.
- @param max_y
- The max y of the bounding box.
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.
- */
- vg_lite_error_t vg_lite_init_arc_path(vg_lite_path_t * path,
- vg_lite_format_t data_format,
- vg_lite_quality_t quality,
- uint32_t path_length,
- void * path_data,
- vg_lite_float_t min_x, vg_lite_float_t min_y,
- vg_lite_float_t max_x, vg_lite_float_t max_y);
- /*!
- @abstract This api clears the path member values.
- @discussion It frees the hw memory if path was ever uploaded.
- @param path
- The path object.
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.
- */
- vg_lite_error_t vg_lite_clear_path(vg_lite_path_t *path);
- /*!
- @abstract Calculate the path command buffer length (in bytes).
- @discussion The app should be response for allocating a buffer according to
- the buffer length calculated by this function. Then the buffer is used by
- the path as command buffer. The driver does not do allocation for the buffer.
- @param cmd
- The opcode array to construct the path.
- @param count
- The count of opcodes.
- @param format
- The data format of the coordinate (VG_LITE_S8, S16, S32, FP32)
- @result
- Return the actual length of the path command buffer.
- */
- int32_t vg_lite_path_calc_length(uint8_t *cmd,
- uint32_t count,
- vg_lite_format_t format);
- /*!
- @abstract Assemble the command buffer for the path.
- @discussion The command buffer is allocated by the application and assigned
- to the path. The function make the final GPU command buffer for the path based
- on the input opcodes (cmd) and coordinates (data). Note that the Application
- must be responsible to alloate a big enough buffer for the path.
- @param path
- The path object.
- @param cmd
- The opcode array to construct the path.
- @param data
- The coordinate data array to construct the path.
- @param seg_count
- The count of the opcodes.
- */
- vg_lite_error_t vg_lite_path_append(vg_lite_path_t *path,
- uint8_t *cmd,
- void *data,
- uint32_t seg_count);
- /*!
- @abstract Upload a path to GPU memory.
- @discussion
- In normal cases, the VGLite driver will copy any path data into a command buffer structure during runtime. This does take some
- time if there are many paths to be rendered. Also, in an embedded system the path data wont change - so it makes sense to
- upload the path data into GPU memory in such a form the GPU can directly access it.
- This function will allocate a buffer that will contain the path data and the required command buffer header and footer data for
- the GPU to access the data directly.
- @param path
- Pointer to a <code>vg_lite_path_t</code> structure that contains the path to be uploaded. Some fields in this structure will be
- modified to point to a command buffer instead of the native path data.
- @result
- A pointer to a <code>vg_lite_buffer_t</code> structure that contains the command buffer and path data after uploading it to GPU
- memory. <code>NULL</code> is returned if there is an error.
- */
- vg_lite_error_t vg_lite_upload_path(vg_lite_path_t *path);
- /*!
- @abstract Set the current CLUT (Color Look Up Table) for index image to use.
- @discussion
- This is a global context state. Once it's set (Not NULL), when an indexed format image is rendered, the image color will
- be got from the CLUT by the image's pixels as indecies.
- @param count
- This is the count of the colors in the look up table.
- For index 1, up to 2 colors in the table;
- For index 2, up to 4 colors in the table;
- For index 4, up to 16 colors in the table;
- For index 8, up to 256 colros in the table.
- Driver is not responsible to check the validation of the CLUT.
- @param colors
- This pointer is directly programmed to the command buffer. So it won't take effect
- unless the command buffer is submitted. The color is in ARGB format with A staying at the high bits.
- @result
- Error code. Currently always returns VG_LITE_SUCCESS since it does not do any checks.
- */
- vg_lite_error_t vg_lite_set_CLUT(uint32_t count,
- uint32_t *colors);
- /*!
- @abstract Fill a path with an image pattern.
- @discussion
- The specified path will be transformed by the given matrix and filled by the tranformed image pattern.
- @param path
- Pointer to a <code>vg_lite_path_t</code> structure that describes the path to draw.
- @param fill_rule
- Specified fill rule for the path.
- @param matrix0
- Pointer to a 3x3 matrix that defines the transformation matrix of the path. If <code>matrix</code> is <code>NULL</code>, an
- identity matrix is assumed which is usually a bad idea since the path can be anything.
- @param source
- Pointer to a <code>vg_lite_buffer_t</code> structure that describes the source of the image pattern.
- @param matrix1
- Pointer to a 3x3 matrix that defines the transformation matrix of source pixels into the target. If matrix is
- <code>NULL</code>, an identity matrix is assumed.
- @param blend
- The blending mode to be applied to each drawn pixel. If no blending is required, set this value to
- <code>VG_LITE_BLEND_NONE</code> (0).
- @param pattern_mode
- The tiling mode that applied to the pixels out of the image after transformed.
- @param pattern_color
- The pattern_color applied by pattern_mode VG_LITE_PATTERN_COLOR. When pixels are out of the image after transformed,
- they are applied "pattern_color".
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.
- */
- vg_lite_error_t vg_lite_draw_pattern(vg_lite_buffer_t *target,
- vg_lite_path_t *path,
- vg_lite_fill_t fill_rule,
- vg_lite_matrix_t *matrix0,
- vg_lite_buffer_t *source,
- vg_lite_matrix_t *matrix1,
- vg_lite_blend_t blend,
- vg_lite_pattern_mode_t pattern_mode,
- vg_lite_color_t pattern_color,
- vg_lite_filter_t filter);
- /*!
- @abstract Init the linear gradient object.
- @discussion
- This API initialize the grad object to its default settings. Since grad has
- an internal buffer object, this API will init the buffer object for rendering use.
- @param grad
- This is the vg_lite_linear_gradient_t object to be initialized.
- @result
- Error code, in case the buffer can't be created.
- */
- vg_lite_error_t vg_lite_init_grad(vg_lite_linear_gradient_t *grad);
- /*!
- @abstract Set the linear gradient members.
- @discussion
- This API sets the values for the members of the gradient definition.
- @param grad
- This is the vg_lite_linear_gradient_t object to be set.
- @param count
- This is the count of the colors in grad.
- The maxmum color stop count is defined by VLC_MAX_GRAD, which is currently 16.
- @param colors
- This is the color array for the gradient stops. The color is in ARGB8888 format
- with alpha at the higher byte.
- @result
- Error code. VG_LITE_INVALID_ARGUMENTS to indicate the parameters are wrong.
- */
- vg_lite_error_t vg_lite_set_grad(vg_lite_linear_gradient_t *grad,
- uint32_t count,
- uint32_t *colors,
- uint32_t *stops);
- /*!
- @abstract Set the radial gradient members.
- @discussion
- This API sets the values for the members of the radial gradient definition.
- @param grad
- This is the vg_lite_radial_gradient_t object to be set.
- @param count
- This is the count of the colors in grad.
- The maxmum color stop count is defined by MAX_COLOR_RAMP_STOPS, which is currently 256.
- @param vgColorRamp
- This is the stop for the radial gradient.The number of parameters is 5,and give the offset and
- color of the stop.Each stop is defined by a floating-point offset value and four floating-point values
- containing the sRGBA color and alpha value associated with each stop, in the form of a non-premultiplied
- (R, G, B, alpha) quad.And the range of all parameters in it is [0,1].
- @param radialGradient
- The radial gradient parameters are supplied as a vector of 5 floats in the order {cx,cy,fx,fy,r}.
- the range of all parameters in it is [0,1].The meaning of the parameters in it is:(cx,cy) is center point,
- (fx,fy) is focal point, and r is radius.
- @param SpreadMode
- The tiling mode that applied to the pixels out of the paint after transformed.
- @param colorRampPremultiplied
- The parameter controls whether color and alpha values are interpolated in premultiplied or non-premultiplied
- form.
- @result
- Error code. VG_LITE_INVALID_ARGUMENTS to indicate the parameters are wrong.
- */
- vg_lite_error_t vg_lite_set_rad_grad(vg_lite_radial_gradient_t *grad,
- uint32_t count,
- vg_lite_color_ramp_t *vgColorRamp,
- vg_lite_radial_gradient_parameter_t radialGradient,
- vg_lite_radial_gradient_spreadmode_t SpreadMode,
- uint8_t colorRampPremultiplied);
- /*!
- @abstract Set the linear gradient members.
- @discussion
- This API sets the values for the members of the linear gradient definition.
- @param grad
- This is the vg_lite_linear_gradient_ext_t object to be set.
- @param count
- This is the count of the colors in grad.
- The maxmum color stop count is defined by MAX_COLOR_RAMP_STOPS, which is currently 256.
- @param vg_color_ramp
- This is the stop for the linear gradient.The number of parameters is 5,and give the offset and
- color of the stop.Each stop is defined by a floating-point offset value and four floating-point values
- containing the sRGBA color and alpha value associated with each stop, in the form of a non-premultiplied
- (R, G, B, alpha) quad.And the range of all parameters in it is [0,1].
- @param linear_gradient
- Refer to the definition by <code>vg_lite_linear_gradient_parameter_t</code>.
- @param spread_mode
- The tiling mode that applied to the pixels out of the paint after transformed.Use tge same spread mode enumeration type as radial gradient.
- @param color_ramp_premultiplied
- The parameter controls whether color and alpha values are interpolated in premultiplied or non-premultiplied
- form.
- @result
- Error code. VG_LITE_INVALID_ARGUMENTS to indicate the parameters are wrong.
- */
- vg_lite_error_t vg_lite_set_linear_grad(vg_lite_linear_gradient_ext_t *grad,
- uint32_t count,
- vg_lite_color_ramp_t *vg_color_ramp,
- vg_lite_linear_gradient_parameter_t linear_gradient,
- vg_lite_radial_gradient_spreadmode_t spread_mode,
- uint8_t color_ramp_premultiplied);
- /*!
- @abstract Update or generate the corresponding image object to render with.
- @discussion
- The vg_lite_linear_gradient_ext_t object has an image buffer which is used to render
- the linear gradient paint. The image buffer will be create/updated by the corresponding
- grad parameters.
- @param grad
- This is the vg_lite_linear_gradient_ext_t object to be updated from.
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.
- */
- vg_lite_error_t vg_lite_update_linear_grad(vg_lite_linear_gradient_ext_t *grad);
- /*!
- @abstract Update or generate the corresponding image object to render with.
- @discussion
- The vg_lite_linear_gradient_t object has an image buffer which is used to render
- the gradient pattern. The image buffer will be create/updated by the corresponding
- grad parameters.
- @param grad
- This is the vg_lite_linear_gradient_t object to be upated from.
- @result
- Error code.
- */
- vg_lite_error_t vg_lite_update_grad(vg_lite_linear_gradient_t *grad);
- /*!
- @abstract Update or generate the corresponding image object to render with.
- @discussion
- The vg_lite_radial_gradient_t object has an image buffer which is used to render
- the radial gradient paint. The image buffer will be create/updated by the corresponding
- grad parameters.
- @param grad
- This is the vg_lite_radial_gradient_t object to be upated from.
- @result
- Error code.
- */
- vg_lite_error_t vg_lite_update_rad_grad(vg_lite_radial_gradient_t *grad);
- /*!
- @abstract Clear the gradient object.
- @discussion
- This will reset the grad members and free the image buffer's memory.
- @param grad
- This is the vg_lite_linear_gradient_t object to be cleared.
- @result
- Error code.
- */
- vg_lite_error_t vg_lite_clear_grad(vg_lite_linear_gradient_t *grad);
- /*!
- @abstract Clear the radial gradient object.
- @discussion
- This will reset the grad members and free the image buffer's memory.
- @param grad
- This is the vg_lite_radial_gradient_t object to be cleared.
- @result
- Error code.
- */
- vg_lite_error_t vg_lite_clear_rad_grad(vg_lite_radial_gradient_t *grad);
- /*!
- @abstract Clear the linear gradient object.
- @discussion
- This will reset the grad members and free the image buffer's memory.
- @param grad
- This is the vg_lite_linear_gradient_ext_t object to be cleared.
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.
- */
- vg_lite_error_t vg_lite_clear_linear_grad(vg_lite_linear_gradient_ext_t *grad);
- /*!
- @abstract Get the pointer to the grad object's matrix.
- @discussion
- This function get the pointer to the gradient object's matrix. Thus the app
- can manipulate the matrix to render the gradient path correctly.
- @param grad
- This is the vg_lite_linear_gradient_t object where to get the matrix.
- @result
- The pointer to the matrix.
- */
- vg_lite_matrix_t * vg_lite_get_grad_matrix(vg_lite_linear_gradient_t *grad);
- /*!
- @abstract Get the pointer to the grad object's matrix.
- @discussion
- This function get the pointer to the gradient object's matrix. Thus the app
- can manipulate the matrix to render the gradient path correctly.
- @param grad
- This is the vg_lite_linear_gradient_ext_t object where to get the matrix.
- @result
- The pointer to the matrix.
- */
- vg_lite_matrix_t * vg_lite_get_linear_grad_matrix(vg_lite_linear_gradient_ext_t *grad);
- /*!
- @abstract Get the pointer to the grad object's matrix.
- @discussion
- This function get the pointer to the radial gradient object's matrix. Thus the app
- can manipulate the matrix to render the radial gradient path correctly.
- @param grad
- This is the vg_lite_radial_gradient_t object where to get the matrix.
- @result
- The pointer to the matrix.
- */
- vg_lite_matrix_t * vg_lite_get_rad_grad_matrix(vg_lite_radial_gradient_t *grad);
- /*!
- @abstract Fill a path with an image pattern.
- @discussion
- The specified path will be transformed by the given matrix and filled by the tranformed image pattern.
- @param path
- Pointer to a <code>vg_lite_path_t</code> structure that describes the path to draw.
- @param fill_rule
- Specified fill rule for the path.
- @param matrix0
- Pointer to a 3x3 matrix that defines the transformation matrix of the path. If <code>matrix</code> is <code>NULL</code>, an
- identity matrix is assumed which is usually a bad idea since the path can be anything.
- @param grad
- Pointer to the gradient object that will be filled the path with.
- @param blend
- The blending mode to be applied to each drawn pixel. If no blending is required, set this value to
- <code>VG_LITE_BLEND_NONE</code> (0).
- @param pattern_mode
- The tiling mode that applied to the pixels out of the image after transformed.
- @param pattern_color
- The pattern_color applied by pattern_mode VG_LITE_PATTERN_COLOR. When pixels are out of the image after transformed,
- they are applied "pattern_color".
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.
- */
- vg_lite_error_t vg_lite_draw_gradient(vg_lite_buffer_t *target,
- vg_lite_path_t *path,
- vg_lite_fill_t fill_rule,
- vg_lite_matrix_t *matrix,
- vg_lite_linear_gradient_t *grad,
- vg_lite_blend_t blend);
- /*!
- @abstract Fill a path with a linear gradient.
- @discussion
- The specified path will be transformed by the given matrix and filled by the tranformed linear gradient.
- @param path
- Pointer to a <code>vg_lite_path_t</code> structure that describes the path to draw.
- @param fill_rule
- Specified fill rule for the path.
- @param path_matrix
- Pointer to a 3x3 matrix that defines the transformation matrix of the path. If <code>matrix</code> is <code>NULL</code>, an
- identity matrix is assumed which is usually a bad idea since the path can be anything.
- @param grad
- This is the vg_lite_linear_gradient_ext_t object to be set.
- @param paint_color
- Specifies the paint color vg_lite_color_t RGBA value to applied by VG_LITE_RADIAL_GRADIENT_SPREAD_FILL,which set by fuction
- vg_lite_set_linear_grad. When pixels are out of the image after transformed,this paint_color is applied to them,See enum
- vg_lite_radial_gradient_spreadmode_t.
- @param blend
- The blending mode to be applied to each drawn pixel. If no blending is required, set this value to
- <code>VG_LITE_BLEND_NONE</code> (0).
- @param filter
- Specified the filter mode vg_lite_filter_t enum value to be applied to each drawn pixel.
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.
- */
- vg_lite_error_t vg_lite_draw_linear_gradient(vg_lite_buffer_t * target,
- vg_lite_path_t * path,
- vg_lite_fill_t fill_rule,
- vg_lite_matrix_t * path_matrix,
- vg_lite_linear_gradient_ext_t *grad,
- vg_lite_color_t paint_color,
- vg_lite_blend_t blend,
- vg_lite_filter_t filter);
- /*!
- @abstract Fill a path with a radial gradient.
- @discussion
- The specified path will be transformed by the given matrix and filled by the tranformed radial gradient.
- @param path
- Pointer to a <code>vg_lite_path_t</code> structure that describes the path to draw.
- @param fill_rule
- Specified fill rule for the path.
- @param path_matrix
- Pointer to a 3x3 matrix that defines the transformation matrix of the path. If <code>matrix</code> is <code>NULL</code>, an
- identity matrix is assumed which is usually a bad idea since the path can be anything.
- @param grad
- This is the vg_lite_radial_gradient_t object to be set.
- @param paint_color
- Specifies the paint color vg_lite_color_t RGBA value to applied by VG_LITE_RADIAL_GRADIENT_SPREAD_FILL,which set by fuction
- vg_lite_set_rad_grad. When pixels are out of the image after transformed,this paint_color is applied to them,See enum
- vg_lite_radial_gradient_spreadmode_t.
- @param blend
- The blending mode to be applied to each drawn pixel. If no blending is required, set this value to
- <code>VG_LITE_BLEND_NONE</code> (0).
- @param filter
- Specified the filter mode vg_lite_filter_t enum value to be applied to each drawn pixel.
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.
- */
- vg_lite_error_t vg_lite_draw_radial_gradient(vg_lite_buffer_t * target,
- vg_lite_path_t * path,
- vg_lite_fill_t fill_rule,
- vg_lite_matrix_t * path_matrix,
- vg_lite_radial_gradient_t *grad,
- vg_lite_color_t paint_color,
- vg_lite_blend_t blend,
- vg_lite_filter_t filter);
- /*!
- @abstract Load an identity matrix.
- @discussion
- Load an identity matrix into a matrix variable.
- @param matrix
- Pointer to a <code>vg_lite_matrix_t</code> structure that will be loaded with an identity matrix.
- */
- void vg_lite_identity(vg_lite_matrix_t *matrix);
- /*!
- @abstract Translate a matrix.
- @discussion
- Translate a matrix to a new position.
- @param x
- X location of the transformation.
- @param y
- Y location of the transformation.
- @param matrix
- Pointer to a <code>vg_lite_matrix_t</code> structure that will be translated.
- */
- void vg_lite_translate(vg_lite_float_t x, vg_lite_float_t y, vg_lite_matrix_t *matrix);
- /*!
- @abstract Scale a matrix.
- @discussion
- Scale a matrix in both x and y directions.
- @param scale_x
- Horizontal scale.
- @param scale_y
- Vertical scale.
- @param matrix
- Pointer to a <code>vg_lite_matrix_t</code> structure that will be scaled.
- */
- void vg_lite_scale(vg_lite_float_t scale_x, vg_lite_float_t scale_y, vg_lite_matrix_t *matrix);
- /*!
- @abstract Rotate a matrix.
- @discussion
- Rotate a matrix a certain number of degrees.
- @param degrees
- Number of degrees to rotate the matrix around. Positive numbers rotate counter clock wise.
- @param matrix
- Pointer to a <code>vg_lite_matrix_t</code> structure that will be rotated.
- */
- void vg_lite_rotate(vg_lite_float_t degrees, vg_lite_matrix_t *matrix);
- /*!
- @abstract Set the command buffer size.
- @discussion
- In the rt device, the memory was limited, need to set the command buffer
- size by the chip.
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.
- */
- vg_lite_error_t vg_lite_set_command_buffer_size(uint32_t size);
- /*!
- @abstract Set scissor used for render target's boundary.
- @discussion
- This function is used to set a scissor into render target so that the out region
- of scissor boundary is not drawn.
- @param x, y, width, height
- The scissor bounds which specifies the x, y, width, and height of the region.
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.*/
- vg_lite_error_t vg_lite_set_scissor(int32_t x, int32_t y, int32_t width, int32_t height);
- /*!
- @abstract Enable scissor.
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.*/
- vg_lite_error_t vg_lite_enable_scissor(void);
- /*!
- @abstract Disable scissor.
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.*/
- vg_lite_error_t vg_lite_disable_scissor(void);
- /*!
- @abstract query the remaining allocate contiguous video memory.
- @param size
- This is a pointer to remaining allocate contiguous video memory.
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.The result correctly returns VG_LITE_SUCCESS,
- return VG_LITE_NO_CONTEXT if not initialized.*/
- vg_lite_error_t vg_lite_mem_avail(uint32_t *size);
- /*!
- @abstract Enable premultiply.
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.*/
- vg_lite_error_t vg_lite_enable_premultiply(void);
- /*!
- @abstract Disable premultiply.
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.*/
- vg_lite_error_t vg_lite_disable_premultiply(void);
- /*!
- @abstract This api use to control dither function switch.Dither is turned off by default.
- @param enable
- 0 means turn off the dither function. 1 means turn on the dither function.
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.
- */
- vg_lite_error_t vg_lite_set_dither(int enable);
- /*!
- @abstract use to set the colorkey.
- @param colorkey
- Defined by <code>vg_lite_color_key4_t</code>.
- @result
- Returns the status as defined by <code>vg_lite_error_t</code>.
- Possible return value in this function:
- VG_LITE_SUCCESS,the result correctly
- VG_LITE_NOT_SUPPORT, if not support colorkey.*/
- vg_lite_error_t vg_lite_set_color_key(vg_lite_color_key4_t colorkey);
- #endif /* VGLITE_VERSION_2_0 */
- /**************************** Capture ********************************************/
- #ifndef vgliteDUMP_PATH
- # define vgliteDUMP_PATH "./"
- #endif
- #ifndef vgliteDUMP_KEY
- # define vgliteDUMP_KEY "process"
- #endif
- #define DUMP_CAPTURE 0
- #if DUMP_CAPTURE
- void _SetDumpFileInfo();
- vg_lite_error_t
- vglitefDump(
- char * String,
- ...
- );
- # define vglitemDUMP vglitefDump
- vg_lite_error_t
- vglitefDumpBuffer(
- char* Tag,
- unsigned int Physical,
- void * Logical,
- unsigned int Offset,
- size_t Bytes
- );
- # define vglitemDUMP_BUFFER vglitefDumpBuffer
- #else
- inline static void __dummy_dump(
- char * Message,
- ...
- )
- {
- }
- # define vglitemDUMP __dummy_dump
- inline static void
- __dummy_dump_buffer(
- char* Tag,
- unsigned int Physical,
- void * Logical,
- unsigned int Offset,
- size_t Bytes
- )
- {
- }
- # define vglitemDUMP_BUFFER __dummy_dump_buffer
- #endif
- /**************************** Capture ********************************************/
- #ifdef __cplusplus
- }
- #endif
- #endif /* _vg_lite_h_ */
|