/****************************************************************************
*
*    Copyright 2012 - 2023 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 "../../../lv_conf_internal.h"
#if LV_USE_VG_LITE_DRIVER

#include <stddef.h>
#include <stdint.h>

/*  VGLite API Constants *******************************************************************************************************************/

#define VGLITE_HEADER_VERSION       7

#ifndef VGLITE_VERSION_3_0
#define VGLITE_VERSION_3_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_3_0      VGLITE_MAKE_VERSION(3, 0, 0)

#define VGLITE_RELEASE_VERSION      VGLITE_MAKE_VERSION(4,0,90)

#define VGL_FALSE                   0
#define VGL_TRUE                    1

/* 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_BREAK                0x0A
#define VLC_OP_HLINE                0x0B
#define VLC_OP_HLINE_REL            0x0C
#define VLC_OP_VLINE                0x0D
#define VLC_OP_VLINE_REL            0x0E
#define VLC_OP_SQUAD                0x0F
#define VLC_OP_SQUAD_REL            0x10
#define VLC_OP_SCUBIC               0x11
#define VLC_OP_SCUBIC_REL           0x12
#define VLC_OP_SCCWARC              0x13
#define VLC_OP_SCCWARC_REL          0x14
#define VLC_OP_SCWARC               0x15
#define VLC_OP_SCWARC_REL           0x16
#define VLC_OP_LCCWARC              0x17
#define VLC_OP_LCCWARC_REL          0x18
#define VLC_OP_LCWARC               0x19
#define VLC_OP_LCWARC_REL           0x1A

/* Macros for path manipulating: See path definitions. */
#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)
#define VLM_PATH_STROKE_ENABLE_UPLOAD(path)    (path).stroke->uploaded.property |= 1
#define VLM_PATH_STROKE_DISABLE_UPLOAD(path)   (path).stroke->uploaded.property &= (~1)
#define VLM_PATH_STROKE_GET_UPLOAD_BIT(path)   ((path).stroke->uploaded.property & 1)

/* Gradient constants. */
#define VLC_MAX_COLOR_RAMP_STOPS    256             /*! The max number of radial gradient stops. */
#define VLC_MAX_GRADIENT_STOPS      16              /*! The max number of gradient stops. */
#define VLC_GRADIENT_BUFFER_WIDTH   1024            /*! The internal gradient buffer width.*/


/* API name defines for backward compatibility to VGLite 2.0 APIs */
#define vg_lite_buffer_upload                   vg_lite_upload_buffer
#define vg_lite_path_append                     vg_lite_append_path
#define vg_lite_path_calc_length                vg_lite_get_path_length
#define vg_lite_set_ts_buffer                   vg_lite_set_tess_buffer
#define vg_lite_set_draw_path_type              vg_lite_set_path_type
#define vg_lite_create_mask_layer               vg_lite_create_masklayer
#define vg_lite_fill_mask_layer                 vg_lite_fill_masklayer
#define vg_lite_blend_mask_layer                vg_lite_blend_masklayer
#define vg_lite_generate_mask_layer_by_path     vg_lite_render_masklayer
#define vg_lite_set_mask_layer                  vg_lite_set_masklayer
#define vg_lite_destroy_mask_layer              vg_lite_destroy_masklayer
#define vg_lite_enable_mask                     vg_lite_enable_masklayer
#define vg_lite_enable_color_transformation     vg_lite_enable_color_transform
#define vg_lite_set_color_transformation        vg_lite_set_color_transform
#define vg_lite_set_image_global_alpha          vg_lite_source_global_alpha
#define vg_lite_set_dest_global_alpha           vg_lite_dest_global_alpha
#define vg_lite_clear_rad_grad                  vg_lite_clear_radial_grad
#define vg_lite_update_rad_grad                 vg_lite_update_radial_grad
#define vg_lite_get_rad_grad_matrix             vg_lite_get_radial_grad_matrix
#define vg_lite_set_rad_grad                    vg_lite_set_radial_grad
#define vg_lite_draw_linear_gradient            vg_lite_draw_linear_grad
#define vg_lite_draw_radial_gradient            vg_lite_draw_radial_grad
#define vg_lite_draw_gradient                   vg_lite_draw_grad
#define vg_lite_mem_avail                       vg_lite_get_mem_size
#define vg_lite_set_update_stroke               vg_lite_update_stroke

#define vg_lite_buffer_image_mode_t             vg_lite_image_mode_t
#define vg_lite_draw_path_type_t                vg_lite_path_type_t
#define vg_lite_linear_gradient_ext_t           vg_lite_ext_linear_gradient_t
#define vg_lite_buffer_transparency_mode_t      vg_lite_transparency_t

/* VG_LITE_BLEND_PREMULTIPLY_SRC_OVER is the same as VG_LITE_BLEND_NORMAL_LVGL */
#define VG_LITE_BLEND_PREMULTIPLY_SRC_OVER      VG_LITE_BLEND_NORMAL_LVGL

/* VGLite API Types ***********************************************************************************************************************/

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;


/* VGLite API Enumerations ****************************************************************************************************************/

#ifndef VG_LITE_ERROR
#define VG_LITE_ERROR  1

/* Error codes that the vg_lite functions can return. */
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 GPU memory. */
    VG_LITE_NO_CONTEXT,             /*! No context or an unintialized context specified. */
    VG_LITE_TIMEOUT,                /*! A timeout has occurred 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_ALREADY_EXISTS,         /*! Object already exists */
    VG_LITE_NOT_ALIGNED,            /*! Data alignment error */
    VG_LITE_FLEXA_TIME_OUT,         /*! VG timeout requesting for segment buffer */
    VG_LITE_FLEXA_HANDSHAKE_FAIL,   /*! VG and SBI synchronizer handshake failed */
} vg_lite_error_t;
#endif

