vg_lite.h

Defines

VGLITE_HEADER_VERSION: causes MSVC error C1189. Not needed because "The __inline keyword is equivalent to inline." See: https://learn.microsoft.com/en-us/cpp/cpp/inline-functions-cpp?view=msvc-170

VGLITE_VERSION_3_0

VGLITE_MAKE_VERSION(major, minor, patch)

VGLITE_VERSION_MAJOR(version)

VGLITE_VERSION_MINOR(version)

VGLITE_VERSION_PATCH(version)

VGLITE_API_VERSION_3_0

VGLITE_RELEASE_VERSION

VGL_FALSE

VGL_TRUE

VLC_OP_END

VLC_OP_CLOSE

VLC_OP_MOVE

VLC_OP_MOVE_REL

VLC_OP_LINE

VLC_OP_LINE_REL

VLC_OP_QUAD

VLC_OP_QUAD_REL

VLC_OP_CUBIC

VLC_OP_CUBIC_REL

VLC_OP_BREAK

VLC_OP_HLINE

VLC_OP_HLINE_REL

VLC_OP_VLINE

VLC_OP_VLINE_REL

VLC_OP_SQUAD

VLC_OP_SQUAD_REL

VLC_OP_SCUBIC

VLC_OP_SCUBIC_REL

VLC_OP_SCCWARC

VLC_OP_SCCWARC_REL

VLC_OP_SCWARC

VLC_OP_SCWARC_REL

VLC_OP_LCCWARC

VLC_OP_LCCWARC_REL

VLC_OP_LCWARC

VLC_OP_LCWARC_REL

VLM_PATH_ENABLE_UPLOAD(path)

VLM_PATH_DISABLE_UPLOAD(path)

VLM_PATH_GET_UPLOAD_BIT(path)

VLC_MAX_COLOR_RAMP_STOPS

VLC_MAX_GRADIENT_STOPS

VLC_GRADIENT_BUFFER_WIDTH

vg_lite_buffer_upload

vg_lite_path_append

vg_lite_path_calc_length

vg_lite_set_ts_buffer

vg_lite_set_draw_path_type

vg_lite_create_mask_layer

vg_lite_fill_mask_layer

vg_lite_blend_mask_layer

vg_lite_generate_mask_layer_by_path

vg_lite_set_mask_layer

vg_lite_destroy_mask_layer

vg_lite_enable_mask

vg_lite_enable_color_transformation

vg_lite_set_color_transformation

vg_lite_set_image_global_alpha

vg_lite_set_dest_global_alpha

vg_lite_clear_rad_grad

vg_lite_update_rad_grad

vg_lite_get_rad_grad_matrix

vg_lite_set_rad_grad

vg_lite_draw_linear_gradient

vg_lite_draw_radial_gradient

vg_lite_draw_gradient

vg_lite_mem_avail

vg_lite_set_update_stroke

vg_lite_buffer_image_mode_t

vg_lite_draw_path_type_t

vg_lite_linear_gradient_ext_t

vg_lite_buffer_transparency_mode_t

VG_LITE_ERROR

Typedefs

typedef unsigned char vg_lite_uint8_t

typedef char vg_lite_int8_t

typedef short vg_lite_int16_t

typedef unsigned short vg_lite_uint16_t

typedef int vg_lite_int32_t

typedef unsigned int vg_lite_uint32_t

typedef unsigned long long vg_lite_uint64_t

typedef float vg_lite_float_t

typedef double vg_lite_double_t

typedef char vg_lite_char

typedef char *vg_lite_string

typedef void *vg_lite_pointer

typedef void vg_lite_void

typedef unsigned int vg_lite_color_t

typedef enum vg_lite_error vg_lite_error_t

typedef enum vg_lite_feature vg_lite_feature_t

typedef enum vg_lite_quality vg_lite_quality_t

typedef enum vg_lite_format vg_lite_format_t

typedef enum vg_lite_buffer_format vg_lite_buffer_format_t

typedef enum vg_lite_swizzle vg_lite_swizzle_t

typedef enum vg_lite_yuv2rgb vg_lite_yuv2rgb_t

typedef enum vg_lite_buffer_layout vg_lite_buffer_layout_t

typedef enum vg_lite_image_mode vg_lite_image_mode_t

typedef enum vg_lite_transparency vg_lite_transparency_t

typedef enum vg_lite_blend vg_lite_blend_t

typedef enum vg_lite_fill vg_lite_fill_t

typedef enum vg_lite_global_alpha vg_lite_global_alpha_t

typedef enum vg_lite_filter vg_lite_filter_t

typedef enum vg_lite_pattern_mode vg_lite_pattern_mode_t

typedef enum vg_lite_paint_type vg_lite_paint_type_t

typedef enum vg_lite_compress_mode vg_lite_compress_mode_t

typedef enum vg_lite_path_type vg_lite_path_type_t

typedef enum vg_lite_cap_style vg_lite_cap_style_t

typedef enum vg_lite_join_style vg_lite_join_style_t

typedef enum vg_lite_mask_operation vg_lite_mask_operation_t

typedef enum vg_lite_orientation vg_lite_orientation_t

typedef enum vg_lite_gamma_conversion vg_lite_gamma_conversion_t

typedef enum vg_lite_index_endian vg_lite_index_endian_t

typedef enum vg_lite_map_flag vg_lite_map_flag_t

typedef enum vg_lite_param_type vg_lite_param_type_t

typedef struct vg_lite_info vg_lite_info_t

typedef struct vg_lite_point vg_lite_point_t

typedef vg_lite_point_t vg_lite_point4_t[4]

typedef struct vg_lite_rectangle vg_lite_rectangle_t

typedef struct vg_lite_matrix vg_lite_matrix_t

typedef struct vg_lite_yuvinfo vg_lite_yuvinfo_t

typedef struct vg_lite_path_point *vg_lite_path_point_ptr

typedef struct vg_lite_path_point vg_lite_path_point_t

typedef struct vg_lite_sub_path *vg_lite_sub_path_ptr

typedef struct vg_lite_sub_path vg_lite_sub_path_t

typedef struct vg_lite_path_list *vg_lite_path_list_ptr

typedef struct vg_lite_path_list vg_lite_path_list_t

typedef struct vg_lite_stroke vg_lite_stroke_t

typedef struct vg_lite_fc_buffer vg_lite_fc_buffer_t

typedef struct vg_lite_buffer vg_lite_buffer_t

typedef struct vg_lite_hw_memory vg_lite_hw_memory_t

typedef struct vg_lite_path vg_lite_path_t

typedef struct vg_lite_color_ramp vg_lite_color_ramp_t

typedef struct vg_lite_linear_gradient_parameter vg_lite_linear_gradient_parameter_t

typedef struct vg_lite_radial_gradient_parameter vg_lite_radial_gradient_parameter_t

typedef struct vg_lite_linear_gradient vg_lite_linear_gradient_t

typedef struct vg_lite_ext_linear_gradient vg_lite_ext_linear_gradient_t

typedef struct vg_lite_radial_gradient vg_lite_radial_gradient_t

typedef struct vg_lite_color_key vg_lite_color_key_t

typedef vg_lite_color_key_t vg_lite_color_key4_t[4]

typedef vg_lite_float_t vg_lite_pixel_matrix_t[20]

typedef struct vg_lite_pixel_channel_enable vg_lite_pixel_channel_enable_t

typedef struct vg_lite_color_transform vg_lite_color_transform_t

Enums

enum vg_lite_error

Values:

enumerator VG_LITE_SUCCESS

enumerator VG_LITE_INVALID_ARGUMENT: Success.

enumerator VG_LITE_OUT_OF_MEMORY: An invalid argument was specified.

enumerator VG_LITE_NO_CONTEXT: Out of memory.

enumerator VG_LITE_TIMEOUT: No context or an unintialized context specified.

enumerator VG_LITE_OUT_OF_RESOURCES: A timeout has occurred during a wait.

enumerator VG_LITE_GENERIC_IO: Out of system resources.

enumerator VG_LITE_NOT_SUPPORT: Cannot communicate with the kernel driver.

enumerator VG_LITE_ALREADY_EXISTS: Function call not supported.

enumerator VG_LITE_NOT_ALIGNED: Object already exists

enumerator VG_LITE_FLEXA_TIME_OUT: Data alignment error

enumerator VG_LITE_FLEXA_HANDSHAKE_FAIL: VG timeout requesting for segment buffer

enum vg_lite_feature

Values:

enumerator gcFEATURE_BIT_VG_IM_INDEX_FORMAT

enumerator gcFEATURE_BIT_VG_SCISSOR

enumerator gcFEATURE_BIT_VG_BORDER_CULLING

enumerator gcFEATURE_BIT_VG_RGBA2_FORMAT

enumerator gcFEATURE_BIT_VG_QUALITY_8X

enumerator gcFEATURE_BIT_VG_IM_FASTCLAER

enumerator gcFEATURE_BIT_VG_RADIAL_GRADIENT

enumerator gcFEATURE_BIT_VG_GLOBAL_ALPHA

enumerator gcFEATURE_BIT_VG_RGBA8_ETC2_EAC

enumerator gcFEATURE_BIT_VG_COLOR_KEY

enumerator gcFEATURE_BIT_VG_DOUBLE_IMAGE

enumerator gcFEATURE_BIT_VG_YUV_OUTPUT

enumerator gcFEATURE_BIT_VG_FLEXA

enumerator gcFEATURE_BIT_VG_24BIT

enumerator gcFEATURE_BIT_VG_DITHER

enumerator gcFEATURE_BIT_VG_USE_DST

enumerator gcFEATURE_BIT_VG_PE_CLEAR

enumerator gcFEATURE_BIT_VG_IM_INPUT

enumerator gcFEATURE_BIT_VG_DEC_COMPRESS

enumerator gcFEATURE_BIT_VG_LINEAR_GRADIENT_EXT

enumerator gcFEATURE_BIT_VG_MASK

enumerator gcFEATURE_BIT_VG_MIRROR

enumerator gcFEATURE_BIT_VG_GAMMA

enumerator gcFEATURE_BIT_VG_NEW_BLEND_MODE

enumerator gcFEATURE_BIT_VG_STENCIL

enumerator gcFEATURE_BIT_VG_SRC_PREMULTIPLIED

enumerator gcFEATURE_BIT_VG_HW_PREMULTIPLY: Valid only if gcFEATURE_BIT_VG_HW_PREMULTIPLY is 0

enumerator gcFEATURE_BIT_VG_COLOR_TRANSFORMATION: HW multiplier can accept either premultiplied or not

enumerator gcFEATURE_BIT_VG_LVGL_SUPPORT

enumerator gcFEATURE_BIT_VG_INDEX_ENDIAN

enumerator gcFEATURE_BIT_VG_24BIT_PLANAR

enumerator gcFEATURE_BIT_VG_PIXEL_MATRIX

enumerator gcFEATURE_BIT_VG_NEW_IMAGE_INDEX

enumerator gcFEATURE_BIT_VG_PARALLEL_PATHS

enumerator gcFEATURE_BIT_VG_STRIPE_MODE

enumerator gcFEATURE_BIT_VG_IM_DEC_INPUT

enumerator gcFEATURE_BIT_VG_GAUSSIAN_BLUR

enumerator gcFEATURE_BIT_VG_RECTANGLE_TILED_OUT

enumerator gcFEATURE_BIT_VG_TESSELLATION_TILED_OUT

enumerator gcFEATURE_BIT_VG_IM_REPEAT_REFLECT

enumerator gcFEATURE_BIT_VG_YUY2_INPUT

enumerator gcFEATURE_BIT_VG_YUV_INPUT

enumerator gcFEATURE_BIT_VG_YUV_TILED_INPUT

enumerator gcFEATURE_BIT_VG_AYUV_INPUT

enumerator gcFEATURE_BIT_VG_16PIXELS_ALIGN

enumerator gcFEATURE_BIT_VG_DEC_COMPRESS_2_0

enumerator gcFEATURE_COUNT

enum vg_lite_quality

Values:

enumerator VG_LITE_HIGH

enumerator VG_LITE_UPPER: High quality 16x anti-aliasing path.

enumerator VG_LITE_MEDIUM: Upper quality 8x anti-aliasing path.