/* Chip features bit */
typedef enum vg_lite_feature {
    gcFEATURE_BIT_VG_IM_INDEX_FORMAT,
    gcFEATURE_BIT_VG_SCISSOR,
    gcFEATURE_BIT_VG_BORDER_CULLING,
    gcFEATURE_BIT_VG_RGBA2_FORMAT,
    gcFEATURE_BIT_VG_QUALITY_8X,
    gcFEATURE_BIT_VG_IM_FASTCLAER,
    gcFEATURE_BIT_VG_RADIAL_GRADIENT,
    gcFEATURE_BIT_VG_GLOBAL_ALPHA,
    gcFEATURE_BIT_VG_RGBA8_ETC2_EAC,
    gcFEATURE_BIT_VG_COLOR_KEY,
    gcFEATURE_BIT_VG_DOUBLE_IMAGE,
    gcFEATURE_BIT_VG_YUV_OUTPUT,
    gcFEATURE_BIT_VG_FLEXA,
    gcFEATURE_BIT_VG_24BIT,
    gcFEATURE_BIT_VG_DITHER,
    gcFEATURE_BIT_VG_USE_DST,
    gcFEATURE_BIT_VG_PE_CLEAR,
    gcFEATURE_BIT_VG_IM_INPUT,
    gcFEATURE_BIT_VG_DEC_COMPRESS,
    gcFEATURE_BIT_VG_LINEAR_GRADIENT_EXT,
    gcFEATURE_BIT_VG_MASK,
    gcFEATURE_BIT_VG_MIRROR,
    gcFEATURE_BIT_VG_GAMMA,
    gcFEATURE_BIT_VG_NEW_BLEND_MODE,
    gcFEATURE_BIT_VG_STENCIL,
    gcFEATURE_BIT_VG_SRC_PREMULTIPLIED, /*! Valid only if gcFEATURE_BIT_VG_HW_PREMULTIPLY is 0   */
    gcFEATURE_BIT_VG_HW_PREMULTIPLY,    /*! HW multiplier can accept either premultiplied or not */
    gcFEATURE_BIT_VG_COLOR_TRANSFORMATION,
    gcFEATURE_BIT_VG_LVGL_SUPPORT,
    gcFEATURE_BIT_VG_INDEX_ENDIAN,
    gcFEATURE_BIT_VG_24BIT_PLANAR,
    gcFEATURE_BIT_VG_PIXEL_MATRIX,
    gcFEATURE_BIT_VG_NEW_IMAGE_INDEX,
    gcFEATURE_BIT_VG_PARALLEL_PATHS,
    gcFEATURE_BIT_VG_STRIPE_MODE,
    gcFEATURE_BIT_VG_IM_DEC_INPUT,
    gcFEATURE_BIT_VG_GAUSSIAN_BLUR,
    gcFEATURE_BIT_VG_RECTANGLE_TILED_OUT,
    gcFEATURE_BIT_VG_TESSELLATION_TILED_OUT,
    gcFEATURE_BIT_VG_IM_REPEAT_REFLECT,
    gcFEATURE_BIT_VG_YUY2_INPUT,
    gcFEATURE_BIT_VG_YUV_INPUT,
    gcFEATURE_BIT_VG_YUV_TILED_INPUT,
    gcFEATURE_BIT_VG_AYUV_INPUT,
    gcFEATURE_BIT_VG_16PIXELS_ALIGN,
    gcFEATURE_BIT_VG_DEC_COMPRESS_2_0,
    gcFEATURE_BIT_VG_NV24_INPUT,
    gcFEATURE_BIT_VG_TILED_LIMIT,
    gcFEATURE_BIT_TILED_MODE,
    gcFEATURE_BIT_VG_SRC_ADDRESS_16BYTES_ALIGNED,
    gcFEATURE_BIT_VG_SRC_ADDRESS_64BYTES_ALIGNED,
    gcFEATURE_BIT_VG_SRC_TILE_4PIXELS_ALIGNED,
    gcFEATURE_BIT_VG_SRC_BUF_ALINGED,
    gcFEATURE_BIT_VG_DST_ADDRESS_64BYTES_ALIGNED,
    gcFEATURE_BIT_VG_DST_TILE_4PIXELS_ALIGNED,
    gcFEATURE_BIT_VG_DST_BUF_ALIGNED,
    gcFEATURE_BIT_VG_DST_24BIT_PLANAR_ALIGNED,
    gcFEATURE_BIT_VG_DST_BUFLEN_ALIGNED,
    gcFEATURE_BIT_VG_FORMAT_SUPPORT_CHECK,
    gcFEATURE_BIT_VG_YUV_ALIGNED_CHECK,
    gcFEATURE_BIT_VG_512_PARALLEL_PATHS,
    gcFEATURE_COUNT
} vg_lite_feature_t;

/* Rendering quality enums. */
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 path without any anti-aliasing. */
} vg_lite_quality_t;

/* Format of path 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;

/* Format of pixel buffer. */
typedef enum vg_lite_buffer_format {
    /* The following OPENVG_* enums are defined corresponding to OpenVG
     * VGImageFormat enums so VGLite API can take OpenVG VGImageFormat enums directly.
     *
     * Note: The bits for each color channel are stored within a machine word
     * from MSB to LSB in the order indicated by the pixel format name.
     * This is opposite of VG_LITE_* formats (from LSB to MSB).
     */

    /* RGB{A,X} channel ordering */
    OPENVG_sRGBX_8888                               =  0,
    OPENVG_sRGBA_8888                               =  1,
    OPENVG_sRGBA_8888_PRE                           =  2,
    OPENVG_sRGB_565                                 =  3,
    OPENVG_sRGBA_5551                               =  4,
    OPENVG_sRGBA_4444                               =  5,
    OPENVG_sL_8                                     =  6,
    OPENVG_lRGBX_8888                               =  7,
    OPENVG_lRGBA_8888                               =  8,
    OPENVG_lRGBA_8888_PRE                           =  9,
    OPENVG_lL_8                                     = 10,
    OPENVG_A_8                                      = 11,
    OPENVG_BW_1                                     = 12,
    OPENVG_A_1                                      = 13,
    OPENVG_A_4                                      = 14,

    /* The following enums 15 ~ 25 do not exist in OpenVG VGImageFormat.
     * They are defined to support OpenVG CTS internalFormat which is set
     * base on "sRGB_NONPRE", "lRGB_NONPRE", "sRGB_PRE", "lRGB_PRE"
     * destination surface configurations.
     */
    OPENVG_sRGBX_8888_PRE                           = 15,
    OPENVG_sRGB_565_PRE                             = 16,
    OPENVG_sRGBA_5551_PRE                           = 17,
    OPENVG_sRGBA_4444_PRE                           = 18,
    OPENVG_lRGBX_8888_PRE                           = 19,
    OPENVG_lRGB_565                                 = 20,
    OPENVG_lRGB_565_PRE                             = 21,
    OPENVG_lRGBA_5551                               = 22,
    OPENVG_lRGBA_5551_PRE                           = 23,
    OPENVG_lRGBA_4444                               = 24,
    OPENVG_lRGBA_4444_PRE                           = 25,

    /* {A,X}RGB channel ordering */
    OPENVG_sXRGB_8888                               =  0 | (1 << 6),
    OPENVG_sARGB_8888                               =  1 | (1 << 6),
    OPENVG_sARGB_8888_PRE                           =  2 | (1 << 6),
    OPENVG_sARGB_1555                               =  4 | (1 << 6),
    OPENVG_sARGB_4444                               =  5 | (1 << 6),
    OPENVG_lXRGB_8888                               =  7 | (1 << 6),
    OPENVG_lARGB_8888                               =  8 | (1 << 6),
    OPENVG_lARGB_8888_PRE                           =  9 | (1 << 6),

    /* BGR{A,X} channel ordering */
    OPENVG_sBGRX_8888                               =  0 | (1 << 7),
    OPENVG_sBGRA_8888                               =  1 | (1 << 7),
    OPENVG_sBGRA_8888_PRE                           =  2 | (1 << 7),
    OPENVG_sBGR_565                                 =  3 | (1 << 7),
    OPENVG_sBGRA_5551                               =  4 | (1 << 7),
    OPENVG_sBGRA_4444                               =  5 | (1 << 7),
    OPENVG_lBGRX_8888                               =  7 | (1 << 7),
    OPENVG_lBGRA_8888                               =  8 | (1 << 7),
    OPENVG_lBGRA_8888_PRE                           =  9 | (1 << 7),

    /* {A,X}BGR channel ordering */
    OPENVG_sXBGR_8888                               =  0 | (1 << 6) | (1 << 7),
    OPENVG_sABGR_8888                               =  1 | (1 << 6) | (1 << 7),
    OPENVG_sABGR_8888_PRE                           =  2 | (1 << 6) | (1 << 7),
    OPENVG_sABGR_1555                               =  4 | (1 << 6) | (1 << 7),
    OPENVG_sABGR_4444                               =  5 | (1 << 6) | (1 << 7),
    OPENVG_lXBGR_8888                               =  7 | (1 << 6) | (1 << 7),
    OPENVG_lABGR_8888                               =  8 | (1 << 6) | (1 << 7),
    OPENVG_lABGR_8888_PRE                           =  9 | (1 << 6) | (1 << 7),

    /* The following VG_LITE_* enums are original VGLite API image format enums.
     *
     * Note: The bits for each color channel are stored within a machine word
     * from LSB to MSB in the order indicated by the pixel format name.
     * This is opposite of OPENVG VG_* formats (from MSB to LSB).
     */
    VG_LITE_RGBA8888                        =  0 | (1 << 10),
    VG_LITE_BGRA8888                        =  1 | (1 << 10),
    VG_LITE_RGBX8888                        =  2 | (1 << 10),
    VG_LITE_BGRX8888                        =  3 | (1 << 10),
    VG_LITE_RGB565                          =  4 | (1 << 10),
    VG_LITE_BGR565                          =  5 | (1 << 10),
    VG_LITE_RGBA4444                        =  6 | (1 << 10),
    VG_LITE_BGRA4444                        =  7 | (1 << 10),
    VG_LITE_BGRA5551                        =  8 | (1 << 10),
    VG_LITE_A4                              =  9 | (1 << 10),
    VG_LITE_A8                              = 10 | (1 << 10),
    VG_LITE_L8                              = 11 | (1 << 10),
    VG_LITE_YUYV                            = 12 | (1 << 10),
    VG_LITE_YUY2                            = 13 | (1 << 10),
    VG_LITE_ANV12                           = 14 | (1 << 10),
    VG_LITE_AYUY2                           = 15 | (1 << 10),
    VG_LITE_NV12                            = 16 | (1 << 10),
    VG_LITE_YV12                            = 17 | (1 << 10),
    VG_LITE_YV24                            = 18 | (1 << 10),
    VG_LITE_YV16                            = 19 | (1 << 10),
    VG_LITE_NV16                            = 20 | (1 << 10),
    VG_LITE_YUY2_TILED                      = 21 | (1 << 10),
    VG_LITE_NV12_TILED                      = 22 | (1 << 10),
    VG_LITE_ANV12_TILED                     = 23 | (1 << 10),
    VG_LITE_AYUY2_TILED                     = 24 | (1 << 10),
    VG_LITE_RGBA2222                        = 25 | (1 << 10),
    VG_LITE_BGRA2222                        = 26 | (1 << 10),
    VG_LITE_ABGR2222                        = 27 | (1 << 10),
    VG_LITE_ARGB2222                        = 28 | (1 << 10),
    VG_LITE_ABGR4444                        = 29 | (1 << 10),
    VG_LITE_ARGB4444                        = 30 | (1 << 10),
    VG_LITE_ABGR8888                        = 31 | (1 << 10),
    VG_LITE_ARGB8888                        = 32 | (1 << 10),
    VG_LITE_ABGR1555                        = 33 | (1 << 10),
    VG_LITE_RGBA5551                        = 34 | (1 << 10),
    VG_LITE_ARGB1555                        = 35 | (1 << 10),
    VG_LITE_XBGR8888                        = 36 | (1 << 10),
    VG_LITE_XRGB8888                        = 37 | (1 << 10),
    VG_LITE_RGBA8888_ETC2_EAC               = 38 | (1 << 10),
    VG_LITE_RGB888                          = 39 | (1 << 10),
    VG_LITE_BGR888                          = 40 | (1 << 10),
    VG_LITE_ABGR8565                        = 41 | (1 << 10),
    VG_LITE_BGRA5658                        = 42 | (1 << 10),
    VG_LITE_ARGB8565                        = 43 | (1 << 10),
    VG_LITE_RGBA5658                        = 44 | (1 << 10),
    VG_LITE_ABGR8565_PLANAR                 = 45 | (1 << 10),
    VG_LITE_BGRA5658_PLANAR                 = 46 | (1 << 10),
    VG_LITE_ARGB8565_PLANAR                 = 47 | (1 << 10),
    VG_LITE_RGBA5658_PLANAR                 = 48 | (1 << 10),
    VG_LITE_NV24                            = 49 | (1 << 10),
    VG_LITE_NV24_TILED                      = 50 | (1 << 10),

    VG_LITE_INDEX_1 = 0 | (1 << 11),  /*! Indexed format. */
    VG_LITE_INDEX_2 = 1 | (1 << 11),
    VG_LITE_INDEX_4 = 2 | (1 << 11),
    VG_LITE_INDEX_8 = 3 | (1 << 11),

} vg_lite_buffer_format_t;