enumerator VG_LITE_LOW: Medium quality 4x anti-aliasing path.

enum vg_lite_format

Values:

enumerator VG_LITE_S8

enumerator VG_LITE_S16: Signed 8-bit coordinates.

enumerator VG_LITE_S32: Signed 16-bit coordinates.

enumerator VG_LITE_FP32: Signed 32-bit coordinates.

enum vg_lite_buffer_format

Values:

enumerator VG_sRGBX_8888

enumerator VG_sRGBA_8888

enumerator VG_sRGBA_8888_PRE

enumerator VG_sRGB_565

enumerator VG_sRGBA_5551

enumerator VG_sRGBA_4444

enumerator VG_sL_8

enumerator VG_lRGBX_8888

enumerator VG_lRGBA_8888

enumerator VG_lRGBA_8888_PRE

enumerator VG_lL_8

enumerator VG_A_8

enumerator VG_BW_1

enumerator VG_A_1

enumerator VG_A_4

enumerator VG_sRGBX_8888_PRE

enumerator VG_sRGB_565_PRE

enumerator VG_sRGBA_5551_PRE

enumerator VG_sRGBA_4444_PRE

enumerator VG_lRGBX_8888_PRE

enumerator VG_lRGB_565

enumerator VG_lRGB_565_PRE

enumerator VG_lRGBA_5551

enumerator VG_lRGBA_5551_PRE

enumerator VG_lRGBA_4444

enumerator VG_lRGBA_4444_PRE

enumerator VG_sXRGB_8888

enumerator VG_sARGB_8888

enumerator VG_sARGB_8888_PRE

enumerator VG_sARGB_1555

enumerator VG_sARGB_4444

enumerator VG_lXRGB_8888

enumerator VG_lARGB_8888

enumerator VG_lARGB_8888_PRE

enumerator VG_sBGRX_8888

enumerator VG_sBGRA_8888

enumerator VG_sBGRA_8888_PRE

enumerator VG_sBGR_565

enumerator VG_sBGRA_5551

enumerator VG_sBGRA_4444

enumerator VG_lBGRX_8888

enumerator VG_lBGRA_8888

enumerator VG_lBGRA_8888_PRE

enumerator VG_sXBGR_8888

enumerator VG_sABGR_8888

enumerator VG_sABGR_8888_PRE

enumerator VG_sABGR_1555

enumerator VG_sABGR_4444

enumerator VG_lXBGR_8888

enumerator VG_lABGR_8888

enumerator VG_lABGR_8888_PRE

enumerator VG_LITE_RGBA8888

enumerator VG_LITE_BGRA8888

enumerator VG_LITE_RGBX8888

enumerator VG_LITE_BGRX8888

enumerator VG_LITE_RGB565

enumerator VG_LITE_BGR565

enumerator VG_LITE_RGBA4444

enumerator VG_LITE_BGRA4444

enumerator VG_LITE_BGRA5551

enumerator VG_LITE_A4

enumerator VG_LITE_A8

enumerator VG_LITE_L8

enumerator VG_LITE_YUYV

enumerator VG_LITE_YUY2

enumerator VG_LITE_ANV12

enumerator VG_LITE_AYUY2

enumerator VG_LITE_NV12

enumerator VG_LITE_YV12

enumerator VG_LITE_YV24

enumerator VG_LITE_YV16

enumerator VG_LITE_NV16

enumerator VG_LITE_YUY2_TILED

enumerator VG_LITE_NV12_TILED

enumerator VG_LITE_ANV12_TILED

enumerator VG_LITE_AYUY2_TILED

enumerator VG_LITE_RGBA2222

enumerator VG_LITE_BGRA2222

enumerator VG_LITE_ABGR2222

enumerator VG_LITE_ARGB2222

enumerator VG_LITE_ABGR4444

enumerator VG_LITE_ARGB4444

enumerator VG_LITE_ABGR8888

enumerator VG_LITE_ARGB8888

enumerator VG_LITE_ABGR1555

enumerator VG_LITE_RGBA5551

enumerator VG_LITE_ARGB1555

enumerator VG_LITE_XBGR8888

enumerator VG_LITE_XRGB8888

enumerator VG_LITE_RGBA8888_ETC2_EAC

enumerator VG_LITE_RGB888

enumerator VG_LITE_BGR888

enumerator VG_LITE_ABGR8565

enumerator VG_LITE_BGRA5658

enumerator VG_LITE_ARGB8565

enumerator VG_LITE_RGBA5658

enumerator VG_LITE_ABGR8565_PLANAR

enumerator VG_LITE_BGRA5658_PLANAR

enumerator VG_LITE_ARGB8565_PLANAR

enumerator VG_LITE_RGBA5658_PLANAR

enumerator VG_LITE_INDEX_1

enumerator VG_LITE_INDEX_2: Indexed format.

enumerator VG_LITE_INDEX_4

enumerator VG_LITE_INDEX_8

enum vg_lite_swizzle

Values:

enumerator VG_LITE_SWIZZLE_UV

enumerator VG_LITE_SWIZZLE_VU

enum vg_lite_yuv2rgb

Values:

enumerator VG_LITE_YUV601

enumerator VG_LITE_YUV709

enum vg_lite_buffer_layout

Values:

enumerator VG_LITE_LINEAR

enumerator VG_LITE_TILED

enum vg_lite_image_mode

Values:

enumerator VG_LITE_ZERO

enumerator VG_LITE_NORMAL_IMAGE_MODE

enumerator VG_LITE_MULTIPLY_IMAGE_MODE

enumerator VG_LITE_STENCIL_MODE

enumerator VG_LITE_NONE_IMAGE_MODE

enumerator VG_LITE_RECOLOR_MODE

enum vg_lite_transparency

Values:

enumerator VG_LITE_IMAGE_OPAQUE

enumerator VG_LITE_IMAGE_TRANSPARENT

enum vg_lite_blend

Values:

enumerator VG_LITE_BLEND_NONE

enumerator VG_LITE_BLEND_SRC_OVER: S, No blend, Non-premultiplied

enumerator VG_LITE_BLEND_DST_OVER: S + (1 - Sa) * D , Non-premultiplied

enumerator VG_LITE_BLEND_SRC_IN: (1 - Da) * S + D , Non-premultiplied

enumerator VG_LITE_BLEND_DST_IN: Da * S , Non-premultiplied

enumerator VG_LITE_BLEND_MULTIPLY: Sa * D , Non-premultiplied

enumerator VG_LITE_BLEND_SCREEN: S * (1 - Da) + D * (1 - Sa) + S * D , Non-premultiplied

enumerator VG_LITE_BLEND_DARKEN: S + D - S * D , Non-premultiplied

enumerator VG_LITE_BLEND_LIGHTEN: min(SrcOver, DstOver) , Non-premultiplied

enumerator VG_LITE_BLEND_ADDITIVE: max(SrcOver, DstOver) , Non-premultiplied

enumerator VG_LITE_BLEND_SUBTRACT: S + D , Non-premultiplied

enumerator VG_LITE_BLEND_SUBTRACT_LVGL: D * (1 - Sa) , Non-premultiplied

enumerator VG_LITE_BLEND_NORMAL_LVGL: D - S , Non-premultiplied

enumerator VG_LITE_BLEND_ADDITIVE_LVGL: S * Sa + (1 - Sa) * D , Non-premultiplied

enumerator VG_LITE_BLEND_MULTIPLY_LVGL: (S + D) * Sa + D * (1 - Sa) , Non-premultiplied

enumerator VG_LITE_BLEND_PREMULTIPLY_SRC_OVER: (S * D) * Sa + D * (1 - Sa) , Non-premultiplied

enumerator OPENVG_BLEND_SRC: S * Sa + (1 - Sa) * D , Non-premultiplied

enumerator OPENVG_BLEND_SRC_OVER: Copy SRC, no blend, Premultiplied

enumerator OPENVG_BLEND_DST_OVER: Porter-Duff SRC_OVER blend, Premultiplied

enumerator OPENVG_BLEND_SRC_IN: Porter-Duff DST_OVER blend, Premultiplied

enumerator OPENVG_BLEND_DST_IN: Porter-Duff SRC_IN blend, Premultiplied

enumerator OPENVG_BLEND_MULTIPLY: Porter-Duff DST_IN blend, Premultiplied

enumerator OPENVG_BLEND_SCREEN: Porter-Duff MULTIPLY blend, Premultiplied

enumerator OPENVG_BLEND_DARKEN: Porter-Duff SCREEN blend, Premultiplied

enumerator OPENVG_BLEND_LIGHTEN: Porter-Duff DARKEN blend, Premultiplied

enumerator OPENVG_BLEND_ADDITIVE: Porter-Duff LIGHTEN blend, Premultiplied

enum vg_lite_fill

Values:

enumerator VG_LITE_FILL_EVEN_ODD

enumerator VG_LITE_FILL_NON_ZERO: A pixel is drawn it it crosses an odd number of path pixels.

enum vg_lite_global_alpha

Values:

enumerator VG_LITE_NORMAL

enumerator VG_LITE_GLOBAL: Use original src/dst alpha value.

enumerator VG_LITE_SCALED: Use global src/dst alpha value to replace original src/dst alpha value.

enum vg_lite_filter

Values:

enumerator VG_LITE_FILTER_POINT

enumerator VG_LITE_FILTER_LINEAR: Fetch the nearest image pixel.

enumerator VG_LITE_FILTER_BI_LINEAR: Used for linear paint.

enumerator VG_LITE_FILTER_GAUSSIAN: Use a 2x2 box around the image pixel and perform an interpolation.

enum vg_lite_pattern_mode

Values:

enumerator VG_LITE_PATTERN_COLOR

enumerator VG_LITE_PATTERN_PAD: Pixel outside the bounds of sourceimage should be taken as the color

enumerator VG_LITE_PATTERN_REPEAT: Pixel outside the bounds of sourceimage should be taken as having the same color as the closest edge pixel

enumerator VG_LITE_PATTERN_REFLECT: Pixel outside the bounds of sourceimage should be repeated indefinitely in all directions

enum vg_lite_paint_type

Values:

enumerator VG_LITE_PAINT_ZERO

enumerator VG_LITE_PAINT_COLOR

enumerator VG_LITE_PAINT_LINEAR_GRADIENT

enumerator VG_LITE_PAINT_RADIAL_GRADIENT

enumerator VG_LITE_PAINT_PATTERN

enum vg_lite_gradient_spreadmode_t

Values:

enumerator VG_LITE_GRADIENT_SPREAD_FILL

enumerator VG_LITE_GRADIENT_SPREAD_PAD

enumerator VG_LITE_GRADIENT_SPREAD_REPEAT

enumerator VG_LITE_GRADIENT_SPREAD_REFLECT

enum vg_lite_compress_mode

Values:

enumerator VG_LITE_DEC_DISABLE

enumerator VG_LITE_DEC_NON_SAMPLE: disable compress

enumerator VG_LITE_DEC_HSAMPLE: compress ratio is 1.6 if use ARGB8888, compress ratio is 2 if use XRGB8888

enumerator VG_LITE_DEC_HV_SAMPLE: compress ratio is 2 if use ARGB8888, compress ratio is 2.6 if use XRGB8888

enum vg_lite_path_type

Values:

enumerator VG_LITE_DRAW_ZERO

enumerator VG_LITE_DRAW_STROKE_PATH

enumerator VG_LITE_DRAW_FILL_PATH

enumerator VG_LITE_DRAW_FILL_STROKE_PATH

enum vg_lite_cap_style

Values:

enumerator VG_LITE_CAP_BUTT

enumerator VG_LITE_CAP_ROUND

enumerator VG_LITE_CAP_SQUARE

enum vg_lite_join_style

Values:

enumerator VG_LITE_JOIN_MITER

enumerator VG_LITE_JOIN_ROUND

enumerator VG_LITE_JOIN_BEVEL

enum vg_lite_mask_operation

Values:

enumerator VG_LITE_CLEAR_MASK

enumerator VG_LITE_FILL_MASK: Set all dest mask values to 0

enumerator VG_LITE_SET_MASK: Set all dest mask values to 1

enumerator VG_LITE_UNION_MASK: Copy from src masklayer to dest masklayer.