/* Swizzle of packed YUV format UV channels. */
typedef enum vg_lite_swizzle {
    VG_LITE_SWIZZLE_UV,
    VG_LITE_SWIZZLE_VU,
} vg_lite_swizzle_t;

/* The YUV<->RGB conversion rule. */
typedef enum vg_lite_yuv2rgb {
    VG_LITE_YUV601,
    VG_LITE_YUV709,
} vg_lite_yuv2rgb_t;

/* The pixel layout in a buffer. */
typedef enum vg_lite_buffer_layout {
    VG_LITE_LINEAR,
    VG_LITE_TILED,
} vg_lite_buffer_layout_t;

/* The image (buffer) rendering mode. Match OpenVG enum VGImageMode */
typedef enum vg_lite_image_mode {
    /* For enum value backward compatibility */
    VG_LITE_ZERO                            = 0,
    VG_LITE_NORMAL_IMAGE_MODE               = 0x1F00,
    VG_LITE_MULTIPLY_IMAGE_MODE             = 0x1F01,
    VG_LITE_STENCIL_MODE                    = 0x1F02,
    VG_LITE_NONE_IMAGE_MODE                 = 0x1F03,
    VG_LITE_RECOLOR_MODE                    = 0x1F04,
} vg_lite_image_mode_t;

/* The image (buffer) transparency mode. */
typedef enum vg_lite_transparency {
    VG_LITE_IMAGE_OPAQUE,
    VG_LITE_IMAGE_TRANSPARENT
} vg_lite_transparency_t;

/* Blending modes. OPENVG_BLEND_* match OpenVG enum VGBlendMode.
 * S and D represent source and destination non-premultiplied RGB color channels.
 * Sa and Da represent the source and destination alpha channels.
 * SP and DP represent source and destination alpha-premultiplied RGB color channels (S*Sa, D*Da).
 */