enumerator VG_LITE_INTERSECT_MASK: Replace dest masklayer by its union with src masklayer.

enumerator VG_LITE_SUBTRACT_MASK: Replace dest masklayer by its intersection with src masklayer.

enum vg_lite_orientation

Values:

enumerator VG_LITE_ORIENTATION_TOP_BOTTOM

enumerator VG_LITE_ORIENTATION_BOTTOM_TOP

enum vg_lite_gamma_conversion

Values:

enumerator VG_LITE_GAMMA_NO_CONVERSION

enumerator VG_LITE_GAMMA_LINEAR: Leave color as is.

enumerator VG_LITE_GAMMA_NON_LINEAR

Convert from sRGB to linear space.

Convert from linear to sRGB space.

enum vg_lite_index_endian

Values:

enumerator VG_LITE_INDEX_LITTLE_ENDIAN

enumerator VG_LITE_INDEX_BIG_ENDIAN: Parse the index pixel from low to high, ! when using index1, the parsing order is bit0~bit7. ! when using index2, the parsing order is bit0:1,bit2:3,bit4:5.bit6:7. ! when using index4, the parsing order is bit0:3,bit4:7.

enum vg_lite_map_flag

Values:

enumerator VG_LITE_MAP_USER_MEMORY

enumerator VG_LITE_MAP_DMABUF

enum vg_lite_param_type

Values:

enumerator VG_LITE_SCISSOR_RECT

enumerator VG_LITE_GPU_IDLE_STATE: count must be 4n for x, y, right, bottom

Functions

vg_lite_error_t vg_lite_init(vg_lite_int32_t tess_width, vg_lite_int32_t tess_height)

vg_lite_error_t vg_lite_close(void)

vg_lite_error_t vg_lite_get_info(vg_lite_info_t *info)

vg_lite_uint32_t vg_lite_get_product_info(vg_lite_char *name, vg_lite_uint32_t *chip_id, vg_lite_uint32_t *chip_rev)

vg_lite_uint32_t vg_lite_query_feature(vg_lite_feature_t feature)

vg_lite_error_t vg_lite_finish(void)

vg_lite_error_t vg_lite_flush(void)

vg_lite_error_t vg_lite_get_register(vg_lite_uint32_t address, vg_lite_uint32_t *result)

vg_lite_error_t vg_lite_get_transform_matrix(vg_lite_point4_t src, vg_lite_point4_t dst, vg_lite_matrix_t *mat)

vg_lite_error_t vg_lite_allocate(vg_lite_buffer_t *buffer)

vg_lite_error_t vg_lite_free(vg_lite_buffer_t *buffer)

vg_lite_error_t vg_lite_upload_buffer(vg_lite_buffer_t *buffer, vg_lite_uint8_t *data[3], vg_lite_uint32_t stride[3])

vg_lite_error_t vg_lite_map(vg_lite_buffer_t *buffer, vg_lite_map_flag_t flag, int32_t fd)

vg_lite_error_t vg_lite_unmap(vg_lite_buffer_t *buffer)

vg_lite_error_t vg_lite_flush_mapped_buffer(vg_lite_buffer_t *buffer)

vg_lite_error_t vg_lite_clear(vg_lite_buffer_t *target, vg_lite_rectangle_t *rect, vg_lite_color_t color)

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)

vg_lite_error_t vg_lite_blit_rect(vg_lite_buffer_t *target, vg_lite_buffer_t *source, vg_lite_rectangle_t *rect, vg_lite_matrix_t *matrix, vg_lite_blend_t blend, vg_lite_color_t color, vg_lite_filter_t filter)

vg_lite_error_t vg_lite_blit2(vg_lite_buffer_t *target, vg_lite_buffer_t *source0, vg_lite_buffer_t *source1, vg_lite_matrix_t *matrix0, vg_lite_matrix_t *matrix1, vg_lite_blend_t blend, vg_lite_filter_t filter)

vg_lite_error_t vg_lite_copy_image(vg_lite_buffer_t *target, vg_lite_buffer_t *source, vg_lite_int32_t sx, vg_lite_int32_t sy, vg_lite_int32_t dx, vg_lite_int32_t dy, vg_lite_int32_t width, vg_lite_int32_t height)

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)

vg_lite_error_t vg_lite_set_stroke(vg_lite_path_t *path, vg_lite_cap_style_t cap_style, vg_lite_join_style_t join_style, vg_lite_float_t line_width, vg_lite_float_t miter_limit, vg_lite_float_t *dash_pattern, vg_lite_uint32_t pattern_count, vg_lite_float_t dash_phase, vg_lite_color_t color)

vg_lite_error_t vg_lite_update_stroke(vg_lite_path_t *path)

vg_lite_error_t vg_lite_set_path_type(vg_lite_path_t *path, vg_lite_path_type_t path_type)

vg_lite_error_t vg_lite_clear_path(vg_lite_path_t *path)

vg_lite_error_t vg_lite_upload_path(vg_lite_path_t *path)

vg_lite_error_t vg_lite_init_path(vg_lite_path_t *path, vg_lite_format_t format, vg_lite_quality_t quality, vg_lite_uint32_t length, vg_lite_pointer 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)

vg_lite_error_t vg_lite_init_arc_path(vg_lite_path_t *path, vg_lite_format_t format, vg_lite_quality_t quality, vg_lite_uint32_t length, vg_lite_pointer 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)

vg_lite_uint32_t vg_lite_get_path_length(vg_lite_uint8_t *opcode, vg_lite_uint32_t count, vg_lite_format_t format)

vg_lite_error_t vg_lite_append_path(vg_lite_path_t *path, vg_lite_uint8_t *opcode, vg_lite_pointer data, vg_lite_uint32_t seg_count)

vg_lite_error_t vg_lite_set_CLUT(vg_lite_uint32_t count, vg_lite_uint32_t *colors)

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 *path_matrix, vg_lite_buffer_t *pattern_image, vg_lite_matrix_t *pattern_matrix, vg_lite_blend_t blend, vg_lite_pattern_mode_t pattern_mode, vg_lite_color_t pattern_color, vg_lite_color_t color, vg_lite_filter_t filter)

vg_lite_error_t vg_lite_init_grad(vg_lite_linear_gradient_t *grad)

vg_lite_error_t vg_lite_clear_grad(vg_lite_linear_gradient_t *grad)

vg_lite_error_t vg_lite_update_grad(vg_lite_linear_gradient_t *grad)

vg_lite_matrix_t *vg_lite_get_grad_matrix(vg_lite_linear_gradient_t *grad)

vg_lite_error_t vg_lite_set_grad(vg_lite_linear_gradient_t *grad, vg_lite_uint32_t count, vg_lite_uint32_t *colors, vg_lite_uint32_t *stops)

vg_lite_error_t vg_lite_draw_grad(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)

vg_lite_error_t vg_lite_clear_linear_grad(vg_lite_ext_linear_gradient_t *grad)

vg_lite_error_t vg_lite_update_linear_grad(vg_lite_ext_linear_gradient_t *grad)

vg_lite_matrix_t *vg_lite_get_linear_grad_matrix(vg_lite_ext_linear_gradient_t *grad)

vg_lite_error_t vg_lite_set_linear_grad(vg_lite_ext_linear_gradient_t *grad, vg_lite_uint32_t count, vg_lite_color_ramp_t *color_ramp, vg_lite_linear_gradient_parameter_t grad_param, vg_lite_gradient_spreadmode_t spread_mode, vg_lite_uint8_t pre_mult)

vg_lite_error_t vg_lite_draw_linear_grad(vg_lite_buffer_t *target, vg_lite_path_t *path, vg_lite_fill_t fill_rule, vg_lite_matrix_t *path_matrix, vg_lite_ext_linear_gradient_t *grad, vg_lite_color_t paint_color, vg_lite_blend_t blend, vg_lite_filter_t filter)

vg_lite_error_t vg_lite_clear_radial_grad(vg_lite_radial_gradient_t *grad)

vg_lite_error_t vg_lite_update_radial_grad(vg_lite_radial_gradient_t *grad)

vg_lite_matrix_t *vg_lite_get_radial_grad_matrix(vg_lite_radial_gradient_t *grad)

vg_lite_error_t vg_lite_set_radial_grad(vg_lite_radial_gradient_t *grad, vg_lite_uint32_t count, vg_lite_color_ramp_t *color_ramp, vg_lite_radial_gradient_parameter_t grad_param, vg_lite_gradient_spreadmode_t spread_mode, vg_lite_uint8_t pre_mult)

vg_lite_error_t vg_lite_draw_radial_grad(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)

vg_lite_error_t vg_lite_identity(vg_lite_matrix_t *matrix)

vg_lite_error_t vg_lite_translate(vg_lite_float_t x, vg_lite_float_t y, vg_lite_matrix_t *matrix)

vg_lite_error_t vg_lite_scale(vg_lite_float_t scale_x, vg_lite_float_t scale_y, vg_lite_matrix_t *matrix)

vg_lite_error_t vg_lite_rotate(vg_lite_float_t degrees, vg_lite_matrix_t *matrix)

vg_lite_error_t vg_lite_set_scissor(vg_lite_int32_t x, vg_lite_int32_t y, vg_lite_int32_t right, vg_lite_int32_t bottom)

vg_lite_error_t vg_lite_scissor_rects(vg_lite_uint32_t nums, vg_lite_rectangle_t rect[])

vg_lite_error_t vg_lite_enable_scissor(void)

vg_lite_error_t vg_lite_disable_scissor(void)

vg_lite_error_t vg_lite_get_mem_size(vg_lite_uint32_t *size)

vg_lite_error_t vg_lite_source_global_alpha(vg_lite_global_alpha_t alpha_mode, vg_lite_uint8_t alpha_value)

vg_lite_error_t vg_lite_dest_global_alpha(vg_lite_global_alpha_t alpha_mode, vg_lite_uint8_t alpha_value)

vg_lite_error_t vg_lite_set_color_key(vg_lite_color_key4_t colorkey)

vg_lite_error_t vg_lite_enable_dither(void)

vg_lite_error_t vg_lite_disable_dither(void)

vg_lite_error_t vg_lite_set_tess_buffer(vg_lite_uint32_t physical, vg_lite_uint32_t size)

vg_lite_error_t vg_lite_set_command_buffer_size(vg_lite_uint32_t size)

vg_lite_error_t vg_lite_set_command_buffer(vg_lite_uint32_t physical, vg_lite_uint32_t size)

vg_lite_error_t vg_lite_set_pixel_matrix(vg_lite_pixel_matrix_t matrix, vg_lite_pixel_channel_enable_t *channel)

vg_lite_error_t vg_lite_gaussian_filter(vg_lite_float_t w0, vg_lite_float_t w1, vg_lite_float_t w2)

vg_lite_error_t vg_lite_enable_masklayer(void)

vg_lite_error_t vg_lite_disable_masklayer(void)

vg_lite_error_t vg_lite_set_masklayer(vg_lite_buffer_t *masklayer)

vg_lite_error_t vg_lite_destroy_masklayer(vg_lite_buffer_t *masklayer)

vg_lite_error_t vg_lite_create_masklayer(vg_lite_buffer_t *masklayer, vg_lite_uint32_t width, vg_lite_uint32_t height)

vg_lite_error_t vg_lite_fill_masklayer(vg_lite_buffer_t *masklayer, vg_lite_rectangle_t *rect, vg_lite_uint8_t value)

vg_lite_error_t vg_lite_blend_masklayer(vg_lite_buffer_t *dst, vg_lite_buffer_t *src, vg_lite_mask_operation_t operation, vg_lite_rectangle_t *rect)

vg_lite_error_t vg_lite_render_masklayer(vg_lite_buffer_t *masklayer, vg_lite_mask_operation_t operation, vg_lite_path_t *path, vg_lite_fill_t fill_rule, vg_lite_color_t color, vg_lite_matrix_t *matrix)

vg_lite_error_t vg_lite_set_mirror(vg_lite_orientation_t orientation)

vg_lite_error_t vg_lite_set_gamma(vg_lite_gamma_conversion_t gamma_value)

vg_lite_error_t vg_lite_enable_color_transform(void)

vg_lite_error_t vg_lite_disable_color_transform(void)

vg_lite_error_t vg_lite_set_color_transform(vg_lite_color_transform_t *values)