typedef enum vg_lite_blend {
    /* Non-premultiplied Blending modes !*/
    VG_LITE_BLEND_NONE                      = 0,        /*!  RGB: S, No blend                                !*/
    /*!  A:   Sa                                         !*/
    VG_LITE_BLEND_SRC_OVER                  = 1,        /*!  RGB: S + D*(1 - Sa)                             !*/
    /*!  A:   Sa + Da*(1 - Sa)                           !*/
    VG_LITE_BLEND_DST_OVER                  = 2,        /*!  RGB: S*(1 - Da) + D                             !*/
    /*!  A:   Sa*(1 - Da) + Da                           !*/
    VG_LITE_BLEND_SRC_IN                    = 3,        /*!  RGB: S*Da                                       !*/
    /*!  A:   Sa*Da                                      !*/
    VG_LITE_BLEND_DST_IN                    = 4,        /*!  RGB: D*Sa                                       !*/
    /*!  A:   Da*Sa                                      !*/
    VG_LITE_BLEND_MULTIPLY                  = 5,        /*!  RGB: S*(1 - Da) + D*(1 - Sa) + S*D              !*/
    /*!  A:   Sa*(1 - Da) + Da*(1 - Sa) + Sa*Da          !*/
    VG_LITE_BLEND_SCREEN                    = 6,        /*!  RGB: S + D - S*D                                !*/
    /*!  A:   Sa + Da - Sa*Da                            !*/
    VG_LITE_BLEND_DARKEN                    = 7,        /*!  RGB: min(SrcOver, DstOver)                      !*/
    /*!  A:   min(SrcOver, DstOver)                      !*/
    VG_LITE_BLEND_LIGHTEN                   = 8,        /*!  RGB: max(SrcOver, DstOver)                      !*/
    /*!  A:   max(SrcOver, DstOver)                      !*/
    VG_LITE_BLEND_ADDITIVE                  = 9,        /*!  RGB: S + D                                      !*/
    /*!  A:   Sa + Da                                    !*/
    VG_LITE_BLEND_SUBTRACT                  = 10,       /*!  RGB: D*(1 - Sa)                                 !*/
    /*!  A:   Da*(1 - Sa)                                !*/
    VG_LITE_BLEND_NORMAL_LVGL               = 11,       /*!  RGB: S*Sa + D*(1 - Sa)                          !*/
    /*!  A:   0xFF                                       !*/
    VG_LITE_BLEND_ADDITIVE_LVGL             = 12,       /*!  RGB: (S + D)*Sa + D*(1 - Sa)                    !*/
    /*!  A:   0xFF                                       !*/
    VG_LITE_BLEND_SUBTRACT_LVGL             = 13,       /*!  RGB: (S - D)*Sa + D*(1 - Sa)                    !*/
    /*!  A:   0xFF                                       !*/
    VG_LITE_BLEND_MULTIPLY_LVGL             = 14,       /*!  RGB: (S*D)*Sa + D*(1 - Sa)                      !*/
    /*!  A:   0xFF                                       !*/

    /* Porter Duff Premultiplied Blending modes !*/
    OPENVG_BLEND_SRC                        = 0x2000,   /*!  RGB: SP / Sa,  No blend                                                    !*/
    /*!  A:   Sa                                                                    !*/
    OPENVG_BLEND_SRC_OVER                   = 0x2001,   /*!  RGB: (SP + DP*(1 - Sa)) / (Sa + Da*(1 - Sa))                               !*/
    /*!  A:   (Sa + Da*(1 - Sa))                                                    !*/
    OPENVG_BLEND_DST_OVER                   = 0x2002,   /*!  RGB: (SP*(1 - Da) + DP) / (Sa*(1 - Da) + Da)                               !*/
    /*!  A:   (Sa*(1 - Da) + Da)                                                    !*/
    OPENVG_BLEND_SRC_IN                     = 0x2003,   /*!  RGB: (SP*Da) / (Sa*Da)                                                     !*/
    /*!  A:   (Sa*Da)                                                               !*/
    OPENVG_BLEND_DST_IN                     = 0x2004,   /*!  RGB: (DP*Sa) / (Sa*Da)                                                     !*/
    /*!  A:   (Sa*Da)                                                               !*/
    OPENVG_BLEND_MULTIPLY                   = 0x2005,   /*!  RGB: (SP*DP + SP*(1 - Da) + DP*(1 - Sa)) / (Sa + Da*(1 - Sa))              !*/
    /*!  A:   (Sa + Da*(1 - Sa))                                                    !*/
    OPENVG_BLEND_SCREEN                     = 0x2006,   /*!  RGB: (SP + DP - (SP*DP)) / (Sa + Da*(1 - Sa))                              !*/
    /*!  A:   (Sa + Da*(1 - Sa))                                                    !*/
    OPENVG_BLEND_DARKEN                     = 0x2007,   /*!  RGB: (min(SP*Da, DP*Sa) + SP*(1 - Da) + DP*(1 - Sa)) / (Sa + Da*(1 - Sa))  !*/
    /*!  A:   (Sa + Da*(1 - Sa))                                                    !*/
    OPENVG_BLEND_LIGHTEN                    = 0x2008,   /*!  RGB: (max(SP*Da, DP*Sa) + SP*(1 - Da) + DP*(1 - Sa)) / (Sa + Da*(1 - Sa))  !*/
    /*!  A:   (Sa + Da*(1 - Sa))                                                    !*/
    OPENVG_BLEND_ADDITIVE                   = 0x2009,   /*!  RGB: (SP + DP) / (Sa + Da)                                                 !*/
    /*!  A:   (Sa + Da)                                                             !*/
} vg_lite_blend_t;

/* Fill rules. Match OpenVG enum VGFillRule */
typedef enum vg_lite_fill {
    VG_LITE_FILL_EVEN_ODD                   = 0x1900,   /*! A pixel is drawn it it crosses an odd number of path pixels. */
    VG_LITE_FILL_NON_ZERO                   = 0x1901,   /*! A pixel is drawn if it crosses at least one path pixel. */
} vg_lite_fill_t;

/* Global alpha modes. */
typedef enum vg_lite_global_alpha {
    VG_LITE_NORMAL = 0,                     /*! Use original src/dst alpha value. */
    VG_LITE_GLOBAL,                         /*! Use global src/dst alpha value to replace original src/dst alpha value. */
    VG_LITE_SCALED,                         /*! Multiply global src/dst alpha value and original src/dst alpha value. */
} vg_lite_global_alpha_t;

/* Filter modes. */
typedef enum vg_lite_filter {
    VG_LITE_FILTER_POINT     = 0,           /*! Fetch the nearest image pixel. */
    VG_LITE_FILTER_LINEAR    = 0x1000,      /*! Used for linear paint. */
    VG_LITE_FILTER_BI_LINEAR = 0x2000,      /*! Use a 2x2 box around the image pixel and perform an interpolation. */
    VG_LITE_FILTER_GAUSSIAN  = 0x3000,      /*! Perform 3x3 gaussian blur with the convolution for image pixel. */
} vg_lite_filter_t;

/* Pattern padding mode. Match OpenVG enum VGTilingMode. */
typedef enum vg_lite_pattern_mode {
    VG_LITE_PATTERN_COLOR   = 0x1D00,       /*! Pixel outside the bounds of sourceimage should be taken as the color */
    VG_LITE_PATTERN_PAD     = 0x1D01,       /*! Pixel outside the bounds of sourceimage should be taken as having the same color as the closest edge pixel */
    VG_LITE_PATTERN_REPEAT  = 0x1D02,       /*! Pixel outside the bounds of sourceimage should be repeated indefinitely in all directions */
    VG_LITE_PATTERN_REFLECT = 0x1D03,       /*! Pixel outside the bounds of sourceimage should be reflected indefinitely in all directions */
} vg_lite_pattern_mode_t;

/* Paint type. Match OpenVG enum VGPaintType. */
typedef enum vg_lite_paint_type {
    /* For enum value backward compatibility */
    VG_LITE_PAINT_ZERO            = 0,
    VG_LITE_PAINT_COLOR           = 0x1B00,
    VG_LITE_PAINT_LINEAR_GRADIENT = 0x1B01,
    VG_LITE_PAINT_RADIAL_GRADIENT = 0x1B02,
    VG_LITE_PAINT_PATTERN         = 0x1B03,
} vg_lite_paint_type_t;

/* Radial gradient padding mode. Match OpenVG enum VGColorRampSpreadMode */
typedef enum {
    VG_LITE_GRADIENT_SPREAD_FILL     = 0,
    VG_LITE_GRADIENT_SPREAD_PAD      = 0x1C00,
    VG_LITE_GRADIENT_SPREAD_REPEAT   = 0x1C01,
    VG_LITE_GRADIENT_SPREAD_REFLECT  = 0x1C02,
} vg_lite_gradient_spreadmode_t;

/* Decnano Compress mode. */
typedef enum vg_lite_compress_mode {
    VG_LITE_DEC_DISABLE = 0,                /*! disable compress */
    VG_LITE_DEC_NON_SAMPLE,                 /*! compress ratio is 1.6 if use ARGB8888, compress ratio is 2 if use XRGB8888 */
    VG_LITE_DEC_HSAMPLE,                    /*! compress ratio is 2 if use ARGB8888, compress ratio is 2.6 if use XRGB8888 */
    VG_LITE_DEC_HV_SAMPLE,                  /*! compress ratio is 2.6 if use ARGB8888, compress ratio is 4 if use XRGB8888 */
} vg_lite_compress_mode_t;

/* Draw path type. Match OpenVG enum VGPaintMode */
typedef enum vg_lite_path_type {
    /* For enum value backward compatibility */
    VG_LITE_DRAW_ZERO                       = 0,
    VG_LITE_DRAW_STROKE_PATH                = (1 << 0),
    VG_LITE_DRAW_FILL_PATH                  = (1 << 1),
    VG_LITE_DRAW_FILL_STROKE_PATH           = (1 << 1 | 1 << 0),
} vg_lite_path_type_t;

/* End cap style. Match OpenVG enum VGCapStyle */
typedef enum vg_lite_cap_style {
    VG_LITE_CAP_BUTT                        = 0x1700,
    VG_LITE_CAP_ROUND                       = 0x1701,
    VG_LITE_CAP_SQUARE                      = 0x1702,
} vg_lite_cap_style_t;