vg_lite_error_t vg_lite_flexa_set_stream(vg_lite_uint8_t stream_id)

vg_lite_error_t vg_lite_flexa_bg_buffer(vg_lite_uint8_t stream_id, vg_lite_buffer_t *buffer, vg_lite_uint32_t seg_count, vg_lite_uint32_t seg_size)

vg_lite_error_t vg_lite_flexa_enable(void)

vg_lite_error_t vg_lite_flexa_disable(void)

vg_lite_error_t vg_lite_flexa_stop_frame(void)

vg_lite_error_t vg_lite_dump_command_buffer(void)

vg_lite_error_t vg_lite_get_parameter(vg_lite_param_type_t type, vg_lite_int32_t count, vg_lite_float_t *params)

struct vg_lite_info

Public Members

vg_lite_uint32_t api_version

vg_lite_uint32_t header_version

vg_lite_uint32_t release_version

vg_lite_uint32_t reserved

struct vg_lite_point

Public Members

vg_lite_int32_t x

vg_lite_int32_t y

struct vg_lite_rectangle

Public Members

vg_lite_int32_t x

vg_lite_int32_t y: Left coordinate of rectangle.

vg_lite_int32_t width: Top coordinate of rectangle.

vg_lite_int32_t height: Width of rectangle.

struct vg_lite_matrix

Public Members

vg_lite_float_t m[3][3]

vg_lite_float_t scaleX: The 3x3 matrix is in [row][column] order.

vg_lite_float_t scaleY

vg_lite_float_t angle

struct vg_lite_yuvinfo

Public Members

vg_lite_swizzle_t swizzle

vg_lite_yuv2rgb_t yuv2rgb: UV swizzle.

vg_lite_uint32_t uv_planar: 601 or 709 conversion standard.

vg_lite_uint32_t v_planar: UV(U) planar address.

vg_lite_uint32_t alpha_planar: V planar address.

vg_lite_uint32_t uv_stride: Alpha planar address.

vg_lite_uint32_t v_stride: UV(U) stride.

vg_lite_uint32_t alpha_stride: V stride.

vg_lite_uint32_t uv_height: Alpha stride.

vg_lite_uint32_t v_height: UV(U) height.

vg_lite_pointer uv_memory: V height.

vg_lite_pointer v_memory: The logical pointer to the UV(U) planar memory.

vg_lite_pointer uv_handle: The logical pointer to the V planar memory.

vg_lite_pointer v_handle: The memory handle of the UV(U) planar.

struct vg_lite_path_point

Public Members

vg_lite_float_t x

vg_lite_float_t y

vg_lite_uint8_t flatten_flag

vg_lite_uint8_t curve_type

vg_lite_float_t tangentX

vg_lite_float_t tangentY

vg_lite_float_t length

vg_lite_path_point_ptr next

vg_lite_path_point_ptr prev

struct vg_lite_sub_path

Public Members

vg_lite_sub_path_ptr next

vg_lite_uint32_t point_count

vg_lite_path_point_ptr point_list

vg_lite_path_point_ptr end_point

vg_lite_uint8_t closed

vg_lite_float_t length

struct vg_lite_path_list

Public Members

vg_lite_path_point_ptr path_points

vg_lite_path_point_ptr path_end

vg_lite_uint32_t point_count

vg_lite_path_list_ptr next

vg_lite_uint8_t closed

struct vg_lite_stroke

Public Members

vg_lite_cap_style_t cap_style

vg_lite_join_style_t join_style

vg_lite_float_t line_width

vg_lite_float_t miter_limit

vg_lite_float_t *dash_pattern

vg_lite_uint32_t pattern_count

vg_lite_float_t dash_phase

vg_lite_float_t dash_length

vg_lite_uint32_t dash_index

vg_lite_float_t half_width

vg_lite_float_t pattern_length

vg_lite_float_t miter_square

vg_lite_path_point_ptr path_points

vg_lite_path_point_ptr path_end

vg_lite_uint32_t point_count

vg_lite_path_point_ptr left_point

vg_lite_path_point_ptr right_point

vg_lite_path_point_ptr stroke_points

vg_lite_path_point_ptr stroke_end

vg_lite_uint32_t stroke_count

vg_lite_path_list_ptr path_list_divide

vg_lite_path_list_ptr cur_list

vg_lite_uint8_t add_end

vg_lite_uint8_t dash_reset

vg_lite_sub_path_ptr stroke_paths

vg_lite_sub_path_ptr last_stroke

vg_lite_uint32_t swing_handling

vg_lite_float_t swing_deltax

vg_lite_float_t swing_deltay

vg_lite_path_point_ptr swing_start

vg_lite_path_point_ptr swing_stroke

vg_lite_float_t swing_length

vg_lite_float_t swing_centlen

vg_lite_uint32_t swing_count

vg_lite_uint8_t need_swing

vg_lite_uint8_t swing_ccw

vg_lite_float_t stroke_length

vg_lite_uint32_t stroke_size

vg_lite_uint8_t fattened

vg_lite_uint8_t closed

struct vg_lite_fc_buffer

Public Members

vg_lite_int32_t width

vg_lite_int32_t height: Width of the buffer in pixels.

vg_lite_int32_t stride: height of the buffer in pixels.

vg_lite_pointer handle: The number of bytes to move from one line in the buffer to the next line.

vg_lite_pointer memory: The memory handle of the buffer's memory as allocated by the VGLite kernel.

vg_lite_uint32_t address: The logical pointer to the buffer's memory for the CPU.

vg_lite_uint32_t color: The address to the buffer's memory for the hardware.

struct vg_lite_buffer

Public Members

vg_lite_int32_t width

vg_lite_int32_t height: Width of the buffer in pixels.

vg_lite_int32_t stride: Height of the buffer in pixels.

vg_lite_buffer_layout_t tiled: The number of bytes to move from one line in the buffer to the next line.

vg_lite_buffer_format_t format: Indicating the buffer memory layout is linear or tiled.

vg_lite_pointer handle: The pixel format of the buffer.

vg_lite_pointer memory: The memory handle of the buffer's memory as allocated by the VGLite kernel.

vg_lite_uint32_t address: The logical pointer to the buffer's memory for the CPU.