/* Line join styles. Match OpenVG enum VGJoinStyle */
typedef enum vg_lite_join_style {
    VG_LITE_JOIN_MITER                      = 0x1800,
    VG_LITE_JOIN_ROUND                      = 0x1801,
    VG_LITE_JOIN_BEVEL                      = 0x1802,
} vg_lite_join_style_t;

/* Mask operation mode. Match OpenVG enum VGMaskOperation */
typedef enum vg_lite_mask_operation {
    VG_LITE_CLEAR_MASK                      = 0x1500,   /*! Set all dest mask values to 0 */
    VG_LITE_FILL_MASK                       = 0x1501,   /*! Set all dest mask values to 1 */
    VG_LITE_SET_MASK                        = 0x1502,   /*! Copy from src masklayer to dest masklayer. */
    VG_LITE_UNION_MASK                      = 0x1503,   /*! Replace dest masklayer by its union with src masklayer. */
    VG_LITE_INTERSECT_MASK                  = 0x1504,   /*! Replace dest masklayer by its intersection with src masklayer. */
    VG_LITE_SUBTRACT_MASK                   = 0x1505,   /*! Subtract src mask in dest masklayer */
} vg_lite_mask_operation_t;

/* Mirror orientation mode. */
typedef enum vg_lite_orientation {
    VG_LITE_ORIENTATION_TOP_BOTTOM,
    VG_LITE_ORIENTATION_BOTTOM_TOP,
} vg_lite_orientation_t;

/* Gamma conversion mode. */
typedef enum vg_lite_gamma_conversion {
    VG_LITE_GAMMA_NO_CONVERSION,            /*! Leave color as is. */
    VG_LITE_GAMMA_LINEAR,                   /*! Convert from sRGB to linear space. */
    VG_LITE_GAMMA_NON_LINEAR                /*! Convert from linear to sRGB space. */
} vg_lite_gamma_conversion_t;

/* Index endian */
typedef enum vg_lite_index_endian {
    VG_LITE_INDEX_LITTLE_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.
                                                 */
    VG_LITE_INDEX_BIG_ENDIAN,               /*! Parse the index pixel from low to high,
                                                 *! when using index1, the parsing order is bit7~bit0.
                                                 *! when using index2, the parsing order is bit7:6,bit5:4,bit3:2.bit1:0.
                                                 *! when using index4, the parsing order is bit4:7,bit0:3.
                                                 */
} vg_lite_index_endian_t;

/* Map flag*/
typedef enum vg_lite_map_flag {
    VG_LITE_MAP_USER_MEMORY             = 0,
    VG_LITE_MAP_DMABUF                  = 0x01,
} vg_lite_map_flag_t;

/*VGLite parameters variable*/
typedef enum vg_lite_param_type {
    VG_LITE_GPU_IDLE_STATE,                 /*! count must be 1 for GPU idle state TRUE or FALSE */
    VG_LITE_SCISSOR_RECT,                   /*! count must be 4n for x, y, right, bottom */
    VG_LITE_HARDWARE_RUNNING_TIME,          /*! count must be 1 */
} vg_lite_param_type_t;

/* Vg lite buffer type */
typedef enum vg_lite_buffer_type {
    VG_LITE_COMMAND_BUFFER,
    VG_LITE_TESSELLATION_BUFFER,
    VG_LITE_RENDER_BUFFER,
} vg_lite_buffer_type_t;

/* Reserve memory index */
typedef enum vg_lite_memory_pool {
    VG_LITE_MEMORY_POOL_1 = 0,
    VG_LITE_MEMORY_POOL_2 = 1,
} vg_lite_memory_pool_t;

typedef enum vg_lite_frame_flag {
    VG_LITE_FRAME_END_FLAG = 1,
} vg_lite_frame_flag_t;

/* VGLite API Structures ******************************************************************************************************************/

/* VGLite driver information */
typedef struct vg_lite_info {
    vg_lite_uint32_t api_version;
    vg_lite_uint32_t header_version;
    vg_lite_uint32_t release_version;
    vg_lite_uint32_t reserved;
} vg_lite_info_t;

/* A 2D Point definition. */
typedef struct vg_lite_point {
    vg_lite_int32_t x;
    vg_lite_int32_t y;
} vg_lite_point_t;

/* Four 2D Point that form a polygon */
typedef vg_lite_point_t vg_lite_point4_t[4];

/* A 2D float Point definition. */
typedef struct vg_lite_float_point {
    vg_lite_float_t x;
    vg_lite_float_t y;
} vg_lite_float_point_t;

/* Four 2D float Point that form a polygon */
typedef vg_lite_float_point_t vg_lite_float_point4_t[4];

/* A rectangle.*/
typedef struct vg_lite_rectangle {
    vg_lite_int32_t x;                      /*! Left coordinate of rectangle. */
    vg_lite_int32_t y;                      /*! Top coordinate of rectangle. */
    vg_lite_int32_t width;                  /*! Width of rectangle. */
    vg_lite_int32_t height;                 /*! Height of rectangle. */
} vg_lite_rectangle_t;

typedef struct vg_lite_matrix {
    vg_lite_float_t m[3][3];                /*! The 3x3 matrix is in [row][column] order. */
    vg_lite_float_t scaleX;
    vg_lite_float_t scaleY;
    vg_lite_float_t angle;
} vg_lite_matrix_t;

typedef struct vg_lite_yuvinfo {
    vg_lite_swizzle_t swizzle;              /*! UV swizzle. */
    vg_lite_yuv2rgb_t yuv2rgb;              /*! 601 or 709 conversion standard. */
    vg_lite_uint32_t uv_planar;             /*! UV(U) planar address. */
    vg_lite_uint32_t v_planar;              /*! V planar address. */
    vg_lite_uint32_t alpha_planar;          /*! Alpha planar address. */
    vg_lite_uint32_t uv_stride;             /*! UV(U) stride. */
    vg_lite_uint32_t v_stride;              /*! V stride. */
    vg_lite_uint32_t alpha_stride;          /*! Alpha stride. */
    vg_lite_uint32_t uv_height;             /*! UV(U) height. */
    vg_lite_uint32_t v_height;              /*! V height. */
    vg_lite_pointer uv_memory;              /*! The logical pointer to the UV(U) planar memory. */
    vg_lite_pointer v_memory;               /*! The logical pointer to the V planar memory. */
    vg_lite_pointer uv_handle;              /*! The memory handle of the UV(U) planar. */
    vg_lite_pointer v_handle;               /*! The memory handle of the V planar. */
} vg_lite_yuvinfo_t;

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. */
    vg_lite_uint8_t flatten_flag;

    /* Curve type for stroke path. */
    vg_lite_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. */
    vg_lite_uint32_t point_count;

    /* Point list. */
    vg_lite_path_point_ptr point_list;

    /* Last point. */
    vg_lite_path_point_ptr end_point;

    /* Whether is path is closed. */
    vg_lite_uint8_t closed;

    /* Sub path length. */
    vg_lite_float_t length;

} vg_lite_sub_path_t;

/* Save divided path data according to MOVE/MOVE_REL. */
typedef struct vg_lite_path_list * vg_lite_path_list_ptr;
typedef struct vg_lite_path_list {
    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;

} vg_lite_path_list_t;

/* Memory allocation info by kernel. */
typedef struct vg_lite_hw_memory {
    vg_lite_pointer handle;                 /*! gpu memory object handle. */
    vg_lite_pointer memory;                 /*! logical memory address. */
    vg_lite_uint32_t address;               /*! GPU memory address. */
    vg_lite_uint32_t bytes;                 /*! Size of memory. */
    vg_lite_uint32_t property;              /*! Currently bit0 is used for path upload state:
                                                 *!   1 : enable auto path data uploading.
                                                 *!   0 : disable path data uploading. path data is embedded in command buffer. */
} vg_lite_hw_memory_t;

typedef struct vg_lite_stroke {
    /* Stroke parameters */
    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;

    /* Total length of stroke dash patterns. */
    vg_lite_float_t                     pattern_length;

    /* For fast checking. */
    vg_lite_float_t                     miter_square;

    /* Temp storage of stroke subPath. */
    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;

    /* Divide stroke path according to move or move_rel for avoiding implicit closure. */
    vg_lite_path_list_ptr               path_list_divide;

    /* pointer to current divided path data. */
    vg_lite_path_list_ptr               cur_list;

    /* Flag that add end_path in driver. */
    vg_lite_uint8_t                     add_end;
    vg_lite_uint8_t                     dash_reset;

    /* Sub path list. */
    vg_lite_sub_path_ptr                stroke_paths;

    /* Last sub path. */
    vg_lite_sub_path_ptr                last_stroke;

    /* Swing area handling. */
    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;

    /* The stroke line is fat line. */
    vg_lite_uint8_t                     fattened;
    vg_lite_uint8_t                     closed;
    vg_lite_hw_memory_t                 uploaded;

} vg_lite_stroke_t;

/* Fast clear buffer. */
typedef struct vg_lite_fc_buffer {
    vg_lite_int32_t width;                  /*! Width of the buffer in pixels. */
    vg_lite_int32_t height;                 /*! height of the buffer in pixels. */
    vg_lite_int32_t stride;                 /*! The number of bytes to move from one line in the buffer to the next line. */
    vg_lite_pointer
    handle;                 /*! The memory handle of the buffer's memory as allocated by the VGLite kernel. */
    vg_lite_pointer memory;                 /*! The logical pointer to the buffer's memory for the CPU. */
    vg_lite_uint32_t address;               /*! The address to the buffer's memory for the hardware. */
    vg_lite_uint32_t color;                 /*! The fastclear color value. */
} vg_lite_fc_buffer_t;

/* Structure for any image or render target. */
typedef struct vg_lite_buffer {
    vg_lite_int32_t width;                  /*! Width of the buffer in pixels. */
    vg_lite_int32_t height;                 /*! Height of the buffer in pixels. */
    vg_lite_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. */
    vg_lite_pointer
    handle;                 /*! The memory handle of the buffer's memory as allocated by the VGLite kernel. */
    vg_lite_pointer memory;                 /*! The logical pointer to the buffer's memory for the CPU. */
    vg_lite_uint32_t address;               /*! The address to the buffer's memory for the hardware. */
    vg_lite_memory_pool_t pool;             /*! The buffer's memory pool. */
    vg_lite_yuvinfo_t yuv;                  /*! The yuv format details. */
    vg_lite_image_mode_t image_mode;        /*! The blit image mode. */
    vg_lite_transparency_t transparency_mode; /*! image transparency mode. */
    vg_lite_fc_buffer_t fc_buffer[3];       /*! 3 fastclear buffers,reserved YUV format. */
    vg_lite_compress_mode_t compress_mode;  /*! Refer to the definition by vg_lite_compress_mode_t. */
    vg_lite_index_endian_t index_endian;    /*! Refer to the definition by vg_lite_index_endian_t. */
    vg_lite_paint_type_t paintType;         /*! Get paintcolor from different paint types. */
    vg_lite_uint8_t fc_enable;              /*! enable im fastclear. */
    vg_lite_uint8_t scissor_buffer;         /*! The buffer is scissor mask buffer. */
    vg_lite_uint8_t premultiplied;          /*! The RGB pixel values are alpha-premultipled */
    vg_lite_uint8_t apply_premult;          /*! Need to apply alpha-premultiply */
    struct vg_lite_buffer * lvgl_buffer;    /*! Buffer for SW LVGL blending support */
    vg_lite_color_t bg_color;               /*! Background for edge filter */
} vg_lite_buffer_t;

/* Path info for drawing command. */
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. */
    vg_lite_uint32_t path_length;           /*! Number of bytes in the path data. */
    vg_lite_pointer path;                   /*! Pointer to the physical description of the path. */
    vg_lite_int8_t
    path_changed;            /*! Indicate whether path data is synced with command buffer (uploaded) or not. */
    vg_lite_int8_t pdata_internal;          /*! Indicate whether path data memory is allocated by driver. */
    vg_lite_path_type_t path_type;          /*! Refer to the definition by vg_lite_path_type_t. */
    vg_lite_stroke_t * stroke;              /*! Pointer to a vg_lite_stroke_t structure.*/
    vg_lite_pointer stroke_path;            /*! Pointer to the physical description of the stroke path. */
    vg_lite_uint32_t stroke_size;           /*! Number of bytes in the stroke path data. */
    vg_lite_color_t stroke_color;           /*! The stroke path fill color. */
    vg_lite_int8_t add_end;                 /*! Flag that add end_path in driver. */
    vg_lite_int8_t
    stroke_valid;            /*! Flag that judge whether current stroke data is come from current pathdata. */
} vg_lite_path_t;

/* Color ramp definition. */
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;

/* Linear gradient parameter */
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;

typedef struct vg_lite_radial_gradient_parameter {
    vg_lite_float_t cx;                                 /*! x coordinate of the center point. */
    vg_lite_float_t cy;                                 /*! y coordinate of the center point. */
    vg_lite_float_t r;                                  /*! radius. */
    vg_lite_float_t fx;                                 /*! x coordinate of the focal point. */
    vg_lite_float_t fy;                                 /*! y coordinate of the focal point. */
} vg_lite_radial_gradient_parameter_t;

/* Linear gradient definition. */
typedef struct vg_lite_linear_gradient {
    vg_lite_uint32_t colors[VLC_MAX_GRADIENT_STOPS];    /*! Colors for stops. */
    vg_lite_uint32_t count;                             /*! Count of colors, up to 16. */
    vg_lite_uint32_t stops[VLC_MAX_GRADIENT_STOPS];     /*! 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;

/* Extended linear gradient definition. */
typedef struct vg_lite_ext_linear_gradient {
    vg_lite_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_grad;    /*!  Include center point,focal point and radius.*/

    vg_lite_uint32_t ramp_length;                       /*! Color ramp for gradient paints provided to driver. */
    vg_lite_color_ramp_t color_ramp[VLC_MAX_COLOR_RAMP_STOPS];

    vg_lite_uint32_t converted_length;                  /*! Converted internal color ramp. */
    vg_lite_color_ramp_t converted_ramp[VLC_MAX_COLOR_RAMP_STOPS + 2];

    vg_lite_uint8_t
    pre_multiplied;                     /*! If color values of color_ramp[] are multiply by alpha value of color_ramp[]. */
    vg_lite_gradient_spreadmode_t
    spread_mode;          /*! The spread mode that applied to the pixels out of the image after transformed. */
} vg_lite_ext_linear_gradient_t;

/* Radial gradient definition. */
typedef struct vg_lite_radial_gradient {
    vg_lite_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 radial_grad;    /*!  Include center point,focal point and radius.*/

    vg_lite_uint32_t ramp_length;                       /*! Color ramp for gradient paints provided to the driver. */
    vg_lite_color_ramp_t color_ramp[VLC_MAX_COLOR_RAMP_STOPS];

    vg_lite_uint32_t converted_length;                  /*! Converted internal color ramp. */
    vg_lite_color_ramp_t converted_ramp[VLC_MAX_COLOR_RAMP_STOPS + 2];

    vg_lite_uint8_t
    pre_multiplied;                     /*! If color values of color_ramp[] are multiply by alpha value of color_ramp[]. */
    vg_lite_gradient_spreadmode_t
    spread_mode;          /*! The spread mode that applied to the pixels out of the image after transformed. */
} vg_lite_radial_gradient_t;

/* Colorkey definition */
typedef struct vg_lite_color_key {
    vg_lite_uint8_t enable;                 /*! The color key is effective only when "enable" is ture, */
    vg_lite_uint8_t low_r;                  /*! The R chanel of low_rgb. */
    vg_lite_uint8_t low_g;                  /*! The G chanel of low_rgb. */
    vg_lite_uint8_t low_b;                  /*! The B chanel of low_rgb. */
    vg_lite_uint8_t alpha;                  /*! The alpha channel to replace destination pixel alpha channel.*/
    vg_lite_uint8_t high_r;                 /*! The R chanel of high_rgb. */
    vg_lite_uint8_t high_g;                 /*! The G chanel of high_rgb. */
    vg_lite_uint8_t high_b;                 /*! The B chanel of high_rgb. */
} vg_lite_color_key_t;

/* Four colorkey definition.
 * 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];

/* Pixel matrix values */
typedef vg_lite_float_t vg_lite_pixel_matrix_t[20];

/* HW pixel channel enable flags */
typedef struct vg_lite_pixel_channel_enable {
    vg_lite_uint8_t enable_a;               /*! Enable A channel.*/
    vg_lite_uint8_t enable_b;               /*! Enable B channel. */
    vg_lite_uint8_t enable_g;               /*! Enable G channel. */
    vg_lite_uint8_t enable_r;               /*! Enable R channel. */
} vg_lite_pixel_channel_enable_t;

/* Pixel color transform */
typedef struct vg_lite_color_transform {
    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;
} vg_lite_color_transform_t;

/* VGLite API Functions *******************************************************************************************************************/

/* Initialize a vglite context. */
vg_lite_error_t vg_lite_init(vg_lite_uint32_t tess_width, vg_lite_uint32_t tess_height);

/* Destroy a vglite context. */
vg_lite_error_t vg_lite_close(void);

/* Get the VGLite driver information. */
vg_lite_error_t vg_lite_get_info(vg_lite_info_t * info);

/* Get the GPU chip information. */
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);