vg_lite_yuvinfo_t yuv: The address to the buffer's memory for the hardware.

vg_lite_image_mode_t image_mode: The yuv format details.

vg_lite_transparency_t transparency_mode: The blit image mode.

vg_lite_fc_buffer_t fc_buffer[3]: image transparency mode.

vg_lite_compress_mode_t compress_mode: 3 fastclear buffers,reserved YUV format.

vg_lite_index_endian_t index_endian: Refer to the definition by vg_lite_compress_mode_t.

vg_lite_paint_type_t paintType: Refer to the definition by vg_lite_index_endian_t.

vg_lite_uint8_t fc_enable: Get paintcolor from different paint types.

vg_lite_uint8_t scissor_layer: enable im fastclear.

vg_lite_uint8_t premultiplied: The buffer is scissor buffer.

struct vg_lite_hw_memory

Public Members

vg_lite_pointer handle

vg_lite_pointer memory: gpu memory object handle.

vg_lite_uint32_t address: logical memory address.

vg_lite_uint32_t bytes: GPU memory address.

vg_lite_uint32_t property: Size of memory.

struct vg_lite_path

Public Members

vg_lite_float_t bounding_box[4]

vg_lite_quality_t quality: Bounding box specified as left, top, right, and bottom.

vg_lite_format_t format: Quality hint for the path.

vg_lite_hw_memory_t uploaded: Coordinate format.

vg_lite_uint32_t path_length: Path data that has been upload into GPU addressable memory.

vg_lite_pointer path: Number of bytes in the path data.

vg_lite_int8_t path_changed: Pointer to the physical description of the path.

vg_lite_int8_t pdata_internal: Indicate whether path data is synced with command buffer (uploaded) or not.

vg_lite_path_type_t path_type: Indicate whether path data memory is allocated by driver.

vg_lite_stroke_t *stroke: Refer to the definition by vg_lite_path_type_t.

vg_lite_pointer stroke_path: Pointer to a vg_lite_stroke_t structure.

vg_lite_uint32_t stroke_size: Pointer to the physical description of the stroke path.

vg_lite_color_t stroke_color: Number of bytes in the stroke path data.

vg_lite_int8_t add_end: The stroke path fill color.

struct vg_lite_color_ramp

Public Members

vg_lite_float_t stop

vg_lite_float_t red: Value for the color stop.

vg_lite_float_t green: Red color channel value for the color stop.

vg_lite_float_t blue: Green color channel value for the color stop.

vg_lite_float_t alpha: Blue color channel value for the color stop.

struct vg_lite_linear_gradient_parameter

Public Members

vg_lite_float_t X0

vg_lite_float_t Y0

vg_lite_float_t X1

vg_lite_float_t Y1

struct vg_lite_radial_gradient_parameter

Public Members

vg_lite_float_t cx

vg_lite_float_t cy: x coordinate of the center point.

vg_lite_float_t r: y coordinate of the center point.

vg_lite_float_t fx: radius.

vg_lite_float_t fy: x coordinate of the focal point.

struct vg_lite_linear_gradient

Public Members

vg_lite_uint32_t colors[16]

vg_lite_uint32_t count: Colors for stops.

vg_lite_uint32_t stops[16]: Count of colors, up to 16.

vg_lite_matrix_t matrix: Color stops, value from 0 to 255.

vg_lite_buffer_t image: The matrix to transform the gradient.

struct vg_lite_ext_linear_gradient

Public Members

vg_lite_uint32_t count

vg_lite_matrix_t matrix: Count of colors, up to 256.

vg_lite_buffer_t image: The matrix to transform the gradient.

vg_lite_linear_gradient_parameter_t linear_grad: The image for rendering as gradient pattern.

vg_lite_uint32_t ramp_length: Include center point,focal point and radius.

vg_lite_color_ramp_t color_ramp[256]: Color ramp for gradient paints provided to driver.

vg_lite_uint32_t converted_length

vg_lite_color_ramp_t converted_ramp[256 + 2]: Converted internal color ramp.

vg_lite_uint8_t pre_multiplied

vg_lite_gradient_spreadmode_t spread_mode: If color values of color_ramp[] are multiply by alpha value of color_ramp[].

struct vg_lite_radial_gradient

Public Members

vg_lite_uint32_t count

vg_lite_matrix_t matrix: Count of colors, up to 256.

vg_lite_buffer_t image: The matrix to transform the gradient.

vg_lite_radial_gradient_parameter_t radial_grad: The image for rendering as gradient pattern.

vg_lite_uint32_t ramp_length: Include center point,focal point and radius.

vg_lite_color_ramp_t color_ramp[256]: Color ramp for gradient paints provided to the driver.

vg_lite_uint32_t converted_length

vg_lite_color_ramp_t converted_ramp[256 + 2]: Converted internal color ramp.

vg_lite_uint8_t pre_multiplied

vg_lite_gradient_spreadmode_t spread_mode: If color values of color_ramp[] are multiply by alpha value of color_ramp[].

struct vg_lite_color_key

Public Members

vg_lite_uint8_t enable

vg_lite_uint8_t low_r: The color key is effective only when "enable" is true,

vg_lite_uint8_t low_g: The R channel of low_rgb.

vg_lite_uint8_t low_b: The G channel of low_rgb.

vg_lite_uint8_t alpha: The B channel of low_rgb.

vg_lite_uint8_t hign_r: The alpha channel to replace destination pixel alpha channel.

vg_lite_uint8_t hign_g: The R channel of hign_rgb.

vg_lite_uint8_t hign_b: The G channel of hign_rgb.

struct vg_lite_pixel_channel_enable

Public Members

vg_lite_uint8_t enable_a

vg_lite_uint8_t enable_b: Enable A channel.

vg_lite_uint8_t enable_g: Enable B channel.

vg_lite_uint8_t enable_r: Enable G channel.

struct vg_lite_color_transform

Public Members

vg_lite_float_t a_scale

vg_lite_float_t a_bias

vg_lite_float_t r_scale

vg_lite_float_t r_bias

vg_lite_float_t g_scale

vg_lite_float_t g_bias

vg_lite_float_t b_scale

vg_lite_float_t b_bias