/* Query if a specific feature is supported. */
vg_lite_uint32_t vg_lite_query_feature(vg_lite_feature_t feature);

/* Flush command buffer and wait for GPU to complete. */
vg_lite_error_t vg_lite_finish(void);

/* Flush the command buffer without waiting for GPU to complete. */
vg_lite_error_t vg_lite_flush(void);

/* Get the value of register from register's address. */
vg_lite_error_t vg_lite_get_register(vg_lite_uint32_t address, vg_lite_uint32_t * result);

/* Generate a 3x3 homogenous matrix to transform 4 source coordinates to 4 target coordinates. */
vg_lite_error_t vg_lite_get_transform_matrix(vg_lite_float_point4_t src, vg_lite_float_point4_t dst,
                                             vg_lite_matrix_t * mat);

/* Allocate a buffer from GPU hardware accessible memory. */
vg_lite_error_t vg_lite_allocate(vg_lite_buffer_t * buffer);

/* Free a buffer allocated by vg_lite_allocate() */
vg_lite_error_t vg_lite_free(vg_lite_buffer_t * buffer);

/* Upload RGB or YUV pixel data to an allocated 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]);

/* Map a buffer into hardware accessible address space. */
vg_lite_error_t vg_lite_map(vg_lite_buffer_t * buffer, vg_lite_map_flag_t flag, int32_t fd);

/* Unmap a buffer that is mapped */
vg_lite_error_t vg_lite_unmap(vg_lite_buffer_t * buffer);

/* flush cache */
vg_lite_error_t vg_lite_flush_mapped_buffer(vg_lite_buffer_t * buffer);

/* Fill a buffer rectangle area with a specified color. */
vg_lite_error_t vg_lite_clear(vg_lite_buffer_t * target, vg_lite_rectangle_t * rect, vg_lite_color_t color);

/* Copy a source image to target buffer with transformation, blending, color mixing, and filtering. */
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);

/* Copy a rectangle area of source image to target buffer with transformation, blending, color mixing, and filtering. */
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);

/* Copy two source images to the target buffer with transformation, blending, and filtering. */
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);

/* Copy a rectangle area of source image to target buffer without transformation, blending, color mixing, and filtering. */
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_uint32_t  width,
                                   vg_lite_uint32_t  height);

/* Draw a path to a target buffer with transformation, color, and blending */
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);

/* Set stroke path attributes. */
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);

/* Update stroke path. */
vg_lite_error_t vg_lite_update_stroke(vg_lite_path_t * path);

/* Set path type. */
vg_lite_error_t vg_lite_set_path_type(vg_lite_path_t * path, vg_lite_path_type_t path_type);

/* Clears all attributes of a path. */
vg_lite_error_t vg_lite_clear_path(vg_lite_path_t * path);

/* Upload a path to GPU memory so GPU can access it directly. */
vg_lite_error_t vg_lite_upload_path(vg_lite_path_t * path);

/* Initialize a path object with attributes. */
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);

/* Initializes a arc path with attributes. */
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);

/* Return the size (in bytes) of command buffer for a path opcode array. */
vg_lite_uint32_t vg_lite_get_path_length(vg_lite_uint8_t * opcode,
                                         vg_lite_uint32_t count,
                                         vg_lite_format_t format);

/* Generate command buffer for the (path) based on input opcodes (opcode) and coordinates (data). */
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);

/* Set CLUT (Color Look Up Table) for index image. The (colors) is in ARGB format. */
vg_lite_error_t vg_lite_set_CLUT(vg_lite_uint32_t count, vg_lite_uint32_t * colors);

/* Draw a path that is filled by a transformed image pattern. */
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);

/* Initialize a linear gradient object with default attributes. */
vg_lite_error_t vg_lite_init_grad(vg_lite_linear_gradient_t * grad);

/* Reset a linear gradient object attributes. */
vg_lite_error_t vg_lite_clear_grad(vg_lite_linear_gradient_t * grad);

/* Update a linear gradient object. */
vg_lite_error_t vg_lite_update_grad(vg_lite_linear_gradient_t * grad);

/* Return pointer to a linear gradient object's matrix. */
vg_lite_matrix_t * vg_lite_get_grad_matrix(vg_lite_linear_gradient_t * grad);

/* Set attributes for a linear gradient object. */
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);

/* Draw a path with a linear gradient object pattern. */
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);

/* Reset an extended linear gradient object attributes and free image buffer. */
vg_lite_error_t vg_lite_clear_linear_grad(vg_lite_ext_linear_gradient_t * grad);

/* Update an extended linear gradient object. */
vg_lite_error_t vg_lite_update_linear_grad(vg_lite_ext_linear_gradient_t * grad);

/* Return pointer to an extended linear gradient object's matrix. */
vg_lite_matrix_t * vg_lite_get_linear_grad_matrix(vg_lite_ext_linear_gradient_t * grad);

/* Set attributes for an extended linear gradient object. */
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);

/* Draw a path with an extended linear gradient object. */
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);

/* Reset a radial gradient object attributes and free image buffer. */
vg_lite_error_t vg_lite_clear_radial_grad(vg_lite_radial_gradient_t * grad);

/* Update a radial gradient object. */
vg_lite_error_t vg_lite_update_radial_grad(vg_lite_radial_gradient_t * grad);

/* Return pointer to a radial gradient object's matrix. */
vg_lite_matrix_t * vg_lite_get_radial_grad_matrix(vg_lite_radial_gradient_t * grad);

/* Set attributes for a radial gradient object. */
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);

/* Draw a path with a radial gradient object pattern. */
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);

/* Load an identity matrix. */
vg_lite_error_t vg_lite_identity(vg_lite_matrix_t * matrix);

/* Translate a matrix. */
vg_lite_error_t vg_lite_translate(vg_lite_float_t x, vg_lite_float_t y, vg_lite_matrix_t * matrix);

/* Scale a 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);

/* Rotate a matrix. */
vg_lite_error_t vg_lite_rotate(vg_lite_float_t degrees, vg_lite_matrix_t * matrix);

/* Set and enable a scissor rectangle for render target. */
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);

/* Set scissor rectangles on mask layer. Scissor rects are enabled/disabled by following APIs. */
vg_lite_error_t vg_lite_scissor_rects(vg_lite_buffer_t * target, vg_lite_uint32_t nums, vg_lite_rectangle_t rect[]);

/* Enable scissor rects defined on mask layer. */
vg_lite_error_t vg_lite_enable_scissor(void);

/* Disable scissor rects defined on mask layer. */
vg_lite_error_t vg_lite_disable_scissor(void);

/* Query size of available contiguous video memory. */
vg_lite_error_t vg_lite_get_mem_size(vg_lite_uint32_t * size);

/* Set global alpha value for source image */
vg_lite_error_t vg_lite_source_global_alpha(vg_lite_global_alpha_t alpha_mode, vg_lite_uint8_t alpha_value);

/* Set global alpha value for destination image. */
vg_lite_error_t vg_lite_dest_global_alpha(vg_lite_global_alpha_t alpha_mode, vg_lite_uint8_t alpha_value);

/* Set colorkey. */
vg_lite_error_t vg_lite_set_color_key(vg_lite_color_key4_t colorkey);

/* Enable dither function. Dither is OFF by default. */
vg_lite_error_t vg_lite_enable_dither(void);

/* Disable dither function. Dither is OFF by default. */
vg_lite_error_t vg_lite_disable_dither(void);

/* Set a 64-byte aligned memory buffer (physical) as VGLite tessellation buffer. */
vg_lite_error_t vg_lite_set_tess_buffer(vg_lite_uint32_t physical, vg_lite_uint32_t size);

/* Can be called before vg_lite_init() to overwrite the default VG_LITE_COMMAND_BUFFER_SIZE */
vg_lite_error_t vg_lite_set_command_buffer_size(vg_lite_uint32_t size);

/* Set a user-defined external memory buffer (physical, 64-byte aligned) as VGLite command buffer.
   It should be called after vg_lite_init(). */
vg_lite_error_t vg_lite_set_command_buffer(vg_lite_uint32_t physical, vg_lite_uint32_t size);

/* Setup a pixel transform matrix m[20] which transforms each pixel as following:
 *
 *              |a'|   |m0  m1  m2  m3  m4 | |a|
 *              |r'|   |m5  m6  m7  m8  m9 | |r|
 *              |g'| = |m10 m11 m12 m13 m14|.|g|
 *              |b'|   |m15 m16 m17 m18 m19| |b|
 *              |1 |   |0   0   0   0   1  | |1|
 *
 *  The pixel transform for A, R, G, B channel can be enabled/disabled individually with (channel) parameter.
 */
vg_lite_error_t vg_lite_set_pixel_matrix(vg_lite_pixel_matrix_t matrix, vg_lite_pixel_channel_enable_t * channel);

/* Setup 3x3 gaussian blur weight values to filter image pixels.
 *
 *  Paramters w0, w1, w2 define a 3x3 gaussian blur weight matrix as below
 *
 *                  |  w2   w1   w2 |
 *                  |  w1   w0   w1 |
 *                  |  w2   w1   w2 |
 *
 *  The sum of 9 kernel weights must be 1.0 to avoid convolution overflow ( w0 + 4*w1 + 4*w2 = 1.0 ).
 *  The 3x3 weight matrix applies to a 3x3 pixel block
 *
 *                  | pixel[i-1][j-1]     pixel[i][j-1]       pixel[i+1][j-1]|
 *                  | pixel[i-1][j]       pixel[i][j]         pixel[i+1][j]  |
 *                  | pixel[i-1][j+1]     pixel[i][j+1]       pixel[i+1][j+1]|
 *
 *  With the following dot product equation:
 *
 *     color[i][j] = w2*pixel[i-1][j-1] + w1*pixel[i][j-1] + w2*pixel[i+1][j-1]
 *                 + w1*pixel[i-1][j]   + w0*pixel[i][j]   + w1*pixel[i+1][j]
 *                 + w2*pixel[i-1][j+1] + w1*pixel[i][j+1] + w2*pixel[i+1][j+1];
 */
vg_lite_error_t vg_lite_gaussian_filter(vg_lite_float_t w0, vg_lite_float_t w1, vg_lite_float_t w2);

/*  Enable masklayer function. Masklayer is OFF by default. */
vg_lite_error_t vg_lite_enable_masklayer(void);

/*  Disable masklayer function. Masklayer is OFF by default. */
vg_lite_error_t vg_lite_disable_masklayer(void);

/* Setup a masklayer. */
vg_lite_error_t vg_lite_set_masklayer(vg_lite_buffer_t * masklayer);

/* Free a masklayer and disable mask operation. */
vg_lite_error_t vg_lite_destroy_masklayer(vg_lite_buffer_t * masklayer);

/* Create a masklayer with default format A8 and default pixel value 255. */
vg_lite_error_t vg_lite_create_masklayer(vg_lite_buffer_t * masklayer,
                                         vg_lite_uint32_t width,
                                         vg_lite_uint32_t height);

/* Set pixel values for a rectangle area in a masklayer */
vg_lite_error_t vg_lite_fill_masklayer(vg_lite_buffer_t * masklayer,
                                       vg_lite_rectangle_t * rect,
                                       vg_lite_uint8_t value);

/* Blend a rectangle area of src masklayer with dst masklayer according to (operation). */
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);

/* Render a (path) with (fill_rule), (color), (matrix) to the masklayer. */
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);

/* Set mirror orientation. */
vg_lite_error_t vg_lite_set_mirror(vg_lite_orientation_t orientation);

/* Set gamma value. */
vg_lite_error_t vg_lite_set_gamma(vg_lite_gamma_conversion_t gamma_value);

/* Enable color transformation, which is OFF by default. */
vg_lite_error_t vg_lite_enable_color_transform(void);

/* Disable color transformation, which is OFF by default. */
vg_lite_error_t vg_lite_disable_color_transform(void);

/* Set pixel color transformation scale and bias values for each pixel channel. */
vg_lite_error_t vg_lite_set_color_transform(vg_lite_color_transform_t * values);

/* Set flexa stream id. */
vg_lite_error_t vg_lite_flexa_set_stream(vg_lite_uint8_t stream_id);

/* set flexa background buffer.*/
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);

/* Enable flexa. */
vg_lite_error_t vg_lite_flexa_enable(void);

/* Disable flexa.*/
vg_lite_error_t vg_lite_flexa_disable(void);

/* Set flexa stop flag after the last frame. */
vg_lite_error_t vg_lite_flexa_stop_frame(void);

/* Dump command buffer */
vg_lite_error_t vg_lite_dump_command_buffer(void);

/* Dump vg_lite_buffer_t image to a png file. Support on Linux for now. */
vg_lite_error_t vg_lite_dump_png(const char * filename, vg_lite_buffer_t * buffer);

/* Return VGLite parameters in params[] array */
vg_lite_error_t vg_lite_get_parameter(vg_lite_param_type_t type,
                                      vg_lite_int32_t count,
                                      vg_lite_pointer params);

/* Set memory pool for different buffer allocations. By default all memory buffers are allocated from VG_LITE_MEMORY_POOL_1.
 * This API must be called before vg_lite_init() for setting VG_LITE_COMMAND_BUFFER or VG_LITE_TESSELLATION_BUFFER memory pools.
 * This API can be called anytime for VG_LITE_RENDER_BUFFER to affect the following vg_lite_allocate() calls.
 */
vg_lite_error_t vg_lite_set_memory_pool(vg_lite_buffer_type_t type, vg_lite_memory_pool_t pool);

/* Set an end flag for GPU to signal its completion of current frame.
 * This API can be called at the end of a frame, and a vg_lite_finish() is contained withen the API.
 * An interrupt will be received to indicate that GPU is idle.
 */
vg_lite_error_t vg_lite_frame_delimiter(vg_lite_frame_flag_t flag);

#endif /* VGLITE_VERSION_3_0 */

#endif /* LV_USE_VG_LITE_DRIVER */

#ifdef __cplusplus
}
#endif

#endif /* VG_LITE_H */
