libs/rt-thread
libs
/
rt-thread
4
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
rt-thread/bsp/imxrt/libraries/drivers/vglite/VGLite/vg_lite.c

10895 lines
363 KiB
C
Raw Normal View History

fix uart1 pin bug, delete and update wrong icf files, add vglite support for rt1170 in IAR environment.
2023-09-20 17:00:30 +08:00
/****************************************************************************
*
* The MIT License (MIT)
*
* Copyright 2012 - 2020 Vivante Corporation, Santa Clara, California.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* 'Software'), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sub license, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial
* portions of the Software.
*
* THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
* IN NO EVENT SHALL VIVANTE AND/OR ITS SUPPLIERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
*****************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <stddef.h>
#include <math.h>
#include "vg_lite.h"
#include "vg_lite_kernel.h"
#if !defined(VG_DRIVER_SINGLE_THREAD)
#include "vg_lite_os.h"
#endif /* not defined(VG_DRIVER_SINGLE_THREAD) */
#if (VG_RENDER_TEXT==1)
#include "vg_lite_text.h"
#endif /* VG_RENDER_TEXT */
#include "vg_lite_flat.h"
/*
* Stop IAR compiler from warning about implicit conversions from float to
* double
*/
#if (defined(__ICCARM__))
#pragma diag_suppress = Pa205
#endif
/* This is the function to call from the VGLite driver to interface with the GPU. */
vg_lite_error_t vg_lite_kernel(vg_lite_kernel_command_t command, void * data);
/*** Command buffer dump ***/
#ifndef DUMP_COMMAND
#define DUMP_COMMAND 0
#endif
#ifndef DUMP_IMAGE
#define DUMP_IMAGE 0
#else
#ifndef DUMP_COMMAND
#define DUMP_COMMAND 0
#endif
#ifndef DUMP_IMAGE
#define DUMP_IMAGE 0
#endif
#endif
#define VG_TARGET_FC_DUMP 0
/* Fast clear is not used by default,if SOC should use this ,set this macro to 1. */
#ifndef VG_TARGET_FAST_CLEAR
#define VG_TARGET_FAST_CLEAR 0
#endif /* VG_TARGET_FAST_CLEAR */
#if DUMP_COMMAND || DUMP_IMAGE
#ifdef __linux__
#include <unistd.h>
#endif
#endif
#if defined(VG_DRIVER_SINGLE_THREAD)
/*** Global Context Access ***/
#define GET_CONTEXT() &s_context
#endif /* VG_DRIVER_SINGLE_THREAD */
/*** Command buffer configurations, double buffer support ***/
#define VG_LITE_COMMAND_BUFFER_SIZE (64 << 10)
#define CMDBUF_BUFFER(context) (context).command_buffer[(context).command_buffer_current]
#define CMDBUF_INDEX(context) (context).command_buffer_current
#define CMDBUF_SIZE(context) (context).command_buffer_size
#define CMDBUF_OFFSET(context) (context).command_offset[(context).command_buffer_current]
#define CMDBUF_SWAP(context) (context).command_buffer_current = \
((context).command_buffer_current + 1) % CMDBUF_COUNT
#if !defined(VG_DRIVER_SINGLE_THREAD)
#ifndef CMDBUF_IN_QUEUE
#define CMDBUF_IN_QUEUE(context, id) \
(vg_lite_os_event_state(&(context)->async_event[(id)]) == VG_LITE_IN_QUEUE)
#endif
#define RESERVE_BYTES_IN_CMDBUF(context) \
{\
((uint32_t *) (CMDBUF_BUFFER((context)) + CMDBUF_OFFSET((context))))[0] = VG_LITE_STATE(0x0a00);\
((uint32_t *) (CMDBUF_BUFFER((context)) + CMDBUF_OFFSET((context))))[1] = 0;\
CMDBUF_OFFSET((context)) += 8;\
}
#endif /* not defined(VG_DRIVER_SINGLE_THREAD) */
#define VG_LITE_RETURN_ERROR(func) \
if ((error = func) != VG_LITE_SUCCESS) \
return error
#define VG_LITE_BREAK_ERROR(func) \
if ((error = func) != VG_LITE_SUCCESS) \
break
#define VG_LITE_ERROR_HANDLER(func) \
if ((error = func) != VG_LITE_SUCCESS) \
goto ErrorHandler
/*** Command macros ***/
#define VG_LITE_END(interrupt) (0x00000000 | interrupt)
#define VG_LITE_SEMAPHORE(id) (0x10000000 | id)
#define VG_LITE_STALL(id) (0x20000000 | id)
#define VG_LITE_STATE(address) (0x30010000 | address)
#define VG_LITE_STATES(count, address) (0x30000000 | ((count) << 16) | address)
#define VG_LITE_DATA(count) (0x40000000 | count)
#define VG_LITE_CALL(count) (0x60000000 | count)
#define VG_LITE_RETURN() (0x70000000)
#define VG_LITE_NOP() (0x80000000)
/*** Shortcuts. ***/
#define A(color) (color) >> 24
#define R(color) ((color) & 0x00ff0000) >> 16
#define G(color) ((color) & 0x0000ff00) >> 8
#define B(color) ((color) & 0xff)
#define ARGB(a, r, g, b) ((a) << 24) | ((r) << 16) | ((g) << 8 ) | (b)
#define ARGB4(a, r, g, b) (((a) & 0xf0) << 8) | (((r) & 0xf0) << 4) | (((g) & 0xf0)) | ((b) >> 4)
#define FC_BURST_BYTES 64
#define FC_BIT_TO_BYTES 64
#define MIN(a, b) ((a) > (b) ? (b) : (a))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
static uint32_t command_buffer_size = VG_LITE_COMMAND_BUFFER_SIZE;
#define FORMAT_ALIGNMENT(stride,align) \
{ \
if((stride) % (align) != 0) \
return VG_LITE_INVALID_ARGUMENT; \
return VG_LITE_SUCCESS; \
}
#define DEST_ALIGNMENT_LIMITATION 64 /* To match hardware alignment requirement */
#if !defined(VG_DRIVER_SINGLE_THREAD)
#define TS_STATE_COUNT 20 /* Initial state count for tessellation buffer. */
#endif /* not defined(VG_DRIVER_SINGLE_THREAD) */
#define MATRIX_ROWS 3
#define GET_MATRIX_VALUES(Pointer) ((float *) (Pointer))
#define MAT(Matrix, Row, Column) (GET_MATRIX_VALUES(Matrix)[Row * MATRIX_ROWS + Column])
#define COLOR_FROM_RAMP(ColorRamp) (((vg_lite_float_t *) ColorRamp) + 1)
#define CLAMP(x, min, max) (((x) < (min)) ? (min) : \
((x) > (max)) ? (max) : (x))
#define LERP(v1, v2, w) ((v1) * (w) + (v2) * (1.0f - (w)))
#define PI 3.141592653589793238462643383279502f
#define SINF(x) ((vg_lite_float_t) sin(x))
#define COSF(x) ((vg_lite_float_t) cos(x))
#define FABSF(x) ((vg_lite_float_t) fabs(x))
#define SQRTF(x) ((vg_lite_float_t) sqrt(x))
#define CLAMP(x, min, max) (((x) < (min)) ? (min) : \
((x) > (max)) ? (max) : (x))
#define ACOSF(x) ((vg_lite_float_t) acos(x))
#define FMODF(x, y) ((vg_lite_float_t) fmod((x), (y)))
#define CEILF(x) ((vg_lite_float_t) ceil(x))
#define FALSE 0
#define TURE 1
#define SIZEOF(a) \
( \
(size_t) (sizeof(a)) \
)
typedef uintptr_t UINTPTR_T;
#define PTR2SIZE(p) \
( \
(UINTPTR_T) (p) \
)
#define GETINCREMENT(pointer, datatype_size) \
(datatype_size - (PTR2SIZE(pointer) & (datatype_size - 1)))
#define SKIPTODATA(pointer, datatype_size, SIZE) \
/* Determine the increment value. */ \
increment = GETINCREMENT(pointer, datatype_size); \
/* Skip to the data. */ \
pointer += increment; \
SIZE -= increment
#define VGSL_GETVALUE(X) \
X = get_value(data_pointer); \
data_pointer += data_type_size; \
size -= data_type_size
#define VGSL_GETCOORDXY(X, Y) \
VGSL_GETVALUE(X); \
VGSL_GETVALUE(Y); \
if (is_relative) { X += ox; Y += oy; }
#define FLOAT_EPSILON 0.001f
#define SWING_NO 0
#define SWING_OUT 1
#define SWING_IN 2
/* Point curve type for generated stroke path. */
#define CURVE_LINE 0
#define CURVE_QUAD_CONTROL 1
#define CURVE_QUAD_ANCHOR 2
#define CURVE_ARC_SCCW 3
#define CURVE_ARC_SCCW_HALF 4
#define FLOAT_PI 3.141592654f
#define FLOAT_PI_TWO 6.283185307f
#define FLOAT_PI_THREE_QUARTER 2.356194490f
#define FLOAT_PI_HALF 1.570796327f
#define FLOAT_PI_QUARTER 0.7853981634f
#define FLOAT_PI_EIGHTH 0.3926990817f
/* cos(PI/8) */
#define FLOAT_COS_PI_EIGHTH 0.9238795325f
#define centerX tangentX
#define centerY tangentY
#define FLOAT_DIFF_EPSILON 0.125f
#define FLOAT_SWING_CENTER_RANGE 0.125f
#define FLOAT_ANGLE_EPSILON 0.0045f
#define FLOAT_ANGLE_EPSILON_COS 0.99999f
#define FLOAT_MIN_ARC_ANGLE 0.044f
#define FLOAT_MIN_ARC_ANGLE_COS 0.999f
/* Float constants. */
#define gcvMAX_POS_FLOAT ((vg_lite_float_t) 3.4028235e+038)
#define gcvMAX_NEG_FLOAT ((vg_lite_float_t) -3.4028235e+038)
#define FLOAT_MIN gcvMAX_NEG_FLOAT
#define FLOAT_MAX gcvMAX_POS_FLOAT
#define FLOAT_FAT_LINE_WIDTH 2.5f
/* Point flatten type for flattened line segments. */
#define vgcFLATTEN_NO 0
#define vgcFLATTEN_START 1
#define vgcFLATTEN_MIDDLE 2
#define vgcFLATTEN_END 3
/* Command size calculation shortcuts. */
#define COMMANDSIZE(CoordinateCount, CoordinateType) \
((1+CoordinateCount) * SIZEOF(CoordinateType))
#define ABS(x) (((x) < 0) ? -(x) : (x))
#define EPS 2.2204460492503131e-14
#if !defined(VG_DRIVER_SINGLE_THREAD)
/* VG:24 + TS:28 + IM:345 + PE:9 + RS:16 +Debug:2 */
#define STATES_COUNT 424
/* STATES_COUNT size + return command size */
#define CONTEXT_BUFFER_SIZE STATES_COUNT * 2 * 4 + 8
#endif /* not defined(VG_DRIVER_SINGLE_THREAD) */
#define UPDATE_BOUNDING_BOX(bbx, point) \
do { \
if ((point).x < (bbx).x) { \
(bbx).width += (bbx).x - (point).x; \
(bbx).x = (point).x; \
} \
if ((point).y < (bbx).y) { \
(bbx).height += (bbx).y - (point).y; \
(bbx).y = (point).y; \
} \
if ((point).x > (bbx).x + (bbx).width) \
(bbx).width = (point).x - (bbx).x; \
if ((point).y > (bbx).y + (bbx).height) \
(bbx).height = (point).y - (bbx).y; \
} while(0)
typedef vg_lite_float_t FLOATVECTOR4[4];
typedef struct vg_lite_ftable {
uint32_t ftable[gcFEATURE_COUNT];
uint32_t ftflag;
} vg_lite_ftable_t;
#if !defined(VG_DRIVER_SINGLE_THREAD)
typedef struct vg_lite_states {
uint32_t state;
uint8_t init;
}vg_lite_states_t;
typedef struct vg_lite_hardware {
vg_lite_states_t hw_states[STATES_COUNT];
} vg_lite_hardware_t;
static vg_lite_hardware_t hw = {0};
#endif /* not defined(VG_DRIVER_SINGLE_THREAD) */
typedef struct vg_lite_context {
vg_lite_kernel_context_t context;
vg_lite_capabilities_t capabilities;
uint8_t * command_buffer[CMDBUF_COUNT];
uint32_t command_buffer_size;
uint32_t command_offset[CMDBUF_COUNT];
uint32_t command_buffer_current;
#if !defined(VG_DRIVER_SINGLE_THREAD)
uint8_t * context_buffer[CMDBUF_COUNT];
uint32_t context_buffer_size;
uint32_t context_buffer_offset[CMDBUF_COUNT];
#endif /* not defined(VG_DRIVER_SINGLE_THREAD) */
vg_lite_tsbuffer_info_t tsbuffer;
vg_lite_buffer_t * rtbuffer; /* DDRLess: this is used as composing buffer. */
#if VG_TARGET_FAST_CLEAR
vg_lite_buffer_t fcBuffer; /* Buffer used for fast clear cache. */
uint32_t clearValue;
#endif
uint32_t scissor_enabled;
#if defined(VG_DRIVER_SINGLE_THREAD)
uint32_t scissor_dirty; /* Indicates whether scissor states are changed or not. e.g., scissors[4] or scissor_enabled. */
#endif /* VG_DRIVER_SINGLE_THREAD */
int32_t scissor[4]; /* Scissor area: x, y, width, height. */
#if !defined(VG_DRIVER_SINGLE_THREAD)
uint32_t start_offset;
uint32_t end_offset;
uint32_t ts_init; /* Indicates whether tessellation buffer states are initialized or not. */
uint32_t ts_record[TS_STATE_COUNT]; /* Tessellation buffer initial states record. */
uint32_t ts_init_used;
uint32_t ts_init_use;
uint32_t ts_dirty;
#endif /* not defined(VG_DRIVER_SINGLE_THREAD) */
uint32_t chip_id;
uint32_t chip_rev;
uint32_t premultiply_enabled;
#if defined(VG_DRIVER_SINGLE_THREAD)
uint32_t premultiply_dirty;
uint8_t init;
#else
uint32_t semaphore_id;
uint32_t * colors[4]; /* index colors. */
uint32_t clut_dirty[4]; /* clut dirty flag. */
uint32_t index_format; /* check if use index. */
uint32_t clut_used[4]; /* check if used index. */
#endif /* VG_DRIVER_SINGLE_THREAD */
vg_lite_ftable_t s_ftable;
} vg_lite_context_t;
#if !defined(VG_DRIVER_SINGLE_THREAD)
typedef struct vg_lite_tls{
/* currently just contains struct vg_lite_context_t */
vg_lite_context_t t_context;
}vg_lite_tls_t;
#endif /* not defined(VG_DRIVER_SINGLE_THREAD) */
typedef struct vg_lite_feature_database{
uint32_t chip_id;
uint32_t chip_version;
uint32_t cid;
uint32_t vg_im_index_format:1;
uint32_t vg_pe_premultiply:1;
uint32_t vg_border_culling:1;
uint32_t vg_rgba2_format:1;
uint32_t vg_quality_8x:1;
uint32_t vg_radial_gradient:1;
uint32_t vg_linear_gradient_ext:1;
uint32_t vg_dither:1;
uint32_t vg_color_key:1;
} vg_lite_feature_database_t;
static vg_lite_feature_database_t VGFeatureInfos[] = {
/* vg255 */
{
GPU_CHIP_ID_GCNanoliteV, /* ChipID */
0x1311, /* ChipRevision */
0x404, /* CID */
0x0, /* gcFEATURE_BIT_VG_IM_INDEX_FORMAT */
0x0, /* gcFEATURE_BIT_VG_PE_PREMULTIPLY */
0x1, /* gcFEATURE_BIT_VG_BORDER_CULLING */
0x1, /* gcFEATURE_BIT_VG_RGBA2_FORMAT */
0X0, /* gcFEATURE_BIT_VG_QUALITY_8X */
0X0, /* gcFEATURE_BIT_VG_RADIAL_GRADIENT */
0x0, /* gcFEATURE_BIT_VG_LINEAR_GRADIENT_EXT */
0x0, /* gcFEATURE_BIT_VG_DITHER */
0x0, /* gcFEATURE_BIT_VG_COLOR_KEY */
},
/* vg255 */
{
GPU_CHIP_ID_GCNanoliteV, /* ChipID */
0x1311, /* ChipRevision */
0x40a, /* CID */
0x1, /* gcFEATURE_BIT_VG_IM_INDEX_FORMAT */
0x0, /* gcFEATURE_BIT_VG_PE_PREMULTIPLY */
0x1, /* gcFEATURE_BIT_VG_BORDER_CULLING */
0x1, /* gcFEATURE_BIT_VG_RGBA2_FORMAT */
0X1, /* gcFEATURE_BIT_VG_QUALITY_8X */
0X0, /* gcFEATURE_BIT_VG_RADIAL_GRADIENT */
0x0, /* gcFEATURE_BIT_VG_LINEAR_GRADIENT_EXT */
0x0, /* gcFEATURE_BIT_VG_DITHER */
0x0, /* gcFEATURE_BIT_VG_COLOR_KEY */
},
/* vg255 */
{
GPU_CHIP_ID_GCNanoliteV, /* ChipID */
0x1311, /* ChipRevision */
0x40b, /* CID */
0x1, /* gcFEATURE_BIT_VG_IM_INDEX_FORMAT */
0x0, /* gcFEATURE_BIT_VG_PE_PREMULTIPLY */
0x1, /* gcFEATURE_BIT_VG_BORDER_CULLING */
0x1, /* gcFEATURE_BIT_VG_RGBA2_FORMAT */
0X1, /* gcFEATURE_BIT_VG_QUALITY_8X */
0X0, /* gcFEATURE_BIT_VG_RADIAL_GRADIENT */
0x0, /* gcFEATURE_BIT_VG_LINEAR_GRADIENT_EXT */
0x0, /* gcFEATURE_BIT_VG_DITHER */
0x0, /* gcFEATURE_BIT_VG_COLOR_KEY */
},
/* vg255 */
{
GPU_CHIP_ID_GCNanoliteV, /* ChipID */
0x1311, /* ChipRevision */
0x40d, /* CID */
0x1, /* gcFEATURE_BIT_VG_IM_INDEX_FORMAT */
0x0, /* gcFEATURE_BIT_VG_PE_PREMULTIPLY */
0x1, /* gcFEATURE_BIT_VG_BORDER_CULLING */
0x1, /* gcFEATURE_BIT_VG_RGBA2_FORMAT */
0X1, /* gcFEATURE_BIT_VG_QUALITY_8X */
0X0, /* gcFEATURE_BIT_VG_RADIAL_GRADIENT */
0x0, /* gcFEATURE_BIT_VG_LINEAR_GRADIENT_EXT */
0x0, /* gcFEATURE_BIT_VG_DITHER */
0x0, /* gcFEATURE_BIT_VG_COLOR_KEY */
},
/* vg255 */
{
GPU_CHIP_ID_GCNanoliteV, /* ChipID */
0x1322, /* ChipRevision */
0x403, /* CID */
0x1, /* gcFEATURE_BIT_VG_IM_INDEX_FORMAT */
0x0, /* gcFEATURE_BIT_VG_PE_PREMULTIPLY */
0x1, /* gcFEATURE_BIT_VG_BORDER_CULLING */
0x1, /* gcFEATURE_BIT_VG_RGBA2_FORMAT */
0X1, /* gcFEATURE_BIT_VG_QUALITY_8X */
0X0, /* gcFEATURE_BIT_VG_RADIAL_GRADIENT */
0x0, /* gcFEATURE_BIT_VG_LINEAR_GRADIENT_EXT */
0x0, /* gcFEATURE_BIT_VG_DITHER */
0x0, /* gcFEATURE_BIT_VG_COLOR_KEY */
},
/* vg355 */
{
GPU_CHIP_ID_GC355, /* ChipID */
0x1217, /* ChipRevision */
0x408, /* CID */
0x0, /* gcFEATURE_BIT_VG_IM_INDEX_FORMAT */
0x1, /* gcFEATURE_BIT_VG_PE_PREMULTIPLY */
0x0, /* gcFEATURE_BIT_VG_BORDER_CULLING */
0x0, /* gcFEATURE_BIT_VG_RGBA2_FORMAT */
0X0, /* gcFEATURE_BIT_VG_QUALITY_8X */
0X1, /* gcFEATURE_BIT_VG_RADIAL_GRADIENT */
0x1, /* gcFEATURE_BIT_VG_LINEAR_GRADIENT_EXT */
0x1, /* gcFEATURE_BIT_VG_DITHER */
0x0, /* gcFEATURE_BIT_VG_COLOR_KEY */
},
/* vg355 */
{
GPU_CHIP_ID_GC355, /* ChipID */
0x1216, /* ChipRevision */
0x0, /* CID */
0x0, /* gcFEATURE_BIT_VG_IM_INDEX_FORMAT */
0x1, /* gcFEATURE_BIT_VG_PE_PREMULTIPLY */
0x0, /* gcFEATURE_BIT_VG_BORDER_CULLING */
0x0, /* gcFEATURE_BIT_VG_RGBA2_FORMAT */
0X0, /* gcFEATURE_BIT_VG_QUALITY_8X */
0X1, /* gcFEATURE_BIT_VG_RADIAL_GRADIENT */
0x1, /* gcFEATURE_BIT_VG_LINEAR_GRADIENT_EXT */
0x1, /* gcFEATURE_BIT_VG_DITHER */
0x0, /* gcFEATURE_BIT_VG_COLOR_KEY */
},
/* vg355 */
{
GPU_CHIP_ID_GC355, /* ChipID */
0x1215, /* ChipRevision */
0x0, /* CID */
0x0, /* gcFEATURE_BIT_VG_IM_INDEX_FORMAT */
0x1, /* gcFEATURE_BIT_VG_PE_PREMULTIPLY */
0x0, /* gcFEATURE_BIT_VG_BORDER_CULLING */
0x0, /* gcFEATURE_BIT_VG_RGBA2_FORMAT */
0X0, /* gcFEATURE_BIT_VG_QUALITY_8X */
0X1, /* gcFEATURE_BIT_VG_RADIAL_GRADIENT */
0x1, /* gcFEATURE_BIT_VG_LINEAR_GRADIENT_EXT */
0x1, /* gcFEATURE_BIT_VG_DITHER */
0x1, /* gcFEATURE_BIT_VG_COLOR_KEY */
}
};
#if defined(VG_DRIVER_SINGLE_THREAD)
vg_lite_context_t s_context = {0};
#endif /* VG_DRIVER_SINGLE_THREAD */
#if DUMP_COMMAND
FILE * fp;
char filename[30];
#endif
int submit_flag = 0;
static vg_lite_float_t _GetS8_NS_NB(int8_t * Data)
{
int8_t x0 = *((int8_t *) Data);
vg_lite_float_t x = (vg_lite_float_t) x0;
return x;
}
static vg_lite_float_t _GetS16_NS_NB(int8_t * Data)
{
int16_t x0 = *((int16_t *) Data);
vg_lite_float_t x = (vg_lite_float_t) x0;
return x;
}
static vg_lite_float_t _GetS32_NS_NB(int8_t * Data)
{
int32_t x0 = *((int32_t *) Data);
vg_lite_float_t x = (vg_lite_float_t) x0;
return x;
}
static vg_lite_float_t _GetF_NS_NB(int8_t * Data)
{
vg_lite_float_t x = *((vg_lite_float_t *) Data);
return x;
}
typedef vg_lite_float_t (* vg_value_getter) (int8_t * Data);
typedef struct vg_lite_control_coord
{
vg_lite_float_t startX;
vg_lite_float_t startY;
vg_lite_float_t lastX;
vg_lite_float_t lastY;
vg_lite_float_t controlX;
vg_lite_float_t controlY;
}
vg_lite_control_coord_t;
static uint32_t _commandSize_float[] =
{
COMMANDSIZE(0, vg_lite_float_t), /* 0: END */
COMMANDSIZE(0, vg_lite_float_t), /* 1: CLOSE */
COMMANDSIZE(2, vg_lite_float_t), /* 2: MOVE */
COMMANDSIZE(2, vg_lite_float_t), /* 3: MOVE_REL */
COMMANDSIZE(2, vg_lite_float_t), /* 4: LINE */
COMMANDSIZE(2, vg_lite_float_t), /* 5: LINE_REL */
COMMANDSIZE(4, vg_lite_float_t), /* 6: QUAD */
COMMANDSIZE(4, vg_lite_float_t), /* 7: QUAD_REL */
COMMANDSIZE(6, vg_lite_float_t), /* 8: CUBIC */
COMMANDSIZE(6, vg_lite_float_t), /* 9: CUBIC_REL */
COMMANDSIZE(5, vg_lite_float_t), /* 10: SCCWARC */
COMMANDSIZE(5, vg_lite_float_t), /* 11: SCCWARC_REL */
COMMANDSIZE(5, vg_lite_float_t), /* 12: SCWARC */
COMMANDSIZE(5, vg_lite_float_t), /* 13: SCWARC_REL */
COMMANDSIZE(5, vg_lite_float_t), /* 14: LCCWARC */
COMMANDSIZE(5, vg_lite_float_t), /* 15: LCCWARC_REL */
COMMANDSIZE(5, vg_lite_float_t), /* 16: LCWARC */
COMMANDSIZE(5, vg_lite_float_t), /* 17: LCWARC_REL */
};
/* Special sqrt(1.0f + x) for quick calculation when 0 <= x <= 1. */
static vg_lite_float_t _Sqrt(
vg_lite_float_t X
)
{
vg_lite_float_t x = X;
vg_lite_float_t s = 1.0f;
s += x * 0.5f;
x *= X;
s -= x * 0.12445995211601257f;
x *= X;
s += x * 0.058032196015119553f;
x *= X;
s -= x * 0.025314478203654289f;
x *= X;
s += x * 0.0059584137052297592f;
return s;
}
static vg_lite_error_t _set_point_tangent(
vg_lite_path_point_ptr Point,
vg_lite_float_t Dx,
vg_lite_float_t Dy
)
{
if(!Point)
return VG_LITE_INVALID_ARGUMENT;
if (Dx == 0.0f)
{
if (Dy == 0.0f)
{
if (Point->prev)
{
Point->length = 0.0f;
Point->tangentX = Point->prev->tangentX;
Point->tangentY = Point->prev->tangentY;
}
else
{
Point->length = 0.0f;
Point->tangentX = 0.0f;
Point->tangentY = 0.0f;
}
}
else
{
Point->tangentX = 0.0f;
if (Dy > 0.0f)
{
Point->length = Dy;
Point->tangentY = 1.0f;
}
else
{
Point->length = -Dy;
Point->tangentY = -1.0f;
}
}
}
else if (Dy == 0.0f)
{
Point->tangentY = 0.0f;
if (Dx > 0.0f)
{
Point->length = Dx;
Point->tangentX = 1.0f;
}
else
{
Point->length = -Dx;
Point->tangentX = -1.0f;
}
}
else
{
vg_lite_float_t l, tx, ty;
vg_lite_float_t dx, dy;
vg_lite_float_t t, t2;
dx = (Dx >= 0.0f ? Dx : -Dx);
dy = (Dy >= 0.0f ? Dy : -Dy);
if (dx >= dy)
{
t = dy / dx;
t2 = t * t;
l = _Sqrt(t2);
Point->length = l * dx;
tx = 1.0f / l;
ty = tx * t;
}
else
{
t = dx / dy;
t2 = t * t;
l = _Sqrt(t2);
Point->length = l * dy;
ty = 1.0f / l;
tx = ty * t;
}
if (Dx < 0.0f) tx = -tx;
if (Dy < 0.0f) ty = -ty;
tx = CLAMP(tx, -1.0f, 1.0f);
ty = CLAMP(ty, -1.0f, 1.0f);
Point->tangentX = tx;
Point->tangentY = ty;
}
return VG_LITE_SUCCESS;
}
vg_lite_error_t _add_point_to_point_list_wdelta(
vg_lite_stroke_conversion_t * stroke_conversion,
vg_lite_float_t X,
vg_lite_float_t Y,
vg_lite_float_t DX,
vg_lite_float_t DY,
uint8_t flatten_flag
)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
vg_lite_path_point_ptr last_point;
vg_lite_path_point_ptr point;
if(!stroke_conversion)
return VG_LITE_INVALID_ARGUMENT;
last_point = stroke_conversion->path_last_point;
point = (vg_lite_path_point_ptr)vg_lite_os_malloc(sizeof(*point));
if(!point)
return VG_LITE_OUT_OF_RESOURCES;
memset(point, 0, sizeof(*point));
point->x = X;
point->y = Y;
point->flatten_flag = flatten_flag;
/* Calculate tangent for last_point. */
VG_LITE_ERROR_HANDLER(_set_point_tangent(last_point, DX, DY));
last_point->next = point;
stroke_conversion->path_last_point = point;
point->prev = last_point;
stroke_conversion->point_count++;
return error;
ErrorHandler:
vg_lite_os_free(point);
point = NULL;
return error;
}
vg_lite_error_t _add_point_to_point_list(
vg_lite_stroke_conversion_t * stroke_conversion,
vg_lite_float_t X,
vg_lite_float_t Y,
uint8_t flatten_flag
)
{
vg_lite_error_t status = VG_LITE_SUCCESS;
vg_lite_path_point_ptr last_point;
vg_lite_path_point_ptr point;
if(!stroke_conversion)
return VG_LITE_INVALID_ARGUMENT;
last_point = stroke_conversion->path_last_point;
if (last_point == NULL)
{
point = (vg_lite_path_point_ptr)vg_lite_os_malloc(sizeof(*point));
if(!point)
return VG_LITE_OUT_OF_RESOURCES;
memset(point, 0, sizeof(*point));
point->x = X;
point->y = Y;
point->flatten_flag = flatten_flag;
point->prev = NULL;
stroke_conversion->path_last_point = stroke_conversion->path_point_list = point;
stroke_conversion->point_count++;
status = VG_LITE_SUCCESS;
}
else
{
vg_lite_float_t dX = X - last_point->x;
vg_lite_float_t dY = Y - last_point->y;
vg_lite_float_t deltaX = (dX >= 0.0f ? dX : -dX);
vg_lite_float_t deltaY = (dY >= 0.0f ? dY : -dY);
/* Check for degenerated line. */
if (deltaX == 0.0f && deltaY == 0.0f)
{
/* Skip degenerated line. */
status = VG_LITE_SUCCESS;
goto ErrorHandler;
}
if (deltaX < FLOAT_EPSILON && deltaY < FLOAT_EPSILON)
{
vg_lite_float_t ratioX, ratioY;
if (deltaX == 0.0f)
{
ratioX = 0.0f;
}
else if (X == 0.0f)
{
ratioX = deltaX;
}
else
{
ratioX = deltaX / X;
if (ratioX < 0.0f) ratioX = -ratioX;
}
if (deltaY == 0.0f)
{
ratioY = 0.0f;
}
else if (Y == 0.0f)
{
ratioY = deltaY;
}
else
{
ratioY = deltaY / Y;
if (ratioY < 0.0f) ratioY = -ratioY;
}
if (ratioX < 1.0e-6f && ratioY < 1.0e-6f)
{
/* Skip degenerated line. */
status = VG_LITE_SUCCESS;
goto ErrorHandler;
}
}
status = _add_point_to_point_list_wdelta(stroke_conversion, X, Y, dX, dY, flatten_flag);
}
ErrorHandler:
return status;
}
static vg_lite_error_t _flatten_path(
vg_lite_stroke_conversion_t * stroke_conversion,
vg_lite_path_t *path
)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
uint32_t increment;
uint8_t is_relative;
uint32_t size;
uint32_t path_command;
uint32_t prev_command;
uint8_t data_type_size;
int8_t* data_pointer = NULL;
vg_lite_float_t sx, sy;
vg_lite_float_t ox, oy;
vg_lite_float_t x0, y0, x1, y1, x2, y2;
vg_value_getter get_value = NULL;
if(!stroke_conversion || !path)
return VG_LITE_INVALID_ARGUMENT;
sx = sy = ox = oy = 0.0f;
prev_command = VLC_OP_MOVE;
/* Determine the data size. */
size = path->path_length;
/* Determine the beginning of the path data. */
data_pointer = (int8_t*)path->path;
/* Select the data picker. */
switch (path->format)
{
case VG_LITE_S8:
data_type_size = 1;
get_value = _GetS8_NS_NB;
break;
case VG_LITE_S16:
data_type_size = 2;
get_value = _GetS16_NS_NB;
break;
case VG_LITE_S32:
data_type_size = 4;
get_value = _GetS32_NS_NB;
break;
case VG_LITE_FP32:
data_type_size = 4;
get_value = _GetF_NS_NB;
break;
default:
error = VG_LITE_INVALID_ARGUMENT;
goto ErrorHandler;
}
/* Add an extra gcvVGCMD_MOVE 0.0 0.0 to handle the case the first command is not gcvVGCMD_MOVE. */
if (*data_pointer != VLC_OP_MOVE)
{
/* Add first point to subpath. */
VG_LITE_ERROR_HANDLER(_add_point_to_point_list(stroke_conversion, sx, sy, vgcFLATTEN_NO));
}
while (size > 0)
{
/* Get the command. */
path_command = *data_pointer & 0x1F;
/* Assume absolute. */
is_relative = FALSE;
switch (path_command)
{
case VLC_OP_END:
/* Skip the command. */
size -= 1;
if (prev_command == VLC_OP_END)
{
/* Continuous gcvVGCMD_CLOSE - do nothing. */
break;
}
/* Check if subPath is already closed. */
if (ox != sx || oy != sy)
{
/* Add a line from current point to the first point of current subpath. */
VG_LITE_ERROR_HANDLER(_add_point_to_point_list(stroke_conversion, sx, sy,vgcFLATTEN_NO));
}
if (stroke_conversion->path_point_list != stroke_conversion->path_last_point)
{
/* Copy tangent data from first point to last_point. */
vg_lite_path_point_ptr first_point = stroke_conversion->path_point_list;
vg_lite_path_point_ptr last_point = stroke_conversion->path_last_point;
last_point->length = first_point->length;
last_point->tangentX = first_point->tangentX;
last_point->tangentY = first_point->tangentY;
}
else
{
/* Single point path. */
vg_lite_path_point_ptr point = stroke_conversion->path_point_list;
point->tangentX = 0.0f;
point->tangentY = 0.0f;
point->length = 0.0f;
}
stroke_conversion->closed = 1;
stroke_conversion->path_last_point->next = NULL;
break;
case VLC_OP_MOVE_REL:
is_relative = 1;
case VLC_OP_MOVE: /* Indicate the beginning of a new sub-path. */
/* Skip to the data. */
SKIPTODATA(data_pointer, data_type_size, size);
VGSL_GETCOORDXY(x0, y0);
/* First command is gcvVGCMD_MOVE. */
/* Add first point to subpath. */
VG_LITE_ERROR_HANDLER(_add_point_to_point_list(stroke_conversion, x0, y0, vgcFLATTEN_NO));
sx = ox = x0;
sy = oy = y0;
break;
case VLC_OP_LINE_REL:
is_relative = 1;
case VLC_OP_LINE:
/* Skip to the data. */
SKIPTODATA(data_pointer, data_type_size, size);
VGSL_GETCOORDXY(x0, y0);
/* Add a point to subpath. */
VG_LITE_ERROR_HANDLER(_add_point_to_point_list(stroke_conversion, x0, y0, vgcFLATTEN_NO));
ox = x0;
oy = y0;
break;
case VLC_OP_QUAD_REL:
is_relative = 1;
case VLC_OP_QUAD:
/* Skip to the data. */
SKIPTODATA(data_pointer, data_type_size, size);
VGSL_GETCOORDXY(x0, y0);
VGSL_GETCOORDXY(x1, y1);
if ((ox == x0 && oy == y0) && (ox == x1 && oy == y1))
{
/* Degenerated Bezier curve. Becomes a point. */
/* Discard zero-length segments. */
}
else if ((ox == x0 && oy == y0) || (x0 == x1 && y0 == y1))
{
/* Degenerated Bezier curve. Becomes a line. */
/* Add a point to subpath. */
VG_LITE_ERROR_HANDLER(_add_point_to_point_list( stroke_conversion, x1, y1, vgcFLATTEN_NO));
}
else
{
VG_LITE_ERROR_HANDLER(_flatten_quad_bezier(stroke_conversion, ox, oy, x0, y0, x1, y1));
}
ox = x1;
oy = y1;
break;
case VLC_OP_CUBIC_REL:
is_relative = 1;
case VLC_OP_CUBIC:
/* Skip to the data. */
SKIPTODATA(data_pointer, data_type_size, size);
VGSL_GETCOORDXY(x0, y0);
VGSL_GETCOORDXY(x1, y1);
VGSL_GETCOORDXY(x2, y2);
if ((ox == x0 && oy == y0) && (ox == x1 && oy == y1) && (ox == x2 && oy == y2))
{
/* Degenerated Bezier curve. Becomes a point. */
/* Discard zero-length segments. */
}
else
{
VG_LITE_ERROR_HANDLER(_flatten_cubic_bezier(stroke_conversion, ox, oy, x0, y0, x1, y1, x2, y2));
}
ox = x2;
oy = y2;
break;
default:
error = VG_LITE_INVALID_ARGUMENT;
goto ErrorHandler;
}
prev_command = path_command;
}
if ((prev_command != VLC_OP_END))
{
stroke_conversion->path_last_point->next = NULL;
if (stroke_conversion->point_count == 1)
{
/* Single point path. */
vg_lite_path_point_ptr point = stroke_conversion->path_point_list;
point->tangentX = 0.0f;
point->tangentY = 0.0f;
point->length = 0.0f;
}
}
ErrorHandler:
return error;
}
static vg_lite_error_t
_add_point_to_right_stroke_point_list_tail(
vg_lite_stroke_conversion_t * stroke_conversion,
vg_lite_float_t X,
vg_lite_float_t Y
)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
vg_lite_path_point_ptr point;
if(!stroke_conversion)
return VG_LITE_INVALID_ARGUMENT;
point = (vg_lite_path_point_ptr)vg_lite_os_malloc(sizeof(*point));
if(!point)
return VG_LITE_OUT_OF_RESOURCES;
memset(point, 0, sizeof(*point));
point->x = X;
point->y = Y;
point->curve_type = CURVE_LINE;
point->prev = stroke_conversion->last_right_stroke_point;
point->next = NULL;
stroke_conversion->last_right_stroke_point->next = point;
stroke_conversion->last_right_stroke_point = point;
stroke_conversion->stroke_point_count++;
stroke_conversion->last_stroke_sub_path->point_count++;
return error;
}
static vg_lite_error_t
_add_point_to_left_stroke_point_list_head(
vg_lite_stroke_conversion_t * stroke_conversion,
vg_lite_float_t X,
vg_lite_float_t Y
)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
vg_lite_path_point_ptr point;
if(!stroke_conversion)
return VG_LITE_INVALID_ARGUMENT;
point = (vg_lite_path_point_ptr)vg_lite_os_malloc(sizeof(*point));
if(!point)
return VG_LITE_OUT_OF_RESOURCES;
memset(point, 0, sizeof(*point));
point->x = X;
point->y = Y;
point->curve_type = CURVE_LINE;
point->next = stroke_conversion->left_stroke_point;
point->prev = NULL;
stroke_conversion->left_stroke_point->prev = point;
stroke_conversion->left_stroke_point = point;
stroke_conversion->stroke_point_count++;
stroke_conversion->last_stroke_sub_path->point_count++;
return error;
}
static vg_lite_error_t _add_stroke_sub_path(
vg_lite_stroke_conversion_t * stroke_conversion,
vg_lite_sub_path_ptr *sub_path
)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
if(!stroke_conversion || !sub_path)
return VG_LITE_INVALID_ARGUMENT;
*sub_path = (vg_lite_sub_path_ptr)vg_lite_os_malloc(sizeof(**sub_path));
if(!*sub_path)
return VG_LITE_OUT_OF_RESOURCES;
memset(*sub_path, 0, sizeof(**sub_path));
if (stroke_conversion->last_stroke_sub_path != NULL)
{
stroke_conversion->last_stroke_sub_path->next = *sub_path;
stroke_conversion->last_stroke_sub_path = *sub_path;
}
else
{
stroke_conversion->last_stroke_sub_path = stroke_conversion->stroke_sub_path_list = *sub_path;
}
return error;
}
static vg_lite_error_t
_add_zero_length_stroke_sub_path(
vg_lite_stroke_conversion_t * stroke_conversion,
vg_lite_sub_path_ptr *stroke_subpath
)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
vg_lite_path_point_ptr new_point,Point;
vg_lite_sub_path_ptr stroke_sub_path;
vg_lite_float_t half_width;
if(!stroke_conversion)
return VG_LITE_INVALID_ARGUMENT;
half_width = stroke_conversion->half_line_width;
Point = stroke_conversion->path_point_list;
if (stroke_conversion->stroke_cap_style == VG_LITE_CAP_BUTT)
{
/* No need to draw zero-length subPath for gcvCAP_BUTT. */
error = VG_LITE_SUCCESS;
goto ErrorHandler;
}
VG_LITE_ERROR_HANDLER(_add_stroke_sub_path(stroke_conversion, &stroke_sub_path));
if (stroke_conversion->stroke_cap_style == VG_LITE_CAP_SQUARE)
{
/* Draw a square along the point's direction. */
vg_lite_float_t dx, dy;
if (Point->tangentX == 0.0f || Point->tangentY == 0.0f)
{
dx = half_width;
dy = 0.0f;
}
else
{
dx = Point->tangentY * half_width;
dy = -Point->tangentX * half_width;
}
new_point = (vg_lite_path_point_ptr)vg_lite_os_malloc(sizeof(*new_point));
if(!new_point)
return VG_LITE_OUT_OF_RESOURCES;
memset(new_point, 0, sizeof(*new_point));
new_point->x = Point->x + dx + dy;
new_point->y = Point->y - dx + dy;
new_point->curve_type = CURVE_LINE;
stroke_sub_path->point_list = stroke_conversion->last_right_stroke_point = new_point;
stroke_sub_path->point_count = 1;
VG_LITE_ERROR_HANDLER(_add_point_to_right_stroke_point_list_tail(stroke_conversion,
Point->x + dx - dy, Point->y + dx + dy));
VG_LITE_ERROR_HANDLER(_add_point_to_right_stroke_point_list_tail(stroke_conversion,
Point->x - dx - dy, Point->y + dx - dy));
VG_LITE_ERROR_HANDLER(_add_point_to_right_stroke_point_list_tail(stroke_conversion,
Point->x - dx + dy, Point->y - dx - dy));
}
else
{
/* Draw a circle. */
new_point = (vg_lite_path_point_ptr)vg_lite_os_malloc(sizeof(*new_point));
if(!new_point)
return VG_LITE_OUT_OF_RESOURCES;
memset(new_point, 0, sizeof(*new_point));
new_point->x = Point->x + half_width;
new_point->y = Point->y;
new_point->curve_type = CURVE_LINE;
stroke_sub_path->point_list = stroke_conversion->last_right_stroke_point = new_point;
stroke_sub_path->point_count = 1;
/* Add upper half circle. */
VG_LITE_ERROR_HANDLER(_add_point_to_right_stroke_point_list_tail(stroke_conversion,
Point->x - half_width, Point->y));
stroke_conversion->last_right_stroke_point->curve_type = CURVE_ARC_SCCW_HALF;
stroke_conversion->last_right_stroke_point->centerX = Point->x;
stroke_conversion->last_right_stroke_point->centerY = Point->y;
/* Add lower half circle. */
VG_LITE_ERROR_HANDLER(_add_point_to_right_stroke_point_list_tail(stroke_conversion,
Point->x + half_width, Point->y));
stroke_conversion->last_right_stroke_point->curve_type = CURVE_ARC_SCCW_HALF;
stroke_conversion->last_right_stroke_point->centerX = Point->x;
stroke_conversion->last_right_stroke_point->centerY = Point->y;
}
stroke_sub_path->last_point = stroke_conversion->last_right_stroke_point;
stroke_sub_path->last_point->next = NULL;
ErrorHandler:
return error;
}
/* Special asin(x) for quick calculation when -sqrt(0.5) <= x <= sqrt(0.5). */
static vg_lite_float_t _Asin(
vg_lite_float_t X
)
{
vg_lite_float_t x = X;
vg_lite_float_t x2 = X * X;
vg_lite_float_t s = X;
x *= x2;
s += x * 0.1660510562575219f;
x *= x2;
s += x * 0.084044676143618186f;
x *= x2;
s += x * 0.0023776176698039313f;
x *= x2;
s += x * 0.10211922020091345f;
return s;
}
/* Special cos(x) for quick calculation when -PI <= x <= PI. */
static vg_lite_float_t _Cos(
vg_lite_float_t X
)
{
vg_lite_float_t x2 = X * X;
vg_lite_float_t x = x2;
vg_lite_float_t s = 1.0f;
s -= x * 0.49985163079668843f;
x *= x2;
s += x * 0.041518066216932693f;
x *= x2;
s -= x * 0.0013422997970712939f;
x *= x2;
s += x * 0.000018930111278021357f;
return s;
}
/* Special sin(x) for quick calculation when -PI <= x <= PI. */
static vg_lite_float_t _Sine(
vg_lite_float_t X
)
{
vg_lite_float_t x = X;
vg_lite_float_t x2 = X * X;
vg_lite_float_t s = X;
x *= x2;
s -= x * 0.16664527099620879f;
x *= x2;
s += x * 0.0083154803736487041f;
x *= x2;
s -= x * 0.00019344151251408578f;
x *= x2;
s += x * 0.0000021810214160988925f;
return s;
}
static vg_lite_float_t
_Angle(
vg_lite_float_t X,
vg_lite_float_t Y,
vg_lite_float_t Length
)
{
vg_lite_float_t angle;
vg_lite_float_t ux = (X >= 0.0f ? X : -X);
vg_lite_float_t uy = (Y >= 0.0f ? Y : -Y);
if (ux > uy)
{
angle = ((uy > 0.0f && ux < Length) ? _Asin(uy / Length) : 0.0f);
}
else
{
angle = ((ux > 0.0f && uy < Length) ? (FLOAT_PI_HALF - _Asin(ux / Length)) : FLOAT_PI_HALF);
}
if (X < 0.0f) angle = FLOAT_PI - angle;
if (Y < 0.0f) angle = -angle;
return angle;
}
/* The arc is always counter clockwise and less than half circle (small). */
static vg_lite_error_t
_convert_circle_arc(
vg_lite_stroke_conversion_t *stroke_conversion,
vg_lite_float_t Radius,
vg_lite_float_t CenterX,
vg_lite_float_t CenterY,
vg_lite_float_t StartX,
vg_lite_float_t StartY,
vg_lite_float_t EndX,
vg_lite_float_t EndY,
uint8_t Half_circle,
vg_lite_path_point_ptr *point_list
)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
/*gceVGCMD segmentCommand;*/
vg_lite_float_t theta1, theta_span;
uint32_t segs;
vg_lite_float_t theta, theta_half, theta2;
vg_lite_float_t cos_theta_half;
vg_lite_float_t control_ratio;
vg_lite_float_t controlX, controlY, anchorX, anchorY;
/*gctFLOAT lastX, lastY;*/
vg_lite_path_point_ptr point, start_point, last_point;
if(!stroke_conversion || !point_list)
return VG_LITE_INVALID_ARGUMENT;
/* Converting. */
theta1 = _Angle(StartX - CenterX, StartY - CenterY, Radius);
if (Half_circle)
{
theta_span = FLOAT_PI;
segs = 4;
theta = FLOAT_PI_QUARTER;
theta_half = FLOAT_PI_EIGHTH;
cos_theta_half = FLOAT_COS_PI_EIGHTH;
}
else
{
theta_span = _Angle(EndX - CenterX, EndY - CenterY, Radius) - theta1;
if (theta_span == 0.0f)
{
/* Handle specail case for huge scaling. */
*point_list = NULL;
error = VG_LITE_SUCCESS;
return error;
}
if ((theta_span < 0))
{
theta_span += FLOAT_PI_TWO;
}
/* Calculate the number of quadratic Bezier curves. */
/* Assumption: most of angles are small angles. */
if (theta_span <= FLOAT_PI_QUARTER) segs = 1;
else if (theta_span <= FLOAT_PI_HALF) segs = 2;
else if (theta_span <= FLOAT_PI_THREE_QUARTER) segs = 3;
else segs = 4;
theta = theta_span / segs;
theta_half = theta / 2.0f;
cos_theta_half = _Cos(theta_half);
}
/* Determine the segment command. */
/*egmentCommand = gcvVGCMD_ARC_QUAD;*/
/* Generate quadratic Bezier curves. */
start_point = last_point = NULL;
control_ratio = Radius / cos_theta_half;
while (segs-- > 0)
{
theta1 += theta;
theta2 = theta1 - theta_half;
if (theta2 > FLOAT_PI) theta2 -= FLOAT_PI_TWO;
controlX = CenterX + _Cos(theta2) * control_ratio;
controlY = CenterY + _Sine(theta2) * control_ratio;
theta2 = theta1;
if (theta2 > FLOAT_PI) theta2 -= FLOAT_PI_TWO;
anchorX = CenterX + _Cos(theta2) * Radius;
anchorY = CenterY + _Sine(theta2) * Radius;
if (segs == 0)
{
/* Use end point directly to avoid accumulated errors. */
anchorX = EndX;
anchorY = EndY;
}
/* Add control point. */
point = (vg_lite_path_point_ptr)vg_lite_os_malloc(sizeof(*point));
if(!point)
return VG_LITE_OUT_OF_RESOURCES;
memset(point, 0, sizeof(*point));
point->x = controlX;
point->y = controlY;
point->curve_type = CURVE_QUAD_CONTROL;
if (last_point)
{
last_point->next = point;
last_point = point;
}
else
{
start_point = last_point = point;
}
/* Add anchor point. */
point = (vg_lite_path_point_ptr)vg_lite_os_malloc(sizeof(*point));
if(!point) {
error = VG_LITE_OUT_OF_RESOURCES;
goto ErrorHandler;
}
memset(point, 0, sizeof(*point));
point->x = anchorX;
point->y = anchorY;
point->curve_type = CURVE_QUAD_ANCHOR;
last_point->next = point;
last_point = point;
}
last_point->next = NULL;
*point_list = start_point;
return error;
ErrorHandler:
/* Return status. */
while (start_point)
{
point = start_point;
start_point = start_point->next;
vg_lite_os_free(point);
}
start_point = last_point = point = NULL;
return error;
}
static vg_lite_error_t
_start_new_stroke_sub_path(
vg_lite_stroke_conversion_t * stroke_conversion,
vg_lite_float_t X,
vg_lite_float_t Y,
vg_lite_float_t Dx,
vg_lite_float_t Dy,
uint8_t add_end_cap,
vg_lite_sub_path_ptr *stroke_subpath
)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
vg_lite_sub_path_ptr stroke_sub_path;
vg_lite_path_point_ptr new_point;
if(!stroke_conversion || !stroke_subpath)
return VG_LITE_INVALID_ARGUMENT;
VG_LITE_ERROR_HANDLER(_add_stroke_sub_path(stroke_conversion, &stroke_sub_path));
new_point = (vg_lite_path_point_ptr)vg_lite_os_malloc(sizeof(*new_point));
if(!new_point)
return VG_LITE_OUT_OF_RESOURCES;
memset(new_point, 0, sizeof(*new_point));
new_point->x = X + Dx;
new_point->y = Y + Dy;
new_point->prev = NULL;
new_point->curve_type = CURVE_LINE;
stroke_conversion->stroke_point_list = stroke_conversion->last_right_stroke_point = new_point;
stroke_sub_path->point_list = stroke_conversion->last_right_stroke_point = new_point;
new_point = (vg_lite_path_point_ptr)vg_lite_os_malloc(sizeof(*new_point));
if(!new_point)
return VG_LITE_OUT_OF_RESOURCES;
memset(new_point, 0, sizeof(*new_point));
new_point->x = X - Dx;
new_point->y = Y - Dy;
new_point->curve_type = CURVE_LINE;
new_point->next = NULL;
stroke_conversion->stroke_last_point = stroke_conversion->left_stroke_point = new_point;
stroke_conversion->stroke_point_count = 2;
stroke_sub_path->last_point = stroke_conversion->left_stroke_point = new_point;
stroke_sub_path->point_count = 2;
if (add_end_cap)
{
/* Add end cap if the subPath is not closed. */
switch (stroke_conversion->stroke_cap_style)
{
case VG_LITE_CAP_BUTT:
/* No adjustment needed. */
break;
case VG_LITE_CAP_ROUND:
/* Add curve. */
/* Add the starting point again as arc. */
VG_LITE_ERROR_HANDLER(_add_point_to_right_stroke_point_list_tail(stroke_conversion,
stroke_sub_path->point_list->x, stroke_sub_path->point_list->y));
stroke_conversion->last_right_stroke_point->curve_type = CURVE_ARC_SCCW_HALF;
stroke_conversion->last_right_stroke_point->centerX = X;
stroke_conversion->last_right_stroke_point->centerY = Y;
/* Change the starting point to end point. */
stroke_sub_path->point_list->x = stroke_sub_path->last_point->x;
stroke_sub_path->point_list->y = stroke_sub_path->last_point->y;
break;
case VG_LITE_CAP_SQUARE:
stroke_conversion->last_right_stroke_point->x += Dy;
stroke_conversion->last_right_stroke_point->y -= Dx;
stroke_conversion->left_stroke_point->x += Dy;
stroke_conversion->left_stroke_point->y -= Dx;
break;
}
}
*stroke_subpath = stroke_sub_path;
ErrorHandler:
return error;
}
static void
_adjust_joint_point(
vg_lite_path_point_ptr Point,
vg_lite_path_point_ptr join_point,
vg_lite_float_t X,
vg_lite_float_t Y,
vg_lite_float_t Ratio
)
{
vg_lite_float_t mx = (join_point->x + X) / 2.0f;
vg_lite_float_t my = (join_point->y + Y) / 2.0f;
vg_lite_float_t dx = mx - Point->x;
vg_lite_float_t dy = my - Point->y;
dx = dx * Ratio;
dy = dy * Ratio;
join_point->x = Point->x + dx;
join_point->y = Point->y + dy;
}
static uint8_t
_is_angle_span_acute(
vg_lite_float_t Ux,
vg_lite_float_t Uy,
vg_lite_float_t Vx,
vg_lite_float_t Vy
)
{
return ((Ux * Vx + Uy * Vy) > 0.0f ? 1 : 0);
}
static vg_lite_error_t
_draw_swing_pie_area(
vg_lite_stroke_conversion_t *stroke_conversion,
vg_lite_path_point_ptr center_point,
uint8_t end_at_prev_point
)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
if(!stroke_conversion)
return VG_LITE_INVALID_ARGUMENT;
if (stroke_conversion->swing_counter_clockwise)
{
vg_lite_path_point_ptr start_point = stroke_conversion->swing_start_stroke_point;
vg_lite_path_point_ptr end_point = NULL, real_end_point = NULL;
vg_lite_path_point_ptr point, prev_point;
uint32_t count = 0;
{
if (end_at_prev_point)
{
/* Detach the end point from leftStrokePoint. */
/* The end point will be added back later. */
real_end_point = stroke_conversion->left_stroke_point;
stroke_conversion->left_stroke_point = real_end_point->next;
stroke_conversion->left_stroke_point->prev = NULL;
}
VG_LITE_ERROR_HANDLER(_add_point_to_left_stroke_point_list_head(stroke_conversion,
center_point->x, center_point->y));
end_point = stroke_conversion->left_stroke_point;
/* Reverse the point list from startPoint to endPoint. */
for (point = start_point; point; point = prev_point)
{
prev_point = point->prev;
point->prev = point->next;
point->next = prev_point;
count++;
}
end_point->next = start_point->prev;
start_point->prev->prev = end_point;
start_point->prev = NULL;
stroke_conversion->left_stroke_point = start_point;
VG_LITE_ERROR_HANDLER(_add_point_to_left_stroke_point_list_head(stroke_conversion,
center_point->x, center_point->y));
VG_LITE_ERROR_HANDLER(_add_point_to_left_stroke_point_list_head(stroke_conversion,
stroke_conversion->swing_start_point->x,
stroke_conversion->swing_start_point->y));
VG_LITE_ERROR_HANDLER(_add_point_to_left_stroke_point_list_head(stroke_conversion,
end_point->prev->x, end_point->prev->y));
if (end_at_prev_point)
{
real_end_point->next = stroke_conversion->left_stroke_point;
stroke_conversion->left_stroke_point->prev = real_end_point;
stroke_conversion->left_stroke_point = real_end_point;
}
}
}
else
{
vg_lite_path_point_ptr start_point = stroke_conversion->swing_start_stroke_point;
vg_lite_path_point_ptr end_point = NULL, real_end_point = NULL;
vg_lite_path_point_ptr point, next_point;
uint32_t count = 0;
{
if (end_at_prev_point)
{
/* Detach the end point from leftStrokePoint. */
/* The end point will be added back later. */
real_end_point = stroke_conversion->last_right_stroke_point;
stroke_conversion->last_right_stroke_point = real_end_point->prev;
stroke_conversion->last_right_stroke_point->next = NULL;
}
VG_LITE_ERROR_HANDLER(_add_point_to_right_stroke_point_list_tail(stroke_conversion,
center_point->x, center_point->y));
end_point = stroke_conversion->last_right_stroke_point;
/* Reverse the point list from startPoint to endPoint. */
for (point = start_point; point; point = next_point)
{
next_point = point->next;
point->next = point->prev;
point->prev = next_point;
count++;
}
end_point->prev = start_point->next;
start_point->next->next = end_point;
start_point->next = NULL;
stroke_conversion->last_right_stroke_point = start_point;
VG_LITE_ERROR_HANDLER(_add_point_to_right_stroke_point_list_tail(stroke_conversion,
center_point->x, center_point->y));
VG_LITE_ERROR_HANDLER(_add_point_to_right_stroke_point_list_tail(stroke_conversion,
stroke_conversion->swing_start_point->x,
stroke_conversion->swing_start_point->y));
VG_LITE_ERROR_HANDLER(_add_point_to_right_stroke_point_list_tail(stroke_conversion,
end_point->next->x, end_point->next->y));
if (end_at_prev_point)
{
real_end_point->prev = stroke_conversion->last_right_stroke_point;
stroke_conversion->last_right_stroke_point->next = real_end_point;
stroke_conversion->last_right_stroke_point = real_end_point;
}
}
}
stroke_conversion->swing_handling = SWING_NO;
ErrorHandler:
return error;
}
static vg_lite_error_t
_process_line_joint(
vg_lite_stroke_conversion_t * stroke_conversion,
vg_lite_path_point_ptr Point,
vg_lite_float_t Length,
vg_lite_float_t prev_length,
uint32_t Swing_handling,
vg_lite_float_t X1,
vg_lite_float_t Y1,
vg_lite_float_t X2,
vg_lite_float_t Y2
)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
vg_lite_join_style_t stroke_join_style = stroke_conversion->stroke_join_style;
vg_lite_float_t half_width = stroke_conversion->half_line_width;
vg_lite_float_t ratio;
vg_lite_float_t min_length_square;
vg_lite_float_t cos_theta;
uint8_t counter_clockwise;
uint8_t fat_line = stroke_conversion->is_fat;
uint32_t swing_handling = SWING_NO;
uint8_t handle_short_line = 0;
if(!stroke_conversion)
return VG_LITE_INVALID_ARGUMENT;
if (stroke_conversion->swing_accu_length < half_width)
{
if (stroke_conversion->swing_need_to_handle)
{
swing_handling = SWING_OUT;
}
else
{
handle_short_line = 1;
}
}
else if (stroke_conversion->stroke_path_length - stroke_conversion->swing_accu_length < half_width)
{
if (stroke_conversion->swing_need_to_handle)
{
swing_handling = SWING_IN;
}
else
{
handle_short_line = 1;
}
}
if (swing_handling != Swing_handling)
{
error = VG_LITE_INVALID_ARGUMENT;
goto ErrorHandler;
}
/* For flattened curves/arcs, the join style is always round. */
if ((Point->flatten_flag != vgcFLATTEN_NO) && fat_line)
{
stroke_join_style = VG_LITE_JOIN_ROUND;
}
/* First, determine the turn is clockwise or counter-clockwise. */
cos_theta = Point->prev->tangentX * Point->tangentX + Point->prev->tangentY * Point->tangentY;
if (cos_theta > FLOAT_ANGLE_EPSILON_COS)
{
/* Straight line or semi-straight line--no need to handle join. */
if (stroke_conversion->swing_handling !=SWING_NO)
{
/* Begin to swing to the opposite direction. */
/* Draw the swing area (pie area). */
VG_LITE_ERROR_HANDLER(_draw_swing_pie_area(stroke_conversion, Point->prev, 1));
}
/* Add the new stroke points. */
VG_LITE_ERROR_HANDLER(_add_point_to_right_stroke_point_list_tail(stroke_conversion, X1, Y1));
VG_LITE_ERROR_HANDLER(_add_point_to_left_stroke_point_list_head(stroke_conversion, X2, Y2));
if (stroke_conversion->swing_handling != SWING_NO)
{
stroke_conversion->swing_count++;
}
goto endCheck;
}
else if (cos_theta < -FLOAT_ANGLE_EPSILON_COS)
{
/* Almost 180 degree turn. */
counter_clockwise = 1;
ratio = FLOAT_MAX;
min_length_square = FLOAT_MAX;
}
else
{
vg_lite_float_t angleSign = Point->prev->tangentX * Point->tangentY - Point->prev->tangentY * Point->tangentX;
counter_clockwise = (angleSign >= 0.0f ? 1 : 0);
ratio = 2.0f / (1.0f + cos_theta);
min_length_square = half_width * half_width * (1.0f - cos_theta) / (1.0f + cos_theta) + 0.02f;
}
if (stroke_conversion->swing_handling != SWING_NO)
{
if (counter_clockwise != stroke_conversion->swing_counter_clockwise)
{
/* Swing to the opposite direction. */
/* Draw the swing area (pie area). */
VG_LITE_ERROR_HANDLER(_draw_swing_pie_area(stroke_conversion, Point->prev, 1));
}
}
if (counter_clockwise)
{
if (stroke_conversion->swing_handling != SWING_NO)
{
vg_lite_path_point_ptr prev_point = stroke_conversion->left_stroke_point->next; /* Skip the line segment movement. */
vg_lite_float_t deltaX = X2 - prev_point->x;
vg_lite_float_t deltaY = Y2 - prev_point->y;
if (_is_angle_span_acute(stroke_conversion->swing_stroke_deltax,
stroke_conversion->swing_stroke_deltay,
deltaX, deltaY))
{
/* Continue swinging. */
stroke_conversion->swing_stroke_deltax = deltaX;
stroke_conversion->swing_stroke_deltay = deltaY;
}
else
{
/* Swing to the max. */
/* Draw the swing area (pie area). */
VG_LITE_ERROR_HANDLER(_draw_swing_pie_area(stroke_conversion, Point->prev, 1));
}
}
/* Check if the miter length is too long for inner intersection. */
if (stroke_conversion->swing_handling == SWING_NO
&& ! handle_short_line
&& min_length_square <= Length * Length
&& min_length_square <= prev_length * prev_length)
{
/* Adjust leftStrokePoint to the intersection point. */
_adjust_joint_point(Point, stroke_conversion->left_stroke_point, X2, Y2, ratio);
}
else if (stroke_conversion->swing_handling == SWING_NO && Point->flatten_flag == vgcFLATTEN_NO)
{
/* Add the point to avoid incorrect sharp angle. */
VG_LITE_ERROR_HANDLER(_add_point_to_left_stroke_point_list_head(stroke_conversion, Point->x, Point->y));
/* Add the point to form a loop to avoid out-of-bound problem. */
VG_LITE_ERROR_HANDLER(_add_point_to_left_stroke_point_list_head(stroke_conversion, X2, Y2));
}
else if (stroke_conversion->swing_handling == SWING_NO && (! fat_line || Swing_handling == SWING_NO))
{
/* Flattened line segments should not have sharp angle. */
/* Add the point to form a loop to avoid out-of-bound problem. */
VG_LITE_ERROR_HANDLER(_add_point_to_left_stroke_point_list_head(stroke_conversion, X2, Y2));
}
else
{
if (stroke_conversion->swing_handling == SWING_NO)
{
vg_lite_path_point_ptr prev_point = stroke_conversion->left_stroke_point;
/* Start swing handling. */
stroke_conversion->swing_handling = Swing_handling;
stroke_conversion->swing_counter_clockwise = 1;
stroke_conversion->swing_start_point = Point;
stroke_conversion->swing_center_length = 0.0f;
stroke_conversion->swing_count= 0;
/* Save stroking path delta. */
stroke_conversion->swing_stroke_deltax = X2 - prev_point->x;
stroke_conversion->swing_stroke_deltay = Y2 - prev_point->y;
/* Add extra center point for swing out pie area. */
/* VIV: [todo] Should adjust prev_point, instead of adding new point? */
VG_LITE_ERROR_HANDLER(_add_point_to_left_stroke_point_list_head(stroke_conversion, Point->x, Point->y));
/* Add extra start stroke point for swing out pie area. */
VG_LITE_ERROR_HANDLER(_add_point_to_left_stroke_point_list_head(stroke_conversion, prev_point->x, prev_point->y));
stroke_conversion->swing_start_stroke_point = stroke_conversion->left_stroke_point;
}
#if USE_MIN_ARC_FILTER
if (cosTheta > FLOAT_MIN_ARC_ANGLE_COS)
{
/* Add a point. */
gcmERR_GOTO(_add_point_to_left_stroke_point_list_head(Context, stroke_conversion, X2, Y2));
VGSL_STAT_COUNTER_INCREASE(vgStrokeFilteredByMinArcAngleCount);
}
else
#endif
{
/* Add curve. */
/* Note that the curve will be reversed, so the direction is CW. */
/* Then, left side is in reversed order, so the direction is CCW. */
VG_LITE_ERROR_HANDLER(_add_point_to_left_stroke_point_list_head(stroke_conversion, X2, Y2));
stroke_conversion->left_stroke_point->curve_type = CURVE_ARC_SCCW;
stroke_conversion->left_stroke_point->centerX = Point->x;
stroke_conversion->left_stroke_point->centerY = Point->y;
}
stroke_conversion->swing_count++;
}
switch (stroke_join_style)
{
case VG_LITE_JOIN_ROUND:
if (cos_theta > FLOAT_MIN_ARC_ANGLE_COS)
{
/* Add a point. */
VG_LITE_ERROR_HANDLER(_add_point_to_right_stroke_point_list_tail(stroke_conversion, X1, Y1));
}
else
{
/* Add curve. */
VG_LITE_ERROR_HANDLER(_add_point_to_right_stroke_point_list_tail(stroke_conversion, X1, Y1));
stroke_conversion->last_right_stroke_point->curve_type = CURVE_ARC_SCCW;
stroke_conversion->last_right_stroke_point->centerX = Point->x;
stroke_conversion->last_right_stroke_point->centerY = Point->y;
}
break;
case VG_LITE_JOIN_MITER:
if (ratio <= stroke_conversion->stroke_miter_limit_square)
{
/* Adjust lastRightStrokePoint to the outer intersection point. */
_adjust_joint_point(Point, stroke_conversion->last_right_stroke_point, X1, Y1, ratio);
break;
}
/* Else use Bevel join style. */
case VG_LITE_JOIN_BEVEL:
VG_LITE_ERROR_HANDLER(_add_point_to_right_stroke_point_list_tail(stroke_conversion, X1, Y1));
break;
}
}
else
{
if (stroke_conversion->swing_handling != SWING_NO)
{
vg_lite_path_point_ptr prev_point = stroke_conversion->last_right_stroke_point->prev; /* Skip the line segment movement. */
vg_lite_float_t deltaX = X1 - prev_point->x;
vg_lite_float_t deltaY = Y1 - prev_point->y;
if (_is_angle_span_acute(stroke_conversion->swing_stroke_deltax,
stroke_conversion->swing_stroke_deltay,
deltaX, deltaY))
{
/* Continue swinging. */
stroke_conversion->swing_stroke_deltax = deltaX;
stroke_conversion->swing_stroke_deltay = deltaY;
}
else
{
/* Swing to the max. */
/* Draw the swing area (pie area). */
VG_LITE_ERROR_HANDLER(_draw_swing_pie_area(stroke_conversion, Point->prev, 1));
}
}
/* Check if the miter length is too long for inner intersection. */
if (stroke_conversion->swing_handling == SWING_NO
&& ! handle_short_line
&& min_length_square <= Length * Length
&& min_length_square <= prev_length * prev_length)
{
/* Adjust lastRightStrokePoint to the intersection point. */
_adjust_joint_point(Point, stroke_conversion->last_right_stroke_point, X1, Y1, ratio);
}
else if (stroke_conversion->swing_handling == SWING_NO && Point->flatten_flag == vgcFLATTEN_NO)
{
/* Add the point to avoid incorrect sharp angle. */
VG_LITE_ERROR_HANDLER(_add_point_to_right_stroke_point_list_tail(stroke_conversion, Point->x, Point->y));
/* Add the point to form a loop to avoid out-of-bound problem. */
VG_LITE_ERROR_HANDLER(_add_point_to_right_stroke_point_list_tail(stroke_conversion, X1, Y1));
}
else if (stroke_conversion->swing_handling == SWING_NO && (! fat_line || Swing_handling == SWING_NO))
{
/* Flattened line segments should not have sharp angle. */
/* Add the point to form a loop to avoid out-of-bound problem. */
VG_LITE_ERROR_HANDLER(_add_point_to_right_stroke_point_list_tail(stroke_conversion, X1, Y1));
}
else
{
if (stroke_conversion->swing_handling == SWING_NO)
{
vg_lite_path_point_ptr prev_point = stroke_conversion->last_right_stroke_point;
/* Start swing handling. */
stroke_conversion->swing_handling = Swing_handling;
stroke_conversion->swing_counter_clockwise = 0;
stroke_conversion->swing_start_point = Point;
stroke_conversion->swing_center_length = 0.0f;
stroke_conversion->swing_count= 0;
/* Save stroking path delta. */
stroke_conversion->swing_stroke_deltax = X1 - prev_point->x;
stroke_conversion->swing_stroke_deltay = Y1 - prev_point->y;
/* Add extra center point for swing out pie area. */
/* VIV: [todo] Should adjust prev_point, instead of adding new point? */
VG_LITE_ERROR_HANDLER(_add_point_to_right_stroke_point_list_tail(stroke_conversion, Point->x, Point->y));
/* Add extra start stroke point for swing out pie area. */
VG_LITE_ERROR_HANDLER(_add_point_to_right_stroke_point_list_tail(stroke_conversion, prev_point->x, prev_point->y));
stroke_conversion->swing_start_stroke_point = stroke_conversion->last_right_stroke_point;
}
if (cos_theta > FLOAT_MIN_ARC_ANGLE_COS)
{
/* Add a point. */
VG_LITE_ERROR_HANDLER(_add_point_to_right_stroke_point_list_tail(stroke_conversion, X1, Y1));
}
else
{
/* Add curve. */
/* Note that the curve will be reversed, so the direction is CCW. */
stroke_conversion->last_right_stroke_point->curve_type = CURVE_ARC_SCCW;
stroke_conversion->last_right_stroke_point->centerX = Point->x;
stroke_conversion->last_right_stroke_point->centerY = Point->y;
VG_LITE_ERROR_HANDLER(_add_point_to_right_stroke_point_list_tail(stroke_conversion, X1, Y1));
}
stroke_conversion->swing_count++;
}
switch (stroke_join_style)
{
case VG_LITE_JOIN_ROUND:
if (cos_theta > FLOAT_MIN_ARC_ANGLE_COS)
{
/* Add a point. */
VG_LITE_ERROR_HANDLER(_add_point_to_left_stroke_point_list_head(stroke_conversion, X2, Y2));
}
else
{
/* Add curve. */
stroke_conversion->left_stroke_point->curve_type = CURVE_ARC_SCCW;
stroke_conversion->left_stroke_point->centerX = Point->x;
stroke_conversion->left_stroke_point->centerY = Point->y;
VG_LITE_ERROR_HANDLER(_add_point_to_left_stroke_point_list_head(stroke_conversion, X2, Y2));
}
break;
case VG_LITE_JOIN_MITER:
if (ratio <= stroke_conversion->stroke_miter_limit_square)
{
/* Adjust leftStrokePoint to the outer intersection point. */
_adjust_joint_point(Point, stroke_conversion->left_stroke_point, X2, Y2, ratio);
break;
}
/* Else use Bevel join style. */
case VG_LITE_JOIN_BEVEL:
VG_LITE_ERROR_HANDLER(_add_point_to_left_stroke_point_list_head(stroke_conversion, X2, Y2));
break;
}
}
endCheck:
if (stroke_conversion->swing_need_to_handle)
{
stroke_conversion->swing_accu_length += Point->length;
}
if (stroke_conversion->swing_handling != SWING_NO)
{
if (Point->flatten_flag == vgcFLATTEN_END ||
(stroke_conversion->swing_handling == SWING_OUT &&
stroke_conversion->swing_accu_length > half_width))
{
/* Draw the swing area (pie area). */
VG_LITE_ERROR_HANDLER(_draw_swing_pie_area(stroke_conversion, Point, 0));
}
else
{
/* Check if center line will move too far. */
stroke_conversion->swing_center_length += Point->length;
if (stroke_conversion->swing_center_length > FLOAT_SWING_CENTER_RANGE)
{
#if USE_NEW_SWING_HANDLE_FOR_END
if (stroke_conversion->currentSubPath->length < half_width ||
Point->next->flatten_flag == vgcFLATTEN_END)
#endif
{
/* Draw the swing area (pie area). */
VG_LITE_ERROR_HANDLER(_draw_swing_pie_area(stroke_conversion, Point, 0));
}
}
}
}
ErrorHandler:
return error;
}
static vg_lite_error_t
_close_stroke_sub_path(
vg_lite_stroke_conversion_t * stroke_conversion,
vg_lite_path_point_ptr Point,
vg_lite_float_t Length,
vg_lite_float_t prev_length,
uint8_t Swing_handling,
vg_lite_path_point_ptr first_stroke_point,
vg_lite_path_point_ptr last_stroke_point
)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
if(!stroke_conversion)
return VG_LITE_INVALID_ARGUMENT;
/* Handle line joint style for the first/last point in closed path. */
VG_LITE_ERROR_HANDLER(_process_line_joint(
stroke_conversion, Point,
Length, prev_length, Swing_handling,
first_stroke_point->x, first_stroke_point->y,
last_stroke_point->x, last_stroke_point->y
));
/* Adjust the two end ponts of the first point. */
first_stroke_point->x = stroke_conversion->last_right_stroke_point->x;
first_stroke_point->y = stroke_conversion->last_right_stroke_point->y;
last_stroke_point->x = stroke_conversion->left_stroke_point->x;
last_stroke_point->y = stroke_conversion->left_stroke_point->y;
/* Concatnate right and left point lists. */
stroke_conversion->last_right_stroke_point->next = stroke_conversion->left_stroke_point;
stroke_conversion->left_stroke_point->prev = stroke_conversion->last_right_stroke_point;
/*gcmERROR_RETURN(_CheckStrokeSubPath(stroke_conversion->lastStrokeSubPath));*/
ErrorHandler:
return error;
}
static vg_lite_error_t _end_stroke_sub_path(
vg_lite_stroke_conversion_t *stroke_conversion,
vg_lite_float_t X,
vg_lite_float_t Y,
vg_lite_float_t Dx,
vg_lite_float_t Dy
)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
if(!stroke_conversion)
return VG_LITE_INVALID_ARGUMENT;
/* Add points for end of line. */
VG_LITE_RETURN_ERROR(_add_point_to_right_stroke_point_list_tail(stroke_conversion, X + Dx, Y + Dy));
VG_LITE_RETURN_ERROR(_add_point_to_left_stroke_point_list_head(stroke_conversion, X - Dx, Y - Dy));
/* Add end cap if the subPath is not closed. */
switch (stroke_conversion->stroke_cap_style)
{
case VG_LITE_CAP_BUTT:
/* No adjustment needed. */
break;
case VG_LITE_CAP_ROUND:
/* Add curve. */
stroke_conversion->left_stroke_point->curve_type = CURVE_ARC_SCCW_HALF;
stroke_conversion->left_stroke_point->centerX = X;
stroke_conversion->left_stroke_point->centerY = Y;
break;
case VG_LITE_CAP_SQUARE:
stroke_conversion->last_right_stroke_point->x -= Dy;
stroke_conversion->last_right_stroke_point->y += Dx;
stroke_conversion->left_stroke_point->x -= Dy;
stroke_conversion->left_stroke_point->y += Dx;
break;
}
/* Concatnate right and left point lists. */
stroke_conversion->last_right_stroke_point->next = stroke_conversion->left_stroke_point;
stroke_conversion->left_stroke_point->prev = stroke_conversion->last_right_stroke_point;
/*gcmERROR_RETURN(_CheckStrokeSubPath(stroke_conversion->lastStrokeSubPath));*/
return error;
}
static vg_lite_error_t _get_next_dash_length(
vg_lite_stroke_conversion_t * stroke_conversion,
uint32_t * dash_index,
vg_lite_float_t * dash_length
)
{
if(!stroke_conversion || !dash_index || !dash_length)
return VG_LITE_INVALID_ARGUMENT;
(*dash_index)++;
if (*dash_index == stroke_conversion->stroke_dash_pattern_count)
{
*dash_index = 0;
}
*dash_length = stroke_conversion->stroke_dash_pattern[*dash_index];
return VG_LITE_SUCCESS;
}
static vg_lite_error_t
_create_stroke_path(
vg_lite_stroke_conversion_t * stroke_conversion
)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
vg_lite_sub_path_ptr stroke_sub_path = NULL,first_stroke_sub_path = NULL;
vg_lite_path_point_ptr point, next_point;
vg_lite_float_t half_width;
vg_lite_float_t x, y;
vg_lite_float_t dx, dy, ux, uy;
vg_lite_float_t length, prev_length, first_length;
vg_lite_float_t dash_length;
uint32_t dash_index;
uint8_t dashing;
uint8_t add_end_cap;
uint8_t need_to_handle_swing = 1 /* (stroke_conversion->strokeCapStyle == gcvCAP_BUTT) */;
vg_lite_path_point_ptr first_right_point = NULL;
vg_lite_path_point_ptr last_left_point = NULL;
vg_lite_float_t first_dx = 0.0f, first_dy = 0.0f;
uint8_t drawing = 0;
vg_lite_float_t total_length = 0.0f;
vg_lite_float_t accu_length = 0.0f;
uint32_t swing_handling = SWING_NO;
if(!stroke_conversion)
return VG_LITE_INVALID_ARGUMENT;
half_width = stroke_conversion->half_line_width;
dashing = stroke_conversion->stroke_dash_pattern_count > 0 ? 1 : 0;
dash_index = stroke_conversion->stroke_dash_initial_index;
dash_length = stroke_conversion->stroke_dash_initial_length;
/* VIV: [todo] Need to check/debug closed stroke path. */
need_to_handle_swing = (stroke_conversion->stroke_cap_style == VG_LITE_CAP_BUTT || stroke_conversion->closed);
if (need_to_handle_swing)
{
uint8_t reallyneed_to_handle_swing = 0;
/* Calculate the total length. */
for (point = stroke_conversion->path_point_list; point; point = point->next)
{
total_length += point->length;
if (point->flatten_flag != vgcFLATTEN_NO)
{
reallyneed_to_handle_swing = 1;
}
}
stroke_conversion->stroke_path_length = total_length;
if (reallyneed_to_handle_swing)
{
swing_handling = SWING_OUT;
}
else
{
need_to_handle_swing = 0;
swing_handling = SWING_NO;
}
}
stroke_conversion->swing_need_to_handle = need_to_handle_swing;
point = stroke_conversion->path_point_list;
next_point = point->next;
if (next_point == NULL)
{
if (!dashing || ((dash_index & 0x1) == 0))
{
/* Single point (zero-length) subpath. */
/* Note that one-MOVE_TO subpaths are removed during parsing. */
VG_LITE_ERROR_HANDLER(_add_zero_length_stroke_sub_path(stroke_conversion, &stroke_sub_path));
}
goto ErrorHandler;
}
/* Adjust closed status for dashing. */
if (dashing && stroke_conversion->closed && ((dash_index & 0x1) == 1))
{
stroke_conversion->closed = FALSE;
}
/* Set add_end_cap. */
add_end_cap = dashing ? 1: (stroke_conversion->closed ? 0 : 1);
/* Process first line. */
first_length = point->length;
ux = point->tangentX;
uy = point->tangentY;
dx = uy * half_width;
dy = -ux * half_width;
if (need_to_handle_swing)
{
stroke_conversion->swing_accu_length = first_length;
}
if (dashing)
{
vg_lite_float_t delta_length;
/* Draw dashes. */
x = point->x;
y = point->y;
do
{
if ((dash_index & 0x1) == 0)
{
VG_LITE_ERROR_HANDLER(_start_new_stroke_sub_path(
stroke_conversion,
x, y,
dx, dy, add_end_cap,
&stroke_sub_path
));
drawing = 1;
add_end_cap = 1;
if (stroke_conversion->closed && (first_stroke_sub_path == NULL))
{
first_stroke_sub_path = stroke_conversion->last_stroke_sub_path;
first_right_point = stroke_conversion->last_right_stroke_point;
last_left_point = stroke_conversion->left_stroke_point;
first_dx = dx;
first_dy = dy;
}
}
delta_length = first_length - dash_length;
if (delta_length >= FLOAT_EPSILON)
{
/* Move (x, y) forward along the line by dash_length. */
x += ux * dash_length;
y += uy * dash_length;
if ((dash_index & 0x1) == 0)
{
VG_LITE_ERROR_HANDLER(_end_stroke_sub_path(
stroke_conversion,
x, y,
dx, dy
));
drawing = 0;
}
VG_LITE_ERROR_HANDLER(_get_next_dash_length(stroke_conversion, &dash_index, &dash_length));
first_length = delta_length;
}
else if (delta_length <= -FLOAT_EPSILON)
{
dash_length = -delta_length;
break;
}
else
{
if ((dash_index & 0x1) == 0)
{
VG_LITE_ERROR_HANDLER(_end_stroke_sub_path(
stroke_conversion,
next_point->x, next_point->y,
dx, dy
));
drawing = 0;
}
VG_LITE_ERROR_HANDLER(_get_next_dash_length(stroke_conversion, &dash_index, &dash_length));
first_length = 0;
break;
}
}
while (1);
}
else
{
VG_LITE_ERROR_HANDLER(_start_new_stroke_sub_path(
stroke_conversion,
point->x, point->y,
dx, dy, add_end_cap,
&stroke_sub_path
));
drawing = 1;
add_end_cap = 1;
}
/* Process the rest of lines. */
prev_length = first_length;
for (point = next_point, next_point = point->next; next_point;
point = next_point, next_point = point->next)
{
if (!dashing || ((dash_index & 0x1) == 0 && drawing))
{
/* Add points for end of line for line join process with next line. */
VG_LITE_ERROR_HANDLER(_add_point_to_right_stroke_point_list_tail(stroke_conversion,
point->x + dx, point->y + dy));
VG_LITE_ERROR_HANDLER(_add_point_to_left_stroke_point_list_head(stroke_conversion,
point->x - dx, point->y - dy));
}
length = point->length;
ux = point->tangentX;
uy = point->tangentY;
dx = uy * half_width;
dy = -ux * half_width;
if (need_to_handle_swing)
{
accu_length += point->prev->length;
stroke_conversion->swing_accu_length = accu_length;
if (accu_length < half_width)
{
swing_handling = SWING_OUT;
}
else if (total_length - accu_length < half_width)
{
swing_handling = SWING_IN;
}
else
{
swing_handling = SWING_NO;
}
}
if (!dashing)
{
/* Handle line joint style. */
VG_LITE_ERROR_HANDLER(_process_line_joint(
stroke_conversion, point,
length, prev_length, swing_handling,
point->x + dx, point->y + dy,
point->x - dx, point->y - dy
));
}
else
{
vg_lite_float_t delta_length;
/* Draw dashes. */
x = point->x;
y = point->y;
if ((dash_index & 0x1) == 0)
{
if (drawing)
{
/* Handle line joint style. */
VG_LITE_ERROR_HANDLER(_process_line_joint(
stroke_conversion, point,
dash_length, prev_length, swing_handling,
x + dx, y + dy,
x - dx, y - dy
));
}
else
{
/* Start a new sub path. */
VG_LITE_ERROR_HANDLER(_start_new_stroke_sub_path(
stroke_conversion,
x, y,
dx, dy, add_end_cap,
&stroke_sub_path
));
drawing = 1;
add_end_cap = 1;
}
}
do
{
delta_length = length - dash_length;
if (delta_length >= FLOAT_EPSILON)
{
/* Move (x, y) forward along the line by dash_length. */
x += ux * dash_length;
y += uy * dash_length;
if ((dash_index & 0x1) == 0)
{
VG_LITE_ERROR_HANDLER(_end_stroke_sub_path(
stroke_conversion,
x, y, dx, dy
));
drawing = 0;
}
VG_LITE_ERROR_HANDLER(_get_next_dash_length(stroke_conversion, &dash_index, &dash_length));
length = delta_length;
}
else if (delta_length <= -FLOAT_EPSILON)
{
dash_length = -delta_length;
break;
}
else
{
if ((dash_index & 0x1) == 0)
{
VG_LITE_ERROR_HANDLER(_end_stroke_sub_path(
stroke_conversion,
next_point->x, next_point->y,
dx, dy
));
drawing = 0;
}
VG_LITE_ERROR_HANDLER(_get_next_dash_length(stroke_conversion, &dash_index, &dash_length));
length = 0;
break;
}
if ((dash_index & 0x1) == 0)
{
VG_LITE_ERROR_HANDLER(_start_new_stroke_sub_path(
stroke_conversion,
x, y,
dx, dy, add_end_cap,
&stroke_sub_path
));
drawing = 1;
add_end_cap = 1;
}
}
while (1);
}
prev_length = length;
}
if (need_to_handle_swing)
{
accu_length += point->prev->length;
stroke_conversion->swing_accu_length = accu_length;
if (accu_length < half_width)
{
swing_handling = SWING_OUT;
}
else if (total_length - accu_length < half_width)
{
swing_handling = SWING_IN;
}
else
{
swing_handling = SWING_NO;
}
}
if (stroke_conversion->swing_handling != SWING_NO)
{
/* Draw the swing area (pie area). */
VG_LITE_ERROR_HANDLER(_draw_swing_pie_area(stroke_conversion, stroke_conversion->path_last_point, FALSE));
}
if (stroke_conversion->closed)
{
if (! dashing || drawing)
{
/* Add points for end of line. */
VG_LITE_ERROR_HANDLER(_add_point_to_right_stroke_point_list_tail(stroke_conversion,
point->x + dx, point->y + dy));
VG_LITE_ERROR_HANDLER(_add_point_to_left_stroke_point_list_head(stroke_conversion,
point->x - dx, point->y - dy));
if (! dashing)
{
/* Handle line joint style for the first/last point in closed path. */
VG_LITE_ERROR_HANDLER(_close_stroke_sub_path(
stroke_conversion, point,
first_length, prev_length, swing_handling,
stroke_sub_path->point_list, stroke_sub_path->last_point
));
}
else
{
/* Handle line joint style for the first/last point in closed path. */
VG_LITE_ERROR_HANDLER(_close_stroke_sub_path(
stroke_conversion, point,
first_length, prev_length, swing_handling,
first_right_point, last_left_point
));
}
}
else if (stroke_conversion->stroke_cap_style != VG_LITE_CAP_BUTT)
{
/* No closing join need. Add end cap for the starting point. */
if (stroke_conversion->stroke_cap_style == VG_LITE_CAP_SQUARE)
{
first_right_point->x += first_dy;
first_right_point->y -= first_dx;
last_left_point->x += first_dy;
last_left_point->y -= first_dx;
}
else
{
vg_lite_sub_path_ptr last_stroke_sub_path = stroke_conversion->last_stroke_sub_path;
vg_lite_path_point_ptr start_point = last_stroke_sub_path->point_list;
vg_lite_path_point_ptr point;
/* Add curve. */
/* Add extra point to the beginning with end point's coordinates. */
point = (vg_lite_path_point_ptr)vg_lite_os_malloc(sizeof(*point));
if(!point)
return VG_LITE_INVALID_ARGUMENT;
memset(point, 0, sizeof(*point));
point->x = last_stroke_sub_path->last_point->x;
point->y = last_stroke_sub_path->last_point->y;
point->next = start_point;
start_point->prev = point;
start_point->curve_type = CURVE_ARC_SCCW;
start_point->centerX = stroke_conversion->path_point_list->x;
start_point->centerY = stroke_conversion->path_point_list->y;
last_stroke_sub_path->point_list = point;
}
}
}
else if (! dashing ||
(((dash_index & 0x1) == 0) && (dash_length < stroke_conversion->stroke_dash_pattern[dash_index])))
{
/* Add end cap if the subPath is not closed. */
VG_LITE_ERROR_HANDLER(_end_stroke_sub_path(
stroke_conversion,
point->x, point->y,
dx, dy
));
drawing = 0;
}
ErrorHandler:
return error;
}
static vg_lite_error_t _copy_stroke_path(
vg_lite_stroke_conversion_t * stroke_conversion,
vg_lite_path_t *path
)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
vg_lite_path_point_ptr point,prev_point,tmp_point;
uint32_t totalsize = 0,real_size = 0;
float *pfloat;
char *cpath = NULL;
char last_opcode = 0;
void *temp_stroke_path_data = NULL;
uint32_t temp_stroke_path_size;
vg_lite_sub_path_ptr sub_path;
vg_lite_float_t half_width;
if(!stroke_conversion || !path)
return VG_LITE_INVALID_ARGUMENT;
half_width = stroke_conversion->half_line_width;
sub_path = stroke_conversion->stroke_sub_path_list;
if(!stroke_conversion || !path || !sub_path)
return VG_LITE_INVALID_ARGUMENT;
while (sub_path)
{
tmp_point = prev_point = point = sub_path->point_list;
totalsize += _commandSize_float[VLC_OP_LINE] * sub_path->point_count + _commandSize_float[VLC_OP_CLOSE];
for(;tmp_point;tmp_point = tmp_point->next)
{
if(tmp_point->curve_type == CURVE_ARC_SCCW || tmp_point->curve_type == CURVE_ARC_SCCW_HALF) {
totalsize += 4 * _commandSize_float[VLC_OP_QUAD];
}
}
temp_stroke_path_data = path->stroke_path_data;
temp_stroke_path_size = path->stroke_path_size;
path->stroke_path_size += totalsize;
if(path->stroke_path_size == 0) {
error = VG_LITE_INVALID_ARGUMENT;
goto ErrorHandler;
}
path->stroke_path_data = (void *)vg_lite_os_malloc(path->stroke_path_size);
if(!path->stroke_path_data) {
error = VG_LITE_OUT_OF_RESOURCES;
goto ErrorHandler;
}
memset(path->stroke_path_data, 0, path->stroke_path_size);
if(temp_stroke_path_data) {
memcpy(path->stroke_path_data,temp_stroke_path_data,temp_stroke_path_size);
vg_lite_os_free(temp_stroke_path_data);
temp_stroke_path_data = NULL;
}
pfloat = (vg_lite_float_t *)((char *)path->stroke_path_data + temp_stroke_path_size);
if(last_opcode == VLC_OP_CLOSE) {
cpath = (char *)(pfloat - 1) + 1;
*cpath++ = VLC_OP_MOVE;
cpath = (char *)pfloat;
}
else {
cpath = (char *)pfloat;
*cpath = VLC_OP_MOVE;
pfloat++;
}
*pfloat++ = point->x;
*pfloat++ = point->y;
real_size += _commandSize_float[VLC_OP_MOVE];
if(last_opcode == VLC_OP_CLOSE)
real_size -= 4;
for (point = point->next; point; prev_point = point, point = point->next)
{
if (point->curve_type == CURVE_LINE)
{
if (point->x == prev_point->x && point->y == prev_point->y)
{
path->stroke_path_size -= _commandSize_float[VLC_OP_LINE];
/* Skip zero-length lines. */
continue;
}
/* Add new command. */
cpath = (char *)pfloat;
*cpath = VLC_OP_LINE;
pfloat++;
/* Set the coordinates. */
*pfloat++ = point->x;
*pfloat++ = point->y;
real_size += _commandSize_float[VLC_OP_LINE];
}
else if (point->curve_type == CURVE_QUAD_CONTROL)
{
/* Add new command. */
cpath = (char *)pfloat;
*cpath = VLC_OP_QUAD;
pfloat++;
/* Set the coordinates. */
prev_point = point, point = point->next;
*pfloat++ = prev_point->x;
*pfloat++ = prev_point->y;
*pfloat++ = point->x;
*pfloat++ = point->y;
real_size += _commandSize_float[VLC_OP_QUAD];
}
else
{
vg_lite_path_point_ptr point_list, p, nextP;
vg_lite_path_point_ptr p2;
if (point->curve_type == CURVE_ARC_SCCW)
{
/* Convert an arc to Bezier curves. */
VG_LITE_ERROR_HANDLER(_convert_circle_arc(stroke_conversion, half_width,
point->centerX, point->centerY,
prev_point->x, prev_point->y,
point->x, point->y,
0, &point_list));
}
else
{
/* Convert a half circle to Bezier curves. */
VG_LITE_ERROR_HANDLER(_convert_circle_arc(stroke_conversion, half_width,
point->centerX, point->centerY,
prev_point->x, prev_point->y,
point->x, point->y,
1, &point_list));
}
if (point_list)
{
for (p = point_list; p; p = nextP)
{
/* Add new command. */
cpath = (char *)pfloat;
*cpath = VLC_OP_QUAD;
pfloat++;
/* Set the coordinates. */
p2 = p->next;
nextP = p2->next;
*pfloat++ = p->x;
*pfloat++ = p->y;
*pfloat++ = p2->x;
*pfloat++ = p2->y;
real_size += _commandSize_float[VLC_OP_QUAD];
vg_lite_os_free(p);
vg_lite_os_free(p2);
}
}
else
{
/* Handle special case of huge scaling. */
/* Add new command. */
cpath = (char *)pfloat;
*cpath = VLC_OP_LINE;
pfloat++;
/* Set the coordinates. */
*pfloat++ = point->x;
*pfloat++ = point->y;
real_size += _commandSize_float[VLC_OP_LINE];
}
}
}
/* Create a CLOSE_PATH command at the end. */
cpath = (char *)pfloat;
if(sub_path->next)
*cpath = VLC_OP_CLOSE;
else
*cpath = VLC_OP_END;
real_size += _commandSize_float[VLC_OP_CLOSE];
path->stroke_path_size = temp_stroke_path_size + real_size;
totalsize = 0;
real_size = 0;
sub_path = sub_path->next;
last_opcode = *cpath;
}
ErrorHandler:
if(temp_stroke_path_data) {
vg_lite_os_free(temp_stroke_path_data);
temp_stroke_path_data = NULL;
}
return error;
}
static vg_lite_error_t _initialize_stroke_dash_parameters(
vg_lite_stroke_conversion_t * stroke_conversion
)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
uint32_t count;
uint32_t i;
vg_lite_float_t *pattern_src;
vg_lite_float_t *pattern,*temp_pattern;
vg_lite_float_t length;
if(!stroke_conversion)
return VG_LITE_INVALID_ARGUMENT;
count = stroke_conversion->stroke_dash_pattern_count;
if (count == 0 || !stroke_conversion->stroke_dash_pattern)
return error;
length = stroke_conversion->stroke_dash_phase;
/* The last pattern is ignored if the number is odd. */
if (count & 0x1) count--;
pattern = (vg_lite_float_t *)vg_lite_os_malloc(count * sizeof(vg_lite_float_t));
if(!pattern)
return VG_LITE_OUT_OF_RESOURCES;
temp_pattern = pattern;
stroke_conversion->stroke_dash_pattern_length = 0.0f;
pattern_src = stroke_conversion->stroke_dash_pattern;
for (i = 0; i < count; i++, pattern++, pattern_src++)
{
if (*pattern_src < 0.0f)
{
*pattern = 0.0f;
}
else
{
*pattern = *pattern_src;
}
stroke_conversion->stroke_dash_pattern_length += *pattern;
}
if (stroke_conversion->stroke_dash_pattern_length < FLOAT_EPSILON)
{
stroke_conversion->stroke_dash_pattern_count = 0;
vg_lite_os_free(temp_pattern);
temp_pattern = NULL;
return error;
}
while (length < 0.0f)
{
length += stroke_conversion->stroke_dash_pattern_length;
}
while (length >= stroke_conversion->stroke_dash_pattern_length)
{
length -= stroke_conversion->stroke_dash_pattern_length;
}
pattern = stroke_conversion->stroke_dash_pattern;
for (i = 0; i < stroke_conversion->stroke_dash_pattern_count; i++, pattern++)
{
if (length <= *pattern) break;
length -= *pattern;
}
stroke_conversion->stroke_dash_initial_index = i;
stroke_conversion->stroke_dash_initial_length = *pattern - length;
vg_lite_os_free(temp_pattern);
temp_pattern = NULL;
return error;
}
vg_lite_error_t vg_lite_update_stroke(
vg_lite_path_t *path
)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
vg_lite_stroke_conversion_t * stroke_conversion;
if(!path)
return VG_LITE_INVALID_ARGUMENT;
if(!path->path_length)
return VG_LITE_SUCCESS;
if(!path->path)
return VG_LITE_INVALID_ARGUMENT;
if (!path->stroke_conversion)
return VG_LITE_INVALID_ARGUMENT;
stroke_conversion = path->stroke_conversion;
/* Free the stroke. */
if (path->stroke_path_data)
{
vg_lite_os_free(path->stroke_path_data);
/* Reset the stroke. */
path->stroke_path_data = NULL;
}
if (stroke_conversion->stroke_line_width >= FLOAT_FAT_LINE_WIDTH
&& stroke_conversion->stroke_line_width >= 1.0f)
{
stroke_conversion->is_fat = 1;
}
VG_LITE_RETURN_ERROR(_initialize_stroke_dash_parameters(stroke_conversion));
VG_LITE_RETURN_ERROR(_flatten_path(stroke_conversion, path));
VG_LITE_RETURN_ERROR(_create_stroke_path(stroke_conversion));
VG_LITE_RETURN_ERROR(_copy_stroke_path(stroke_conversion, path));
return error;
}
vg_lite_error_t vg_lite_set_stroke(
vg_lite_path_t *path,
vg_lite_cap_style_t stroke_cap_style,
vg_lite_join_style_t stroke_join_style,
vg_lite_float_t stroke_line_width,
vg_lite_float_t stroke_miter_limit,
vg_lite_float_t *stroke_dash_pattern,
uint32_t stroke_dash_pattern_count,
vg_lite_float_t stroke_dash_phase,
vg_lite_color_t stroke_color
)
{
if(!path || stroke_line_width <= 0)
return VG_LITE_INVALID_ARGUMENT;
if(stroke_miter_limit < 1.0f)
stroke_miter_limit = 1.0f;
if (!path->stroke_conversion) {
path->stroke_conversion = (vg_lite_stroke_conversion_t *)vg_lite_os_malloc(sizeof(vg_lite_stroke_conversion_t));
if (!path->stroke_conversion)
return VG_LITE_OUT_OF_RESOURCES;
memset(path->stroke_conversion, 0, sizeof(vg_lite_stroke_conversion_t));
}
path->stroke_conversion->stroke_cap_style = stroke_cap_style;
path->stroke_conversion->stroke_join_style = stroke_join_style;
path->stroke_conversion->stroke_line_width = stroke_line_width;
path->stroke_conversion->stroke_miter_limit = stroke_miter_limit;
path->stroke_conversion->half_line_width = stroke_line_width / 2.0f;
path->stroke_conversion->stroke_miter_limit_square = path->stroke_conversion->stroke_miter_limit * path->stroke_conversion->stroke_miter_limit;
path->stroke_conversion->stroke_dash_pattern = stroke_dash_pattern;
path->stroke_conversion->stroke_dash_pattern_count = stroke_dash_pattern_count;
path->stroke_conversion->stroke_dash_phase = stroke_dash_phase;
path->stroke_color = stroke_color;
return VG_LITE_SUCCESS;
}
static inline vg_lite_error_t transform_bounding_box(vg_lite_rectangle_t *in_bbx,
vg_lite_matrix_t *matrix,
vg_lite_rectangle_t *clip,
vg_lite_rectangle_t *out_bbx,
vg_lite_point_t *origin);
#if (VG_BLIT_WORKAROUND == 1)
/*
* Calculates the minimal possible target buffer starting from a given target
* buffer and considering a source texture (to blit), graphic transformations
* and clipping window.
*/
static vg_lite_error_t config_new_target(vg_lite_buffer_t *target,
vg_lite_buffer_t *source,
vg_lite_matrix_t *matrix,
vg_lite_rectangle_t *clip,
vg_lite_buffer_t *new_target);
#endif /* VG_BLIT_WORKAROUND */
static vg_lite_error_t swap(float *a,float *b)
{
float temp;
if(a == NULL || b == NULL)
return VG_LITE_INVALID_ARGUMENT;
temp = *a;
*a = *b;
*b = temp;
return VG_LITE_SUCCESS;
}
static vg_lite_float_t _angle(
vg_lite_float_t Ux,
vg_lite_float_t Uy,
vg_lite_float_t Vx,
vg_lite_float_t Vy
)
{
vg_lite_float_t dot, length, angle, cosVal;
int32_t sign;
dot = Ux * Vx + Uy * Vy;
length = SQRTF(Ux * Ux + Uy * Uy) * SQRTF(Vx * Vx + Vy * Vy);
sign = (Ux * Vy - Uy * Vx < 0) ? -1 : 1;
cosVal = dot / length;
cosVal = CLAMP(cosVal, -1.0f, 1.0f);
angle = sign * ACOSF(cosVal);
return angle;
}
/*!
@discussion
Convert arc to multi-segment bezier curve.
@param HorRadius
Major axis radius.
@param VerRadius
minor axis radius.
@param RotAngle
Rotation angle.
@param EndX
End coordinate x.
@param EndX
End coordinate y.
@param CounterClockwise
If this is 0,anticlockwise rotation,if this is 1,clockwise rotation.
@param Large
1 means big arc,0 means little arc.
@param Relative
1 means absolute coordinates,0 means relative coordinates.
@param coords
Including the start point coordinates of the path,the control point of the last segment of the path,
and the end point of the last segment of the path.
@param path_data
Path data usr for internal conversion.
@param offset
The offset of path_data.
@param last_size
The remain unconverted size of the original path data.
@result
Error code. VG_LITE_INVALID_ARGUMENTS to indicate the parameters are wrong.
*/
vg_lite_error_t _convert_arc(
vg_lite_float_t HorRadius,
vg_lite_float_t VerRadius,
vg_lite_float_t RotAngle,
vg_lite_float_t EndX,
vg_lite_float_t EndY,
uint8_t CounterClockwise,
uint8_t Large,
uint8_t Relative,
vg_lite_control_coord_t* coords,
void ** path_data,
uint32_t *offset,
uint32_t last_size
)
{
vg_lite_float_t endX, endY;
uint8_t segmentCommand;
vg_lite_float_t phi, cosPhi, sinPhi;
vg_lite_float_t dxHalf, dyHalf;
vg_lite_float_t x1Prime, y1Prime;
vg_lite_float_t rx, ry;
vg_lite_float_t x1PrimeSquare, y1PrimeSquare;
vg_lite_float_t lambda;
vg_lite_float_t rxSquare, rySquare;
int32_t sign;
vg_lite_float_t sq, signedSq;
vg_lite_float_t cxPrime, cyPrime;
vg_lite_float_t theta1, thetaSpan;
int32_t segs;
vg_lite_float_t theta, ax, ay, x, y;
vg_lite_float_t controlX, controlY, anchorX, anchorY;
vg_lite_float_t lastX, lastY;
uint32_t bufferSize;
char *pchar, *arcPath;
vg_lite_float_t *pfloat;
/*******************************************************************
** Converting.
*/
if(path_data == NULL || *path_data == NULL || offset == NULL || coords == NULL)
return VG_LITE_INVALID_ARGUMENT;
if (Relative)
{
endX = EndX + coords->lastX;
endY = EndY + coords->lastY;
}
else
{
endX = EndX;
endY = EndY;
}
phi = RotAngle / 180.0f * PI;
cosPhi = COSF(phi);
sinPhi = SINF(phi);
if (Relative)
{
dxHalf = - EndX / 2.0f;
dyHalf = - EndY / 2.0f;
}
else
{
dxHalf = (coords->lastX - endX) / 2.0f;
dyHalf = (coords->lastY - endY) / 2.0f;
}
x1Prime = cosPhi * dxHalf + sinPhi * dyHalf;
y1Prime = -sinPhi * dxHalf + cosPhi * dyHalf;
rx = FABSF(HorRadius);
ry = FABSF(VerRadius);
x1PrimeSquare = x1Prime * x1Prime;
y1PrimeSquare = y1Prime * y1Prime;
lambda = x1PrimeSquare / (rx * rx) + y1PrimeSquare / (ry * ry);
if (lambda > 1.0f)
{
rx *= SQRTF(lambda);
ry *= SQRTF(lambda);
}
rxSquare = rx * rx;
rySquare = ry * ry;
sign = (Large == CounterClockwise) ? -1 : 1;
sq = ( rxSquare * rySquare
- rxSquare * y1PrimeSquare
- rySquare * x1PrimeSquare
)
/
( rxSquare * y1PrimeSquare
+ rySquare * x1PrimeSquare
);
signedSq = sign * ((sq < 0) ? 0 : SQRTF(sq));
cxPrime = signedSq * (rx * y1Prime / ry);
cyPrime = signedSq * -(ry * x1Prime / rx);
theta1 = _angle(1, 0, (x1Prime - cxPrime) / rx, (y1Prime - cyPrime) / ry);
theta1 = FMODF(theta1, 2 * PI);
thetaSpan = _angle(( x1Prime - cxPrime) / rx, ( y1Prime - cyPrime) / ry,
(-x1Prime - cxPrime) / rx, (-y1Prime - cyPrime) / ry);
if (!CounterClockwise && (thetaSpan > 0))
{
thetaSpan -= 2 * PI;
}
else if (CounterClockwise && (thetaSpan < 0))
{
thetaSpan += 2 * PI;
}
thetaSpan = FMODF(thetaSpan, 2 * PI);
/*******************************************************************
** Drawing.
*/
segs = (int32_t) (CEILF(FABSF(thetaSpan) / (45.0f / 180.0f * PI)));
theta = thetaSpan / segs;
ax = coords->lastX - COSF(theta1) * rx;
ay = coords->lastY - SINF(theta1) * ry;
/* Determine the segment command. */
segmentCommand = Relative
? VLC_OP_QUAD_REL
: VLC_OP_QUAD;
/* Determine the size of the buffer required. */
bufferSize = (1 + 2 * 2) * SIZEOF(vg_lite_float_t) * segs;
arcPath = (char *)vg_lite_os_malloc(*offset + bufferSize + last_size);
if (arcPath == NULL)
return VG_LITE_OUT_OF_MEMORY;
memset(arcPath, 0, *offset + bufferSize + last_size);
memcpy(arcPath,(char *)*path_data,*offset);
vg_lite_os_free(*path_data);
*path_data = arcPath;
pchar = arcPath + *offset;
pfloat = (vg_lite_float_t *)pchar;
/* Set initial last point. */
lastX = coords->lastX;
lastY = coords->lastY;
while (segs-- > 0)
{
theta1 += theta;
controlX = ax + COSF(theta1 - (theta / 2.0f)) * rx / COSF(theta / 2.0f);
controlY = ay + SINF(theta1 - (theta / 2.0f)) * ry / COSF(theta / 2.0f);
anchorX = ax + COSF(theta1) * rx;
anchorY = ay + SINF(theta1) * ry;
if (RotAngle != 0)
{
x = coords->lastX + cosPhi * (controlX - coords->lastX) - sinPhi * (controlY - coords->lastY);
y = coords->lastY + sinPhi * (controlX - coords->lastX) + cosPhi * (controlY - coords->lastY);
controlX = x;
controlY = y;
x = coords->lastX + cosPhi * (anchorX - coords->lastX) - sinPhi * (anchorY - coords->lastY);
y = coords->lastY + sinPhi * (anchorX - coords->lastX) + cosPhi * (anchorY - coords->lastY);
anchorX = x;
anchorY = y;
}
if (segs == 0)
{
/* Use end point directly to avoid accumulated errors. */
anchorX = endX;
anchorY = endY;
}
/* Adjust relative coordinates. */
if (Relative)
{
vg_lite_float_t nextLastX = anchorX;
vg_lite_float_t nextLastY = anchorY;
controlX -= lastX;
controlY -= lastY;
anchorX -= lastX;
anchorY -= lastY;
lastX = nextLastX;
lastY = nextLastY;
}
pchar = (char*)pfloat;
*pchar = segmentCommand ;
pfloat++;
*pfloat++ = controlX;
*pfloat++ = controlY;
*pfloat++ = anchorX;
*pfloat++ = anchorY;
*offset += (1 + 2 * 2) * SIZEOF(vg_lite_float_t);
}
/* Update the control coordinates. */
coords->lastX = endX;
coords->lastY = endY;
coords->controlX = endX;
coords->controlY = endY;
return VG_LITE_SUCCESS;
}
vg_lite_error_t _allocate_command_buffer(uint32_t size)
{
vg_lite_kernel_allocate_t allocate;
vg_lite_error_t error = VG_LITE_SUCCESS;
#if defined(VG_DRIVER_SINGLE_THREAD)
vg_lite_context_t *ctx = &s_context;
#else
vg_lite_context_t *ctx;
vg_lite_tls_t *tls;
tls = (vg_lite_tls_t *) vg_lite_os_get_tls();
if(tls == NULL)
return VG_LITE_NO_CONTEXT;
ctx = &tls->t_context;
#endif
if(size == 0)
return VG_LITE_SUCCESS;
allocate.bytes = size;
allocate.contiguous = 1;
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_ALLOCATE, &allocate));
ctx->context.command_buffer[0] = allocate.memory_handle;
ctx->context.command_buffer_logical[0] = allocate.memory;
ctx->context.command_buffer_physical[0] = allocate.memory_gpu;
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_ALLOCATE, &allocate));
ctx->context.command_buffer[1] = allocate.memory_handle;
ctx->context.command_buffer_logical[1] = allocate.memory;
ctx->context.command_buffer_physical[1] = allocate.memory_gpu;
ctx->command_buffer[0] = ctx->context.command_buffer_logical[0];
ctx->command_buffer[1] = ctx->context.command_buffer_logical[1];
ctx->command_buffer_size = size;
ctx->command_offset[0] = 0;
ctx->command_offset[1] = 0;
ctx->command_buffer_current = 0;
#if !defined(VG_DRIVER_SINGLE_THREAD)
ctx->start_offset = 0;
ctx->end_offset = 0;
ctx->ts_init = 0;
memset(ctx->ts_record, 0, sizeof(ctx->ts_record));
#endif
return error;
}
vg_lite_error_t _free_command_buffer()
{
vg_lite_kernel_free_t free;
vg_lite_error_t error = VG_LITE_SUCCESS;
#if defined(VG_DRIVER_SINGLE_THREAD)
vg_lite_context_t *ctx = &s_context;
#else
vg_lite_context_t *ctx;
vg_lite_tls_t* tls;
tls = (vg_lite_tls_t *) vg_lite_os_get_tls();
if(tls == NULL)
return VG_LITE_NO_CONTEXT;
ctx = &tls->t_context;
#endif
if(ctx->context.command_buffer[0]){
free.memory_handle = ctx->context.command_buffer[0];
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_FREE, &free));
ctx->context.command_buffer[0] = 0;
ctx->context.command_buffer_logical[0] = 0;
}
if(ctx->context.command_buffer[1]){
free.memory_handle = ctx->context.command_buffer[1];
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_FREE, &free));
ctx->context.command_buffer[1] = 0;
ctx->context.command_buffer_logical[1] = 0;
}
return error;
}
static void ClampColor(FLOATVECTOR4 Source,FLOATVECTOR4 Target,uint8_t Premultiplied)
{
vg_lite_float_t colorMax;
/* Clamp the alpha channel. */
Target[3] = CLAMP(Source[3], 0.0f, 1.0f);
/* Determine the maximum value for the color channels. */
colorMax = Premultiplied ? Target[3] : 1.0f;
/* Clamp the color channels. */
Target[0] = CLAMP(Source[0], 0.0f, colorMax);
Target[1] = CLAMP(Source[1], 0.0f, colorMax);
Target[2] = CLAMP(Source[2], 0.0f, colorMax);
}
static uint8_t PackColorComponent(vg_lite_float_t value)
{
/* Compute the rounded normalized value. */
vg_lite_float_t rounded = value * 255.0f + 0.5f;
/* Get the integer part. */
int32_t roundedInt = (int32_t) rounded;
/* Clamp to 0..1 range. */
uint8_t clamped = (uint8_t) CLAMP(roundedInt, 0, 255);
/* Return result. */
return clamped;
}
#if !defined(VG_DRIVER_SINGLE_THREAD)
static void command_buffer_copy(void *new_cmd, void *old_cmd, uint32_t start, uint32_t end, uint32_t *cmd_count)
{
uint32_t i = start,j;
uint32_t *p_new_cmd32,*p_cmd32,*temp;
uint32_t data_count = 0;
memset(&hw,0,sizeof(vg_lite_hardware_t));
temp = NULL;
p_new_cmd32 = (uint32_t *)new_cmd;
p_cmd32 = (uint32_t *)old_cmd;
while(i < end)
{
/* data command is 0x40000000 | count, and count = databytes / 8 ,and data command and databytes should align to 8 */
if((*p_cmd32 & 0xF0000000) == 0x40000000) {
data_count = *p_cmd32 & 0x0FFFFFFF;
data_count++;
p_cmd32 += 2 * data_count;
i += data_count * 8;
/* SEMAPHORE command is 0x10000000 | id,stall command is 0x20000000 | id , call command is is 0x20000000 | count,
and this three command should occupy 8bytes*/
}else if((*p_cmd32 & 0xF0000000) == 0x20000000 || (*p_cmd32 & 0xF0000000) == 0x10000000
|| (*p_cmd32 & 0xF0000000) == 0x60000000 || (*p_cmd32 & 0xF0000000) == 0x80000000){
p_cmd32 += 2;
i += 8;
/* register command is 0x30000000 | ((count) << 16) | address,
and the bytes of this command add register count should align to 8 */
}else if((*p_cmd32 & 0xF0000000) == 0x30000000) {
/* get register data count */
data_count = (*p_cmd32 & 0x0FFFFFFF) >> 16;
if(data_count == 1)
{
temp = p_cmd32 + 1;
if(hw.hw_states[*p_cmd32 & 0xff].state != *temp || !hw.hw_states[*p_cmd32 & 0xff].init){
hw.hw_states[*p_cmd32 & 0xff].state = *temp;
hw.hw_states[*p_cmd32 & 0xff].init = 1;
for(j = 0; j < 2; j++) {
*p_new_cmd32 = *p_cmd32;
p_new_cmd32++;
p_cmd32++;
*cmd_count += 4;
i += 4;
}
}
else
{
p_cmd32 += 2;
i += 8;
}
}else{
/* the bytes of register count add register command */
data_count++;
if(data_count % 2 != 0)
data_count++;
for(j = 0; j < data_count; j++) {
*p_new_cmd32 = *p_cmd32;
p_new_cmd32++;
p_cmd32++;
*cmd_count += 4;
i += 4;
}
}
}
}
}
#endif /* not defined(VG_DRIVER_SINGLE_THREAD) */
static void _memset(void *p, unsigned char value, int size)
{
int i;
for (i = 0; i < size; i++) {
((unsigned char*) p)[i] = value;
}
}
static int has_valid_command_buffer(vg_lite_context_t *context)
{
if(context == NULL)
return 0;
if(context->command_buffer_current >= CMDBUF_COUNT)
return 0;
if(context->command_buffer[context->command_buffer_current] == NULL)
return 0;
return 1;
}
#if !defined(VG_DRIVER_SINGLE_THREAD)
static int has_valid_context_buffer(vg_lite_context_t *context)
{
if(context == NULL)
return 0;
if(context->context_buffer == NULL)
return 0;
return 1;
}
#endif /* not defined(VG_DRIVER_SINGLE_THREAD) */
#if DUMP_IMAGE
static void dump_img(void * memory, int width, int height, vg_lite_buffer_format_t format)
{
FILE * fp;
char imgname[255] = {'\0'};
int i;
static int num = 1;
unsigned int* pt = (unsigned int*) memory;
sprintf(imgname, "img_pid%d_%d.txt", getpid(), num++);
fp = fopen(imgname, "w");
if (fp == NULL)
printf("error!\n");
switch (format) {
case VG_LITE_INDEX_1:
for(i = 0; i < width * height / 32; ++i)
{
fprintf(fp, "0x%08x\n",pt[i]);
}
break;
case VG_LITE_INDEX_2:
for(i = 0; i < width * height / 16; ++i)
{
fprintf(fp, "0x%08x\n",pt[i]);
}
break;
case VG_LITE_INDEX_4:
for(i = 0; i < width * height / 8; ++i)
{
fprintf(fp, "0x%08x\n",pt[i]);
}
break;
case VG_LITE_INDEX_8:
for(i = 0; i < width * height / 4; ++i)
{
fprintf(fp, "0x%08x\n",pt[i]);
}
break;
case VG_LITE_RGBA2222:
for(i = 0; i < width * height / 4; ++i)
{
fprintf(fp, "0x%08x\n",pt[i]);
}
break;
case VG_LITE_RGBA4444:
case VG_LITE_BGRA4444:
case VG_LITE_RGB565:
case VG_LITE_BGR565:
for(i = 0; i < width * height / 2; ++i)
{
fprintf(fp, "0x%08x\n",pt[i]);
}
break;
case VG_LITE_RGBA8888:
case VG_LITE_BGRA8888:
case VG_LITE_RGBX8888:
case VG_LITE_BGRX8888:
for(i = 0; i < width * height; ++i)
{
fprintf(fp, "0x%08x\n",pt[i]);
}
break;
default:
break;
}
fclose(fp);
fp = NULL;
}
#endif
/* Convert VGLite data format to HW value. */
static uint32_t convert_path_format(vg_lite_format_t format)
{
switch (format) {
case VG_LITE_S8:
return 0;
case VG_LITE_S16:
return 0x100000;
case VG_LITE_S32:
return 0x200000;
case VG_LITE_FP32:
return 0x300000;
default:
return 0;
}
}
/* Convert VGLite quality enums to HW values. */
static uint32_t convert_path_quality(vg_lite_quality_t quality)
{
switch (quality) {
case VG_LITE_HIGH:
return 0x3;
case VG_LITE_UPPER:
return 0x2;
case VG_LITE_MEDIUM:
return 0x1;
default:
return 0x0;
}
}
static uint32_t rgb_to_l(uint32_t color)
{
uint32_t l = (uint32_t)((0.2126f * (vg_lite_float_t)(color & 0xFF)) +
(0.7152f * (vg_lite_float_t)((color >> 8) & 0xFF)) +
(0.0722f * (vg_lite_float_t)((color >> 16) & 0xFF)));
return l | (l << 24);
}
/* Get the bpp information of a color format. */
static void get_format_bytes(vg_lite_buffer_format_t format,
uint32_t *mul,
uint32_t *div,
uint32_t *bytes_align)
{
*mul = *div = 1;
*bytes_align = 4;
switch (format) {
case VG_LITE_L8:
case VG_LITE_A8:
*bytes_align = 16;
break;
case VG_LITE_A4:
*div = 2;
*bytes_align = 8;
break;
case VG_LITE_ABGR1555:
case VG_LITE_ARGB1555:
case VG_LITE_BGRA5551:
case VG_LITE_RGBA5551:
case VG_LITE_RGBA4444:
case VG_LITE_BGRA4444:
case VG_LITE_ABGR4444:
case VG_LITE_ARGB4444:
case VG_LITE_RGB565:
case VG_LITE_BGR565:
case VG_LITE_YUYV:
case VG_LITE_YUY2:
case VG_LITE_YUY2_TILED:
/* AYUY2 buffer memory = YUY2 + alpha. */
case VG_LITE_AYUY2:
case VG_LITE_AYUY2_TILED:
*mul = 2;
*bytes_align = 32;
break;
case VG_LITE_RGBA8888:
case VG_LITE_BGRA8888:
case VG_LITE_ABGR8888:
case VG_LITE_ARGB8888:
case VG_LITE_RGBX8888:
case VG_LITE_BGRX8888:
case VG_LITE_XBGR8888:
case VG_LITE_XRGB8888:
*mul = 4;
*bytes_align = 64;
break;
case VG_LITE_NV12:
case VG_LITE_NV12_TILED:
*mul = 3;
*bytes_align = 32;
break;
case VG_LITE_ANV12:
case VG_LITE_ANV12_TILED:
*mul = 4;
*bytes_align = 64;
break;
case VG_LITE_INDEX_1:
*div = 8;
*bytes_align = 8;
break;
case VG_LITE_INDEX_2:
*div = 4;
*bytes_align = 8;
break;
case VG_LITE_INDEX_4:
*div = 2;
*bytes_align = 8;
break;
case VG_LITE_INDEX_8:
*bytes_align = 16;
break;
case VG_LITE_RGBA2222:
case VG_LITE_BGRA2222:
case VG_LITE_ABGR2222:
case VG_LITE_ARGB2222:
*mul = 1;
*bytes_align = 8;
break;
default:
break;
}
}
/* Convert VGLite target color format to HW value. */
static uint32_t convert_target_format(vg_lite_buffer_format_t format, vg_lite_capabilities_t caps)
{
switch (format) {
case VG_LITE_A8:
return 0x0;
case VG_LITE_L8:
return 0x6;
case VG_LITE_ABGR4444:
return 0x14;
case VG_LITE_ARGB4444:
return 0x34;
case VG_LITE_RGBA4444:
return 0x24;
case VG_LITE_BGRA4444:
return 0x4;
case VG_LITE_RGB565:
return 0x21;
case VG_LITE_BGR565:
return 0x1;
case VG_LITE_ABGR8888:
return 0x13;
case VG_LITE_ARGB8888:
return 0x33;
case VG_LITE_RGBA8888:
return 0x23;
case VG_LITE_BGRA8888:
return 0x3;
case VG_LITE_RGBX8888:
return 0x22;
case VG_LITE_BGRX8888:
return 0x2;
case VG_LITE_XBGR8888:
return 0x12;
case VG_LITE_XRGB8888:
return 0x32;
case VG_LITE_ABGR1555:
return 0x15;
case VG_LITE_RGBA5551:
return 0x25;
case VG_LITE_ARGB1555:
return 0x35;
case VG_LITE_BGRA5551:
return 0x5;
case VG_LITE_YUYV:
case VG_LITE_YUY2:
case VG_LITE_YUY2_TILED:
return 0x8;
case VG_LITE_NV12:
case VG_LITE_NV12_TILED:
return 0xB;
case VG_LITE_ANV12:
case VG_LITE_ANV12_TILED:
return 0xE;
case VG_LITE_BGRA2222:
return 0x7;
case VG_LITE_RGBA2222:
return 0x27;
case VG_LITE_ABGR2222:
return 0x17;
case VG_LITE_ARGB2222:
return 0x37;
case VG_LITE_AYUY2:
case VG_LITE_AYUY2_TILED:
default:
return 0xF;
}
}
/* determine source IM is aligned by specified bytes */
static vg_lite_error_t _check_source_aligned(vg_lite_buffer_format_t format,uint32_t stride)
{
switch (format) {
case VG_LITE_A4:
case VG_LITE_INDEX_1:
case VG_LITE_INDEX_2:
case VG_LITE_INDEX_4:
FORMAT_ALIGNMENT(stride,8);
break;
case VG_LITE_L8:
case VG_LITE_A8:
case VG_LITE_INDEX_8:
case VG_LITE_RGBA2222:
case VG_LITE_BGRA2222:
case VG_LITE_ABGR2222:
case VG_LITE_ARGB2222:
FORMAT_ALIGNMENT(stride,16);
break;
case VG_LITE_RGBA4444:
case VG_LITE_BGRA4444:
case VG_LITE_ABGR4444:
case VG_LITE_ARGB4444:
case VG_LITE_RGB565:
case VG_LITE_BGR565:
case VG_LITE_BGRA5551:
case VG_LITE_RGBA5551:
case VG_LITE_ABGR1555:
case VG_LITE_ARGB1555:
case VG_LITE_YUYV:
case VG_LITE_YUY2:
case VG_LITE_NV12:
case VG_LITE_YV12:
case VG_LITE_YV24:
case VG_LITE_YV16:
case VG_LITE_NV16:
FORMAT_ALIGNMENT(stride,32);
break;
case VG_LITE_RGBA8888:
case VG_LITE_BGRA8888:
case VG_LITE_ABGR8888:
case VG_LITE_ARGB8888:
case VG_LITE_RGBX8888:
case VG_LITE_BGRX8888:
case VG_LITE_XBGR8888:
case VG_LITE_XRGB8888:
FORMAT_ALIGNMENT(stride,64);
break;
default:
return VG_LITE_SUCCESS;
}
}
/* Convert VGLite source color format to HW values. */
static uint32_t convert_source_format(vg_lite_buffer_format_t format)
{
switch (format) {
case VG_LITE_L8:
return 0x0;
case VG_LITE_A4:
return 0x1;
case VG_LITE_A8:
return 0x2;
case VG_LITE_RGBA4444:
return 0x23;
case VG_LITE_BGRA4444:
return 0x3;
case VG_LITE_ABGR4444:
return 0x13;
case VG_LITE_ARGB4444:
return 0x33;
case VG_LITE_RGB565:
return 0x25;
case VG_LITE_BGR565:
return 0x5;
case VG_LITE_RGBA8888:
return 0x27;
case VG_LITE_BGRA8888:
return 0x7;
case VG_LITE_ABGR8888:
return 0x17;
case VG_LITE_ARGB8888:
return 0x37;
case VG_LITE_RGBX8888:
return 0x26;
case VG_LITE_BGRX8888:
return 0x6;
case VG_LITE_XBGR8888:
return 0x16;
case VG_LITE_XRGB8888:
return 0x36;
case VG_LITE_BGRA5551:
return 0x4;
case VG_LITE_RGBA5551:
return 0x24;
case VG_LITE_ABGR1555:
return 0x14;
case VG_LITE_ARGB1555:
return 0x34;
case VG_LITE_YUYV:
return 0x8;
case VG_LITE_YUY2:
case VG_LITE_YUY2_TILED:
return 0x8;
case VG_LITE_NV12:
case VG_LITE_NV12_TILED:
return 0xB;
case VG_LITE_ANV12:
case VG_LITE_ANV12_TILED:
return 0xE;
case VG_LITE_YV12:
return 0x9;
case VG_LITE_YV24:
return 0xD;
case VG_LITE_YV16:
return 0xC;
case VG_LITE_NV16:
return 0xA;
case VG_LITE_AYUY2:
case VG_LITE_AYUY2_TILED:
default:
return 0xF;
case VG_LITE_INDEX_1:
return 0x200;
case VG_LITE_INDEX_2:
return 0x400;
case VG_LITE_INDEX_4:
return 0x600;
case VG_LITE_INDEX_8:
return 0x800;
case VG_LITE_RGBA2222:
return 0xA20;
case VG_LITE_BGRA2222:
return 0xA00;
case VG_LITE_ABGR2222:
return 0xA10;
case VG_LITE_ARGB2222:
return 0xA30;
}
}
/* Convert VGLite blend modes to HW values. */
static uint32_t convert_blend(vg_lite_blend_t blend)
{
switch (blend) {
case VG_LITE_BLEND_SRC_OVER:
return 0x00000100;
case VG_LITE_BLEND_DST_OVER:
return 0x00000200;
case VG_LITE_BLEND_SRC_IN:
return 0x00000300;
case VG_LITE_BLEND_DST_IN:
return 0x00000400;
case VG_LITE_BLEND_SCREEN:
return 0x00000600;
case VG_LITE_BLEND_MULTIPLY:
return 0x00000500;
case VG_LITE_BLEND_ADDITIVE:
return 0x00000900;
case VG_LITE_BLEND_SUBTRACT:
return 0x00000A00;
default:
return 0;
}
}
/* Convert VGLite uv swizzle enums to HW values. */
static uint32_t convert_uv_swizzle(vg_lite_swizzle_t swizzle)
{
switch (swizzle) {
case VG_LITE_SWIZZLE_UV:
return 0x00000040;
break;
case VG_LITE_SWIZZLE_VU:
return 0x00000050;
default:
return 0;
break;
}
}
/* Convert VGLite yuv standard enums to HW values. */
static uint32_t convert_yuv2rgb(vg_lite_yuv2rgb_t yuv)
{
switch (yuv) {
case VG_LITE_YUV601:
return 0;
break;
case VG_LITE_YUV709:
return 0x00008000;
default:
return 0;
break;
}
}
/* Initialize the feature table of a chip. */
static vg_lite_error_t fill_feature_table(uint32_t * feature)
{
uint16_t size = sizeof(VGFeatureInfos) / sizeof(VGFeatureInfos[0]);
uint16_t i;
uint32_t cid = 0;
#if defined(VG_DRIVER_SINGLE_THREAD)
vg_lite_context_t *ctx = &s_context;
#else
vg_lite_context_t *ctx;
vg_lite_tls_t* tls;
tls = (vg_lite_tls_t *) vg_lite_os_get_tls();
if(tls == NULL)
return VG_LITE_NO_CONTEXT;
ctx = &tls->t_context;
#endif
/* Clear all bits. */
_memset(feature, 0, sizeof(uint32_t) * gcFEATURE_COUNT);
vg_lite_get_product_info(NULL,&ctx->chip_id,&ctx->chip_rev);
if(ctx->chip_id == GPU_CHIP_ID_GC355)
ctx->premultiply_enabled = 1;
vg_lite_get_register(0x30, &cid);
for(i = 0;i < size; i++){
if ((VGFeatureInfos[i].chip_id == ctx->chip_id)
&& (VGFeatureInfos[i].chip_version == ctx->chip_rev)
&& (VGFeatureInfos[i].cid == cid)
)
{
feature[gcFEATURE_BIT_VG_IM_INDEX_FORMAT] = VGFeatureInfos[i].vg_im_index_format;
feature[gcFEATURE_BIT_VG_PE_PREMULTIPLY] = VGFeatureInfos[i].vg_pe_premultiply;
feature[gcFEATURE_BIT_VG_BORDER_CULLING] = VGFeatureInfos[i].vg_border_culling;
feature[gcFEATURE_BIT_VG_RGBA2_FORMAT] = VGFeatureInfos[i].vg_rgba2_format;
feature[gcFEATURE_BIT_VG_QUALITY_8X] = VGFeatureInfos[i].vg_quality_8x;
feature[gcFEATURE_BIT_VG_RADIAL_GRADIENT] = VGFeatureInfos[i].vg_radial_gradient;
feature[gcFEATURE_BIT_VG_LINEAR_GRADIENT_EXT] = VGFeatureInfos[i].vg_linear_gradient_ext;
feature[gcFEATURE_BIT_VG_DITHER] = VGFeatureInfos[i].vg_dither;
feature[gcFEATURE_BIT_VG_COLOR_KEY] = VGFeatureInfos[i].vg_color_key;
break;
}
}
if(i == size) {
return VG_LITE_INVALID_ARGUMENT;
}
ctx->s_ftable.ftflag = 1;
return VG_LITE_SUCCESS;
}
#if !defined(VG_DRIVER_SINGLE_THREAD)
static vg_lite_error_t flush(vg_lite_context_t *context);
#endif /* not defined(VG_DRIVER_SINGLE_THREAD) */
static vg_lite_error_t submit(vg_lite_context_t * context);
#if defined(VG_DRIVER_SINGLE_THREAD)
static vg_lite_error_t stall(vg_lite_context_t * context, uint32_t time_ms, uint32_t mask);
#else
static vg_lite_error_t stall(vg_lite_context_t * context, uint32_t time_ms);
#endif /* VG_DRIVER_SINGLE_THREAD */
#if !defined(VG_DRIVER_SINGLE_THREAD)
/* Push a state array into context buffer. */
static vg_lite_error_t push_states_to_context(vg_lite_context_t * context, uint32_t address, uint32_t count, uint32_t *data)
{
uint32_t i, command_id;
vg_lite_error_t error;
if (!has_valid_context_buffer(context))
return VG_LITE_NO_CONTEXT;
command_id = CMDBUF_INDEX(*context);
if(CMDBUF_IN_QUEUE(&context->context, command_id))
VG_LITE_RETURN_ERROR(stall(context, 0));
/* Reserve enough space in the context buffer for flush and submit */
if (context->context_buffer_offset[command_id] + 8 >= context->context_buffer_size) {
return VG_LITE_OUT_OF_RESOURCES;
}
((uint32_t *) (context->context_buffer[command_id] + context->context_buffer_offset[command_id]))[0] = VG_LITE_STATES(count, address);
for (i = 0; i < count; i++) {
((uint32_t *) (context->context_buffer[command_id] + context->context_buffer_offset[command_id]))[1 + i] = data[i];
}
if (i%2 == 0) {
((uint32_t *) (context->context_buffer[command_id] + context->context_buffer_offset[command_id]))[1 + i] = VG_LITE_NOP();
}
context->context_buffer_offset[command_id] += VG_LITE_ALIGN(count + 1, 2) * 4;
return VG_LITE_SUCCESS;
}
static vg_lite_error_t update_context_buffer()
{
vg_lite_error_t error = VG_LITE_SUCCESS;
vg_lite_kernel_context_switch_t check;
vg_lite_tls_t* tls;
uint32_t command_id;
tls = (vg_lite_tls_t *) vg_lite_os_get_tls();
if(tls == NULL)
return VG_LITE_NO_CONTEXT;
command_id = CMDBUF_INDEX(tls->t_context);
check.context =(uint32_t)&tls->t_context.context;
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_QUERY_CONTEXT_SWITCH, &check));
/* if context have been switched and this task need use index. */
if(check.isContextSwitched && tls->t_context.index_format)
{
uint32_t clut_addr[4]={0x0A98,0x0A9C,0x0AA0,0x0B00};
uint32_t clut_count[4]={2,4,16,256};
for(int i = 0; i < 4; i++)
{
/* check which index colors would be use in this task. */
if(tls->t_context.colors[i] && tls->t_context.clut_used[i]){
VG_LITE_RETURN_ERROR(push_states_to_context(&tls->t_context, clut_addr[i], clut_count[i], tls->t_context.colors[i]));
tls->t_context.clut_used[i] = 0;
}
}
tls->t_context.index_format = 0;
}
/* Set tessellation buffer states */
if(check.isContextSwitched && tls->t_context.ts_init && !tls->t_context.ts_init_used && tls->t_context.ts_init_use){
/* Reserve enough space in the context buffer for flush and submit */
if (tls->t_context.context_buffer_offset[command_id] + 80 >= tls->t_context.context_buffer_size) {
return VG_LITE_OUT_OF_RESOURCES;
}
memcpy(tls->t_context.context_buffer[command_id] + tls->t_context.context_buffer_offset[command_id], tls->t_context.ts_record, 80);
tls->t_context.ts_init = 0;
tls->t_context.ts_init_used = 0;
tls->t_context.ts_init_use = 0;
tls->t_context.context_buffer_offset[command_id] += 80;
}
if(tls->t_context.context_buffer_offset[command_id]){
((uint32_t *) (tls->t_context.context_buffer[command_id] + tls->t_context.context_buffer_offset[command_id]))[0] = VG_LITE_RETURN();
((uint32_t *) (tls->t_context.context_buffer[command_id] + tls->t_context.context_buffer_offset[command_id]))[1] = 0;
tls->t_context.context_buffer_offset[command_id] += 8;
((uint32_t *) CMDBUF_BUFFER(tls->t_context))[0] = VG_LITE_CALL((tls->t_context.context_buffer_offset[command_id] + 7) / 8);
((uint32_t *) CMDBUF_BUFFER(tls->t_context))[1] = tls->t_context.context.context_buffer_physical[command_id];
tls->t_context.context_buffer_offset[command_id] = 0;
}
return error;
}
#endif /* not defined(VG_DRIVER_SINGLE_THREAD) */
#if defined(VG_DRIVER_SINGLE_THREAD)
/* Push a state array into current command buffer. */
static vg_lite_error_t push_states(vg_lite_context_t * context, uint32_t address, uint32_t count, uint32_t *data)
{
uint32_t i;
vg_lite_error_t error;
if (!has_valid_command_buffer(context))
return VG_LITE_NO_CONTEXT;
if (CMDBUF_OFFSET(*context) + 8 + VG_LITE_ALIGN(count + 1, 2) * 4 >= CMDBUF_SIZE(*context)) {
VG_LITE_RETURN_ERROR(submit(context));
VG_LITE_RETURN_ERROR(stall(context, 0, (uint32_t)~0));
}
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[0] = VG_LITE_STATES(count, address);
for (i = 0; i < count; i++) {
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[1 + i] = data[i];
}
if (i%2 == 0) {
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[1 + i] = VG_LITE_NOP();
}
CMDBUF_OFFSET(*context) += VG_LITE_ALIGN(count + 1, 2) * 4;
return VG_LITE_SUCCESS;
}
/* Push a single state command into the current command buffer. */
static vg_lite_error_t push_state(vg_lite_context_t * context, uint32_t address, uint32_t data)
{
vg_lite_error_t error;
if (!has_valid_command_buffer(context))
return VG_LITE_NO_CONTEXT;
if (CMDBUF_OFFSET(*context) + 16 >= CMDBUF_SIZE(*context)) {
VG_LITE_RETURN_ERROR(submit(context));
VG_LITE_RETURN_ERROR(stall(context, 0, (uint32_t)~0));
}
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[0] = VG_LITE_STATE(address);
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[1] = data;
CMDBUF_OFFSET(*context) += 8;
return VG_LITE_SUCCESS;
}
/* Push a single state command with given address. */
static vg_lite_error_t push_state_ptr(vg_lite_context_t * context, uint32_t address, void * data_ptr)
{
vg_lite_error_t error;
uint32_t data = *(uint32_t *) data_ptr;
if (!has_valid_command_buffer(context))
return VG_LITE_NO_CONTEXT;
if (CMDBUF_OFFSET(*context) + 16 >= CMDBUF_SIZE(*context)) {
VG_LITE_RETURN_ERROR(submit(context));
VG_LITE_RETURN_ERROR(stall(context, 0, (uint32_t)~0));
}
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[0] = VG_LITE_STATE(address);
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[1] = data;
CMDBUF_OFFSET(*context) += 8;
return VG_LITE_SUCCESS;
}
/* Push a "call" command into the current command buffer. */
static vg_lite_error_t push_call(vg_lite_context_t * context, uint32_t address, uint32_t bytes)
{
vg_lite_error_t error;
if (!has_valid_command_buffer(context))
return VG_LITE_NO_CONTEXT;
if (CMDBUF_OFFSET(*context) + 16 >= CMDBUF_SIZE(*context)) {
VG_LITE_RETURN_ERROR(submit(context));
VG_LITE_RETURN_ERROR(stall(context, 0, (uint32_t)~0));
}
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[0] = VG_LITE_CALL((bytes + 7) / 8);
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[1] = address;
CMDBUF_OFFSET(*context) += 8;
return VG_LITE_SUCCESS;
}
/* Push a rectangle command into the current command buffer. */
static vg_lite_error_t push_rectangle(vg_lite_context_t * context, int x, int y, int width, int height)
{
vg_lite_error_t error;
if (!has_valid_command_buffer(context))
return VG_LITE_NO_CONTEXT;
if (CMDBUF_OFFSET(*context) + 16 >= CMDBUF_SIZE(*context)) {
VG_LITE_RETURN_ERROR(submit(context));
VG_LITE_RETURN_ERROR(stall(context, 0, (uint32_t)~0));
}
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[0] = VG_LITE_DATA(1);
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[1] = 0;
((uint16_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[4] = (uint16_t)x;
((uint16_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[5] = (uint16_t)y;
((uint16_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[6] = (uint16_t)width;
((uint16_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[7] = (uint16_t)height;
CMDBUF_OFFSET(*context) += 16;
return VG_LITE_SUCCESS;
}
/* Push a data array into the current command buffer. */
static vg_lite_error_t push_data(vg_lite_context_t * context, int size, void * data)
{
vg_lite_error_t error;
int bytes = VG_LITE_ALIGN(size, 8);
if (!has_valid_command_buffer(context))
return VG_LITE_NO_CONTEXT;
if (CMDBUF_OFFSET(*context) + 16 + bytes >= CMDBUF_SIZE(*context)) {
VG_LITE_RETURN_ERROR(submit(context));
VG_LITE_RETURN_ERROR(stall(context, 0, (uint32_t)~0));
}
((uint64_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[(bytes / 8)] = 0;
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[0] = VG_LITE_DATA(bytes / 8);
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[1] = 0;
memcpy(CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context) + 8, data, size);
CMDBUF_OFFSET(*context) += 8 + bytes;
return VG_LITE_SUCCESS;
}
/* Push a "stall" command into the current command buffer. */
static vg_lite_error_t push_stall(vg_lite_context_t * context, uint32_t module)
{
vg_lite_error_t error;
if (!has_valid_command_buffer(context))
return VG_LITE_NO_CONTEXT;
if (CMDBUF_OFFSET(*context) + 16 >= CMDBUF_SIZE(*context)) {
VG_LITE_RETURN_ERROR(submit(context));
VG_LITE_RETURN_ERROR(stall(context, 0, (uint32_t)~0));
}
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[0] = VG_LITE_SEMAPHORE(module);
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[1] = 0;
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[2] = VG_LITE_STALL(module);
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[3] = 0;
CMDBUF_OFFSET(*context) += 16;
return VG_LITE_SUCCESS;
}
#else
/* Push a state array into current command buffer. */
static vg_lite_error_t push_states(vg_lite_context_t * context, uint32_t address, uint32_t count, uint32_t *data)
{
uint32_t i, command_id, index;
vg_lite_error_t error;
if (!has_valid_command_buffer(context))
return VG_LITE_NO_CONTEXT;
command_id = CMDBUF_INDEX(*context);
if(CMDBUF_IN_QUEUE(&context->context, command_id))
VG_LITE_RETURN_ERROR(stall(context, 0));
/* Reserve enough space in the command buffer for flush and submit */
if (CMDBUF_OFFSET(*context) + 40 + VG_LITE_ALIGN(count + 1, 2) * 4 >= CMDBUF_SIZE(*context)) {
uint32_t cmd_count = 0,start_offset = 0;
context->end_offset = CMDBUF_OFFSET(*context);
start_offset = context->start_offset;
VG_LITE_RETURN_ERROR(flush(context));
VG_LITE_RETURN_ERROR(submit(context));
CMDBUF_SWAP(*context);
command_id = CMDBUF_INDEX(*context);
if(CMDBUF_IN_QUEUE(&context->context, command_id))
VG_LITE_RETURN_ERROR(stall(context, 0));
RESERVE_BYTES_IN_CMDBUF(*context);
if(context->ts_init){
memcpy(CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context), context->ts_record, 80);
CMDBUF_OFFSET(*context) += 80;
context->ts_init_used = 1;
}
/* update start offset */
context->start_offset = CMDBUF_OFFSET(*context);
index = (command_id? 0 : 1);
command_buffer_copy((void *)(CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)), (void *)(context->command_buffer[index] + start_offset),
start_offset, context->end_offset, &cmd_count);
CMDBUF_OFFSET(*context) += cmd_count;
}
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[0] = VG_LITE_STATES(count, address);
for (i = 0; i < count; i++) {
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[1 + i] = data[i];
}
if (i%2 == 0) {
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[1 + i] = VG_LITE_NOP();
}
#if DUMP_COMMAND
{
uint32_t loops;
if (strncmp(filename, "Commandbuffer", 13)) {
sprintf(filename, "Commandbuffer_pid%d.txt", getpid());
}
fp = fopen(filename, "a");
if (fp == NULL)
printf("error!\n");
fprintf(fp, "Command buffer: 0x%08x, ",
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[0]);
for (loops = 0; loops < count / 2; loops++) {
fprintf(fp, "0x%08x,\nCommand buffer: 0x%08x, ",
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[(loops + 1) * 2 - 1],
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[(loops + 1) * 2]);
}
fprintf(fp, "0x%08x,\n",
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[(loops + 1) * 2 - 1]);
fclose(fp);
fp = NULL;
}
#endif
CMDBUF_OFFSET(*context) += VG_LITE_ALIGN(count + 1, 2) * 4;
return VG_LITE_SUCCESS;
}
/* Push a single state command into the current command buffer. */
static vg_lite_error_t push_state(vg_lite_context_t * context, uint32_t address, uint32_t data)
{
vg_lite_error_t error;
uint32_t command_id, index;
if (!has_valid_command_buffer(context))
return VG_LITE_NO_CONTEXT;
command_id = CMDBUF_INDEX(*context);
if(CMDBUF_IN_QUEUE(&context->context, command_id))
VG_LITE_RETURN_ERROR(stall(context, 0));
/* Reserve enough space in the command buffer for flush and submit */
if (CMDBUF_OFFSET(*context) + 56 >= CMDBUF_SIZE(*context)) {
uint32_t cmd_count = 0,start_offset = 0;
context->end_offset = CMDBUF_OFFSET(*context);
start_offset = context->start_offset;
VG_LITE_RETURN_ERROR(flush(context));
VG_LITE_RETURN_ERROR(submit(context));
CMDBUF_SWAP(*context);
command_id = CMDBUF_INDEX(*context);
if(CMDBUF_IN_QUEUE(&context->context, command_id))
VG_LITE_RETURN_ERROR(stall(context, 0));
RESERVE_BYTES_IN_CMDBUF(*context);
if(context->ts_init){
memcpy(CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context), context->ts_record, 80);
CMDBUF_OFFSET(*context) += 80;
context->ts_init_used = 1;
}
/* update start offset */
context->start_offset = CMDBUF_OFFSET(*context);
index = (command_id? 0 : 1);
command_buffer_copy((void *)(CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)), (void *)(context->command_buffer[index] + start_offset),
start_offset, context->end_offset, &cmd_count);
CMDBUF_OFFSET(*context) += cmd_count;
}
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[0] = VG_LITE_STATE(address);
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[1] = data;
#if DUMP_COMMAND
if (strncmp(filename, "Commandbuffer", 13)) {
sprintf(filename, "Commandbuffer_pid%d.txt", getpid());
}
fp = fopen(filename, "a");
if (fp == NULL)
printf("error!\n");
fprintf(fp, "Command buffer: 0x%08x, 0x%08x,\n",
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[0],
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[1]);
fclose(fp);
fp = NULL;
#endif
CMDBUF_OFFSET(*context) += 8;
return VG_LITE_SUCCESS;
}
/* Push a single state command with given address. */
static vg_lite_error_t push_state_ptr(vg_lite_context_t * context, uint32_t address, void * data_ptr)
{
vg_lite_error_t error;
uint32_t command_id, index;
uint32_t data = *(uint32_t *) data_ptr;
if (!has_valid_command_buffer(context))
return VG_LITE_NO_CONTEXT;
command_id = CMDBUF_INDEX(*context);
if(CMDBUF_IN_QUEUE(&context->context, command_id))
VG_LITE_RETURN_ERROR(stall(context, 0));
/* Reserve enough space in the command buffer for flush and submit */
if (CMDBUF_OFFSET(*context) + 56 >= CMDBUF_SIZE(*context)) {
uint32_t cmd_count = 0,start_offset = 0;
context->end_offset = CMDBUF_OFFSET(*context);
start_offset = context->start_offset;
VG_LITE_RETURN_ERROR(flush(context));
VG_LITE_RETURN_ERROR(submit(context));
CMDBUF_SWAP(*context);
command_id = CMDBUF_INDEX(*context);
if(CMDBUF_IN_QUEUE(&context->context, command_id))
VG_LITE_RETURN_ERROR(stall(context, 0));
RESERVE_BYTES_IN_CMDBUF(*context);
if(context->ts_init){
memcpy(CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context), context->ts_record, 80);
CMDBUF_OFFSET(*context) += 80;
context->ts_init_used = 1;
}
/* update start offset */
context->start_offset = CMDBUF_OFFSET(*context);
index = (command_id? 0 : 1);
command_buffer_copy((void *)(CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)), (void *)(context->command_buffer[index] + start_offset),
start_offset, context->end_offset, &cmd_count);
CMDBUF_OFFSET(*context) += cmd_count;
}
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[0] = VG_LITE_STATE(address);
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[1] = data;
#if DUMP_COMMAND
if (strncmp(filename, "Commandbuffer", 13)) {
sprintf(filename, "Commandbuffer_pid%d.txt", getpid());
}
fp = fopen(filename, "a");
if (fp == NULL)
printf("error!\n");
fprintf(fp, "Command buffer: 0x%08x, 0x%08x,\n",
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[0],
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[1]);
fclose(fp);
fp = NULL;
#endif
CMDBUF_OFFSET(*context) += 8;
return VG_LITE_SUCCESS;
}
/* Push a "call" command into the current command buffer. */
static vg_lite_error_t push_call(vg_lite_context_t * context, uint32_t address, uint32_t bytes)
{
vg_lite_error_t error;
uint32_t command_id, index;
if (!has_valid_command_buffer(context))
return VG_LITE_NO_CONTEXT;
command_id = CMDBUF_INDEX(*context);
if(CMDBUF_IN_QUEUE(&context->context, command_id))
VG_LITE_RETURN_ERROR(stall(context, 0));
/* Reserve enough space in the command buffer for flush and submit */
if (CMDBUF_OFFSET(*context) + 56 >= CMDBUF_SIZE(*context)) {
uint32_t cmd_count = 0,start_offset = 0;
context->end_offset = CMDBUF_OFFSET(*context);
start_offset = context->start_offset;
VG_LITE_RETURN_ERROR(flush(context));
VG_LITE_RETURN_ERROR(submit(context));
CMDBUF_SWAP(*context);
command_id = CMDBUF_INDEX(*context);
if(CMDBUF_IN_QUEUE(&context->context, command_id))
VG_LITE_RETURN_ERROR(stall(context, 0));
RESERVE_BYTES_IN_CMDBUF(*context);
if(context->ts_init){
memcpy(CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context), context->ts_record, 80);
CMDBUF_OFFSET(*context) += 80;
context->ts_init_used = 1;
}
/* update start offset */
context->start_offset = CMDBUF_OFFSET(*context);
index = (command_id? 0 : 1);
command_buffer_copy((void *)(CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)), (void *)(context->command_buffer[index] + start_offset),
start_offset, context->end_offset, &cmd_count);
CMDBUF_OFFSET(*context) += cmd_count;
}
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[0] = VG_LITE_CALL((bytes + 7) / 8);
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[1] = address;
#if DUMP_COMMAND
if (strncmp(filename, "Commandbuffer", 13)) {
sprintf(filename, "Commandbuffer_pid%d.txt", getpid());
}
fp = fopen(filename, "a");
if (fp == NULL)
printf("error!\n");
fprintf(fp, "Command buffer: 0x%08x, 0x%08x,\n",
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[0],
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[1]);
fclose(fp);
fp = NULL;
#endif
CMDBUF_OFFSET(*context) += 8;
return VG_LITE_SUCCESS;
}
/* Push a rectangle command into the current command buffer. */
static vg_lite_error_t push_rectangle(vg_lite_context_t * context, int x, int y, int width, int height)
{
vg_lite_error_t error;
uint32_t command_id, index;
if (!has_valid_command_buffer(context))
return VG_LITE_NO_CONTEXT;
command_id = CMDBUF_INDEX(*context);
if(CMDBUF_IN_QUEUE(&context->context, command_id))
VG_LITE_RETURN_ERROR(stall(context, 0));
/* Reserve enough space in the command buffer for flush and submit */
if (CMDBUF_OFFSET(*context) + 56 >= CMDBUF_SIZE(*context)) {
uint32_t cmd_count = 0,start_offset = 0;
context->end_offset = CMDBUF_OFFSET(*context);
start_offset = context->start_offset;
VG_LITE_RETURN_ERROR(flush(context));
VG_LITE_RETURN_ERROR(submit(context));
CMDBUF_SWAP(*context);
command_id = CMDBUF_INDEX(*context);
if(CMDBUF_IN_QUEUE(&context->context, command_id))
VG_LITE_RETURN_ERROR(stall(context, 0));
RESERVE_BYTES_IN_CMDBUF(*context);
if(context->ts_init){
memcpy(CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context), context->ts_record, 80);
CMDBUF_OFFSET(*context) += 80;
context->ts_init_used = 1;
}
/* update start offset */
context->start_offset = CMDBUF_OFFSET(*context);
index = (command_id? 0 : 1);
command_buffer_copy((void *)(CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)), (void *)(context->command_buffer[index] + start_offset),
start_offset, context->end_offset, &cmd_count);
CMDBUF_OFFSET(*context) += cmd_count;
}
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[0] = VG_LITE_DATA(1);
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[1] = 0;
((uint16_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[4] = (uint16_t)x;
((uint16_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[5] = (uint16_t)y;
((uint16_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[6] = (uint16_t)width;
((uint16_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[7] = (uint16_t)height;
#if DUMP_COMMAND
if (strncmp(filename, "Commandbuffer", 13)) {
sprintf(filename, "Commandbuffer_pid%d.txt", getpid());
}
fp = fopen(filename, "a");
if (fp == NULL)
printf("error!\n");
fprintf(fp, "Command buffer: 0x%08x, 0x%08x,\n",
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[0], 0);
fprintf(fp, "Command buffer: 0x%08x, 0x%08x,\n",
((uint16_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[5] << 16 |
((uint16_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[4],
((uint16_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[7] << 16 |
((uint16_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[6]);
fclose(fp);
fp = NULL;
#endif
CMDBUF_OFFSET(*context) += 16;
return VG_LITE_SUCCESS;
}
/* Push a data array into the current command buffer. */
static vg_lite_error_t push_data(vg_lite_context_t * context, int size, void * data)
{
vg_lite_error_t error;
uint32_t command_id, index;
int bytes = VG_LITE_ALIGN(size, 8);
if (!has_valid_command_buffer(context))
return VG_LITE_NO_CONTEXT;
command_id = CMDBUF_INDEX(*context);
if(CMDBUF_IN_QUEUE(&context->context, command_id))
VG_LITE_RETURN_ERROR(stall(context, 0));
/* Reserve enough space in the command buffer for flush and submit */
if (CMDBUF_OFFSET(*context) + 48 + bytes >= CMDBUF_SIZE(*context)) {
uint32_t cmd_count = 0,start_offset = 0;
context->end_offset = CMDBUF_OFFSET(*context);
start_offset = context->start_offset;
VG_LITE_RETURN_ERROR(flush(context));
VG_LITE_RETURN_ERROR(submit(context));
CMDBUF_SWAP(*context);
command_id = CMDBUF_INDEX(*context);
if(CMDBUF_IN_QUEUE(&context->context, command_id))
VG_LITE_RETURN_ERROR(stall(context, 0));
RESERVE_BYTES_IN_CMDBUF(*context);
if(context->ts_init){
memcpy(CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context), context->ts_record, 80);
CMDBUF_OFFSET(*context) += 80;
context->ts_init_used = 1;
}
/* update start offset */
context->start_offset = CMDBUF_OFFSET(*context);
index = (command_id? 0 : 1);
command_buffer_copy((void *)(CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)), (void *)(context->command_buffer[index] + start_offset),
start_offset, context->end_offset, &cmd_count);
CMDBUF_OFFSET(*context) += cmd_count;
}
((uint64_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[(bytes / 8)] = 0;
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[0] = VG_LITE_DATA(bytes / 8);
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[1] = 0;
memcpy(CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context) + 8, data, size);
#if DUMP_COMMAND
{
int loops;
if (strncmp(filename, "Commandbuffer", 13)) {
sprintf(filename, "Commandbuffer_pid%d.txt", getpid());
}
fp = fopen(filename, "a");
if (fp == NULL)
printf("error!\n");
fprintf(fp, "Command buffer: 0x%08x, 0x%08x,\n",
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[0], 0);
for (loops = 0; loops < bytes / 8; loops++) {
fprintf(fp, "Command buffer: 0x%08x, 0x%08x,\n",
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[(loops + 1) * 2],
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[(loops + 1) * 2 + 1]);
}
fclose(fp);
fp = NULL;
}
#endif
CMDBUF_OFFSET(*context) += 8 + bytes;
return VG_LITE_SUCCESS;
}
/* Push a "stall" command into the current command buffer. */
static vg_lite_error_t push_stall(vg_lite_context_t * context, uint32_t module)
{
vg_lite_error_t error;
uint32_t command_id, index;
if (!has_valid_command_buffer(context))
return VG_LITE_NO_CONTEXT;
command_id = CMDBUF_INDEX(*context);
if(CMDBUF_IN_QUEUE(&context->context, command_id))
VG_LITE_RETURN_ERROR(stall(context, 0));
/* Reserve enough space in the command buffer for flush and submit */
if (CMDBUF_OFFSET(*context) + 56 >= CMDBUF_SIZE(*context)) {
uint32_t cmd_count = 0,start_offset = 0;
context->end_offset = CMDBUF_OFFSET(*context);
start_offset = context->start_offset;
VG_LITE_RETURN_ERROR(flush(context));
VG_LITE_RETURN_ERROR(submit(context));
CMDBUF_SWAP(*context);
command_id = CMDBUF_INDEX(*context);
if(CMDBUF_IN_QUEUE(&context->context, command_id))
VG_LITE_RETURN_ERROR(stall(context, 0));
RESERVE_BYTES_IN_CMDBUF(*context);
if(context->ts_init){
memcpy(CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context), context->ts_record, 80);
CMDBUF_OFFSET(*context) += 80;
context->ts_init_used = 1;
}
/* update start offset */
context->start_offset = CMDBUF_OFFSET(*context);
index = (command_id? 0 : 1);
command_buffer_copy((void *)(CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)), (void *)(context->command_buffer[index] + start_offset),
start_offset, context->end_offset, &cmd_count);
CMDBUF_OFFSET(*context) += cmd_count;
}
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[0] = VG_LITE_SEMAPHORE(module);
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[1] = 0;
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[2] = VG_LITE_STALL(module);
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[3] = 0;
#if DUMP_COMMAND
if (strncmp(filename, "Commandbuffer", 13)) {
sprintf(filename, "Commandbuffer_pid%d.txt", getpid());
}
fp = fopen(filename, "a");
if (fp == NULL)
printf("error!\n");
fprintf(fp, "Command buffer: 0x%08x, 0x%08x,\n",
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[0], 0);
fprintf(fp, "Command buffer: 0x%08x, 0x%08x,\n",
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[2], 0);
fclose(fp);
fp = NULL;
#endif
CMDBUF_OFFSET(*context) += 16;
return VG_LITE_SUCCESS;
}
static vg_lite_error_t flush(vg_lite_context_t *context)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
uint32_t address0 = 0x0A34;
uint32_t address1 = 0x0A1B;
uint32_t data0 = 0;
uint32_t data1 = 0x00000001;
uint32_t module = 7;
/* Check if there is a valid context and an allocated command buffer. */
if (!has_valid_command_buffer(context))
return VG_LITE_NO_CONTEXT;
/* Check if there is anything to flush. */
if (CMDBUF_OFFSET(*context) == 0)
return VG_LITE_INVALID_ARGUMENT;
/* Check if there is enough space in the command buffer. */
if (CMDBUF_OFFSET(*context) + 32 > CMDBUF_SIZE(*context)) {
return VG_LITE_OUT_OF_RESOURCES;
}
/* Finialize command buffer. */
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[0] = VG_LITE_STATE(address0);
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[1] = data0;
/* flush target */
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[2] = VG_LITE_STATE(address1);
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[3] = data1;
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[4] = VG_LITE_SEMAPHORE(module);
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[5] = 0;
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[6] = VG_LITE_STALL(module);
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[7] = 0;
CMDBUF_OFFSET(*context) += 32;
return error;
}
#endif /* VG_DRIVER_SINGLE_THREAD */
/* Submit the current command buffer to HW and reset the current command buffer offset. */
static vg_lite_error_t submit(vg_lite_context_t *context)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
vg_lite_kernel_submit_t submit;
/* Check if there is a valid context and an allocated command buffer. */
if (!has_valid_command_buffer(context))
return VG_LITE_NO_CONTEXT;
/* Check if there is anything to submit. */
if (CMDBUF_OFFSET(*context) == 0)
return VG_LITE_INVALID_ARGUMENT;
/* Check if there is enough space in the command buffer for the END. */
if (CMDBUF_OFFSET(*context) + 8 > CMDBUF_SIZE(*context)) {
/* Reset command buffer offset. */
CMDBUF_OFFSET(*context) = 0;
return VG_LITE_OUT_OF_RESOURCES;
}
/* Append END command into the command buffer. */
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[0] = VG_LITE_END(0);
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[1] = 0;
#if DUMP_COMMAND
if (strncmp(filename, "Commandbuffer", 13)) {
sprintf(filename, "Commandbuffer_pid%d.txt", getpid());
}
fp = fopen(filename, "a");
if (fp == NULL)
printf("error!\n");
fprintf(fp, "Command buffer: 0x%08x, 0x%08x,\n",
((uint32_t *) (CMDBUF_BUFFER(*context) + CMDBUF_OFFSET(*context)))[0], 0);
fprintf(fp, "Command buffer addr is : %p,\n", CMDBUF_BUFFER(*context));
fprintf(fp, "Command buffer offset is : %d,\n", CMDBUF_OFFSET(*context) + 8);
fclose(fp);
fp = NULL;
#endif
CMDBUF_OFFSET(*context) += 8;
/* Submit the command buffer. */
submit.context = &context->context;
submit.commands = CMDBUF_BUFFER(*context);
submit.command_size = CMDBUF_OFFSET(*context);
submit.command_id = CMDBUF_INDEX(*context);
#if defined(VG_DRIVER_SINGLE_THREAD)
/* Wait if GPU has not completed previous CMD buffer */
if (submit_flag) {
VG_LITE_RETURN_ERROR(stall(&s_context, 0, (uint32_t)~0));
}
#endif /* VG_DRIVER_SINGLE_THREAD */
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_SUBMIT, &submit));
#if defined(VG_DRIVER_SINGLE_THREAD)
submit_flag = 1;
#endif /* VG_DRIVER_SINGLE_THREAD */
vglitemDUMP_BUFFER("command", (unsigned int)CMDBUF_BUFFER(*context),
submit.context->command_buffer_logical[CMDBUF_INDEX(*context)], 0, submit.command_size);
vglitemDUMP("@[commit]");
/* Reset command buffer. */
CMDBUF_OFFSET(*context) = 0;
return error;
}
/* Wait for the HW to finish the current execution. */
#if defined(VG_DRIVER_SINGLE_THREAD)
static vg_lite_error_t stall(vg_lite_context_t *context, uint32_t time_ms, uint32_t mask)
#else
static vg_lite_error_t stall(vg_lite_context_t *context, uint32_t time_ms)
#endif /* VG_DRIVER_SINGLE_THREAD */
{
vg_lite_error_t error;
vg_lite_kernel_wait_t wait;
vglitemDUMP("@[stall]");
/* Wait until GPU is ready. */
wait.context = &context->context;
#if defined(VG_DRIVER_SINGLE_THREAD)
wait.timeout_ms = time_ms > 0 ? time_ms : VG_LITE_INFINITE;
wait.event_mask = mask;
#else
wait.timeout_ms = time_ms > 0 ? time_ms : VG_LITE_MAX_WAIT_TIME;
wait.command_id = CMDBUF_INDEX(*context);
#endif /* VG_DRIVER_SINGLE_THREAD */
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_WAIT, &wait));
#if defined(VG_DRIVER_SINGLE_THREAD)
submit_flag = 0;
#endif /* VG_DRIVER_SINGLE_THREAD */
return VG_LITE_SUCCESS;
}
/* Get the inversion of a matrix. */
VG_LITE_OPTIMIZE(LOW) static int inverse(vg_lite_matrix_t * result, vg_lite_matrix_t * matrix)
{
vg_lite_float_t det00, det01, det02;
vg_lite_float_t d;
int isAffine;
/* Test for identity matrix. */
if (matrix == NULL) {
result->m[0][0] = 1.0f;
result->m[0][1] = 0.0f;
result->m[0][2] = 0.0f;
result->m[1][0] = 0.0f;
result->m[1][1] = 1.0f;
result->m[1][2] = 0.0f;
result->m[2][0] = 0.0f;
result->m[2][1] = 0.0f;
result->m[2][2] = 1.0f;
/* Success. */
return 1;
}
det00 = (matrix->m[1][1] * matrix->m[2][2]) - (matrix->m[2][1] * matrix->m[1][2]);
det01 = (matrix->m[2][0] * matrix->m[1][2]) - (matrix->m[1][0] * matrix->m[2][2]);
det02 = (matrix->m[1][0] * matrix->m[2][1]) - (matrix->m[2][0] * matrix->m[1][1]);
/* Compute determinant. */
d = (matrix->m[0][0] * det00) + (matrix->m[0][1] * det01) + (matrix->m[0][2] * det02);
/* Return 0 if there is no inverse matrix. */
if (d == 0.0f)
return 0;
/* Compute reciprocal. */
d = 1.0f / d;
/* Determine if the matrix is affine. */
isAffine = (matrix->m[2][0] == 0.0f) && (matrix->m[2][1] == 0.0f) && (matrix->m[2][2] == 1.0f);
result->m[0][0] = d * det00;
result->m[0][1] = d * ((matrix->m[2][1] * matrix->m[0][2]) - (matrix->m[0][1] * matrix->m[2][2]));
result->m[0][2] = d * ((matrix->m[0][1] * matrix->m[1][2]) - (matrix->m[1][1] * matrix->m[0][2]));
result->m[1][0] = d * det01;
result->m[1][1] = d * ((matrix->m[0][0] * matrix->m[2][2]) - (matrix->m[2][0] * matrix->m[0][2]));
result->m[1][2] = d * ((matrix->m[1][0] * matrix->m[0][2]) - (matrix->m[0][0] * matrix->m[1][2]));
result->m[2][0] = isAffine ? 0.0f : d * det02;
result->m[2][1] = isAffine ? 0.0f : d * ((matrix->m[2][0] * matrix->m[0][1]) - (matrix->m[0][0] * matrix->m[2][1]));
result->m[2][2] = isAffine ? 1.0f : d * ((matrix->m[0][0] * matrix->m[1][1]) - (matrix->m[1][0] * matrix->m[0][1]));
/* Success. */
return 1;
}
/* Transform a 2D point by a given matrix. */
static int transform(vg_lite_point_t * result, vg_lite_float_t x, vg_lite_float_t y, vg_lite_matrix_t * matrix)
{
vg_lite_float_t pt_x;
vg_lite_float_t pt_y;
vg_lite_float_t pt_w;
/* Test for identity matrix. */
if (matrix == NULL) {
result->x = (int)x;
result->y = (int)y;
/* Success. */
return 1;
}
/* Transform x, y, and w. */
pt_x = (x * matrix->m[0][0]) + (y * matrix->m[0][1]) + matrix->m[0][2];
pt_y = (x * matrix->m[1][0]) + (y * matrix->m[1][1]) + matrix->m[1][2];
pt_w = (x * matrix->m[2][0]) + (y * matrix->m[2][1]) + matrix->m[2][2];
if (pt_w <= 0.0f)
return 0;
/* Compute projected x and y. */
result->x = (int)(pt_x / pt_w);
result->y = (int)(pt_y / pt_w);
/* Success. */
return 1;
}
/*!
Flush specific VG module.
*/
static vg_lite_error_t flush_target()
{
vg_lite_error_t error = VG_LITE_SUCCESS;
#if defined(VG_DRIVER_SINGLE_THREAD)
vg_lite_context_t *ctx = &s_context;
#else
vg_lite_context_t *ctx;
vg_lite_tls_t* tls;
tls = (vg_lite_tls_t *) vg_lite_os_get_tls();
if(tls == NULL)
return VG_LITE_NO_CONTEXT;
ctx = &tls->t_context;
#endif /* VG_DRIVER_SINGLE_THREAD */
do {
VG_LITE_BREAK_ERROR(push_state(ctx, 0x0A1B, 0x00000001));
VG_LITE_BREAK_ERROR(push_stall(ctx, 7));
} while (0);
return error;
}
/****************** FAST_CLEAR feature implementation. ***************/
#if VG_TARGET_FAST_CLEAR
static vg_lite_error_t convert_color(vg_lite_buffer_format_t format, uint32_t value, uint32_t *result, int *bpp)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
uint32_t r, g, b, a;
int Bpp = 0;
r = B(value);
g = G(value);
b = R(value);
a = A(value);
do {
switch (format) {
case VG_LITE_RGBA8888:
*result = ARGB(a, b, g, r);
Bpp = 32;
break;
case VG_LITE_BGRA8888:
*result = ARGB(a, r, g, b);
Bpp = 32;
break;
case VG_LITE_RGBX8888:
*result = ARGB(0xff, b, g, r);
Bpp = 32;
break;
case VG_LITE_BGRX8888:
*result = ARGB(0xff, r, g, b);
Bpp = 32;
break;
case VG_LITE_RGBA4444:
*result = ARGB4(a, b, g, r);
Bpp = 16;
break;
case VG_LITE_BGRA4444:
*result = ARGB4(a, r, g, b);
Bpp = 16;
break;
case VG_LITE_RGB565:
*result = ((b & 0xf8) << 8) |
((g & 0xfc) << 3) |
((r & 0xf8) >> 3);
Bpp = 16;
break;
case VG_LITE_BGR565:
*result = ((r & 0xf8) << 8) |
((g & 0xfc) << 3) |
((b & 0xf8) >> 3);
Bpp = 16;
break;
case VG_LITE_BGRA5551:
*result = ((b & 0xf8) << 8) |
((g & 0xf8) << 3) |
((r & 0xf8) >> 2) |
((a & 0x80) >> 7);
Bpp = 16;
break;
case VG_LITE_A8:
*result = ARGB(a, a, a, a);
Bpp = 8;
break;
case VG_LITE_L8:
*result = ARGB(r, r, r, r);
Bpp = 8;
break;
default:
error = VG_LITE_NOT_SUPPORT;
break;
}
} while (0);
if (bpp != NULL) {
*bpp = Bpp;
}
if (Bpp == 16) {
*result = ((*result) << 16) | (*result);
}
return error;
}
/* Fill Target buffer by FC buffer. Only used in cmodel/fpga for verification. */
#if defined(DEBUG) || defined(_DEBUG)
static vg_lite_error_t fill_fc_target(vg_lite_buffer_t *target, vg_lite_buffer_t *fcb)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
uint8_t *fc = (uint8_t *)fcb->memory;
uint16_t *target16;
uint32_t *target32;
uint8_t *target8;
uint32_t clear32;
int byte_done = 0;
int i, j, k;
int bpp;
do {
convert_color(target->format, s_context.clearValue, &clear32, &bpp);
if (bpp == 32) {
target32 = (uint32_t *)target->memory;
for (i = 0; i < fcb->width; i++) {
for (j = 0; j < 8; j++) { /* Loop the bits*/
if (!(((*fc) >> j) & 1)) {
for (k = 0; k < 64 / 4; k++) {
target32[k] = clear32;
byte_done+=4;
if (byte_done >= target->stride * target->height) {
return error;
}
}
}
target32 += 64/4;
}
fc++;
}
}
else if (bpp == 16){
target16 = (uint16_t *)target->memory;
for (i = 0; i < fcb->width; i++) {
for (j = 0; j < 8; j++) { /* Loop the bits*/
if (!(((*fc) >> j) & 1)) {
for (k = 0; k < 64 / 2; k++) {
target16[k] = (uint16_t)clear32;
byte_done+=2;
if (byte_done >= target->stride * target->height) {
return error;
}
}
}
target16 += 64/2;
}
fc++;
}
}
else if (bpp == 8) {
target8 = (uint8_t *)target->memory;
for (i = 0; i < fcb->width; i++) {
for (j = 0; j < 8; j++) { /* Loop the bits*/
if (!(((*fc) >> j) & 1)) {
for (k = 0; k < 64; k++) {
target8[k] = (uint8_t)clear32;
byte_done++;
if (byte_done >= target->stride * target->height) {
return error;
}
}
}
target8 += 64;
}
fc++;
}
}
} while (0);
return error;
}
#endif
/* Update the fast_clear buffer when render target switched. */
static vg_lite_error_t update_fc_buffer(vg_lite_buffer_t *target)
{
int rt_bytes;
vg_lite_error_t error = VG_LITE_SUCCESS;
vg_lite_context_t *context = GET_CONTEXT();
vg_lite_kernel_allocate_t allocate;
do {
if (target == NULL) {
error = VG_LITE_INVALID_ARGUMENT;
break;
}
rt_bytes = target->stride * target->height;
rt_bytes = VG_LITE_ALIGN(rt_bytes, (FC_BIT_TO_BYTES * 8));
rt_bytes = rt_bytes / FC_BIT_TO_BYTES / 8;
/* Only allocate new buffer when the allocated is not big enough. Yes*/
if (rt_bytes > context->fcBuffer.stride ) {
vg_lite_free(&context->fcBuffer);
context->fcBuffer.width = rt_bytes; /* The actually used bytes. */
rt_bytes = VG_LITE_ALIGN(rt_bytes, FC_BURST_BYTES); /* The allocated aligned bytes. */
context->fcBuffer.stride = rt_bytes;
allocate.bytes = rt_bytes;
allocate.contiguous = 1;
VG_LITE_BREAK_ERROR(vg_lite_kernel(VG_LITE_ALLOCATE, &allocate));
context->fcBuffer.handle = allocate.memory_handle;
context->fcBuffer.memory = allocate.memory;
context->fcBuffer.address = allocate.memory_gpu;
}
else {
/* Just update the fc buffer size. */
context->fcBuffer.width = rt_bytes;
}
memset(context->fcBuffer.memory, 0xff, context->fcBuffer.stride);
} while (0);
return error;
}
/* Update FC registers and clear FC buffer. */
static vg_lite_error_t clear_fc(uint32_t value)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
vg_lite_context_t *context = GET_CONTEXT();
uint32_t bytes_to_clear = context->fcBuffer.stride / FC_BURST_BYTES;
do {
VG_LITE_BREAK_ERROR(push_state(context, 0x0A9A, context->fcBuffer.address)); /* FC buffer address. */
VG_LITE_BREAK_ERROR(push_state(context, 0x0A9B, value)); /* FC clear value. */
VG_LITE_BREAK_ERROR(push_state(context, 0x0AB0, 0x80000000 | bytes_to_clear)); /* FC clear command. */
} while (0);
return error;
}
#if VG_TARGET_FC_DUMP
static int fc_buf_dump(vg_lite_buffer_t *target, vg_lite_buffer_t *fcb)
{
int error = VG_LITE_SUCCESS;
uint8_t *fc = (uint8_t *)fcb->memory;
uint8_t *target8;
int byte_done = 0;
int target_bytes;
int i, j;
static unsigned s_cnt;
unsigned cnt = s_cnt;
FILE *fpFCBuf;
FILE *fpTargetBuf;
FILE *fpTargetBufInfo;
char buf[256];
s_cnt++;
sprintf(buf, "vg255v2.fc_buf.f%04d.txt", cnt);
fpFCBuf = fopen(buf, "wt");
if (NULL == fpFCBuf) {
fprintf(stderr, "[Warning] Open file \'%s\' fail.\n", buf);
return -1;
}
sprintf(buf, "vg255v2.target_buf_info.f%04d.txt", cnt);
fpTargetBufInfo = fopen(buf, "wt");
if (NULL == fpTargetBufInfo) {
fprintf(stderr, "[Warning] Open file \'%s\' fail.\n", buf);
fclose(fpFCBuf);
return -1;
} else {
fprintf(fpTargetBufInfo, "%-12s: %d\n", "format", target->format);
fprintf(fpTargetBufInfo, "%-12s: %d\n", "tiled", target->tiled);
fprintf(fpTargetBufInfo, "%-12s: %d\n", "width", target->width);
fprintf(fpTargetBufInfo, "%-12s: %d\n", "height", target->height);
fprintf(fpTargetBufInfo, "%-12s: %d\n", "stride", target->stride);
fclose(fpTargetBufInfo);
}
sprintf(buf, "vg255v2.target_buf.f%04d.txt", cnt);
fpTargetBuf = fopen(buf, "wt");
if (NULL == fpTargetBuf) {
fprintf(stderr, "[Warning] Open file \'%s\' fail.\n", buf);
fclose(fpFCBuf);
return -1;
}
/* Dump FC buffer & Dump target buffer */
target8 = (uint8_t *)target->memory;
target_bytes = target->stride * target->height;
for (i = 0; i < fcb->width; ++i)
{
fprintf(fpFCBuf, "%02x\n", fc[i]);
/* 1 byte of fc related with 512 bytes of target buffer */
for (j = 0; j < 128; ++j) {
fprintf(fpTargetBuf, "%02x", byte_done < target_bytes ? target8[0] : 0);
byte_done++;
fprintf(fpTargetBuf, "%02x", byte_done < target_bytes ? target8[1] : 0);
byte_done++;
fprintf(fpTargetBuf, "%02x", byte_done < target_bytes ? target8[2] : 0);
byte_done++;
fprintf(fpTargetBuf, "%02x\n", byte_done < target_bytes ? target8[3] : 0);
byte_done++;
target8 += 4;
}
}
fclose(fpFCBuf);
fclose(fpTargetBuf);
return error;
}
#endif /* VG_TARGET_FC_DUMP */
#endif
/* Set the current render target. */
#if defined(VG_DRIVER_SINGLE_THREAD)
static vg_lite_error_t set_render_target(vg_lite_buffer_t *target)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
uint32_t yuv2rgb = 0;
uint32_t uv_swiz = 0;
int32_t tiled;
int32_t dst_align_width;
uint32_t mul, div, align;
if(target == NULL) {
return VG_LITE_INVALID_ARGUMENT;
} else if(s_context.scissor_enabled && (s_context.scissor[2] <= 0 || s_context.scissor[3] <= 0)) {
/* Check scissoring rectangle dimensions
A scissoring rectangle with width <= 0 or height <= 0 must be
ignored. If scissoring is enabled and no valid scissoring rectangles
are present, no drawing occurs. */
return VG_LITE_NO_CONTEXT;
}
/* Skip if render target and scissor are not changed. */
if ((s_context.rtbuffer != NULL) &&
!(memcmp(s_context.rtbuffer,target,sizeof(vg_lite_buffer_t))) &&
(s_context.scissor_dirty == 0) && (s_context.premultiply_dirty == 0))
{
return VG_LITE_SUCCESS;
}
if ((target != NULL) &&
(target->format == VG_LITE_YUY2 ||
target->format == VG_LITE_AYUY2 ||
target->format == VG_LITE_YUY2_TILED ||
target->format == VG_LITE_AYUY2_TILED))
{
return VG_LITE_NOT_SUPPORT;
}
#if VG_TARGET_FAST_CLEAR
/* Flush target if necessary when switching. */
if (s_context.rtbuffer&& s_context.rtbuffer->memory) { /* If it's not the first time to set target. */
vg_lite_finish();
}
update_fc_buffer(target);
#else
if (s_context.rtbuffer && s_context.rtbuffer->memory) {
/* Flush the old target. */
vg_lite_finish();
}
#endif
tiled = (target->tiled != VG_LITE_LINEAR) ? 0x10000000 : 0;
if (((target->format >= VG_LITE_YUY2) &&
(target->format <= VG_LITE_AYUY2)) ||
((target->format >= VG_LITE_YUY2_TILED) &&
(target->format <= VG_LITE_AYUY2_TILED))) {
yuv2rgb = convert_yuv2rgb(target->yuv.yuv2rgb);
uv_swiz = convert_uv_swizzle(target->yuv.swizzle);
}
/* Program render target. */
if (s_context.premultiply_dirty || s_context.rtbuffer != target || memcmp(s_context.rtbuffer,target,sizeof(vg_lite_buffer_t)) ) {
if(target->tiled == VG_LITE_TILED) {
if((target->stride % DEST_ALIGNMENT_LIMITATION) != 0)
return VG_LITE_INVALID_ARGUMENT;
}
if(s_context.premultiply_enabled) {
VG_LITE_RETURN_ERROR(push_state(&s_context, 0x0A10,
convert_target_format(target->format, s_context.capabilities) | 0x00010000 | uv_swiz | yuv2rgb));
}else {
VG_LITE_RETURN_ERROR(push_state(&s_context, 0x0A10,
convert_target_format(target->format, s_context.capabilities) | 0x00010000 | uv_swiz | yuv2rgb | 0x100));
}
if (target->yuv.uv_planar)
{ /* Program uv plane address if necessary. */
VG_LITE_RETURN_ERROR(push_state(&s_context, 0x0A5C, target->yuv.uv_planar));
}
if (target->yuv.alpha_planar) {
VG_LITE_RETURN_ERROR(push_state(&s_context, 0x0A5D, target->yuv.alpha_planar));
}
VG_LITE_RETURN_ERROR(push_state(&s_context, 0x0A11, target->address));
VG_LITE_RETURN_ERROR(push_state(&s_context, 0x0A12, target->stride | tiled));
s_context.premultiply_dirty = 0;
}
get_format_bytes(target->format, &mul, &div, &align);
dst_align_width = target->stride * div / mul;
if (s_context.scissor_dirty != 0) {
if (s_context.scissor_enabled) {
VG_LITE_RETURN_ERROR(push_state(&s_context, 0x0A13, (s_context.scissor[0] + s_context.scissor[2]) | ((s_context.scissor[1] + s_context.scissor[3]) << 16)));
}
else {
VG_LITE_RETURN_ERROR(push_state(&s_context, 0x0A13, dst_align_width | (target->height << 16)));
}
s_context.scissor_dirty = 0;
}
else {
VG_LITE_RETURN_ERROR(push_state(&s_context, 0x0A13, dst_align_width | (target->height << 16)));
}
memcpy(s_context.rtbuffer, target, sizeof(vg_lite_buffer_t));
return error;
}
#else
static vg_lite_error_t set_render_target(vg_lite_buffer_t *target)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
uint32_t yuv2rgb = 0;
uint32_t uv_swiz = 0;
int32_t tiled;
vg_lite_tls_t* tls;
int32_t dst_align_width;
uint32_t mul, div, align;
tls = (vg_lite_tls_t *) vg_lite_os_get_tls();
if(tls == NULL)
return VG_LITE_NO_CONTEXT;
if(target == NULL) {
return VG_LITE_INVALID_ARGUMENT;
} else if(tls->t_context.scissor_enabled && (tls->t_context.scissor[2] <= 0 || tls->t_context.scissor[3] <= 0)) {
/* Check scissoring rectangle dimensions
A scissoring rectangle with width <= 0 or height <= 0 must be
ignored. If scissoring is enabled and no valid scissoring rectangles
are present, no drawing occurs. */
return VG_LITE_NO_CONTEXT;
}
tls->t_context.start_offset = CMDBUF_OFFSET(tls->t_context);
if ((target != NULL) &&
(target->format == VG_LITE_YUY2 ||
target->format == VG_LITE_AYUY2 ||
target->format == VG_LITE_YUY2_TILED ||
target->format == VG_LITE_AYUY2_TILED))
{
return VG_LITE_NOT_SUPPORT;
}
#if VG_TARGET_FAST_CLEAR
/* Flush target if necessary when switching. */
if (tls->t_context.rtbuffer != NULL) { /* If it's not the first time to set target. */
vg_lite_finish();
}
update_fc_buffer(target);
#endif
tiled = (target->tiled != VG_LITE_LINEAR) ? 0x10000000 : 0;
if (((target->format >= VG_LITE_YUY2) &&
(target->format <= VG_LITE_AYUY2)) ||
((target->format >= VG_LITE_YUY2_TILED) &&
(target->format <= VG_LITE_AYUY2_TILED))) {
yuv2rgb = convert_yuv2rgb(target->yuv.yuv2rgb);
uv_swiz = convert_uv_swizzle(target->yuv.swizzle);
}
/* Program render target. */
if(target->tiled == VG_LITE_TILED) {
if((target->stride % DEST_ALIGNMENT_LIMITATION) != 0)
return VG_LITE_INVALID_ARGUMENT;
}
if(tls->t_context.premultiply_enabled) {
VG_LITE_RETURN_ERROR(push_state(&tls->t_context, 0x0A10,
convert_target_format(target->format, tls->t_context.capabilities) | 0x00010000 | uv_swiz | yuv2rgb));
} else {
VG_LITE_RETURN_ERROR(push_state(&tls->t_context, 0x0A10,
convert_target_format(target->format, tls->t_context.capabilities) | 0x00010000 | uv_swiz | yuv2rgb | 0x100));
}
if (target->yuv.uv_planar)
{ /* Program uv plane address if necessary. */
VG_LITE_RETURN_ERROR(push_state(&tls->t_context, 0x0A5C, target->yuv.uv_planar));
}
if (target->yuv.alpha_planar) {
VG_LITE_RETURN_ERROR(push_state(&tls->t_context, 0x0A5D, target->yuv.alpha_planar));
}
VG_LITE_RETURN_ERROR(push_state(&tls->t_context, 0x0A11, target->address));
VG_LITE_RETURN_ERROR(push_state(&tls->t_context, 0x0A12, target->stride | tiled));
get_format_bytes(target->format, &mul, &div, &align);
dst_align_width = target->stride * div / mul;
if (tls->t_context.scissor_enabled) {
VG_LITE_RETURN_ERROR(push_state(&tls->t_context, 0x0A13, (tls->t_context.scissor[0] + tls->t_context.scissor[2]) | ((tls->t_context.scissor[1] + tls->t_context.scissor[3]) << 16)));
}
else {
VG_LITE_RETURN_ERROR(push_state(&tls->t_context, 0x0A13, dst_align_width | (target->height << 16)));
}
tls->t_context.rtbuffer = target;
return error;
}
#endif /* VG_DRIVER_SINGLE_THREAD */
static inline vg_lite_error_t transform_bounding_box(vg_lite_rectangle_t *in_bbx,
vg_lite_matrix_t *matrix,
vg_lite_rectangle_t *clip,
vg_lite_rectangle_t *out_bbx,
vg_lite_point_t *origin)
{
vg_lite_point_t temp;
memset(out_bbx, 0, sizeof(vg_lite_rectangle_t));
/* Transform image point (x, y). */
if (!transform(&temp, in_bbx->x, in_bbx->y, matrix))
return VG_LITE_INVALID_ARGUMENT;
out_bbx->x = temp.x;
out_bbx->y = temp.y;
/* Provide position of the new origin to the caller if requested. */
if (origin != NULL) {
origin->x = temp.x;
origin->y = temp.y;
}
/* Transform image point (x, y+height). */
if (!transform(&temp, in_bbx->x, (in_bbx->y + in_bbx->height), matrix))
return VG_LITE_INVALID_ARGUMENT;
UPDATE_BOUNDING_BOX(*out_bbx, temp);
/* Transform image point (x+width, y+height). */
if (!transform(&temp, (in_bbx->x + in_bbx->width), (in_bbx->y + in_bbx->height),
matrix))
return VG_LITE_INVALID_ARGUMENT;
UPDATE_BOUNDING_BOX(*out_bbx, temp);
/* Transform image point (x+width, y). */
if (!transform(&temp, (in_bbx->x + in_bbx->width), in_bbx->y, matrix))
return VG_LITE_INVALID_ARGUMENT;
UPDATE_BOUNDING_BOX(*out_bbx, temp);
/* Clip is required */
if (clip) {
out_bbx->x = MAX(out_bbx->x, clip->x);
out_bbx->y = MAX(out_bbx->y, clip->y);
out_bbx->width = MIN((out_bbx->x + out_bbx->width), (clip->x + clip->width)) - out_bbx->x;
out_bbx->height = MIN((out_bbx->y + out_bbx->height), (clip->y + clip->height)) - out_bbx->y;
}
return VG_LITE_SUCCESS;
}
#if (VG_BLIT_WORKAROUND == 1)
/*
* Calculates the minimal possible target buffer starting from a given target
* buffer and considering a source texture (to blit), graphic transformations
* and clipping window.
*/
static vg_lite_error_t config_new_target(vg_lite_buffer_t *target,
vg_lite_buffer_t *source,
vg_lite_matrix_t *matrix,
vg_lite_rectangle_t *bbx,
vg_lite_buffer_t *new_target)
{
uint8_t *p;
vg_lite_point_t origin;
vg_lite_rectangle_t src_bbx, bounding_box, clip;
int tx, ty;
uint32_t mul, div, required_align, align;
/*
* Acquire the bounding box of the transformed source image and the location
* of its origin.
*/
memset(&src_bbx, 0, sizeof(vg_lite_rectangle_t));
src_bbx.width = source->width;
src_bbx.height = source->height;
if (bbx == NULL) {
/*
* If no clipping rectangle provided, just configure the clip bounds to
* be as big as the target
*/
memset(&clip, 0, sizeof(vg_lite_rectangle_t));
clip.width = target->width;
clip.height = target->height;
} else {
/* Otherwise clip according to the bounding box specified by the caller */
memcpy(&clip, bbx, sizeof(vg_lite_rectangle_t));
}
transform_bounding_box(&src_bbx, matrix, &clip, &bounding_box, &origin);
/* Calculate the data address of the new target */
get_format_bytes(target->format, &mul, &div, &required_align);
p = target->memory;
p += bounding_box.y * target->stride + bounding_box.x * (mul / div);
align = (uint32_t)p & (required_align - 1);
p -= align;
/*
* Update pixel coordinate of the base address. The width of the target will
* increase, since the x coordinate of the bounding box decreases to
* accomodate the image data alignment.
*/
tx = align / (mul / div);
bounding_box.x -= tx;
bounding_box.width += tx;
/* Update bounding box if provided by the caller */
if (bbx) {
bbx->x = tx;
bbx->y = 0;
}
/* Calculate translation from the source image origin to the target origin. */
tx = origin.x - bounding_box.x;
ty = origin.y - bounding_box.y;
/* Copy content of the target buffer descriptor into the new target. */
memcpy(new_target, target, sizeof(vg_lite_buffer_t));
/* Update the new buffer */
new_target->memory = p;
new_target->address = (uint32_t) p;
new_target->width = bounding_box.width;
new_target->height = bounding_box.height;
/* Update matrix */
matrix->m[0][2] = tx;
matrix->m[1][2] = ty;
return VG_LITE_SUCCESS;
}
#endif /* VG_BLIT_WORKAROUND */
static vg_lite_error_t set_interpolation_steps(vg_lite_buffer_t *target,
vg_lite_float_t s_width,
vg_lite_float_t s_height,
vg_lite_matrix_t *matrix)
{
vg_lite_matrix_t im;
vg_lite_rectangle_t src_bbx, bounding_box, clip;
vg_lite_float_t xs[3], ys[3], cs[3];
vg_lite_error_t error = VG_LITE_SUCCESS;
float dx = 0.0f, dy = 0.0f;
#if defined(VG_DRIVER_SINGLE_THREAD)
vg_lite_context_t *ctx = &s_context;
#else
vg_lite_context_t *ctx;
vg_lite_tls_t *tls;
tls = (vg_lite_tls_t *) vg_lite_os_get_tls();
if(tls == NULL)
return VG_LITE_NO_CONTEXT;
ctx = &tls->t_context;
#endif /* VG_DRIVER_SINGLE_THREAD */
#define ERR_LIMIT 0.0000610351562f
/* Get bounding box. */
memset(&src_bbx, 0, sizeof(vg_lite_rectangle_t));
memset(&clip, 0, sizeof(vg_lite_rectangle_t));
src_bbx.width = (int32_t)s_width;
src_bbx.height = (int32_t)s_height;
if (ctx->scissor_enabled) {
clip.x = ctx->scissor[0];
clip.y = ctx->scissor[1];
clip.width = ctx->scissor[2];
clip.height = ctx->scissor[3];
} else {
clip.x = clip.y = 0;
clip.width = ctx->rtbuffer->width;
clip.height = ctx->rtbuffer->height;
}
transform_bounding_box(&src_bbx, matrix, &clip, &bounding_box, NULL);
/* Compute inverse matrix. */
if (!inverse(&im, matrix))
return VG_LITE_INVALID_ARGUMENT;
/* Compute interpolation steps. */
/* X step */
xs[0] = im.m[0][0] / s_width;
xs[1] = im.m[1][0] / s_height;
xs[2] = im.m[2][0];
/* Y step */
ys[0] = im.m[0][1] / s_width;
ys[1] = im.m[1][1] / s_height;
ys[2] = im.m[2][1];
/* C step 2 */
cs[2] = 0.5f * (im.m[2][0] + im.m[2][1]) + im.m[2][2];
/* Keep track of the rounding errors (underflow) */
if (ctx->chip_id == GPU_CHIP_ID_GCNanoliteV) {
/* Check if matrix has rotation or perspective transformations */
if (matrix != NULL &&
(matrix->m[0][1] != 0.0f || matrix->m[1][0] != 0.0f ||
matrix->m[2][0] != 0.0f || matrix->m[2][1] != 0.0f ||
matrix->m[2][2] != 1.0f)) {
if (xs[0] != 0.0f && -ERR_LIMIT < xs[0] && xs[0] < ERR_LIMIT)
dx = 0.5f * (2 * bounding_box.x + bounding_box.width) * im.m[0][0];
else if (ys[0] != 0.0f && -ERR_LIMIT < ys[0] && ys[0] < ERR_LIMIT)
dx = 0.5f * (2 * bounding_box.y + bounding_box.height) * im.m[0][1];
if (xs[1] != 0.0f && -ERR_LIMIT < xs[1] && xs[1] < ERR_LIMIT)
dy = 0.5f * (2 * bounding_box.x + bounding_box.width) * im.m[1][0];
else if (ys[1] != 0.0f && -ERR_LIMIT < ys[1] && ys[1] < ERR_LIMIT)
dy = 0.5f * (2 * bounding_box.y + bounding_box.height) * im.m[1][1];
}
}
/* C step 0, 1*/
cs[0] = (0.5f * (im.m[0][0] + im.m[0][1]) + im.m[0][2] + dx) / s_width;
cs[1] = (0.5f * (im.m[1][0] + im.m[1][1]) + im.m[1][2] + dy) / s_height;
/* Set command buffer */
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A18, (void *)&cs[0]));
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A19, (void *)&cs[1]));
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A1A, (void *)&cs[2]));
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A1C, (void *)&xs[0]));
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A1D, (void *)&xs[1]));
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A1E, (void *)&xs[2]));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A1F, 0x00000001));
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A20, (void *)&ys[0]));
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A21, (void *)&ys[1]));
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A22, (void *)&ys[2]));
return VG_LITE_SUCCESS;
}
/*************** API Functions ***********************************************/
vg_lite_error_t vg_lite_get_transform_matrix(vg_lite_point4_t src, vg_lite_point4_t dst,vg_lite_matrix_t *mat)
{
float a[8][8],b[9],A[64];
int i, j, k, m = 8, n = 1;
int astep = 8,bstep = 1;
float d;
if(src == NULL || dst == NULL || mat == NULL)
return VG_LITE_INVALID_ARGUMENT;
for(i = 0; i < 4; ++i )
{
a[i][0] = a[i+4][3] = src[i].x;
a[i][1] = a[i+4][4] = src[i].y;
a[i][2] = a[i+4][5] = 1;
a[i][3] = a[i][4] = a[i][5] =
a[i+4][0] = a[i+4][1] = a[i+4][2] = 0;
a[i][6] = -src[i].x*dst[i].x;
a[i][7] = -src[i].y*dst[i].x;
a[i+4][6] = -src[i].x*dst[i].y;
a[i+4][7] = -src[i].y*dst[i].y;
b[i] = dst[i].x;
b[i+4] = dst[i].y;
}
for(i = 0; i < 8; ++i )
{
for(j = 0; j < 8; ++j )
{
A[8 * i + j] = a[i][j];
}
}
for (i = 0; i < m; i++)
{
k = i;
for (j = i + 1; j < m; j++)
if (ABS(A[j*astep + i]) > ABS(A[k*astep + i]))
k = j;
if (ABS(A[k*astep + i]) < EPS)
return VG_LITE_INVALID_ARGUMENT;
if (k != i)
{
for (j = i; j < m; j++)
swap(&A[i*astep + j], &A[k*astep + j]);
for (j = 0; j < n; j++)
swap(&b[i*bstep + j], &b[k*bstep + j]);
}
d = -1 / A[i*astep + i];
for (j = i + 1; j < m; j++)
{
float alpha = A[j*astep + i] * d;
for (k = i + 1; k < m; k++)
A[j*astep + k] += alpha * A[i*astep + k];
for (k = 0; k < n; k++)
b[j*bstep + k] += alpha * b[i*bstep + k];
}
}
for (i = m - 1; i >= 0; i--)
for (j = 0; j < n; j++)
{
float s = b[i*bstep + j];
for (k = i + 1; k < m; k++)
s -= A[i*astep + k] * b[k*bstep + j];
b[i*bstep + j] = s / A[i*astep + i];
}
b[8] = 1;
for(i = 0; i < 3; ++i )
{
for(j = 0; j < 3; ++j )
{
mat->m[i][j] = b[i* 3 + j];
}
}
return VG_LITE_SUCCESS;
}
vg_lite_error_t vg_lite_clear(vg_lite_buffer_t * target,
vg_lite_rectangle_t * rectangle,
vg_lite_color_t color)
{
vg_lite_error_t error;
int32_t x, y, width, height;
uint32_t color32;
#if defined(VG_DRIVER_SINGLE_THREAD)
vg_lite_context_t *ctx = &s_context;
#else
vg_lite_context_t *ctx;
vg_lite_tls_t* tls;
tls = (vg_lite_tls_t *) vg_lite_os_get_tls();
if(tls == NULL)
return VG_LITE_NO_CONTEXT;
ctx = &tls->t_context;
#endif /* VG_DRIVER_SINGLE_THREAD */
error = set_render_target(target);
if (error != VG_LITE_SUCCESS) {
return error;
} else if (error == VG_LITE_NO_CONTEXT) {
/* If scissoring is enabled and no valid scissoring rectangles
are present, no drawing occurs */
return VG_LITE_SUCCESS;
}
/* Get rectangle. */
x = (rectangle != NULL) ? rectangle->x : 0;
y = (rectangle != NULL) ? rectangle->y : 0;
width = (rectangle != NULL) ? rectangle->width : ctx->rtbuffer->width;
height = (rectangle != NULL) ? rectangle->height : ctx->rtbuffer->height;
/* Compute the valid rectangle. */
if (x < 0)
{
width += x;
x = 0;
}
if (y < 0)
{
height += y;
y = 0;
}
if (ctx->scissor_enabled)
{
int right, bottom;
right = x + width;
bottom = y + height;
/* Bounds check. */
if ((ctx->scissor[0] >= x + width) ||
(ctx->scissor[0] + ctx->scissor[2] <= x) ||
(ctx->scissor[1] >= y + height) ||
(ctx->scissor[1] + ctx->scissor[3] <= y))
{
/* Do nothing. */
return VG_LITE_SUCCESS;
}
/* Intersects the scissor and the rectangle. */
x = (x > ctx->scissor[0] ? x : ctx->scissor[0]);
y = (y > ctx->scissor[1] ? y : ctx->scissor[1]);
right = (right < ctx->scissor[0] + ctx->scissor[2] ? right : ctx->scissor[0] + ctx->scissor[2]);
bottom = (bottom < ctx->scissor[1] + ctx->scissor[3] ? bottom : ctx->scissor[1] + ctx->scissor[3]);
width = right - x;
height = bottom - y;
}
/* Get converted color when target is in L8 format. */
color32 = (target->format == VG_LITE_L8) ? rgb_to_l(color) : color;
#if VG_TARGET_FAST_CLEAR
if ((rectangle == NULL) ||
((x == 0) && (y == 0) &&
(width == ctx->rtbuffer->width) &&
(height == ctx->rtbuffer->height))) {
ctx->clearValue = color32;
convert_color(ctx->rtbuffer->format, color32, &color32, NULL);
clear_fc((uint32_t)color32);
}
else
#endif
{
/* Setup the command buffer. */
if(ctx->premultiply_enabled) {
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A00, 0x00000001));
} else {
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A00, 0x10000001));
}
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A02, color32));
VG_LITE_RETURN_ERROR(push_rectangle(ctx, x, y, width, height));
VG_LITE_RETURN_ERROR(flush_target());
}
/* Success. */
return VG_LITE_SUCCESS;
}
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 error;
vg_lite_rectangle_t src_bbx, bounding_box, clip;
uint32_t imageMode;
uint32_t blend_mode;
uint32_t transparency_mode = 0;
vg_lite_blend_t forced_blending = blend;
uint32_t conversion = 0;
uint32_t tiled_source;
#if (VG_BLIT_WORKAROUND == 1)
vg_lite_matrix_t new_matrix;
vg_lite_buffer_t new_target;
#endif /* VG_BLIT_WORKAROUND */
#if defined(VG_DRIVER_SINGLE_THREAD)
vg_lite_context_t *ctx = &s_context;
#else
vg_lite_context_t *ctx;
vg_lite_tls_t *tls;
tls = (vg_lite_tls_t *) vg_lite_os_get_tls();
if(tls == NULL)
return VG_LITE_NO_CONTEXT;
ctx = &tls->t_context;
#endif /* VG_DRIVER_SINGLE_THREAD */
/* Calculate bounding box */
memset(&src_bbx, 0, sizeof(vg_lite_rectangle_t));
memset(&clip, 0, sizeof(vg_lite_rectangle_t));
src_bbx.width = source->width;
src_bbx.height = source->height;
if (ctx->scissor_enabled) {
clip.x = ctx->scissor[0];
clip.y = ctx->scissor[1];
clip.width = ctx->scissor[2];
clip.height = ctx->scissor[3];
} else {
clip.width = target->width;
clip.height = target->height;
}
transform_bounding_box(&src_bbx, matrix, &clip, &bounding_box, NULL);
#if (VG_BLIT_WORKAROUND==1)
/*
* The blit output quality workaround works only for afine transformations
* because it is based on the process of cumulating translations into the
* matrix. This process is not possible for non-affine transformations, such
* as the perspective projections.
*/
if ((matrix->m[2][0] == 0) && (matrix->m[2][1] == 0)) {
/*
* Make a local copy of the transformation matrix in order not to mess
* up the user's matrix.
*/
memcpy(&new_matrix, matrix, sizeof(vg_lite_matrix_t));
matrix = &new_matrix;
config_new_target(target, source, matrix, &bounding_box, &new_target);
target = &new_target;
}
#endif /* VG_BLIT_WORKAROUND */
error = set_render_target(target);
if (error != VG_LITE_SUCCESS) {
return error;
} else if (error == VG_LITE_NO_CONTEXT) {
/* If scissoring is enabled and no valid scissoring rectangles
are present, no drawing occurs */
return VG_LITE_SUCCESS;
}
transparency_mode = (source->transparency_mode == VG_LITE_IMAGE_TRANSPARENT ? 0x8000:0);
/* Check if the specified matrix has rotation or perspective. */
if ( (matrix != NULL)
&& ( (matrix->m[0][1] != 0.0f)
|| (matrix->m[1][0] != 0.0f)
|| (matrix->m[2][0] != 0.0f)
|| (matrix->m[2][1] != 0.0f)
|| (matrix->m[2][2] != 1.0f)
)
&& ( blend == VG_LITE_BLEND_NONE
|| blend == VG_LITE_BLEND_SRC_IN
|| blend == VG_LITE_BLEND_DST_IN
)
) {
if(vg_lite_query_feature(gcFEATURE_BIT_VG_BORDER_CULLING)) {
/* Mark that we have rotation. */
transparency_mode = 0x8000;
}else
{
blend_mode = VG_LITE_BLEND_SRC_OVER;
}
}
/* Check whether L8 is supported or not. */
if ((target->format == VG_LITE_L8) && ((source->format != VG_LITE_L8) && (source->format != VG_LITE_A8))) {
conversion = 0x80000000;
}
/* determine if source specify bytes are aligned */
error = _check_source_aligned(source->format,source->stride);
if (error != VG_LITE_SUCCESS) {
return error;
}
/* Determine image mode (NORMAL, NONE or MULTIPLY) depending on the color. */
imageMode = (source->image_mode == VG_LITE_NONE_IMAGE_MODE) ? 0 : (source->image_mode == VG_LITE_MULTIPLY_IMAGE_MODE) ? 0x00002000 : 0x00001000;
blend_mode = convert_blend(forced_blending);
tiled_source = (source->tiled != VG_LITE_LINEAR) ? 0x10000000 : 0 ;
#if !defined(VG_DRIVER_SINGLE_THREAD)
/* Setup the command buffer. */
if(source->format >= VG_LITE_INDEX_1 && source->format <= VG_LITE_INDEX_8)
{
/* this task will use index format,set index_flag to 1. */
ctx->index_format = 1;
switch (source->format) {
case VG_LITE_INDEX_8:
if(ctx->clut_dirty[3]){
VG_LITE_RETURN_ERROR(push_states(ctx, 0x0B00, 256, tls->t_context.colors[3]));
tls->t_context.clut_dirty[3] = 0;
}
else
{
ctx->clut_used[3] = 1;
}
break;
case VG_LITE_INDEX_4:
if(ctx->clut_dirty[2]){
VG_LITE_RETURN_ERROR(push_states(ctx, 0x0AA0, 16, ctx->colors[2]));
ctx->clut_dirty[2] = 0;
}
else
{
ctx->clut_used[2] = 1;
}
break;
case VG_LITE_INDEX_2:
if(ctx->clut_dirty[1]){
VG_LITE_RETURN_ERROR(push_states(ctx, 0x0A9C, 4, ctx->colors[1]));
ctx->clut_dirty[1] = 0;
}
else
{
ctx->clut_used[1] = 1;
}
break;
default:
if(ctx->clut_dirty[0]){
VG_LITE_RETURN_ERROR(push_states(ctx, 0x0A98, 2, ctx->colors[0]));
ctx->clut_dirty[0] = 0;
}
else
{
ctx->clut_used[0] = 1;
}
}
}
#endif /* not defined(VG_DRIVER_SINGLE_THREAD) */
if(!ctx->premultiply_enabled && source->format != VG_LITE_A8 && source->format != VG_LITE_A4) {
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A00, 0x10000001 | imageMode | blend_mode | transparency_mode));
} else {
/* enable pre-multiplied from VG to VGPE */
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A00, 0x00000001 | imageMode | blend_mode | transparency_mode));
}
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A02, color));
VG_LITE_RETURN_ERROR(set_interpolation_steps(target, source->width, source->height, matrix));
if(!ctx->premultiply_enabled && source->format != VG_LITE_A8 && source->format != VG_LITE_A4) {
if(source->transparency_mode == VG_LITE_IMAGE_OPAQUE){
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A25, convert_source_format(source->format) | filter | conversion | 0x01000100));
} else {
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A25, convert_source_format(source->format) | filter | conversion | 0x00000100));
}
} else {
/* enable pre-multiplied in imager unit */
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A25, convert_source_format(source->format) | filter | conversion));
}
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A27, 0));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A29, source->address));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A2B, source->stride | tiled_source));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A2D, 0));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A2F, source->width | (source->height << 16)));
VG_LITE_RETURN_ERROR(push_rectangle(ctx, bounding_box.x, bounding_box.y, bounding_box.width,
bounding_box.height));
error = flush_target();
vglitemDUMP_BUFFER("image", source->address, source->memory, 0, (source->stride)*(source->height));
#if DUMP_IMAGE
dump_img(source->memory, source->width, source->height, source->format);
#endif
return error;
}
vg_lite_error_t vg_lite_blit_rect(vg_lite_buffer_t * target,
vg_lite_buffer_t * source,
uint32_t * rect,
vg_lite_matrix_t * matrix,
vg_lite_blend_t blend,
vg_lite_color_t color,
vg_lite_filter_t filter)
{
vg_lite_error_t error;
vg_lite_rectangle_t src_bbx, bounding_box, clip;
uint32_t imageMode;
uint32_t transparency_mode = 0;
uint32_t blend_mode;
vg_lite_blend_t forced_blending = blend;
uint32_t conversion = 0;
uint32_t tiled_source;
uint32_t rect_x = 0, rect_y = 0, rect_w = 0, rect_h = 0;
int32_t src_align_width;
uint32_t mul, div, align;
#if (VG_BLIT_WORKAROUND == 1)
vg_lite_matrix_t new_matrix;
vg_lite_buffer_t new_target;
#endif /* VG_BLIT_WORKAROUND */
#if defined(VG_DRIVER_SINGLE_THREAD)
vg_lite_context_t *ctx = &s_context;
#else
vg_lite_context_t *ctx;
vg_lite_tls_t *tls;
tls = (vg_lite_tls_t *) vg_lite_os_get_tls();
if(tls == NULL)
return VG_LITE_NO_CONTEXT;
ctx = &tls->t_context;
#endif /* VG_DRIVER_SINGLE_THREAD */
transparency_mode = (source->transparency_mode == VG_LITE_IMAGE_TRANSPARENT ? 0x8000:0);
/* Check if the specified matrix has rotation or perspective. */
if ( (matrix != NULL)
&& ( (matrix->m[0][1] != 0.0f)
|| (matrix->m[1][0] != 0.0f)
|| (matrix->m[2][0] != 0.0f)
|| (matrix->m[2][1] != 0.0f)
|| (matrix->m[2][2] != 1.0f)
)
&& ( blend == VG_LITE_BLEND_NONE
|| blend == VG_LITE_BLEND_SRC_IN
|| blend == VG_LITE_BLEND_DST_IN
)
) {
if(vg_lite_query_feature(gcFEATURE_BIT_VG_BORDER_CULLING)) {
/* Mark that we have rotation. */
transparency_mode = 0x8000;
}else
{
blend_mode = VG_LITE_BLEND_SRC_OVER;
}
}
/* Check whether L8 is supported or not. */
if ((target->format == VG_LITE_L8) && ((source->format != VG_LITE_L8) && (source->format != VG_LITE_A8))) {
conversion = 0x80000000;
}
/* determine if source specify bytes are aligned */
error = _check_source_aligned(source->format,source->stride);
if (error != VG_LITE_SUCCESS) {
return error;
}
get_format_bytes(source->format, &mul, &div, &align);
src_align_width = source->stride * div / mul;
memset(&src_bbx, 0, sizeof(vg_lite_rectangle_t));
/* Set source region. */
if (rect != NULL) {
rect_x = rect[0];
rect_y = rect[1];
rect_w = rect[2];
rect_h = rect[3];
if ((rect_x > (uint32_t)src_align_width) || (rect_y > (uint32_t)source->height) ||
(rect_w == 0) || (rect_h == 0))
{
/*No intersection*/
return VG_LITE_INVALID_ARGUMENT;
}
if (rect_x + rect_w > (uint32_t)src_align_width)
{
rect_w = src_align_width - rect_x;
}
if (rect_y + rect_h > (uint32_t)source->height)
{
rect_h = source->height - rect_y;
}
src_bbx.width = rect_w;
src_bbx.height = rect_h;
}
else {
rect_x = rect_y = 0;
rect_w = src_bbx.width = src_align_width;
rect_h = src_bbx.height = source->height;
}
/* Calculate bounding box. */
memset(&clip, 0, sizeof(vg_lite_rectangle_t));
if (ctx->scissor_enabled) {
clip.x = ctx->scissor[0];
clip.y = ctx->scissor[1];
clip.width = ctx->scissor[2];
clip.height = ctx->scissor[3];
} else {
clip.x = clip.y = 0;
clip.width = target->width;
clip.height = target->height;
}
transform_bounding_box(&src_bbx, matrix, &clip, &bounding_box, NULL);
#if (VG_BLIT_WORKAROUND==1)
/*
* The blit output quality workaround works only for afine transformations
* because it is based on the process of cumulating translations into the
* matrix. This process is not possible for non-affine transformations, such
* as the perspective projections.
*/
if ((matrix->m[2][0] == 0) && (matrix->m[2][1] == 0)) {
/*
* Make a local copy of the transformation matrix in order not to mess
* up the user's matrix.
*/
memcpy(&new_matrix, matrix, sizeof(vg_lite_matrix_t));
matrix = &new_matrix;
config_new_target(target, source, matrix, &bounding_box, &new_target);
target = &new_target;
}
#endif /* VG_BLIT_WORKAROUND */
error = set_render_target(target);
if (error != VG_LITE_SUCCESS) {
return error;
} else if (error == VG_LITE_NO_CONTEXT) {
/* If scissoring is enabled and no valid scissoring rectangles
are present, no drawing occurs */
return VG_LITE_SUCCESS;
}
/* Determine image mode (NORMAL, NONE or MULTIPLY) depending on the color. */
imageMode = (source->image_mode == VG_LITE_NONE_IMAGE_MODE) ? 0 : (source->image_mode == VG_LITE_MULTIPLY_IMAGE_MODE) ? 0x00002000 : 0x00001000;
blend_mode = convert_blend(forced_blending);
tiled_source = (source->tiled != VG_LITE_LINEAR) ? 0x10000000 : 0 ;
#if !defined(VG_DRIVER_SINGLE_THREAD)
/* Setup the command buffer. */
if(source->format >= VG_LITE_INDEX_1 && source->format <= VG_LITE_INDEX_8)
{
/* this task will use index format,set index_flag to 1. */
ctx->index_format = 1;
switch (source->format) {
case VG_LITE_INDEX_8:
if(tls->t_context.clut_dirty[3]){
VG_LITE_RETURN_ERROR(push_states(ctx, 0x0B00, 256, ctx->colors[3]));
ctx->clut_dirty[3] = 0;
}
else
{
tls->t_context.clut_used[3] = 1;
}
break;
case VG_LITE_INDEX_4:
if(tls->t_context.clut_dirty[2]){
VG_LITE_RETURN_ERROR(push_states(&tls->t_context, 0x0AA0, 16, tls->t_context.colors[2]));
tls->t_context.clut_dirty[2] = 0;
}
else
{
tls->t_context.clut_used[2] = 1;
}
break;
case VG_LITE_INDEX_2:
if(tls->t_context.clut_dirty[1]){
VG_LITE_RETURN_ERROR(push_states(&tls->t_context, 0x0A9C, 4, tls->t_context.colors[1]));
tls->t_context.clut_dirty[1] = 0;
}
else
{
tls->t_context.clut_used[1] = 1;
}
break;
default:
if(tls->t_context.clut_dirty[0]){
VG_LITE_RETURN_ERROR(push_states(&tls->t_context, 0x0A98, 2, tls->t_context.colors[0]));
tls->t_context.clut_dirty[0] = 0;
}
else
{
tls->t_context.clut_used[0] = 1;
}
}
}
#endif /* not defined(VG_DRIVER_SINGLE_THREAD) */
if(!ctx->premultiply_enabled && source->format != VG_LITE_A8 && source->format != VG_LITE_A4) {
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A00, 0x10000001 | imageMode | blend_mode | transparency_mode));
} else {
/* enable pre-multiplied from VG to VGPE */
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A00, 0x00000001 | imageMode | blend_mode | transparency_mode));
}
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A02, color));
VG_LITE_RETURN_ERROR(set_interpolation_steps(target, rect_w, rect_h, matrix));
if(!ctx->premultiply_enabled && source->format != VG_LITE_A8 && source->format != VG_LITE_A4) {
if(source->transparency_mode == VG_LITE_IMAGE_OPAQUE){
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A25, convert_source_format(source->format) | filter | conversion | 0x01000100));
} else {
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A25, convert_source_format(source->format) | filter | conversion | 0x00000100));
}
} else {
/* enable pre-multiplied in imager unit */
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A25, convert_source_format(source->format) | filter | conversion));
}
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A27, 0));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A29, source->address));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A2B, source->stride | tiled_source));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A2D, rect_x | (rect_y << 16)));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A2F, rect_w | (rect_h << 16)));
VG_LITE_RETURN_ERROR(push_rectangle(ctx, bounding_box.x, bounding_box.y, bounding_box.width,
bounding_box.height));
error = flush_target();
vglitemDUMP_BUFFER("image", source->address, source->memory, 0, (source->stride)*(source->height));
#if DUMP_IMAGE
dump_img(source->memory, src_align_width, source->height, source->format);
#endif
return error;
}
/* Program initial states for tessellation buffer. */
static vg_lite_error_t program_tessellation(vg_lite_context_t *context)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
uint32_t tessellation_size;
#if !defined(VG_DRIVER_SINGLE_THREAD)
uint32_t offset;
#endif /* not defined(VG_DRIVER_SINGLE_THREAD) */
tessellation_size = ( context->tsbuffer.tessellation_buffer_size[2]
? context->tsbuffer.tessellation_buffer_size[2]
: context->tsbuffer.tessellation_buffer_size[1]
);
#if !defined(VG_DRIVER_SINGLE_THREAD)
offset = CMDBUF_OFFSET(*context);
#endif /* not defined(VG_DRIVER_SINGLE_THREAD) */
/* Since TS buffer won't change during runtime, we program it here in initialization. */
/* Program tessellation buffer: input for VG module. */
VG_LITE_RETURN_ERROR(push_state(context, 0x0A30, context->tsbuffer.tessellation_buffer_gpu[0])); /* Tessellation buffer address. */
VG_LITE_RETURN_ERROR(push_state(context, 0x0A31, context->tsbuffer.tessellation_buffer_gpu[1])); /* L1 address of tessellation buffer. */
VG_LITE_RETURN_ERROR(push_state(context, 0x0A32, context->tsbuffer.tessellation_buffer_gpu[2])); /* L2 address of tessellation buffer. */
VG_LITE_RETURN_ERROR(push_state(context, 0x0A33, context->tsbuffer.tessellation_stride));
/* Program tessellation control: for TS module. */
VG_LITE_RETURN_ERROR(push_state(context, 0x0A35, context->tsbuffer.tessellation_buffer_gpu[0]));
VG_LITE_RETURN_ERROR(push_state(context, 0x0A36, context->tsbuffer.tessellation_buffer_gpu[1]));
VG_LITE_RETURN_ERROR(push_state(context, 0x0A37, context->tsbuffer.tessellation_buffer_gpu[2]));
VG_LITE_RETURN_ERROR(push_state(context, 0x0A38, context->tsbuffer.tessellation_stride));
VG_LITE_RETURN_ERROR(push_state(context, 0x0A3A, context->tsbuffer.tessellation_width_height));
VG_LITE_RETURN_ERROR(push_state(context, 0x0A3D, tessellation_size / 64));
#if !defined(VG_DRIVER_SINGLE_THREAD)
/* Backup tessellation buffer states. */
context->ts_init_used = 0;
context->ts_init_use = 0;
context->ts_dirty = 1;
memcpy(context->ts_record, (CMDBUF_BUFFER(*context) + offset), 80);
CMDBUF_OFFSET(*context) = 0;
#endif /* not defined(VG_DRIVER_SINGLE_THREAD) */
return error;
}
#if defined(VG_DRIVER_SINGLE_THREAD)
vg_lite_error_t vg_lite_init(int32_t tessellation_width,
int32_t tessellation_height)
{
vg_lite_error_t error;
vg_lite_kernel_initialize_t initialize;
s_context.rtbuffer = (vg_lite_buffer_t *)malloc(sizeof(vg_lite_buffer_t));
if(!s_context.rtbuffer)
return VG_LITE_OUT_OF_RESOURCES;
memset(s_context.rtbuffer, 0, sizeof(vg_lite_buffer_t));
if (tessellation_width <= 0) {
tessellation_width = 0;
tessellation_height = 0;
}
if (tessellation_height <= 0) {
tessellation_height = 0;
tessellation_width = 0;
}
tessellation_width = VG_LITE_ALIGN(tessellation_width, 16);
#if VG_TARGET_FAST_CLEAR
vg_lite_get_product_info(NULL,&s_context.chip_id,&s_context.chip_rev);
vg_lite_get_register(0x30, &cid);
if(s_context.chip_id == 0x255 && s_context.chip_rev == 0x1311 && cid == 0x404)
{
tessellation_width = 64;
tessellation_height = 64;
}
#endif
/* Allocate a command buffer and a tessellation buffer. */
initialize.command_buffer_size = command_buffer_size;
initialize.tessellation_width = tessellation_width;
initialize.tessellation_height = tessellation_height;
initialize.context = &s_context.context;
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_INITIALIZE, &initialize));
/* Save draw context. */
s_context.capabilities = initialize.capabilities;
s_context.command_buffer[0] = (uint8_t *)initialize.command_buffer[0];
s_context.command_buffer[1] = (uint8_t *)initialize.command_buffer[1];
s_context.command_buffer_size = initialize.command_buffer_size;
s_context.command_offset[0] = 0;
s_context.command_offset[1] = 0;
if ((tessellation_width > 0) &&
(tessellation_height > 0))
{
/* Set and Program Tessellation Buffer states. */
s_context.tsbuffer.tessellation_buffer_gpu[0] = initialize.tessellation_buffer_gpu[0];
s_context.tsbuffer.tessellation_buffer_gpu[1] = initialize.tessellation_buffer_gpu[1];
s_context.tsbuffer.tessellation_buffer_gpu[2] = initialize.tessellation_buffer_gpu[2];
s_context.tsbuffer.tessellation_buffer_logic[0] = initialize.tessellation_buffer_logic[0];
s_context.tsbuffer.tessellation_buffer_logic[1] = initialize.tessellation_buffer_logic[1];
s_context.tsbuffer.tessellation_buffer_logic[2] = initialize.tessellation_buffer_logic[2];
s_context.tsbuffer.tessellation_stride = initialize.tessellation_stride;
s_context.tsbuffer.tessellation_width_height = initialize.tessellation_width_height;
s_context.tsbuffer.tessellation_buffer_size[0] = initialize.tessellation_buffer_size[0];
s_context.tsbuffer.tessellation_buffer_size[1] = initialize.tessellation_buffer_size[1];
s_context.tsbuffer.tessellation_buffer_size[2] = initialize.tessellation_buffer_size[2];
s_context.tsbuffer.tessellation_shift = initialize.tessellation_shift;
VG_LITE_RETURN_ERROR(program_tessellation(&s_context));
}
/* Fill feature table. */
if (!s_context.s_ftable.ftflag){
VG_LITE_RETURN_ERROR(fill_feature_table(s_context.s_ftable.ftable));
}
#if VG_TARGET_FAST_CLEAR
/* Reset the FAST_CLEAR buffer. */
memset(&s_context.fcBuffer, 0, sizeof(s_context.fcBuffer));
s_context.fcBuffer.format = VG_LITE_A8;
s_context.fcBuffer.height = 1;
s_context.clearValue = 0;
#endif
/* Init scissor rect. */
s_context.scissor[0] =
s_context.scissor[1] =
s_context.scissor[2] =
s_context.scissor[3] = 0;
#if DUMP_CAPTURE
_SetDumpFileInfo();
#endif
#if (VG_RENDER_TEXT==1)
vg_lite_text_init();
#endif /* VG_RENDER_TEXT */
return VG_LITE_SUCCESS;
}
#else
vg_lite_error_t vg_lite_init(int32_t tessellation_width,
int32_t tessellation_height)
{
vg_lite_error_t error;
vg_lite_kernel_initialize_t initialize;
vg_lite_tls_t* task_tls;
error = (vg_lite_error_t)vg_lite_os_init_tls_array();
if(error != VG_LITE_SUCCESS)
return error;
task_tls = (vg_lite_tls_t *) vg_lite_os_get_tls();
if(task_tls)
return VG_LITE_SUCCESS;
task_tls = (vg_lite_tls_t *) vg_lite_os_malloc(sizeof(vg_lite_tls_t));
if(!task_tls)
return VG_LITE_OUT_OF_RESOURCES;
memset(task_tls,0,sizeof(vg_lite_tls_t));
error = (vg_lite_error_t)vg_lite_os_set_tls((void *) task_tls);
if(error != VG_LITE_SUCCESS)
return error;
task_tls->t_context.rtbuffer = NULL;
if (tessellation_width <= 0) {
tessellation_width = 0;
tessellation_height = 0;
}
if (tessellation_height <= 0) {
tessellation_height = 0;
tessellation_width = 0;
}
tessellation_width = VG_LITE_ALIGN(tessellation_width, 16);
/* Allocate a command buffer and a tessellation buffer. */
initialize.command_buffer_size = command_buffer_size;
initialize.context_buffer_size = CONTEXT_BUFFER_SIZE;
initialize.tessellation_width = tessellation_width;
initialize.tessellation_height = tessellation_height;
initialize.context = &task_tls->t_context.context;
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_INITIALIZE, &initialize));
/* Save draw context. */
task_tls->t_context.capabilities = initialize.capabilities;
task_tls->t_context.command_buffer[0] = (uint8_t *)initialize.command_buffer[0];
task_tls->t_context.command_buffer[1] = (uint8_t *)initialize.command_buffer[1];
task_tls->t_context.command_buffer_size = initialize.command_buffer_size;
task_tls->t_context.command_offset[0] = 0;
task_tls->t_context.command_offset[1] = 0;
task_tls->t_context.command_buffer_current = 0;
task_tls->t_context.context_buffer[0] = (uint8_t *)initialize.context_buffer[0];
task_tls->t_context.context_buffer[1] = (uint8_t *)initialize.context_buffer[1];
task_tls->t_context.context_buffer_size = initialize.context_buffer_size;
task_tls->t_context.context_buffer_offset[0] = 0;
task_tls->t_context.context_buffer_offset[1] = 0;
task_tls->t_context.start_offset = 0;
task_tls->t_context.end_offset = 0;
task_tls->t_context.ts_init = 0;
memset(task_tls->t_context.ts_record, 0, sizeof(task_tls->t_context.ts_record));
if ((tessellation_width > 0) &&
(tessellation_height > 0))
{
/* Set and Program Tessellation Buffer states. */
task_tls->t_context.tsbuffer.tessellation_buffer_gpu[0] = initialize.tessellation_buffer_gpu[0];
task_tls->t_context.tsbuffer.tessellation_buffer_gpu[1] = initialize.tessellation_buffer_gpu[1];
task_tls->t_context.tsbuffer.tessellation_buffer_gpu[2] = initialize.tessellation_buffer_gpu[2];
task_tls->t_context.tsbuffer.tessellation_buffer_logic[0] = initialize.tessellation_buffer_logic[0];
task_tls->t_context.tsbuffer.tessellation_buffer_logic[1] = initialize.tessellation_buffer_logic[1];
task_tls->t_context.tsbuffer.tessellation_buffer_logic[2] = initialize.tessellation_buffer_logic[2];
task_tls->t_context.tsbuffer.tessellation_stride = initialize.tessellation_stride;
task_tls->t_context.tsbuffer.tessellation_width_height = initialize.tessellation_width_height;
task_tls->t_context.tsbuffer.tessellation_buffer_size[0] = initialize.tessellation_buffer_size[0];
task_tls->t_context.tsbuffer.tessellation_buffer_size[1] = initialize.tessellation_buffer_size[1];
task_tls->t_context.tsbuffer.tessellation_buffer_size[2] = initialize.tessellation_buffer_size[2];
task_tls->t_context.tsbuffer.tessellation_shift = initialize.tessellation_shift;
VG_LITE_RETURN_ERROR(program_tessellation(&task_tls->t_context));
}
VG_LITE_RETURN_ERROR(push_state(&task_tls->t_context, 0x0A00, 0x0));
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_LOCK, NULL));
/* Fill feature table. */
if (!task_tls->t_context.s_ftable.ftflag){
VG_LITE_RETURN_ERROR(fill_feature_table(task_tls->t_context.s_ftable.ftable));
}
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_UNLOCK, NULL));
#if VG_TARGET_FAST_CLEAR
/* Reset the FAST_CLEAR buffer. */
memset(&task_tls->t_context.fcBuffer, 0, sizeof(task_tls->t_context.fcBuffer));
task_tls->t_context.fcBuffer.format = VG_LITE_A8;
task_tls->t_context.fcBuffer.height = 1;
task_tls->t_context.clearValue = 0;
#endif
/* Init scissor rect. */
task_tls->t_context.scissor[0] =
task_tls->t_context.scissor[1] =
task_tls->t_context.scissor[2] =
task_tls->t_context.scissor[3] = 0;
#if DUMP_CAPTURE
_SetDumpFileInfo();
#endif
#if (VG_RENDER_TEXT==1)
vg_lite_text_init();
#endif /* VG_RENDER_TEXT */
return VG_LITE_SUCCESS;
}
#endif /* VG_DRIVER_SINGLE_THREAD */
vg_lite_error_t vg_lite_set_draw_path_type(vg_lite_path_t * path,vg_lite_draw_path_type_t path_type)
{
if(!path || (path_type > VG_LITE_DRAW_STROKE_PATH + 1))
return VG_LITE_INVALID_ARGUMENT;
path->path_type = path_type;
return VG_LITE_SUCCESS;
}
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)
{
uint32_t blend_mode;
uint32_t format, quality, tiling, fill;
uint32_t tessellation_size;
vg_lite_error_t error;
vg_lite_point_t point_min = {0}, point_max = {0}, temp = {0};
int x, y, width, height;
uint8_t ts_is_fullscreen = 0;
#if DUMP_COMMAND
uint32_t return_offset = 0;
vg_lite_kernel_allocate_t memory;
#endif
int32_t dst_align_width;
uint32_t mul, div, align;
#if defined(VG_DRIVER_SINGLE_THREAD)
vg_lite_context_t *ctx = &s_context;
#else
vg_lite_context_t *ctx;
vg_lite_tls_t *tls;
tls = (vg_lite_tls_t *) vg_lite_os_get_tls();
if(tls == NULL)
return VG_LITE_NO_CONTEXT;
ctx = &tls->t_context;
#endif /* VG_DRIVER_SINGLE_THREAD */
if(!path)
return VG_LITE_INVALID_ARGUMENT;
if(!path->path_length)
return VG_LITE_SUCCESS;
if(!path->path)
return VG_LITE_INVALID_ARGUMENT;
if(!vg_lite_query_feature(gcFEATURE_BIT_VG_QUALITY_8X) && path->quality == VG_LITE_UPPER){
return VG_LITE_NOT_SUPPORT;
}
error = set_render_target(target);
if (error != VG_LITE_SUCCESS) {
return error;
} else if (error == VG_LITE_NO_CONTEXT) {
/* If scissoring is enabled and no valid scissoring rectangles
are present, no drawing occurs */
return VG_LITE_SUCCESS;
}
width = ctx->tsbuffer.tessellation_width_height & 0xFFFF;
height = ctx->tsbuffer.tessellation_width_height >> 16;
get_format_bytes(target->format, &mul, &div, &align);
dst_align_width = target->stride * div / mul;
if(width == 0 || height == 0)
return VG_LITE_NO_CONTEXT;
if ((dst_align_width <= width) && (target->height <= height))
{
ts_is_fullscreen = 1;
point_min.x = 0;
point_min.y = 0;
point_max.x = dst_align_width;
point_max.y = target->height;
}
if (ts_is_fullscreen == 0){
transform(&temp, (vg_lite_float_t)path->bounding_box[0], (vg_lite_float_t)path->bounding_box[1], matrix);
point_min = point_max = temp;
transform(&temp, (vg_lite_float_t)path->bounding_box[2], (vg_lite_float_t)path->bounding_box[1], matrix);
if (temp.x < point_min.x) point_min.x = temp.x;
if (temp.y < point_min.y) point_min.y = temp.y;
if (temp.x > point_max.x) point_max.x = temp.x;
if (temp.y > point_max.y) point_max.y = temp.y;
transform(&temp, (vg_lite_float_t)path->bounding_box[2], (vg_lite_float_t)path->bounding_box[3], matrix);
if (temp.x < point_min.x) point_min.x = temp.x;
if (temp.y < point_min.y) point_min.y = temp.y;
if (temp.x > point_max.x) point_max.x = temp.x;
if (temp.y > point_max.y) point_max.y = temp.y;
transform(&temp, (vg_lite_float_t)path->bounding_box[0], (vg_lite_float_t)path->bounding_box[3], matrix);
if (temp.x < point_min.x) point_min.x = temp.x;
if (temp.y < point_min.y) point_min.y = temp.y;
if (temp.x > point_max.x) point_max.x = temp.x;
if (temp.y > point_max.y) point_max.y = temp.y;
if (point_min.x < 0) point_min.x = 0;
if (point_min.y < 0) point_min.y = 0;
if (point_max.x > dst_align_width) point_max.x = dst_align_width;
if (point_max.y > target->height) point_max.y = target->height;
}
if (ctx->scissor_enabled) {
point_min.x = MAX(point_min.x, ctx->scissor[0]);
point_min.y = MAX(point_min.y, ctx->scissor[1]);
point_max.x = MIN(point_max.x, ctx->scissor[0] + ctx->scissor[2]);
point_max.y = MIN(point_max.y, ctx->scissor[1] + ctx->scissor[3]);
}
/* Convert states into hardware values. */
blend_mode = convert_blend(blend);
format = convert_path_format(path->format);
quality = convert_path_quality(path->quality);
tiling = (ctx->capabilities.cap.tiled == 2) ? 0x2000000 : 0;
fill = (fill_rule == VG_LITE_FILL_EVEN_ODD) ? 0x10 : 0;
tessellation_size = ( ctx->tsbuffer.tessellation_buffer_size[2]
? ctx->tsbuffer.tessellation_buffer_size[2]
: ctx->tsbuffer.tessellation_buffer_size[1]
);
#if !defined(VG_DRIVER_SINGLE_THREAD)
if(ctx->ts_dirty){
memcpy(CMDBUF_BUFFER(*ctx) + CMDBUF_OFFSET(*ctx), ctx->ts_record, 80);
CMDBUF_OFFSET(*ctx) += 80;
ctx->ts_dirty = 0;
ctx->ts_init_used = 1;
}
else
{
ctx->ts_init_use = 1;
}
#endif /* not defined(VG_DRIVER_SINGLE_THREAD) */
/* Setup the command buffer. */
/* Program color register. */
if(ctx->premultiply_enabled) {
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A00, ctx->capabilities.cap.tiled | blend_mode));
} else {
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A00, 0x10000000 | ctx->capabilities.cap.tiled | blend_mode));
}
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A02, color));
/* Program tessellation control: for TS module. */
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A34, 0x01000200 | format | quality | tiling | fill));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A3B, 0x3F800000)); /* Path tessellation SCALE. */
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A3C, 0x00000000)); /* Path tessellation BIAS. */
/* Program matrix. */
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A40, (void *) &matrix->m[0][0]));
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A41, (void *) &matrix->m[0][1]));
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A42, (void *) &matrix->m[0][2]));
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A43, (void *) &matrix->m[1][0]));
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A44, (void *) &matrix->m[1][1]));
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A45, (void *) &matrix->m[1][2]));
if (VLM_PATH_GET_UPLOAD_BIT(*path) == 1) {
vglitemDUMP_BUFFER("path", path->uploaded.address, (uint8_t *)(path->uploaded.memory), 0, path->uploaded.bytes);
}
vglitemDUMP("@[memory 0x%08X 0x%08X]", ctx->tsbuffer.tessellation_buffer_gpu[0], ctx->tsbuffer.tessellation_buffer_size[0]);
/* Setup tessellation loop. */
if((path->path_type & 0x1) == VG_LITE_DRAW_FILL_PATH) {
for (y = point_min.y; y < point_max.y; y += height) {
for (x = point_min.x; x < point_max.x; x += width) {
/* Tessellate path. */
VG_LITE_RETURN_ERROR(push_stall(ctx, 15));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A1B, 0x00011000));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A01, x | (y << 16)));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A39, x | (y << 16)));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A3D, tessellation_size / 64));
if (VLM_PATH_GET_UPLOAD_BIT(*path) == 1) {
VG_LITE_RETURN_ERROR(push_call(ctx, path->uploaded.address, path->uploaded.bytes));
#if (DUMP_COMMAND)
if (strncmp(filename, "Commandbuffer", 13)) {
sprintf(filename, "Commandbuffer_pid%d.txt", getpid());
}
fp = fopen(filename, "a");
if (fp == NULL)
printf("error!\n");
fprintf(fp, "Command buffer: 0x%08x, 0x%08x,\n",
((uint32_t *) memory.memory)[0], 0);
unsigned char* pt = (unsigned char*) memory.memory;
for(int i = 8; i <= return_offset * 4 - 1; i = i + 4)
{
if (i % 8 == 0)
fprintf(fp, "Command buffer: ");
if (i % 4 == 0)
fprintf(fp, "0x");
for (int j = 3; j >= 0; --j)
fprintf(fp, "%02x", pt[i + j]);
if ((i / 4 + 1) % 2 == 0)
fprintf(fp, ",\n");
else
fprintf(fp, ", ");
}
fprintf(fp, "Command buffer: 0x%08x, 0x%08x,\n",
((uint32_t *) memory.memory)[return_offset], 0);
fclose(fp);
fp = NULL;
#endif
} else {
push_data(ctx, path->path_length, path->path);
}
}
}
}
/* Setup tessellation loop. */
if(path->path_type == VG_LITE_DRAW_STROKE_PATH || path->path_type == VG_LITE_DRAW_FILL_STROKE_PATH) {
for (y = point_min.y; y < point_max.y; y += height) {
for (x = point_min.x; x < point_max.x; x += width) {
/* Tessellate path. */
VG_LITE_RETURN_ERROR(push_stall(ctx, 15));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A1B, 0x00011000));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A01, x | (y << 16)));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A39, x | (y << 16)));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A3D, tessellation_size / 64));
if (VLM_PATH_GET_UPLOAD_BIT(*path) == 1) {
VG_LITE_RETURN_ERROR(push_call(ctx, path->uploaded.address, path->uploaded.bytes));
#if (DUMP_COMMAND)
if (strncmp(filename, "Commandbuffer", 13)) {
sprintf(filename, "Commandbuffer_pid%d.txt", getpid());
}
fp = fopen(filename, "a");
if (fp == NULL)
printf("error!\n");
fprintf(fp, "Command buffer: 0x%08x, 0x%08x,\n",
((uint32_t *) memory.memory)[0], 0);
unsigned char* pt = (unsigned char*) memory.memory;
for(int i = 8; i <= return_offset * 4 - 1; i = i + 4)
{
if (i % 8 == 0)
fprintf(fp, "Command buffer: ");
if (i % 4 == 0)
fprintf(fp, "0x");
for (int j = 3; j >= 0; --j)
fprintf(fp, "%02x", pt[i + j]);
if ((i / 4 + 1) % 2 == 0)
fprintf(fp, ",\n");
else
fprintf(fp, ", ");
}
fprintf(fp, "Command buffer: 0x%08x, 0x%08x,\n",
((uint32_t *) memory.memory)[return_offset], 0);
fclose(fp);
fp = NULL;
#endif
} else {
format = convert_path_format(VG_LITE_FP32);
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A34, 0x01000200 | format | quality | tiling | 0x0));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A02, path->stroke_color));
push_data(ctx, path->stroke_path_size, path->stroke_path_data);
}
}
}
}
/* Finialize command buffer. */
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A34, 0));
VG_LITE_RETURN_ERROR(flush_target());
#if !defined(VG_DRIVER_SINGLE_THREAD)
ctx->ts_init = 1;
#endif /* not defined(VG_DRIVER_SINGLE_THREAD) */
return error;
}
vg_lite_error_t vg_lite_close(void)
{
vg_lite_error_t error;
vg_lite_kernel_terminate_t terminate;
#if defined(VG_DRIVER_SINGLE_THREAD)
vg_lite_context_t *ctx = &s_context;
#else
vg_lite_context_t *ctx;
vg_lite_tls_t* tls;
tls = (vg_lite_tls_t *) vg_lite_os_get_tls();
if(tls == NULL)
return VG_LITE_NO_CONTEXT;
ctx = &tls->t_context;
#endif /* VG_DRIVER_SINGLE_THREAD */
#if VG_TARGET_FAST_CLEAR
if (ctx->fcBuffer.handle != NULL) {
vg_lite_free(&ctx->fcBuffer);
}
#endif
/* Termnate the draw context. */
terminate.context = &ctx->context;
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_TERMINATE, &terminate));
#if defined(VG_DRIVER_SINGLE_THREAD)
if(ctx->rtbuffer)
free(ctx->rtbuffer);
submit_flag = 0;
/* Reset the draw context. */
_memset(ctx, 0, sizeof(s_context));
/* Reset the s_ftable. */
_memset(&ctx->s_ftable, 0, sizeof(ctx->s_ftable));
ctx->init = 0;
#else
/* Reset the draw context. */
if(tls->t_context.colors){
free(ctx->colors[0]);
free(ctx->colors[1]);
free(ctx->colors[2]);
free(ctx->colors[3]);
}
_memset(ctx, 0, sizeof(*ctx));
vg_lite_os_reset_tls();
vg_lite_os_free((void *) tls);
vg_lite_os_deinit_tls_array();
#endif /* VG_DRIVER_SINGLE_THREAD */
#if DUMP_CAPTURE
_SetDumpFileInfo();
#endif
return VG_LITE_SUCCESS;
}
/* Handle tiled & yuv allocation. Currently including NV12, ANV12, YV12, YV16, NV16, YV24. */
static vg_lite_error_t _allocate_tiled_yuv_planar(vg_lite_buffer_t *buffer)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
uint32_t yplane_size = 0;
vg_lite_kernel_allocate_t allocate, uv_allocate, v_allocate;
if ((buffer->format < VG_LITE_NV12) || (buffer->format > VG_LITE_ANV12_TILED)
|| (buffer->format == VG_LITE_AYUY2) || (buffer->format == VG_LITE_YUY2_TILED))
{
return error;
}
/* For NV12, there are 2 planes (Y, UV);
For ANV12, there are 3 planes (Y, UV, Alpha).
Each plane must be aligned by (4, 8).
Then Y plane must be aligned by (8, 8).
For YVxx, there are 3 planes (Y, U, V).
YV12 is similar to NV12, both YUV420 format.
YV16 and NV16 are YUV422 format.
YV24 is YUV444 format.
*/
buffer->width = VG_LITE_ALIGN(buffer->width, 8);
buffer->height = VG_LITE_ALIGN(buffer->height, 8);
buffer->stride = VG_LITE_ALIGN(buffer->width, 128);
switch (buffer->format) {
case VG_LITE_NV12:
case VG_LITE_ANV12:
case VG_LITE_NV12_TILED:
case VG_LITE_ANV12_TILED:
buffer->yuv.uv_stride = buffer->stride;
buffer->yuv.alpha_stride = buffer->stride;
buffer->yuv.uv_height = buffer->height / 2;
break;
case VG_LITE_NV16:
buffer->yuv.uv_stride = buffer->stride;
buffer->yuv.uv_height = buffer->height;
break;
case VG_LITE_YV12:
buffer->yuv.uv_stride =
buffer->yuv.v_stride = buffer->stride / 2;
buffer->yuv.uv_height =
buffer->yuv.v_height = buffer->height / 2;
break;
case VG_LITE_YV16:
buffer->yuv.uv_stride =
buffer->yuv.v_stride = buffer->stride;
buffer->yuv.uv_height =
buffer->yuv.v_height = buffer->height / 2;
break;
case VG_LITE_YV24:
buffer->yuv.uv_stride =
buffer->yuv.v_stride = buffer->stride;
buffer->yuv.uv_height =
buffer->yuv.v_height = buffer->height;
break;
default:
return error;
}
yplane_size = buffer->stride * buffer->height;
/* Allocate buffer memory: Y. */
allocate.bytes = yplane_size;
allocate.contiguous = 1;
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_ALLOCATE, &allocate));
/* Save the allocation. */
buffer->handle = allocate.memory_handle;
buffer->memory = allocate.memory;
buffer->address = allocate.memory_gpu;
if ((buffer->format == VG_LITE_NV12) || (buffer->format == VG_LITE_ANV12)
|| (buffer->format == VG_LITE_NV16) || (buffer->format == VG_LITE_NV12_TILED)
|| (buffer->format == VG_LITE_ANV12_TILED)) {
/* Allocate buffer memory: UV. */
uv_allocate.bytes = buffer->yuv.uv_stride * buffer->yuv.uv_height;
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_ALLOCATE, &uv_allocate));
buffer->yuv.uv_handle = uv_allocate.memory_handle;
buffer->yuv.uv_memory = uv_allocate.memory;
buffer->yuv.uv_planar = uv_allocate.memory_gpu;
if ((buffer->format == VG_LITE_ANV12) || (buffer->format == VG_LITE_ANV12_TILED)) {
uv_allocate.bytes = yplane_size;
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_ALLOCATE, &uv_allocate));
buffer->yuv.alpha_planar = uv_allocate.memory_gpu;
}
} else {
/* Allocate buffer memory: U, V. */
uv_allocate.bytes = buffer->yuv.uv_stride * buffer->yuv.uv_height;
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_ALLOCATE, &uv_allocate));
buffer->yuv.uv_handle = uv_allocate.memory_handle;
buffer->yuv.uv_memory = uv_allocate.memory;
buffer->yuv.uv_planar = uv_allocate.memory_gpu;
v_allocate.bytes = buffer->yuv.v_stride * buffer->yuv.v_height;
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_ALLOCATE, &v_allocate));
buffer->yuv.v_handle = v_allocate.memory_handle;
buffer->yuv.v_memory = v_allocate.memory;
buffer->yuv.v_planar = v_allocate.memory_gpu;
}
return error;
}
vg_lite_error_t vg_lite_allocate(vg_lite_buffer_t * buffer)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
vg_lite_kernel_allocate_t allocate;
/* Reset planar. */
buffer->yuv.uv_planar =
buffer->yuv.v_planar =
buffer->yuv.alpha_planar = 0;
/* Align height in case format is tiled. */
if (buffer->format >= VG_LITE_YUY2 && buffer->format <= VG_LITE_NV16) {
buffer->height = VG_LITE_ALIGN(buffer->height, 4);
buffer->yuv.swizzle = VG_LITE_SWIZZLE_UV;
}
if (buffer->format >= VG_LITE_YUY2_TILED && buffer->format <= VG_LITE_AYUY2_TILED) {
buffer->height = VG_LITE_ALIGN(buffer->height, 4);
buffer->tiled = VG_LITE_TILED;
buffer->yuv.swizzle = VG_LITE_SWIZZLE_UV;
}
if ((buffer->format >= VG_LITE_NV12 && buffer->format <= VG_LITE_ANV12_TILED
&& buffer->format != VG_LITE_AYUY2 && buffer->format != VG_LITE_YUY2_TILED)) {
_allocate_tiled_yuv_planar(buffer);
}
else {
/* Driver need compute the stride always with RT500 project. */
uint32_t mul, div, align;
#if defined(VG_DRIVER_SINGLE_THREAD)
vg_lite_context_t *ctx = &s_context;
#else
vg_lite_context_t *ctx;
vg_lite_tls_t* tls;
tls = (vg_lite_tls_t *) vg_lite_os_get_tls();
if(tls == NULL)
return VG_LITE_NO_CONTEXT;
ctx = &tls->t_context;
#endif /* VG_DRIVER_SINGLE_THREAD */
get_format_bytes(buffer->format, &mul, &div, &align);
vg_lite_get_product_info(NULL,&ctx->chip_id,NULL);
buffer->stride = VG_LITE_ALIGN((buffer->width * mul / div), align);
/* Allocate the buffer. */
allocate.bytes = buffer->stride * buffer->height;
#if VG_TARGET_FAST_CLEAR
allocate.bytes = VG_LITE_ALIGN(allocate.bytes, 64);
#endif
allocate.contiguous = 1;
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_ALLOCATE, &allocate));
/* Save the buffer allocation. */
buffer->handle = allocate.memory_handle;
buffer->memory = allocate.memory;
buffer->address = allocate.memory_gpu;
if ((buffer->format == VG_LITE_AYUY2) || (buffer->format == VG_LITE_AYUY2_TILED)) {
allocate.bytes = buffer->stride * buffer->height;
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_ALLOCATE, &allocate));
buffer->yuv.alpha_planar = allocate.memory_gpu;
}
}
return VG_LITE_SUCCESS;
}
#if defined(VG_DRIVER_SINGLE_THREAD)
vg_lite_error_t vg_lite_free(vg_lite_buffer_t * buffer)
{
vg_lite_error_t error;
vg_lite_kernel_free_t free, uv_free, v_free;
if(buffer == NULL)
return VG_LITE_INVALID_ARGUMENT;
if (!(memcmp(s_context.rtbuffer,buffer,sizeof(vg_lite_buffer_t))) ) {
if (VG_LITE_SUCCESS == submit(&s_context)) {
VG_LITE_RETURN_ERROR(stall(&s_context, 0, ~0));
}
vglitemDUMP("@[swap 0x%08X %dx%d +%u]",
s_context.rtbuffer->address,
s_context.rtbuffer->width, s_context.rtbuffer->height,
s_context.rtbuffer->stride);
vglitemDUMP_BUFFER(
"framebuffer",
s_context.rtbuffer->address,s_context.rtbuffer->memory,
0,
s_context.rtbuffer->stride*(s_context.rtbuffer->height));
memset(s_context.rtbuffer, 0, sizeof(vg_lite_buffer_t));
}
if (buffer->yuv.uv_planar) {
/* Free UV(U) planar buffer. */
uv_free.memory_handle = buffer->yuv.uv_handle;
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_FREE, &uv_free));
/* Mark the buffer as freed. */
buffer->yuv.uv_handle = NULL;
buffer->yuv.uv_memory = NULL;
}
if (buffer->yuv.v_planar) {
/* Free V planar buffer. */
v_free.memory_handle = buffer->yuv.v_handle;
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_FREE, &v_free));
/* Mark the buffer as freed. */
buffer->yuv.v_handle = NULL;
buffer->yuv.v_memory = NULL;
}
/* Make sure we have a valid memory handle. */
if (buffer->handle == NULL) {
return VG_LITE_INVALID_ARGUMENT;
}
/* Free the buffer. */
free.memory_handle = buffer->handle;
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_FREE, &free));
/* Mark the buffer as freed. */
buffer->handle = NULL;
buffer->memory = NULL;
return VG_LITE_SUCCESS;
}
#else
vg_lite_error_t vg_lite_free(vg_lite_buffer_t * buffer)
{
vg_lite_error_t error;
vg_lite_kernel_free_t free, uv_free, v_free;
vg_lite_tls_t* tls;
tls = (vg_lite_tls_t *) vg_lite_os_get_tls();
if(tls == NULL)
return VG_LITE_NO_CONTEXT;
if(buffer == NULL)
return VG_LITE_INVALID_ARGUMENT;
if (tls->t_context.rtbuffer == buffer && !(memcmp(tls->t_context.rtbuffer,buffer,sizeof(vg_lite_buffer_t))) ) {
if (VG_LITE_SUCCESS == submit(&tls->t_context)) {
VG_LITE_RETURN_ERROR(stall(&tls->t_context, 0));
}
vglitemDUMP("@[swap 0x%08X %dx%d +%u]",
tls->t_context.rtbuffer->address,
tls->t_context.rtbuffer->width, tls->t_context.rtbuffer->height,
tls->t_context.rtbuffer->stride);
vglitemDUMP_BUFFER(
"framebuffer",
tls->t_context.rtbuffer->address,tls->t_context.rtbuffer->memory,
0,
tls->t_context.rtbuffer->stride*(tls->t_context.rtbuffer->height));
memset(tls->t_context.rtbuffer, 0, sizeof(vg_lite_buffer_t));
}
if (buffer->yuv.uv_planar) {
/* Free UV(U) planar buffer. */
uv_free.memory_handle = buffer->yuv.uv_handle;
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_FREE, &uv_free));
/* Mark the buffer as freed. */
buffer->yuv.uv_handle = NULL;
buffer->yuv.uv_memory = NULL;
}
if (buffer->yuv.v_planar) {
/* Free V planar buffer. */
v_free.memory_handle = buffer->yuv.v_handle;
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_FREE, &v_free));
/* Mark the buffer as freed. */
buffer->yuv.v_handle = NULL;
buffer->yuv.v_memory = NULL;
}
/* Make sure we have a valid memory handle. */
if (buffer->handle == NULL) {
return VG_LITE_INVALID_ARGUMENT;
}
/* Free the buffer. */
free.memory_handle = buffer->handle;
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_FREE, &free));
/* Mark the buffer as freed. */
buffer->handle = NULL;
buffer->memory = NULL;
return VG_LITE_SUCCESS;
}
#endif /* VG_DRIVER_SINGLE_THREAD */
vg_lite_error_t vg_lite_map(vg_lite_buffer_t * buffer)
{
vg_lite_error_t error;
vg_lite_kernel_map_t map;
/* We either need a logical or physical address. */
if (buffer->memory == NULL && buffer->address == 0) {
return VG_LITE_INVALID_ARGUMENT;
}
/* Check if we need to compute the stride. Usually map a pre-allocated memory, so the stride
usually should be set*/
if (buffer->stride == 0) {
uint32_t mul, div, align;
get_format_bytes(buffer->format, &mul, &div, &align);
/* Compute the stride to be aligned. */
buffer->stride = VG_LITE_ALIGN((buffer->width * mul / div), align);
}
/* Map the buffer. */
map.bytes = buffer->stride * buffer->height;
map.logical = buffer->memory;
map.physical = buffer->address;
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_MAP, &map));
/* Save the buffer allocation. */
buffer->handle = map.memory_handle;
buffer->address = map.memory_gpu;
return VG_LITE_SUCCESS;
}
vg_lite_error_t vg_lite_unmap(vg_lite_buffer_t * buffer)
{
vg_lite_error_t error;
vg_lite_kernel_unmap_t unmap;
/* Make sure we have a valid memory handle. */
if (buffer->handle == NULL) {
return VG_LITE_INVALID_ARGUMENT;
}
/* Unmap the buffer. */
unmap.memory_handle = buffer->handle;
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_UNMAP, &unmap));
/* Mark the buffer as freed. */
buffer->handle = NULL;
return VG_LITE_SUCCESS;
}
vg_lite_error_t vg_lite_get_register(uint32_t address, uint32_t * result)
{
vg_lite_error_t error;
vg_lite_kernel_info_t data;
/* Get input register address. */
data.addr = address;
/* Get register info. */
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_CHECK, &data));
/* Return register info. */
*result = data.reg;
return VG_LITE_SUCCESS;
}
void vg_lite_get_info(vg_lite_info_t *info)
{
if (info != NULL)
{
info->api_version = VGLITE_API_VERSION_2_0;
info->header_version = VGLITE_HEADER_VERSION;
info->release_version = VGLITE_RELEASE_VERSION;
info->reserved = 0;
}
}
uint32_t vg_lite_get_product_info(char *name, uint32_t *chip_id, uint32_t *chip_rev)
{
const char *product_name = "GCNanoLiteV";
uint32_t name_len;
uint32_t rev = 0, id = 0;
vg_lite_get_register(0x24, &rev);
vg_lite_get_register(0x20, &id);
name_len = strlen(product_name) + 1;
if (name != NULL)
{
memcpy(name, product_name, name_len);
}
if (chip_id != NULL)
{
*chip_id = id;
}
if (chip_rev != NULL)
{
*chip_rev = rev;
}
return name_len;
}
uint32_t vg_lite_query_feature(vg_lite_feature_t feature)
{
uint32_t result;
#if defined(VG_DRIVER_SINGLE_THREAD)
vg_lite_context_t *ctx = &s_context;
#else
vg_lite_context_t *ctx;
vg_lite_tls_t *tls;
tls = (vg_lite_tls_t *) vg_lite_os_get_tls();
if (tls == NULL)
return VG_LITE_NO_CONTEXT;
ctx = &tls->t_context;
#endif /* VG_DRIVER_SINGLE_THREAD */
if (feature < gcFEATURE_COUNT)
result = ctx->s_ftable.ftable[feature];
else
result = 0;
return result;
}
#if defined(VG_DRIVER_SINGLE_THREAD)
vg_lite_error_t vg_lite_finish()
{
vg_lite_error_t error;
/* Return if there is nothing to submit. */
if (CMDBUF_OFFSET(s_context) == 0)
{
if(submit_flag)
VG_LITE_RETURN_ERROR(stall(&s_context, 0, (uint32_t)~0));
return VG_LITE_SUCCESS;
}
/* Flush is moved from each draw to here. */
VG_LITE_RETURN_ERROR(flush_target());
VG_LITE_RETURN_ERROR(submit(&s_context));
VG_LITE_RETURN_ERROR(stall(&s_context, 0, (uint32_t)~0));
#if VG_TARGET_FAST_CLEAR
/*Only used in cmodel/fpga. In final SOC this SW FC decoder should be removed. */
if (s_context.rtbuffer != NULL) {
#if VG_TARGET_FC_DUMP
fc_buf_dump(s_context.rtbuffer, &s_context.fcBuffer);
#endif /* VG_TARGET_FC_DUMP */
}
#endif
CMDBUF_SWAP(s_context);
/* Reset command buffer. */
CMDBUF_OFFSET(s_context) = 0;
return VG_LITE_SUCCESS;
}
vg_lite_error_t vg_lite_flush(void)
{
vg_lite_error_t error;
/* Return if there is nothing to submit. */
if (CMDBUF_OFFSET(s_context) == 0)
return VG_LITE_SUCCESS;
/* Wait if GPU has not completed previous CMD buffer */
if (submit_flag)
{
VG_LITE_RETURN_ERROR(stall(&s_context, 0, (uint32_t)~0));
}
/* Submit the current command buffer. */
VG_LITE_RETURN_ERROR(flush_target());
VG_LITE_RETURN_ERROR(submit(&s_context));
CMDBUF_SWAP(s_context);
/* Reset command buffer. */
CMDBUF_OFFSET(s_context) = 0;
return VG_LITE_SUCCESS;
}
#else
vg_lite_error_t vg_lite_finish()
{
vg_lite_error_t error;
vg_lite_tls_t* tls;
uint32_t command_id, index;
tls = (vg_lite_tls_t *) vg_lite_os_get_tls();
if(tls == NULL)
return VG_LITE_NO_CONTEXT;
command_id = CMDBUF_INDEX(tls->t_context);
index = command_id ? 0 : 1;
if (CMDBUF_OFFSET(tls->t_context) <= 8){
/* Return if there is nothing to submit. */
if (!CMDBUF_IN_QUEUE(&tls->t_context.context, 0) && !CMDBUF_IN_QUEUE(&tls->t_context.context, 1) )
return VG_LITE_SUCCESS;
/* This frame has unfinished command. */
else if(CMDBUF_IN_QUEUE(&tls->t_context.context, index))
{
CMDBUF_SWAP(tls->t_context);
VG_LITE_RETURN_ERROR(stall(&tls->t_context, 0));
}
/* This frame has unfinished command. */
else if(CMDBUF_IN_QUEUE(&tls->t_context.context, command_id))
{
VG_LITE_RETURN_ERROR(stall(&tls->t_context, 0));
}
CMDBUF_OFFSET(tls->t_context) = 0;
VG_LITE_RETURN_ERROR(push_state(&tls->t_context, 0x0A00, 0x0));
return VG_LITE_SUCCESS;
}
else
{
/* Flush is moved from each draw to here. */
VG_LITE_RETURN_ERROR(flush_target());
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_LOCK, NULL));
/* if context have been switched and this task need use index. */
VG_LITE_RETURN_ERROR(update_context_buffer());
VG_LITE_RETURN_ERROR(submit(&tls->t_context));
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_UNLOCK, NULL));
VG_LITE_RETURN_ERROR(stall(&tls->t_context, 0));
}
#if VG_TARGET_FAST_CLEAR
/*Only used in cmodel/fpga. In final SOC this SW FC decoder should be removed. */
if (tls->t_context.rtbuffer != NULL) {
#if VG_TARGET_FC_DUMP
fc_buf_dump(tls->t_context.rtbuffer, &tls->t_context.fcBuffer);
#endif /* VG_TARGET_FC_DUMP */
}
#endif
CMDBUF_SWAP(tls->t_context);
CMDBUF_OFFSET(tls->t_context) = 0;
VG_LITE_RETURN_ERROR(push_state(&tls->t_context, 0x0A00, 0x0));
tls->t_context.ts_init_used = 0;
tls->t_context.ts_init_use = 0;
tls->t_context.ts_init = 0;
return VG_LITE_SUCCESS;
}
vg_lite_error_t vg_lite_flush(void)
{
vg_lite_error_t error;
vg_lite_tls_t* tls;
tls = (vg_lite_tls_t *) vg_lite_os_get_tls();
if(tls == NULL)
return VG_LITE_NO_CONTEXT;
/* Return if there is nothing to submit. */
if (CMDBUF_OFFSET(tls->t_context) == 0)
return VG_LITE_SUCCESS;
/* Submit the current command buffer. */
VG_LITE_RETURN_ERROR(flush_target());
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_LOCK, NULL));
/* if context have been switched and this task need use index. */
VG_LITE_RETURN_ERROR(update_context_buffer());
VG_LITE_RETURN_ERROR(submit(&tls->t_context));
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_UNLOCK, NULL));
CMDBUF_SWAP(tls->t_context);
CMDBUF_OFFSET(tls->t_context) = 0;
VG_LITE_RETURN_ERROR(push_state(&tls->t_context, 0x0A00, 0x0));
tls->t_context.ts_init_used = 0;
tls->t_context.ts_init_use = 0;
tls->t_context.ts_init = 0;
return VG_LITE_SUCCESS;
}
#endif /* VG_DRIVER_SINGLE_THREAD */
vg_lite_error_t vg_lite_init_arc_path(vg_lite_path_t * path,
vg_lite_format_t data_format,
vg_lite_quality_t quality,
uint32_t path_length,
void * path_data,
vg_lite_float_t min_x, vg_lite_float_t min_y,
vg_lite_float_t max_x, vg_lite_float_t max_y)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
uint32_t i = 0,command = 0,offset = 0;
vg_lite_float_t moveToX,moveToY,lineToX,lineToY,controlX, controlY,quadToX, quadToY;
vg_lite_float_t controlX1, controlY1,controlX2, controlY2,cubicToX, cubicToY;
vg_lite_float_t horRadius,verRadius,rotAngle,endX,endY;
float *pfloat,*fpath;
char *cpath,*pathdata;
vg_lite_control_coord_t coords;
if(path == NULL || path_data == NULL || data_format != VG_LITE_FP32)
return VG_LITE_INVALID_ARGUMENT;
memset(path, 0, sizeof(*path));
if(!path_length)
{
path->format = data_format;
path->quality = quality;
path->bounding_box[0] = min_x;
path->bounding_box[1] = min_y;
path->bounding_box[2] = max_x;
path->bounding_box[3] = max_y;
path->path_length = 0;
path->path = NULL;
path->pdata_internal = 1;
path->path_changed = 1;
path->uploaded.address = 0;
path->uploaded.bytes = 0;
path->uploaded.handle = NULL;
path->uploaded.memory = NULL;
return VG_LITE_SUCCESS;
}
memset(&coords, 0, sizeof(vg_lite_control_coord_t));
pathdata = (char *)vg_lite_os_malloc(path_length);
if (pathdata == NULL)
return VG_LITE_OUT_OF_MEMORY;
memset(pathdata, 0, path_length);
pfloat = (vg_lite_float_t *)path_data;
while(i < path_length)
{
cpath = (char *)pfloat;
command = (uint32_t)*cpath;
pfloat++;
switch (command)
{
case VLC_OP_END:
cpath = (char *)pathdata + offset;
fpath = (vg_lite_float_t *)cpath;
*cpath = VLC_OP_END;
offset += _commandSize_float[VLC_OP_END];
i += _commandSize_float[VLC_OP_END];
break;
case VLC_OP_CLOSE:
/* Update the control coordinates. */
coords.lastX = coords.startX;
coords.lastY = coords.startY;
coords.controlX = coords.startX;
coords.controlY = coords.startY;
cpath = (char *)pathdata + offset;
fpath = (vg_lite_float_t *)cpath;
*cpath = VLC_OP_CLOSE;
offset += _commandSize_float[VLC_OP_CLOSE];
i += _commandSize_float[VLC_OP_CLOSE];
break;
case VLC_OP_MOVE:
moveToX = *pfloat++;
moveToY = *pfloat++;
/* Update the control coordinates. */
coords.startX = moveToX;
coords.startY = moveToY;
coords.lastX = moveToX;
coords.lastY = moveToY;
coords.controlX = moveToX;
coords.controlY = moveToY;
cpath = (char *)pathdata + offset;
fpath = (vg_lite_float_t *)cpath;
*cpath = VLC_OP_MOVE;
fpath++;
*fpath++ = moveToX;
*fpath++ = moveToY;
offset += _commandSize_float[VLC_OP_MOVE];
i += _commandSize_float[VLC_OP_MOVE];
break;
case VLC_OP_MOVE_REL:
moveToX = *pfloat++;
moveToY = *pfloat++;
cpath = (char *)pathdata + offset;
fpath = (vg_lite_float_t *)cpath;
*cpath = VLC_OP_MOVE_REL;
fpath++;
*fpath++ = moveToX;
*fpath++ = moveToY;
offset += _commandSize_float[VLC_OP_MOVE_REL];
i += _commandSize_float[VLC_OP_MOVE_REL];
/* Determine the absolute coordinates. */
moveToX += coords.lastX;
moveToY += coords.lastY;
/* Update the control coordinates. */
coords.startX = moveToX;
coords.startY = moveToY;
coords.lastX = moveToX;
coords.lastY = moveToY;
coords.controlX = moveToX;
coords.controlY = moveToY;
break;
case VLC_OP_LINE:
lineToX = *pfloat++;
lineToY = *pfloat++;
/* Update the control coordinates. */
coords.lastX = lineToX;
coords.lastY = lineToY;
coords.controlX = lineToX;
coords.controlY = lineToY;
cpath = (char *)pathdata + offset;
fpath = (vg_lite_float_t *)cpath;
*cpath = VLC_OP_LINE;
fpath++;
*fpath++ = lineToX;
*fpath++ = lineToY;
offset += _commandSize_float[VLC_OP_LINE];
i += _commandSize_float[VLC_OP_LINE];
break;
case VLC_OP_LINE_REL:
lineToX = *pfloat++;
lineToY = *pfloat++;
cpath = (char *)pathdata + offset;
fpath = (vg_lite_float_t *)cpath;
*cpath = VLC_OP_LINE_REL;
fpath++;
*fpath++ = lineToX;
*fpath++ = lineToY;
offset += _commandSize_float[VLC_OP_LINE_REL];
i += _commandSize_float[VLC_OP_LINE_REL];
/* Determine the absolute coordinates. */
lineToX += coords.lastX;
lineToY += coords.lastY;
/* Update the control coordinates. */
coords.lastX = lineToX;
coords.lastY = lineToY;
coords.controlX = lineToX;
coords.controlY = lineToY;
break;
case VLC_OP_QUAD:
controlX = *pfloat++;
controlY = *pfloat++;
quadToX = *pfloat++;
quadToY = *pfloat++;
/* Update the control coordinates. */
coords.lastX = quadToX;
coords.lastY = quadToY;
coords.controlX = controlX;
coords.controlY = controlY;
cpath = (char *)pathdata + offset;
fpath = (vg_lite_float_t *)cpath;
*cpath = VLC_OP_QUAD;
fpath++;
*fpath++ = controlX;
*fpath++ = controlY;
*fpath++ = quadToX;
*fpath++ = quadToY;
offset += _commandSize_float[VLC_OP_QUAD];
i += _commandSize_float[VLC_OP_QUAD];
break;
case VLC_OP_QUAD_REL:
controlX = *pfloat++;
controlY = *pfloat++;
quadToX = *pfloat++;
quadToY = *pfloat++;
cpath = (char *)pathdata + offset;
fpath = (vg_lite_float_t *)cpath;
*cpath = VLC_OP_QUAD_REL;
fpath++;
*fpath++ = controlX;
*fpath++ = controlY;
*fpath++ = quadToX;
*fpath++ = quadToY;
offset += _commandSize_float[VLC_OP_QUAD_REL];
i += _commandSize_float[VLC_OP_QUAD_REL];
/* Determine the absolute coordinates. */
controlX += coords.lastX;
controlY += coords.lastY;
quadToX += coords.lastX;
quadToY += coords.lastY;
/* Update the control coordinates. */
coords.lastX = quadToX;
coords.lastY = quadToY;
coords.controlX = controlX;
coords.controlY = controlY;
break;
case VLC_OP_CUBIC:
controlX1 = *pfloat++;
controlY1 = *pfloat++;
controlX2 = *pfloat++;
controlY2 = *pfloat++;
cubicToX = *pfloat++;
cubicToY = *pfloat++;
/* Update the control coordinates. */
coords.lastX = cubicToX;
coords.lastY = cubicToY;
coords.controlX = controlX2;
coords.controlY = controlY2;
cpath = (char *)pathdata + offset;
fpath = (vg_lite_float_t *)cpath;
*cpath = VLC_OP_CUBIC;
fpath++;
*fpath++ = controlX1;
*fpath++ = controlY1;
*fpath++ = controlX2;
*fpath++ = controlY2;
*fpath++ = cubicToX;
*fpath++ = cubicToY;
offset += _commandSize_float[VLC_OP_CUBIC];
i += _commandSize_float[VLC_OP_CUBIC];
break;
case VLC_OP_CUBIC_REL:
controlX1 = *pfloat++;
controlY1 = *pfloat++;
controlX2 = *pfloat++;
controlY2 = *pfloat++;
cubicToX = *pfloat++;
cubicToY = *pfloat++;
cpath = (char *)pathdata + offset;
fpath = (vg_lite_float_t *)cpath;
*cpath = VLC_OP_CUBIC_REL;
fpath++;
*fpath++ = controlX1;
*fpath++ = controlY1;
*fpath++ = controlX2;
*fpath++ = controlY2;
*fpath++ = cubicToX;
*fpath++ = cubicToY;
offset += _commandSize_float[VLC_OP_CUBIC_REL];
i += _commandSize_float[VLC_OP_CUBIC_REL];
/* Determine the absolute coordinates. */
controlX2 += coords.lastX;
controlY2 += coords.lastY;
cubicToX += coords.lastX;
cubicToY += coords.lastY;
/* Update the control coordinates. */
coords.lastX = cubicToX;
coords.lastY = cubicToY;
coords.controlX = controlX2;
coords.controlY = controlY2;
break;
case VLC_OP_SCCWARC:
horRadius = *pfloat++;
verRadius = *pfloat++;
rotAngle = *pfloat++;
endX = *pfloat++;
endY = *pfloat++;
i += _commandSize_float[VLC_OP_SCCWARC];
VG_LITE_ERROR_HANDLER(_convert_arc(horRadius,verRadius,rotAngle,endX,endY,FALSE,FALSE,FALSE,&coords,(void *)&pathdata,&offset,path_length - i));
break;
case VLC_OP_SCCWARC_REL:
horRadius = *pfloat++;
verRadius = *pfloat++;
rotAngle = *pfloat++;
endX = *pfloat++;
endY = *pfloat++;
i += _commandSize_float[VLC_OP_SCCWARC_REL];
VG_LITE_ERROR_HANDLER(_convert_arc(horRadius,verRadius,rotAngle,endX,endY,FALSE,FALSE,TURE,&coords,(void *)&pathdata,&offset,path_length - i));
break;
case VLC_OP_SCWARC:
horRadius = *pfloat++;
verRadius = *pfloat++;
rotAngle = *pfloat++;
endX = *pfloat++;
endY = *pfloat++;
i += _commandSize_float[VLC_OP_SCCWARC_REL];
VG_LITE_ERROR_HANDLER(_convert_arc(horRadius,verRadius,rotAngle,endX,endY,TURE,FALSE,FALSE,&coords,(void *)&pathdata,&offset,path_length - i));
break;
case VLC_OP_SCWARC_REL:
horRadius = *pfloat++;
verRadius = *pfloat++;
rotAngle = *pfloat++;
endX = *pfloat++;
endY = *pfloat++;
i += _commandSize_float[VLC_OP_SCCWARC_REL];
VG_LITE_ERROR_HANDLER(_convert_arc(horRadius,verRadius,rotAngle,endX,endY,TURE,FALSE,TURE,&coords,(void *)&pathdata,&offset,path_length - i));
break;
case VLC_OP_LCCWARC:
horRadius = *pfloat++;
verRadius = *pfloat++;
rotAngle = *pfloat++;
endX = *pfloat++;
endY = *pfloat++;
i += _commandSize_float[VLC_OP_SCCWARC_REL];
VG_LITE_ERROR_HANDLER(_convert_arc(horRadius,verRadius,rotAngle,endX,endY,FALSE,TURE,FALSE,&coords,(void *)&pathdata,&offset,path_length - i));
break;
case VLC_OP_LCCWARC_REL:
horRadius = *pfloat++;
verRadius = *pfloat++;
rotAngle = *pfloat++;
endX = *pfloat++;
endY = *pfloat++;
i += _commandSize_float[VLC_OP_SCCWARC_REL];
VG_LITE_ERROR_HANDLER(_convert_arc(horRadius,verRadius,rotAngle,endX,endY,FALSE,TURE,TURE,&coords,(void *)&pathdata,&offset,path_length - i));
break;
case VLC_OP_LCWARC:
horRadius = *pfloat++;
verRadius = *pfloat++;
rotAngle = *pfloat++;
endX = *pfloat++;
endY = *pfloat++;
i += _commandSize_float[VLC_OP_SCCWARC_REL];
VG_LITE_ERROR_HANDLER(_convert_arc(horRadius,verRadius,rotAngle,endX,endY,TURE,TURE,FALSE,&coords,(void *)&pathdata,&offset,path_length - i));
break;
case VLC_OP_LCWARC_REL:
horRadius = *pfloat++;
verRadius = *pfloat++;
rotAngle = *pfloat++;
endX = *pfloat++;
endY = *pfloat++;
i += _commandSize_float[VLC_OP_SCCWARC_REL];
VG_LITE_ERROR_HANDLER(_convert_arc(horRadius,verRadius,rotAngle,endX,endY,TURE,TURE,TURE,&coords,(void *)&pathdata,&offset,path_length - i));
break;
default:
break;
}
}
path->format = data_format;
path->quality = quality;
path->bounding_box[0] = min_x;
path->bounding_box[1] = min_y;
path->bounding_box[2] = max_x;
path->bounding_box[3] = max_y;
path->path_length = offset;
path->path = pathdata;
path->pdata_internal = 1;
path->path_changed = 1;
path->uploaded.address = 0;
path->uploaded.bytes = 0;
path->uploaded.handle = NULL;
path->uploaded.memory = NULL;
return VG_LITE_SUCCESS;
ErrorHandler:
vg_lite_os_free(pathdata);
pathdata = NULL;
return error;
}
vg_lite_error_t vg_lite_init_path(vg_lite_path_t * path,
vg_lite_format_t data_format,
vg_lite_quality_t quality,
uint32_t path_length,
void * path_data,
vg_lite_float_t min_x, vg_lite_float_t min_y,
vg_lite_float_t max_x, vg_lite_float_t max_y)
{
if(path == NULL)
return VG_LITE_INVALID_ARGUMENT;
memset(path, 0, sizeof(*path));
path->format = data_format;
path->quality = quality;
path->bounding_box[0] = min_x;
path->bounding_box[1] = min_y;
path->bounding_box[2] = max_x;
path->bounding_box[3] = max_y;
path->path_length = path_length;
path->path = path_data;
path->path_changed = 1;
path->uploaded.address = 0;
path->uploaded.bytes = 0;
path->uploaded.handle = NULL;
path->uploaded.memory = NULL;
path->uploaded.property = 0;
path->pdata_internal = 0;
return VG_LITE_SUCCESS;
}
vg_lite_error_t vg_lite_clear_path(vg_lite_path_t * path)
{
vg_lite_error_t error;
if (path->uploaded.handle != NULL)
{
vg_lite_kernel_free_t free_cmd;
free_cmd.memory_handle = path->uploaded.handle;
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_FREE, &free_cmd));
}
path->uploaded.address = 0;
path->uploaded.bytes = 0;
path->uploaded.handle = NULL;
path->uploaded.memory = NULL;
if(path->pdata_internal == 1 && path->path != NULL){
vg_lite_os_free(path->path);
}
path->path = NULL;
if(path->stroke_path_data) {
vg_lite_os_free(path->stroke_path_data);
path->stroke_path_data = NULL;
}
if (path->stroke_conversion) {
if(path->stroke_conversion->path_point_list) {
vg_lite_path_point_ptr temp_point;
while(path->stroke_conversion->path_point_list) {
temp_point = path->stroke_conversion->path_point_list->next;
vg_lite_os_free(path->stroke_conversion->path_point_list);
path->stroke_conversion->path_point_list = temp_point;
}
temp_point = NULL;
}
if(path->stroke_conversion->stroke_sub_path_list) {
vg_lite_sub_path_ptr temp_sub_path;
while(path->stroke_conversion->stroke_sub_path_list) {
temp_sub_path = path->stroke_conversion->stroke_sub_path_list->next;
if(path->stroke_conversion->stroke_sub_path_list->point_list) {
vg_lite_path_point_ptr temp_point;
while(path->stroke_conversion->stroke_sub_path_list->point_list) {
temp_point = path->stroke_conversion->stroke_sub_path_list->point_list->next;
vg_lite_os_free(path->stroke_conversion->stroke_sub_path_list->point_list);
path->stroke_conversion->stroke_sub_path_list->point_list = temp_point;
}
temp_point = NULL;
}
vg_lite_os_free(path->stroke_conversion->stroke_sub_path_list);
path->stroke_conversion->stroke_sub_path_list = temp_sub_path;
}
temp_sub_path = NULL;
}
vg_lite_os_free(path->stroke_conversion);
path->stroke_conversion = NULL;
}
return VG_LITE_SUCCESS;
}
#if defined(VG_DRIVER_SINGLE_THREAD)
vg_lite_error_t vg_lite_set_CLUT(uint32_t count,
uint32_t * colors)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
uint32_t addr = 0x0B00;
if(!s_context.s_ftable.ftable[gcFEATURE_BIT_VG_IM_INDEX_FORMAT])
return VG_LITE_NOT_SUPPORT;
switch (count) {
case 256:
addr = 0x0B00;
break;
case 16:
addr = 0x0AA0;
break;
case 4:
addr = 0x0A9C;
break;
case 2:
addr = 0x0A98;
break;
default:
error = VG_LITE_INVALID_ARGUMENT;
return error;
break;
}
VG_LITE_RETURN_ERROR(push_states(&s_context, addr, count, colors));
return error;
}
#else
vg_lite_error_t vg_lite_set_CLUT(uint32_t count,
uint32_t * colors)
{
vg_lite_tls_t* tls;
vg_lite_error_t error = VG_LITE_SUCCESS;
tls = (vg_lite_tls_t *) vg_lite_os_get_tls();
if(tls == NULL)
return VG_LITE_NO_CONTEXT;
if(!tls->t_context.s_ftable.ftable[gcFEATURE_BIT_VG_IM_INDEX_FORMAT])
return VG_LITE_NOT_SUPPORT;
switch (count) {
case 2:
tls->t_context.clut_dirty[0] = 1;
tls->t_context.clut_used[0] = 0;
if(!tls->t_context.colors[0])
tls->t_context.colors[0] = (uint32_t *)malloc(count * sizeof(uint32_t));
memcpy(tls->t_context.colors[0], colors, count * sizeof(uint32_t));
break;
case 4:
tls->t_context.clut_dirty[1] = 1;
tls->t_context.clut_used[1] = 0;
if(!tls->t_context.colors[1])
tls->t_context.colors[1] = (uint32_t *)malloc(count * sizeof(uint32_t));
memcpy(tls->t_context.colors[1], colors, count * sizeof(uint32_t));
break;
case 16:
tls->t_context.clut_dirty[2] = 1;
tls->t_context.clut_used[2] = 0;
if(!tls->t_context.colors[2])
tls->t_context.colors[2] = (uint32_t *)malloc(count * sizeof(uint32_t));
memcpy(tls->t_context.colors[2], colors, count * sizeof(uint32_t));
break;
case 256:
tls->t_context.clut_dirty[3] = 1;
tls->t_context.clut_used[3] = 0;
if(!tls->t_context.colors[3])
tls->t_context.colors[3] = (uint32_t *)malloc(count * sizeof(uint32_t));
memcpy(tls->t_context.colors[3], colors, count * sizeof(uint32_t));
break;
default:
error = VG_LITE_INVALID_ARGUMENT;
return error;
break;
}
return error;
}
#endif /* VG_DRIVER_SINGLE_THREAD */
vg_lite_error_t vg_lite_draw_pattern(vg_lite_buffer_t * target,
vg_lite_path_t * path,
vg_lite_fill_t fill_rule,
vg_lite_matrix_t * matrix0,
vg_lite_buffer_t * source,
vg_lite_matrix_t * matrix1,
vg_lite_blend_t blend,
vg_lite_pattern_mode_t pattern_mode,
vg_lite_color_t pattern_color,
vg_lite_filter_t filter)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
uint32_t imageMode;
uint32_t blend_mode;
uint32_t conversion = 0;
uint32_t tiled_source;
vg_lite_matrix_t * matrix = matrix1;
uint32_t pattern_tile = 0;
uint32_t transparency_mode = 0;
int32_t dst_align_width;
uint32_t mul, div, align;
#if defined(VG_DRIVER_SINGLE_THREAD)
vg_lite_context_t *ctx = &s_context;
#else
vg_lite_context_t *ctx;
vg_lite_tls_t *tls;
tls = (vg_lite_tls_t *) vg_lite_os_get_tls();
if(tls == NULL)
return VG_LITE_NO_CONTEXT;
ctx = &tls->t_context;
#endif /* VG_DRIVER_SINGLE_THREAD */
if(!path)
return VG_LITE_INVALID_ARGUMENT;
if(!path->path_length)
return VG_LITE_SUCCESS;
if(!path->path)
return VG_LITE_INVALID_ARGUMENT;
/* The following code is from "draw path" */
uint32_t format, quality, tiling, fill;
uint32_t tessellation_size;
#if DUMP_COMMAND
vg_lite_kernel_allocate_t memory;
uint32_t return_offset = 0;
#endif
vg_lite_point_t point_min = {0}, point_max = {0}, temp = {0};
int x, y, width, height;
uint8_t ts_is_fullscreen = 0;
if(!vg_lite_query_feature(gcFEATURE_BIT_VG_QUALITY_8X) && path->quality == VG_LITE_UPPER){
return VG_LITE_NOT_SUPPORT;
}
if(source->format == VG_LITE_A4 || source->format == VG_LITE_A8) {
return VG_LITE_NOT_SUPPORT;
}
error = set_render_target(target);
if (error != VG_LITE_SUCCESS) {
return error;
} else if (error == VG_LITE_NO_CONTEXT) {
/* If scissoring is enabled and no valid scissoring rectangles
are present, no drawing occurs */
return VG_LITE_SUCCESS;
}
transparency_mode = (source->transparency_mode == VG_LITE_IMAGE_TRANSPARENT ? 0x8000:0);
width = ctx->tsbuffer.tessellation_width_height & 0xFFFF;
height = ctx->tsbuffer.tessellation_width_height >> 16;
get_format_bytes(target->format, &mul, &div, &align);
dst_align_width = target->stride * div / mul;
if(width == 0 || height == 0)
return VG_LITE_NO_CONTEXT;
if ((dst_align_width <= width) && (target->height <= height))
{
ts_is_fullscreen = 1;
point_min.x = 0;
point_min.y = 0;
point_max.x = dst_align_width;
point_max.y = target->height;
}
/* If target is L8 and source is in YUV or RGB (not L8 or A8) then we have to convert RGB into L8. */
if ((target->format == VG_LITE_L8) && ((source->format != VG_LITE_L8) && (source->format != VG_LITE_A8))) {
conversion = 0x80000000;
}
/* Determine image mode (NORMAL or MULTIPLY) depending on the color. */
imageMode = (source->image_mode == VG_LITE_NONE_IMAGE_MODE) ? 0 : (source->image_mode == VG_LITE_MULTIPLY_IMAGE_MODE) ? 0x00002000 : 0x00001000;
tiled_source = (source->tiled != VG_LITE_LINEAR) ? 0x10000000 : 0 ;
if (pattern_mode == VG_LITE_PATTERN_COLOR)
{
uint8_t a,r,g,b;
pattern_tile = 0;
a = pattern_color >> 24;
r = pattern_color >> 16;
g = pattern_color >> 8;
b = pattern_color;
pattern_color = (a << 24) | (b << 16) | (g << 8) | r;
}
else if (pattern_mode == VG_LITE_PATTERN_PAD)
{
pattern_tile = 0x1000;
}
else
{
return VG_LITE_INVALID_ARGUMENT;
}
#if !defined(VG_DRIVER_SINGLE_THREAD)
if(ctx->ts_dirty){
memcpy(CMDBUF_BUFFER(*ctx) + CMDBUF_OFFSET(*ctx), ctx->ts_record, 80);
CMDBUF_OFFSET(*ctx) += 80;
ctx->ts_dirty = 0;
ctx->ts_init_used = 1;
}
else
{
ctx->ts_init_use = 1;
}
/* Setup the command buffer. */
if(source->format >= VG_LITE_INDEX_1 && source->format <= VG_LITE_INDEX_8)
{
/* this task will use index format,set index_flag to 1. */
ctx->index_format = 1;
switch (source->format) {
case VG_LITE_INDEX_8:
if(ctx->clut_dirty[3]){
VG_LITE_RETURN_ERROR(push_states(ctx, 0x0B00, 256, ctx->colors[3]));
ctx->clut_dirty[3] = 0;
}
else
{
ctx->clut_used[3] = 1;
}
break;
case VG_LITE_INDEX_4:
if(ctx->clut_dirty[2]){
VG_LITE_RETURN_ERROR(push_states(ctx, 0x0AA0, 16, ctx->colors[2]));
ctx->clut_dirty[2] = 0;
}
else
{
ctx->clut_used[2] = 1;
}
break;
case VG_LITE_INDEX_2:
if(ctx->clut_dirty[1]){
VG_LITE_RETURN_ERROR(push_states(ctx, 0x0A9C, 4, ctx->colors[1]));
ctx->clut_dirty[1] = 0;
}
else
{
ctx->clut_used[1] = 1;
}
break;
default:
if(ctx->clut_dirty[0]){
VG_LITE_RETURN_ERROR(push_states(ctx, 0x0A98, 2, ctx->colors[0]));
ctx->clut_dirty[0] = 0;
}
else
{
ctx->clut_used[0] = 1;
}
}
}
#endif /* not defined(VG_DRIVER_SINGLE_THREAD) */
VG_LITE_RETURN_ERROR(set_interpolation_steps(target, source->width, source->height, matrix));
if(!ctx->premultiply_enabled && source->format != VG_LITE_A8 && source->format != VG_LITE_A4) {
if(source->transparency_mode == VG_LITE_IMAGE_OPAQUE){
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A25, convert_source_format(source->format) |
filter | pattern_tile | conversion | 0x01000100));
} else {
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A25, convert_source_format(source->format) |
filter | pattern_tile | conversion | 0x00000100));
}
} else {
/* enable pre-multiplied in imager unit */
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A25, convert_source_format(source->format) |
filter | pattern_tile | conversion));
}
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A27, pattern_color));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A29, source->address));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A2B, source->stride | tiled_source));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A2D, 0));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A2F, source->width | (source->height << 16)));
/* Work on path states. */
matrix = matrix0;
if (ts_is_fullscreen == 0){
transform(&temp, (vg_lite_float_t)path->bounding_box[0], (vg_lite_float_t)path->bounding_box[1], matrix);
point_min = point_max = temp;
transform(&temp, (vg_lite_float_t)path->bounding_box[2], (vg_lite_float_t)path->bounding_box[1], matrix);
if (temp.x < point_min.x) point_min.x = temp.x;
if (temp.y < point_min.y) point_min.y = temp.y;
if (temp.x > point_max.x) point_max.x = temp.x;
if (temp.y > point_max.y) point_max.y = temp.y;
transform(&temp, (vg_lite_float_t)path->bounding_box[2], (vg_lite_float_t)path->bounding_box[3], matrix);
if (temp.x < point_min.x) point_min.x = temp.x;
if (temp.y < point_min.y) point_min.y = temp.y;
if (temp.x > point_max.x) point_max.x = temp.x;
if (temp.y > point_max.y) point_max.y = temp.y;
transform(&temp, (vg_lite_float_t)path->bounding_box[0], (vg_lite_float_t)path->bounding_box[3], matrix);
if (temp.x < point_min.x) point_min.x = temp.x;
if (temp.y < point_min.y) point_min.y = temp.y;
if (temp.x > point_max.x) point_max.x = temp.x;
if (temp.y > point_max.y) point_max.y = temp.y;
point_min.x = MAX(point_min.x, 0);
point_min.y = MAX(point_min.y, 0);
point_max.x = MIN(point_max.x, dst_align_width);
point_max.y = MIN(point_max.y, target->height);
}
if (ctx->scissor_enabled) {
point_min.x = MAX(point_min.x, ctx->scissor[0]);
point_min.y = MAX(point_min.y, ctx->scissor[1]);
point_max.x = MIN(point_max.x, ctx->scissor[0] + ctx->scissor[2]);
point_max.y = MIN(point_max.y, ctx->scissor[1] + ctx->scissor[3]);
}
/* Convert states into hardware values. */
blend_mode = convert_blend(blend);
format = convert_path_format(path->format);
quality = convert_path_quality(path->quality);
tiling = (ctx->capabilities.cap.tiled == 2) ? 0x2000000 : 0;
fill = (fill_rule == VG_LITE_FILL_EVEN_ODD) ? 0x10 : 0;
tessellation_size = ( ctx->tsbuffer.tessellation_buffer_size[2]
? ctx->tsbuffer.tessellation_buffer_size[2]
: ctx->tsbuffer.tessellation_buffer_size[1]
);
/* Setup the command buffer. */
/* Program color register. */
if(!ctx->premultiply_enabled && source->format != VG_LITE_A8 && source->format != VG_LITE_A4) {
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A00, 0x10000000 | ctx->capabilities.cap.tiled | 0x00000002 | imageMode | blend_mode | transparency_mode));
} else {
/* enable pre-multiplied from VG to VGPE */
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A00, ctx->capabilities.cap.tiled | 0x00000002 | imageMode | blend_mode | transparency_mode));
}
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A34, 0x01000400 | format | quality | tiling | fill));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A3B, 0x3F800000)); /* Path tessellation SCALE. */
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A3C, 0x00000000)); /* Path tessellation BIAS. */
/* Program matrix. */
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A40, (void *) &matrix->m[0][0]));
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A41, (void *) &matrix->m[0][1]));
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A42, (void *) &matrix->m[0][2]));
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A43, (void *) &matrix->m[1][0]));
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A44, (void *) &matrix->m[1][1]));
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A45, (void *) &matrix->m[1][2]));
if (VLM_PATH_GET_UPLOAD_BIT(*path) == 1) {
vglitemDUMP_BUFFER("path", path->uploaded.address, (uint8_t *)(path->uploaded.memory), 0, path->uploaded.bytes);
}
vglitemDUMP("@[memory 0x%08X 0x%08X]", ctx->tsbuffer.tessellation_buffer_gpu[0], ctx->tsbuffer.tessellation_buffer_size[0]);
/* Setup tessellation loop. */
if((path->path_type & 0x1) == VG_LITE_DRAW_FILL_PATH) {
for (y = point_min.y; y < point_max.y; y += height) {
for (x = point_min.x; x < point_max.x; x += width) {
/* Tessellate path. */
VG_LITE_RETURN_ERROR(push_stall(ctx, 15));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A1B, 0x00011000));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A01, x | (y << 16)));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A39, x | (y << 16)));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A3D, tessellation_size / 64));
if (VLM_PATH_GET_UPLOAD_BIT(*path) == 1) {
VG_LITE_RETURN_ERROR(push_call(ctx, path->uploaded.address, path->uploaded.bytes));
#if (DUMP_COMMAND)
if (strncmp(filename, "Commandbuffer", 13)) {
sprintf(filename, "Commandbuffer_pid%d.txt", getpid());
}
fp = fopen(filename, "a");
if (fp == NULL)
printf("error!\n");
fprintf(fp, "Command buffer: 0x%08x, 0x%08x,\n",
((uint32_t *) memory.memory)[0], 0);
unsigned char* pt = (unsigned char*) memory.memory;
for(int i = 8; i <= return_offset * 4 - 1; i = i + 4)
{
if (i % 8 == 0)
fprintf(fp, "Command buffer: ");
if (i % 4 == 0)
fprintf(fp, "0x");
for (int j = 3; j >= 0; --j)
fprintf(fp, "%02x", pt[i + j]);
if ((i / 4 + 1) % 2 == 0)
fprintf(fp, ",\n");
else
fprintf(fp, ", ");
}
fprintf(fp, "Command buffer: 0x%08x, 0x%08x,\n",
((uint32_t *) memory.memory)[return_offset], 0);
fclose(fp);
fp = NULL;
#endif
} else {
push_data(ctx, path->path_length, path->path);
}
}
}
}
/* Setup tessellation loop. */
if(path->path_type == VG_LITE_DRAW_STROKE_PATH || path->path_type == VG_LITE_DRAW_FILL_STROKE_PATH) {
for (y = point_min.y; y < point_max.y; y += height) {
for (x = point_min.x; x < point_max.x; x += width) {
/* Tessellate path. */
VG_LITE_RETURN_ERROR(push_stall(ctx, 15));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A1B, 0x00011000));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A01, x | (y << 16)));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A39, x | (y << 16)));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A3D, tessellation_size / 64));
if (VLM_PATH_GET_UPLOAD_BIT(*path) == 1) {
VG_LITE_RETURN_ERROR(push_call(ctx, path->uploaded.address, path->uploaded.bytes));
#if (DUMP_COMMAND)
if (strncmp(filename, "Commandbuffer", 13)) {
sprintf(filename, "Commandbuffer_pid%d.txt", getpid());
}
fp = fopen(filename, "a");
if (fp == NULL)
printf("error!\n");
fprintf(fp, "Command buffer: 0x%08x, 0x%08x,\n",
((uint32_t *) memory.memory)[0], 0);
unsigned char* pt = (unsigned char*) memory.memory;
for(int i = 8; i <= return_offset * 4 - 1; i = i + 4)
{
if (i % 8 == 0)
fprintf(fp, "Command buffer: ");
if (i % 4 == 0)
fprintf(fp, "0x");
for (int j = 3; j >= 0; --j)
fprintf(fp, "%02x", pt[i + j]);
if ((i / 4 + 1) % 2 == 0)
fprintf(fp, ",\n");
else
fprintf(fp, ", ");
}
fprintf(fp, "Command buffer: 0x%08x, 0x%08x,\n",
((uint32_t *) memory.memory)[return_offset], 0);
fclose(fp);
fp = NULL;
#endif
} else {
format = convert_path_format(VG_LITE_FP32);
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A34, 0x01000200 | format | quality | tiling | 0x0));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A02, path->stroke_color));
push_data(ctx, path->stroke_path_size, path->stroke_path_data);
}
}
}
}
/* Finialize command buffer. */
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A34, 0));
VG_LITE_RETURN_ERROR(flush_target());
vglitemDUMP_BUFFER("image", source->address, source->memory, 0, (source->stride)*(source->height));
#if DUMP_IMAGE
dump_img(source->memory, source->width, source->height, source->format);
#endif
#if !defined(VG_DRIVER_SINGLE_THREAD)
tls->t_context.ts_init = 1;
#endif /* not defined(VG_DRIVER_SINGLE_THREAD) */
return error;
}
vg_lite_error_t vg_lite_draw_linear_gradient(vg_lite_buffer_t * target,
vg_lite_path_t * path,
vg_lite_fill_t fill_rule,
vg_lite_matrix_t * path_matrix,
vg_lite_linear_gradient_ext_t *grad,
vg_lite_color_t paint_color,
vg_lite_blend_t blend,
vg_lite_filter_t filter)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
uint32_t image_mode;
uint32_t blend_mode;
uint32_t conversion = 0;
uint32_t tiled_source;
int32_t dst_align_width;
uint32_t mul, div, align;
vg_lite_matrix_t inverse_matrix;
vg_lite_buffer_t * source = &grad->image;
vg_lite_matrix_t * matrix = &grad->matrix;
uint32_t linear_tile = 0;
uint32_t transparency_mode = 0;
void *data;
/* The following code is from "draw path" */
uint32_t format, quality, tiling, fill;
uint32_t tessellation_size;
vg_lite_kernel_allocate_t memory;
vg_lite_kernel_free_t free_memory;
uint32_t return_offset = 0;
vg_lite_point_t point_min = {0}, point_max = {0}, temp = {0};
int x, y, width, height;
uint8_t ts_is_fullscreen = 0;
vg_lite_float_t dx, dy, dxdx_dydy;
vg_lite_float_t lg_step_x_lin, lg_step_y_lin, lg_constant_lin;
#if defined(VG_DRIVER_SINGLE_THREAD)
vg_lite_context_t *ctx = &s_context;
#else
vg_lite_context_t *ctx;
vg_lite_tls_t* tls;
tls = (vg_lite_tls_t *) vg_lite_os_get_tls();
if (tls == NULL)
return VG_LITE_NO_CONTEXT;
ctx = &tls->t_context;
#endif /* VG_DRIVER_SINGLE_THREAD */
if(!path)
return VG_LITE_INVALID_ARGUMENT;
if(!path->path_length)
return VG_LITE_SUCCESS;
if(!path->path)
return VG_LITE_INVALID_ARGUMENT;
if(!vg_lite_query_feature(gcFEATURE_BIT_VG_LINEAR_GRADIENT_EXT))
return VG_LITE_NOT_SUPPORT;
if(!vg_lite_query_feature(gcFEATURE_BIT_VG_QUALITY_8X) && path->quality == VG_LITE_UPPER){
return VG_LITE_NOT_SUPPORT;
}
if(source->format == VG_LITE_A4 || source->format == VG_LITE_A8) {
return VG_LITE_NOT_SUPPORT;
}
error = set_render_target(target);
if (error != VG_LITE_SUCCESS) {
return error;
} else if (error == VG_LITE_NO_CONTEXT) {
/* If scissoring is enabled and no valid scissoring rectangles
are present, no drawing occurs */
return VG_LITE_SUCCESS;
}
transparency_mode = (source->transparency_mode == VG_LITE_IMAGE_TRANSPARENT ? 0x8000:0);
width = ctx->tsbuffer.tessellation_width_height & 0xFFFF;
height = ctx->tsbuffer.tessellation_width_height >> 16;
get_format_bytes(target->format, &mul, &div, &align);
dst_align_width = target->stride * div / mul;
if(width == 0 || height == 0)
return VG_LITE_NO_CONTEXT;
if ((dst_align_width <= width) && (target->height <= height))
{
ts_is_fullscreen = 1;
point_min.x = 0;
point_min.y = 0;
point_max.x = dst_align_width;
point_max.y = target->height;
}
/* If target is L8 and source is in YUV or RGB (not L8 or A8) then we have to convert RGB into L8. */
if ((target->format == VG_LITE_L8) && ((source->format != VG_LITE_L8) && (source->format != VG_LITE_A8))) {
conversion = 0x80000000;
}
/* Determine image mode (NORMAL or MULTIPLY) depending on the color. */
image_mode = (source->image_mode == VG_LITE_NONE_IMAGE_MODE) ? 0 : (source->image_mode == VG_LITE_MULTIPLY_IMAGE_MODE) ? 0x00002000 : 0x00001000;
tiled_source = (source->tiled != VG_LITE_LINEAR) ? 0x10000000 : 0 ;
linear_tile = (grad->spread_mode == VG_LITE_RADIAL_GRADIENT_SPREAD_FILL) ? 0 :
(grad->spread_mode == VG_LITE_RADIAL_GRADIENT_SPREAD_PAD) ? 0x1000 :
(grad->spread_mode == VG_LITE_RADIAL_GRADIENT_SPREAD_REPEAT) ? 0x2000 : 0x3000;
if (grad->spread_mode == VG_LITE_RADIAL_GRADIENT_SPREAD_FILL)
{
uint8_t a,r,g,b;
a = paint_color >> 24;
r = paint_color >> 16;
g = paint_color >> 8;
b = paint_color;
paint_color = (a << 24) | (b << 16) | (g << 8) | r;
}
/* compute radial gradient paremeters */
if (!inverse(&inverse_matrix, matrix))
return VG_LITE_INVALID_ARGUMENT;
dx = grad->linear_gradient.X1 - grad->linear_gradient.X0;
dy = grad->linear_gradient.Y1 - grad->linear_gradient.Y0;
dxdx_dydy = dx * dx + dy * dy;
/*
** dx (T(x) - x0) + dy (T(y) - y0)
** g = -------------------------------
** dx^2 + dy^2
**
** where
**
** dx := x1 - x0
** dy := y1 - y1
** T(x) := (x + 0.5) m00 + (y + 0.5) m01 + m02
** = x m00 + y m01 + 0.5 (m00 + m01) + m02
** T(y) := (x + 0.5) m10 + (y + 0.5) m11 + m12
** = x m10 + y m11 + 0.5 (m10 + m11) + m12.
**
** We can factor the top line into:
**
** = dx (x m00 + y m01 + 0.5 (m00 + m01) + m02 - x0)
** + dy (x m10 + y m11 + 0.5 (m10 + m11) + m12 - y0)
**
** = x (dx m00 + dy m10)
** + y (dx m01 + dy m11)
** + dx (0.5 (m00 + m01) + m02 - x0)
** + dy (0.5 (m10 + m11) + m12 - y0).
*/
lg_step_x_lin
= (dx * MAT(&inverse_matrix, 0, 0) + dy * MAT(&inverse_matrix, 1, 0))
/ dxdx_dydy;
lg_step_y_lin
= (dx * MAT(&inverse_matrix, 0, 1) + dy * MAT(&inverse_matrix, 1, 1))
/ dxdx_dydy;
lg_constant_lin =
(
(
0.5f * ( MAT(&inverse_matrix, 0, 0) + MAT(&inverse_matrix, 0, 1) )
+ MAT(&inverse_matrix, 0, 2) - grad->linear_gradient.X0
) * dx
+
(
0.5f * ( MAT(&inverse_matrix, 1, 0) + MAT(&inverse_matrix, 1, 1) )
+ MAT(&inverse_matrix, 1, 2) - grad->linear_gradient.Y0
) * dy
)
/ dxdx_dydy;
#if !defined(VG_DRIVER_SINGLE_THREAD)
if(ctx->ts_dirty){
memcpy(CMDBUF_BUFFER(*ctx) + CMDBUF_OFFSET(*ctx), ctx->ts_record, 80);
CMDBUF_OFFSET(*ctx) += 80;
ctx->ts_dirty = 0;
ctx->ts_init_used = 1;
}
else
{
ctx->ts_init_use = 1;
}
#endif /* not defined(VG_DRIVER_SINGLE_THREAD) */
/* Setup the command buffer. */
/* linear gradient parameters*/
data = &lg_constant_lin;
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A04,*(uint32_t*) data));
data = &lg_step_x_lin;
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A06,*(uint32_t*) data));
data = &lg_step_y_lin;
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A08,*(uint32_t*) data));
VG_LITE_RETURN_ERROR(set_interpolation_steps(target, source->width, source->height, matrix));
if(!ctx->premultiply_enabled) {
if(source->transparency_mode == VG_LITE_IMAGE_OPAQUE){
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A24, convert_source_format(source->format) |
filter | linear_tile | conversion | 0x01000100));
} else {
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A24, convert_source_format(source->format) |
filter | linear_tile | conversion | 0x00000100));
}
} else {
/* enable pre-multiplied in imager unit */
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A24, convert_source_format(source->format) |
filter | linear_tile | conversion));
}
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A26, paint_color));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A28, source->address));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A2A, tiled_source));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A2C, 0));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A2E, source->width));
/* Work on path states. */
matrix = path_matrix;
if (ts_is_fullscreen == 0){
transform(&temp, (vg_lite_float_t)path->bounding_box[0], (vg_lite_float_t)path->bounding_box[1], matrix);
point_min = point_max = temp;
transform(&temp, (vg_lite_float_t)path->bounding_box[2], (vg_lite_float_t)path->bounding_box[1], matrix);
if (temp.x < point_min.x) point_min.x = temp.x;
if (temp.y < point_min.y) point_min.y = temp.y;
if (temp.x > point_max.x) point_max.x = temp.x;
if (temp.y > point_max.y) point_max.y = temp.y;
transform(&temp, (vg_lite_float_t)path->bounding_box[2], (vg_lite_float_t)path->bounding_box[3], matrix);
if (temp.x < point_min.x) point_min.x = temp.x;
if (temp.y < point_min.y) point_min.y = temp.y;
if (temp.x > point_max.x) point_max.x = temp.x;
if (temp.y > point_max.y) point_max.y = temp.y;
transform(&temp, (vg_lite_float_t)path->bounding_box[0], (vg_lite_float_t)path->bounding_box[3], matrix);
if (temp.x < point_min.x) point_min.x = temp.x;
if (temp.y < point_min.y) point_min.y = temp.y;
if (temp.x > point_max.x) point_max.x = temp.x;
if (temp.y > point_max.y) point_max.y = temp.y;
point_min.x = MAX(point_min.x, 0);
point_min.y = MAX(point_min.y, 0);
point_max.x = MIN(point_max.x, dst_align_width);
point_max.y = MIN(point_max.y, target->height);
}
if (ctx->scissor_enabled) {
point_min.x = MAX(point_min.x, ctx->scissor[0]);
point_min.y = MAX(point_min.y, ctx->scissor[1]);
point_max.x = MIN(point_max.x, ctx->scissor[0] + ctx->scissor[2]);
point_max.y = MIN(point_max.y, ctx->scissor[1] + ctx->scissor[3]);
}
/* Convert states into hardware values. */
blend_mode = convert_blend(blend);
format = convert_path_format(path->format);
quality = convert_path_quality(path->quality);
tiling = (ctx->capabilities.cap.tiled == 2) ? 0x2000000 : 0;
fill = (fill_rule == VG_LITE_FILL_EVEN_ODD) ? 0x10 : 0;
tessellation_size = ( ctx->tsbuffer.tessellation_buffer_size[2]
? ctx->tsbuffer.tessellation_buffer_size[2]
: ctx->tsbuffer.tessellation_buffer_size[1]
);
/* Setup the command buffer. */
/* Program color register. */
if(!ctx->premultiply_enabled) {
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A00, 0x11000000 | ctx->capabilities.cap.tiled | 0x00000002 | image_mode | blend_mode | transparency_mode));
} else {
/* enable pre-multiplied from VG to VGPE */
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A00, 0x01000000 | ctx->capabilities.cap.tiled | 0x00000002 | image_mode | blend_mode | transparency_mode));
}
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A34, 0x01000400 | format | quality | tiling | fill));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A3B, 0x3F800000)); /* Path tessellation SCALE. */
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A3C, 0x00000000)); /* Path tessellation BIAS. */
/* Program matrix. */
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A40, (void *) &matrix->m[0][0]));
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A41, (void *) &matrix->m[0][1]));
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A42, (void *) &matrix->m[0][2]));
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A43, (void *) &matrix->m[1][0]));
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A44, (void *) &matrix->m[1][1]));
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A45, (void *) &matrix->m[1][2]));
if (VLM_PATH_GET_UPLOAD_BIT(*path) == 1)
{
if (path->path_changed != 0) {
if (path->uploaded.handle != NULL) {
free_memory.memory_handle = path->uploaded.handle;
vg_lite_kernel(VG_LITE_FREE, &free_memory);
path->uploaded.address = 0;
path->uploaded.memory = NULL;
path->uploaded.handle = NULL;
}
/* Allocate memory for the path data. */
memory.bytes = 16 + VG_LITE_ALIGN(path->path_length, 8);
return_offset = (8 + VG_LITE_ALIGN(path->path_length, 8)) / 4;
memory.contiguous = 1;
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_ALLOCATE, &memory));
((uint64_t *) memory.memory)[(path->path_length + 7) / 8] = 0;
((uint32_t *) memory.memory)[0] = VG_LITE_DATA((path->path_length + 7) / 8);
((uint32_t *) memory.memory)[1] = 0;
memcpy((uint8_t *) memory.memory + 8, path->path, path->path_length);
((uint32_t *) memory.memory)[return_offset] = VG_LITE_RETURN();
((uint32_t *) memory.memory)[return_offset + 1] = 0;
path->uploaded.handle = memory.memory_handle;
path->uploaded.memory = memory.memory;
path->uploaded.address = memory.memory_gpu;
path->uploaded.bytes = memory.bytes;
path->path_changed = 0;
}
}
if (VLM_PATH_GET_UPLOAD_BIT(*path) == 1) {
vglitemDUMP_BUFFER("path", path->uploaded.address, (uint8_t *)(path->uploaded.memory), 0, path->uploaded.bytes);
}
vglitemDUMP("@[memory 0x%08X 0x%08X]", ctx->tsbuffer.tessellation_buffer_gpu[0], ctx->tsbuffer.tessellation_buffer_size[0]);
/* Setup tessellation loop. */
if((path->path_type & 0x1) == VG_LITE_DRAW_FILL_PATH) {
for (y = point_min.y; y < point_max.y; y += height) {
for (x = point_min.x; x < point_max.x; x += width) {
/* Tessellate path. */
VG_LITE_RETURN_ERROR(push_stall(ctx, 15));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A1B, 0x00011000));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A01, x | (y << 16)));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A39, x | (y << 16)));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A3D, tessellation_size / 64));
if (VLM_PATH_GET_UPLOAD_BIT(*path) == 1) {
VG_LITE_RETURN_ERROR(push_call(ctx, path->uploaded.address, path->uploaded.bytes));
#if (DUMP_COMMAND)
if (strncmp(filename, "Commandbuffer", 13)) {
sprintf(filename, "Commandbuffer_pid%d.txt", getpid());
}
fp = fopen(filename, "a");
if (fp == NULL)
printf("error!\n");
fprintf(fp, "Command buffer: 0x%08x, 0x%08x,\n",
((uint32_t *) memory.memory)[0], 0);
unsigned char* pt = (unsigned char*) memory.memory;
for(int i = 8; i <= return_offset * 4 - 1; i = i + 4)
{
if (i % 8 == 0)
fprintf(fp, "Command buffer: ");
if (i % 4 == 0)
fprintf(fp, "0x");
for (int j = 3; j >= 0; --j)
fprintf(fp, "%02x", pt[i + j]);
if ((i / 4 + 1) % 2 == 0)
fprintf(fp, ",\n");
else
fprintf(fp, ", ");
}
fprintf(fp, "Command buffer: 0x%08x, 0x%08x,\n",
((uint32_t *) memory.memory)[return_offset], 0);
fclose(fp);
fp = NULL;
#endif
} else {
push_data(ctx, path->path_length, path->path);
}
}
}
}
/* Setup tessellation loop. */
if(path->path_type == VG_LITE_DRAW_STROKE_PATH || path->path_type == VG_LITE_DRAW_FILL_STROKE_PATH) {
for (y = point_min.y; y < point_max.y; y += height) {
for (x = point_min.x; x < point_max.x; x += width) {
/* Tessellate path. */
VG_LITE_RETURN_ERROR(push_stall(ctx, 15));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A1B, 0x00011000));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A01, x | (y << 16)));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A39, x | (y << 16)));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A3D, tessellation_size / 64));
if (VLM_PATH_GET_UPLOAD_BIT(*path) == 1) {
VG_LITE_RETURN_ERROR(push_call(ctx, path->uploaded.address, path->uploaded.bytes));
#if (DUMP_COMMAND)
if (strncmp(filename, "Commandbuffer", 13)) {
sprintf(filename, "Commandbuffer_pid%d.txt", getpid());
}
fp = fopen(filename, "a");
if (fp == NULL)
printf("error!\n");
fprintf(fp, "Command buffer: 0x%08x, 0x%08x,\n",
((uint32_t *) memory.memory)[0], 0);
unsigned char* pt = (unsigned char*) memory.memory;
for(int i = 8; i <= return_offset * 4 - 1; i = i + 4)
{
if (i % 8 == 0)
fprintf(fp, "Command buffer: ");
if (i % 4 == 0)
fprintf(fp, "0x");
for (int j = 3; j >= 0; --j)
fprintf(fp, "%02x", pt[i + j]);
if ((i / 4 + 1) % 2 == 0)
fprintf(fp, ",\n");
else
fprintf(fp, ", ");
}
fprintf(fp, "Command buffer: 0x%08x, 0x%08x,\n",
((uint32_t *) memory.memory)[return_offset], 0);
fclose(fp);
fp = NULL;
#endif
} else {
format = convert_path_format(VG_LITE_FP32);
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A34, 0x01000200 | format | quality | tiling | 0x0));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A02, path->stroke_color));
push_data(ctx, path->stroke_path_size, path->stroke_path_data);
}
}
}
}
/* Finialize command buffer. */
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A34, 0));
vglitemDUMP_BUFFER("image", source->address, source->memory, 0, (source->stride)*(source->height));
#if DUMP_IMAGE
dump_img(source->memory, source->width, source->height, source->format);
#endif
#if !defined(VG_DRIVER_SINGLE_THREAD)
tls->t_context.ts_init = 1;
#endif /* not defined(VG_DRIVER_SINGLE_THREAD) */
return error;
}
vg_lite_error_t vg_lite_draw_radial_gradient(vg_lite_buffer_t * target,
vg_lite_path_t * path,
vg_lite_fill_t fill_rule,
vg_lite_matrix_t * path_matrix,
vg_lite_radial_gradient_t *grad,
vg_lite_color_t paint_color,
vg_lite_blend_t blend,
vg_lite_filter_t filter)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
uint32_t imageMode;
uint32_t blend_mode;
uint32_t conversion = 0;
uint32_t tiled_source;
int32_t dst_align_width;
uint32_t mul, div, align;
vg_lite_matrix_t inverse_matrix;
vg_lite_buffer_t * source = &grad->image;
vg_lite_matrix_t * matrix = &grad->matrix;
uint32_t rad_tile = 0;
uint32_t transparency_mode = 0;
void *data;
/* The following code is from "draw path" */
uint32_t format, quality, tiling, fill;
uint32_t tessellation_size;
vg_lite_kernel_allocate_t memory;
vg_lite_kernel_free_t free_memory;
uint32_t return_offset = 0;
vg_lite_point_t point_min = {0}, point_max = {0}, temp = {0};
int x, y, width, height;
uint8_t ts_is_fullscreen = 0;
vg_lite_float_t radius;
vg_lite_float_t centerX, centerY;
vg_lite_float_t focalX, focalY;
vg_lite_float_t fx, fy;
vg_lite_float_t fxfy_2;
vg_lite_float_t radius2;
vg_lite_float_t r2_fx2, r2_fy2;
vg_lite_float_t r2_fx2_2, r2_fy2_2;
vg_lite_float_t r2_fx2_fy2;
vg_lite_float_t r2_fx2_fy2sq;
vg_lite_float_t cx, cy;
vg_lite_float_t rgConstantLin, rgStepXLin, rgStepYLin;
vg_lite_float_t rgConstantRad, rgStepXRad, rgStepYRad;
vg_lite_float_t rgStepXXRad, rgStepYYRad, rgStepXYRad;
#if defined(VG_DRIVER_SINGLE_THREAD)
vg_lite_context_t *ctx = &s_context;
#else
vg_lite_context_t *ctx;
vg_lite_tls_t* tls;
tls = (vg_lite_tls_t *) vg_lite_os_get_tls();
if(tls == NULL)
return VG_LITE_NO_CONTEXT;
ctx = &tls->t_context;
#endif /* VG_DRIVER_SINGLE_THREAD */
if(!path)
return VG_LITE_INVALID_ARGUMENT;
if(!path->path_length)
return VG_LITE_SUCCESS;
if(!path->path)
return VG_LITE_INVALID_ARGUMENT;
if(!vg_lite_query_feature(gcFEATURE_BIT_VG_RADIAL_GRADIENT))
return VG_LITE_NOT_SUPPORT;
if(!vg_lite_query_feature(gcFEATURE_BIT_VG_QUALITY_8X) && path->quality == VG_LITE_UPPER){
return VG_LITE_NOT_SUPPORT;
}
if(source->format == VG_LITE_A4 || source->format == VG_LITE_A8) {
return VG_LITE_NOT_SUPPORT;
}
radius = grad->radialGradient.r;
if(radius <= 0)
return VG_LITE_INVALID_ARGUMENT;
error = set_render_target(target);
if (error != VG_LITE_SUCCESS) {
return error;
} else if (error == VG_LITE_NO_CONTEXT) {
/* If scissoring is enabled and no valid scissoring rectangles
are present, no drawing occurs */
return VG_LITE_SUCCESS;
}
transparency_mode = (source->transparency_mode == VG_LITE_IMAGE_TRANSPARENT ? 0x8000:0);
width = ctx->tsbuffer.tessellation_width_height & 0xFFFF;
height = ctx->tsbuffer.tessellation_width_height >> 16;
get_format_bytes(target->format, &mul, &div, &align);
dst_align_width = target->stride * div / mul;
if(width == 0 || height == 0)
return VG_LITE_NO_CONTEXT;
if ((dst_align_width <= width) && (target->height <= height))
{
ts_is_fullscreen = 1;
point_min.x = 0;
point_min.y = 0;
point_max.x = dst_align_width;
point_max.y = target->height;
}
/* If target is L8 and source is in YUV or RGB (not L8 or A8) then we have to convert RGB into L8. */
if ((target->format == VG_LITE_L8) && ((source->format != VG_LITE_L8) && (source->format != VG_LITE_A8))) {
conversion = 0x80000000;
}
/* Determine image mode (NORMAL or MULTIPLY) depending on the color. */
imageMode = (source->image_mode == VG_LITE_NONE_IMAGE_MODE) ? 0 : (source->image_mode == VG_LITE_MULTIPLY_IMAGE_MODE) ? 0x00002000 : 0x00001000;
tiled_source = (source->tiled != VG_LITE_LINEAR) ? 0x10000000 : 0 ;
rad_tile = (grad->SpreadMode == VG_LITE_RADIAL_GRADIENT_SPREAD_FILL) ? 0 :
(grad->SpreadMode == VG_LITE_RADIAL_GRADIENT_SPREAD_PAD) ? 0x1000 :
(grad->SpreadMode == VG_LITE_RADIAL_GRADIENT_SPREAD_REPEAT) ? 0x2000 : 0x3000;
if (grad->SpreadMode == VG_LITE_RADIAL_GRADIENT_SPREAD_FILL)
{
uint8_t a,r,g,b;
a = paint_color >> 24;
r = paint_color >> 16;
g = paint_color >> 8;
b = paint_color;
paint_color = (a << 24) | (b << 16) | (g << 8) | r;
}
/* compute radial gradient paremeters */
/* Compute inverse matrix. */
if (!inverse(&inverse_matrix, matrix))
return VG_LITE_INVALID_ARGUMENT;
/* Make shortcuts to the gradient information. */
centerX = grad->radialGradient.cx;
centerY = grad->radialGradient.cy;
focalX = grad->radialGradient.fx;
focalY = grad->radialGradient.fy;
/* Compute constants of the equation. */
fx = focalX - centerX;
fy = focalY - centerY;
radius2 = radius * radius;
if (fx*fx + fy*fy > radius2)
{
/* If the focal point is outside the circle, let's move it
to inside the circle. Per vg11 spec pg125 "If (fx, fy) lies outside ...
For here, we set it at 0.9 ratio to the center.
*/
vg_lite_float_t fr = (vg_lite_float_t)sqrt(fx*fx + fy*fy);
fx = radius * fx / fr * 0.9f;
fy = radius * fy / fr * 0.9f;
focalX = grad->radialGradient.fx + fx;
focalY = grad->radialGradient.fy + fy;
}
fxfy_2 = 2.0f * fx * fy;
r2_fx2 = radius2 - fx * fx;
r2_fy2 = radius2 - fy * fy;
r2_fx2_2 = 2.0f * r2_fx2;
r2_fy2_2 = 2.0f * r2_fy2;
r2_fx2_fy2 = r2_fx2 - fy * fy;
r2_fx2_fy2sq = r2_fx2_fy2 * r2_fx2_fy2;
/* _____________________________________
** dx fx + dy fy + \/r^2 (dx^2 + dy^2) - (dx fy - dy fx)^2
** g = -------------------------------------------------------
** r^2 - fx^2 - fy^2
**
** Where
**
** dx := F(x) - focalX
** dy := F(y) - focalY
** fx := focalX - centerX
** fy := focalX - centerY
**
** and
**
** F(x) := (x + 0.5) m00 + (y + 0.5) m01 + m02
** F(y) := (x + 0.5) m10 + (y + 0.5) m11 + m12
**
** So, dx can be factored into
**
** dx = (x + 0.5) m00 + (y + 0.5) m01 + m02 - focalX
** = x m00 + y m01 + 0.5 m00 + 0.5 m01 + m02 - focalX
**
** = x m00 + y m01 + cx
**
** where
**
** cx := 0.5 m00 + 0.5 m01 + m02 - focalX
**
** The same way we can factor dy into
**
** dy = x m10 + y m11 + cy
**
** where
**
** cy := 0.5 m10 + 0.5 m11 + m12 - focalY.
**
** Now we can rewrite g as
** ______________________________________
** dx fx + dy fy / r^2 (dx^2 + dy^2) - (dx fy - dy fx)^2
** g = ----------------- + \ / -------------------------------------
** r^2 - fx^2 - fy^2 \/ (r^2 - fx^2 - fy^2)^2
** ____
** = gLin + \/gRad
**
** where
**
** dx fx + dy fy
** gLin := -----------------
** r^2 - fx^2 - fy^2
**
** r^2 (dx^2 + dy^2) - (dx fy - dy fx)^2
** gRad := -------------------------------------
** (r^2 - fx^2 - fy^2)^2
*/
cx
= 0.5f * ( MAT(&inverse_matrix, 0, 0) + MAT(&inverse_matrix, 0, 1) )
+ MAT(&inverse_matrix, 0, 2)
- focalX;
cy
= 0.5f * ( MAT(&inverse_matrix, 1, 0) + MAT(&inverse_matrix, 1, 1) )
+ MAT(&inverse_matrix, 1, 2)
- focalY;
/*
** dx fx + dy fy
** gLin := -----------------
** r^2 - fx^2 - fy^2
**
** We can factor the top half into
**
** = (x m00 + y m01 + cx) fx + (x m10 + y m11 + cy) fy
**
** = x (m00 fx + m10 fy)
** + y (m01 fx + m11 fy)
** + cx fx + cy fy.
*/
rgStepXLin
= ( MAT(&inverse_matrix, 0, 0) * fx + MAT(&inverse_matrix, 1, 0) * fy )
/ r2_fx2_fy2;
rgStepYLin
= ( MAT(&inverse_matrix, 0, 1) * fx + MAT(&inverse_matrix, 1, 1) * fy )
/ r2_fx2_fy2;
rgConstantLin = ( cx * fx + cy * fy ) / r2_fx2_fy2;
/*
** r^2 (dx^2 + dy^2) - (dx fy - dy fx)^2
** gRad := -------------------------------------
** (r^2 - fx^2 - fy^2)^2
**
** r^2 (dx^2 + dy^2) - dx^2 fy^2 - dy^2 fx^2 + 2 dx dy fx fy
** := ---------------------------------------------------------
** (r^2 - fx^2 - fy^2)^2
**
** dx^2 (r^2 - fy^2) + dy^2 (r^2 - fx^2) + 2 dx dy fx fy
** := -----------------------------------------------------
** (r^2 - fx^2 - fy^2)^2
**
** First, lets factor dx^2 into
**
** dx^2 = (x m00 + y m01 + cx)^2
** = x^2 m00^2 + y^2 m01^2 + 2 x y m00 m01
** + 2 x m00 cx + 2 y m01 cx + cx^2
**
** = x^2 (m00^2)
** + y^2 (m01^2)
** + x y (2 m00 m01)
** + x (2 m00 cx)
** + y (2 m01 cx)
** + cx^2.
**
** The same can be done for dy^2:
**
** dy^2 = x^2 (m10^2)
** + y^2 (m11^2)
** + x y (2 m10 m11)
** + x (2 m10 cy)
** + y (2 m11 cy)
** + cy^2.
**
** Let's also factor dx dy into
**
** dx dy = (x m00 + y m01 + cx) (x m10 + y m11 + cy)
** = x^2 m00 m10 + y^2 m01 m11 + x y m00 m11 + x y m01 m10
** + x m00 cy + x m10 cx + y m01 cy + y m11 cx + cx cy
**
** = x^2 (m00 m10)
** + y^2 (m01 m11)
** + x y (m00 m11 + m01 m10)
** + x (m00 cy + m10 cx)
** + y (m01 cy + m11 cx)
** + cx cy.
**
** Now that we have all this, lets look at the top of gRad.
**
** = dx^2 (r^2 - fy^2) + dy^2 (r^2 - fx^2) + 2 dx dy fx fy
** = x^2 m00^2 (r^2 - fy^2) + y^2 m01^2 (r^2 - fy^2)
** + x y 2 m00 m01 (r^2 - fy^2) + x 2 m00 cx (r^2 - fy^2)
** + y 2 m01 cx (r^2 - fy^2) + cx^2 (r^2 - fy^2)
** + x^2 m10^2 (r^2 - fx^2) + y^2 m11^2 (r^2 - fx^2)
** + x y 2 m10 m11 (r^2 - fx^2) + x 2 m10 cy (r^2 - fx^2)
** + y 2 m11 cy (r^2 - fx^2) + cy^2 (r^2 - fx^2)
** + x^2 m00 m10 2 fx fy + y^2 m01 m11 2 fx fy
** + x y (m00 m11 + m01 m10) 2 fx fy
** + x (m00 cy + m10 cx) 2 fx fy + y (m01 cy + m11 cx) 2 fx fy
** + cx cy 2 fx fy
**
** = x^2 ( m00^2 (r^2 - fy^2)
** + m10^2 (r^2 - fx^2)
** + m00 m10 2 fx fy
** )
** + y^2 ( m01^2 (r^2 - fy^2)
** + m11^2 (r^2 - fx^2)
** + m01 m11 2 fx fy
** )
** + x y ( 2 m00 m01 (r^2 - fy^2)
** + 2 m10 m11 (r^2 - fx^2)
** + (m00 m11 + m01 m10) 2 fx fy
** )
** + x ( 2 m00 cx (r^2 - fy^2)
** + 2 m10 cy (r^2 - fx^2)
** + (m00 cy + m10 cx) 2 fx fy
** )
** + y ( 2 m01 cx (r^2 - fy^2)
** + 2 m11 cy (r^2 - fx^2)
** + (m01 cy + m11 cx) 2 fx fy
** )
** + cx^2 (r^2 - fy^2) + cy^2 (r^2 - fx^2) + cx cy 2 fx fy.
*/
rgStepXXRad =
(
MAT(&inverse_matrix, 0, 0) * MAT(&inverse_matrix, 0, 0) * r2_fy2
+ MAT(&inverse_matrix, 1, 0) * MAT(&inverse_matrix, 1, 0) * r2_fx2
+ MAT(&inverse_matrix, 0, 0) * MAT(&inverse_matrix, 1, 0) * fxfy_2
)
/ r2_fx2_fy2sq;
rgStepYYRad =
(
MAT(&inverse_matrix, 0, 1) * MAT(&inverse_matrix, 0, 1) * r2_fy2
+ MAT(&inverse_matrix, 1, 1) * MAT(&inverse_matrix, 1, 1) * r2_fx2
+ MAT(&inverse_matrix, 0, 1) * MAT(&inverse_matrix, 1, 1) * fxfy_2
)
/ r2_fx2_fy2sq;
rgStepXYRad =
(
MAT(&inverse_matrix, 0, 0) * MAT(&inverse_matrix, 0, 1) * r2_fy2_2
+ MAT(&inverse_matrix, 1, 0) * MAT(&inverse_matrix, 1, 1) * r2_fx2_2
+ (
MAT(&inverse_matrix, 0, 0) * MAT(&inverse_matrix, 1, 1)
+ MAT(&inverse_matrix, 0, 1) * MAT(&inverse_matrix, 1, 0)
)
* fxfy_2
)
/ r2_fx2_fy2sq;
rgStepXRad =
(
MAT(&inverse_matrix, 0, 0) * cx * r2_fy2_2
+ MAT(&inverse_matrix, 1, 0) * cy * r2_fx2_2
+ (
MAT(&inverse_matrix, 0, 0) * cy
+ MAT(&inverse_matrix, 1, 0) * cx
)
* fxfy_2
)
/ r2_fx2_fy2sq;
rgStepYRad =
(
MAT(&inverse_matrix, 0, 1) * cx * r2_fy2_2
+ MAT(&inverse_matrix, 1, 1) * cy * r2_fx2_2
+ (
MAT(&inverse_matrix, 0, 1) * cy
+ MAT(&inverse_matrix, 1, 1) * cx
)
* fxfy_2
)
/ r2_fx2_fy2sq;
rgConstantRad =
(
cx * cx * r2_fy2
+ cy * cy * r2_fx2
+ cx * cy * fxfy_2
)
/ r2_fx2_fy2sq;
#if !defined(VG_DRIVER_SINGLE_THREAD)
if(ctx->ts_dirty){
memcpy(CMDBUF_BUFFER(*ctx) + CMDBUF_OFFSET(*ctx), ctx->ts_record, 80);
CMDBUF_OFFSET(*ctx) += 80;
ctx->ts_dirty = 0;
ctx->ts_init_used = 1;
}
else
{
ctx->ts_init_use = 1;
}
#endif /* not defined(VG_DRIVER_SINGLE_THREAD) */
/* Setup the command buffer. */
/* rad gradient parameters*/
data = &rgConstantLin;
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A04,*(uint32_t*) data));
data = &rgStepXLin;
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A06,*(uint32_t*) data));
data = &rgStepYLin;
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A08,*(uint32_t*) data));
data = &rgConstantRad;
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A05,*(uint32_t*) data));
data = &rgStepXRad;
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A07,*(uint32_t*) data));
data = &rgStepYRad;
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A09,*(uint32_t*) data));
data = &rgStepXXRad;
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A03,*(uint32_t*) data));
data = &rgStepYYRad;
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A0A,*(uint32_t*) data));
data = &rgStepXYRad;
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A0B,*(uint32_t*) data));
VG_LITE_RETURN_ERROR(set_interpolation_steps(target, source->width, source->height, matrix));
if(!ctx->premultiply_enabled) {
if(source->transparency_mode == VG_LITE_IMAGE_OPAQUE){
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A24, convert_source_format(source->format) |
filter | rad_tile | conversion | 0x01000100));
} else {
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A24, convert_source_format(source->format) |
filter | rad_tile | conversion | 0x00000100));
}
} else {
/* enable pre-multiplied in imager unit */
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A24, convert_source_format(source->format) |
filter | rad_tile | conversion));
}
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A26, paint_color));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A28, source->address));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A2A, tiled_source));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A2C, 0));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A2E, source->width));
/* Work on path states. */
matrix = path_matrix;
if (ts_is_fullscreen == 0){
transform(&temp, (vg_lite_float_t)path->bounding_box[0], (vg_lite_float_t)path->bounding_box[1], matrix);
point_min = point_max = temp;
transform(&temp, (vg_lite_float_t)path->bounding_box[2], (vg_lite_float_t)path->bounding_box[1], matrix);
if (temp.x < point_min.x) point_min.x = temp.x;
if (temp.y < point_min.y) point_min.y = temp.y;
if (temp.x > point_max.x) point_max.x = temp.x;
if (temp.y > point_max.y) point_max.y = temp.y;
transform(&temp, (vg_lite_float_t)path->bounding_box[2], (vg_lite_float_t)path->bounding_box[3], matrix);
if (temp.x < point_min.x) point_min.x = temp.x;
if (temp.y < point_min.y) point_min.y = temp.y;
if (temp.x > point_max.x) point_max.x = temp.x;
if (temp.y > point_max.y) point_max.y = temp.y;
transform(&temp, (vg_lite_float_t)path->bounding_box[0], (vg_lite_float_t)path->bounding_box[3], matrix);
if (temp.x < point_min.x) point_min.x = temp.x;
if (temp.y < point_min.y) point_min.y = temp.y;
if (temp.x > point_max.x) point_max.x = temp.x;
if (temp.y > point_max.y) point_max.y = temp.y;
point_min.x = MAX(point_min.x, 0);
point_min.y = MAX(point_min.y, 0);
point_max.x = MIN(point_max.x, dst_align_width);
point_max.y = MIN(point_max.y, target->height);
}
if (ctx->scissor_enabled) {
point_min.x = MAX(point_min.x, ctx->scissor[0]);
point_min.y = MAX(point_min.y, ctx->scissor[1]);
point_max.x = MIN(point_max.x, ctx->scissor[0] + ctx->scissor[2]);
point_max.y = MIN(point_max.y, ctx->scissor[1] + ctx->scissor[3]);
}
/* Convert states into hardware values. */
blend_mode = convert_blend(blend);
format = convert_path_format(path->format);
quality = convert_path_quality(path->quality);
tiling = (ctx->capabilities.cap.tiled == 2) ? 0x2000000 : 0;
fill = (fill_rule == VG_LITE_FILL_EVEN_ODD) ? 0x10 : 0;
tessellation_size = ( ctx->tsbuffer.tessellation_buffer_size[2]
? ctx->tsbuffer.tessellation_buffer_size[2]
: ctx->tsbuffer.tessellation_buffer_size[1]
);
/* Setup the command buffer. */
/* Program color register. */
if(!ctx->premultiply_enabled) {
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A00, 0x12000000 | ctx->capabilities.cap.tiled | 0x00000002 | imageMode | blend_mode | transparency_mode));
} else {
/* enable pre-multiplied from VG to VGPE */
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A00, 0x02000000 | ctx->capabilities.cap.tiled | 0x00000002 | imageMode | blend_mode | transparency_mode));
}
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A34, 0x01000400 | format | quality | tiling | fill));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A3B, 0x3F800000)); /* Path tessellation SCALE. */
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A3C, 0x00000000)); /* Path tessellation BIAS. */
/* Program matrix. */
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A40, (void *) &matrix->m[0][0]));
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A41, (void *) &matrix->m[0][1]));
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A42, (void *) &matrix->m[0][2]));
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A43, (void *) &matrix->m[1][0]));
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A44, (void *) &matrix->m[1][1]));
VG_LITE_RETURN_ERROR(push_state_ptr(ctx, 0x0A45, (void *) &matrix->m[1][2]));
if (VLM_PATH_GET_UPLOAD_BIT(*path) == 1)
{
if (path->path_changed != 0) {
if (path->uploaded.handle != NULL) {
free_memory.memory_handle = path->uploaded.handle;
vg_lite_kernel(VG_LITE_FREE, &free_memory);
path->uploaded.address = 0;
path->uploaded.memory = NULL;
path->uploaded.handle = NULL;
}
/* Allocate memory for the path data. */
memory.bytes = 16 + VG_LITE_ALIGN(path->path_length, 8);
return_offset = (8 + VG_LITE_ALIGN(path->path_length, 8)) / 4;
memory.contiguous = 1;
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_ALLOCATE, &memory));
((uint64_t *) memory.memory)[(path->path_length + 7) / 8] = 0;
((uint32_t *) memory.memory)[0] = VG_LITE_DATA((path->path_length + 7) / 8);
((uint32_t *) memory.memory)[1] = 0;
memcpy((uint8_t *) memory.memory + 8, path->path, path->path_length);
((uint32_t *) memory.memory)[return_offset] = VG_LITE_RETURN();
((uint32_t *) memory.memory)[return_offset + 1] = 0;
path->uploaded.handle = memory.memory_handle;
path->uploaded.memory = memory.memory;
path->uploaded.address = memory.memory_gpu;
path->uploaded.bytes = memory.bytes;
path->path_changed = 0;
}
}
if (VLM_PATH_GET_UPLOAD_BIT(*path) == 1) {
vglitemDUMP_BUFFER("path", path->uploaded.address, (uint8_t *)(path->uploaded.memory), 0, path->uploaded.bytes);
}
vglitemDUMP("@[memory 0x%08X 0x%08X]", ctx->tsbuffer.tessellation_buffer_gpu[0], ctx->tsbuffer.tessellation_buffer_size[0]);
/* Setup tessellation loop. */
if((path->path_type & 0x1) == VG_LITE_DRAW_FILL_PATH) {
for (y = point_min.y; y < point_max.y; y += height) {
for (x = point_min.x; x < point_max.x; x += width) {
/* Tessellate path. */
VG_LITE_RETURN_ERROR(push_stall(ctx, 15));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A1B, 0x00011000));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A01, x | (y << 16)));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A39, x | (y << 16)));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A3D, tessellation_size / 64));
if (VLM_PATH_GET_UPLOAD_BIT(*path) == 1) {
VG_LITE_RETURN_ERROR(push_call(ctx, path->uploaded.address, path->uploaded.bytes));
#if (DUMP_COMMAND)
if (strncmp(filename, "Commandbuffer", 13)) {
sprintf(filename, "Commandbuffer_pid%d.txt", getpid());
}
fp = fopen(filename, "a");
if (fp == NULL)
printf("error!\n");
fprintf(fp, "Command buffer: 0x%08x, 0x%08x,\n",
((uint32_t *) memory.memory)[0], 0);
unsigned char* pt = (unsigned char*) memory.memory;
for(int i = 8; i <= return_offset * 4 - 1; i = i + 4)
{
if (i % 8 == 0)
fprintf(fp, "Command buffer: ");
if (i % 4 == 0)
fprintf(fp, "0x");
for (int j = 3; j >= 0; --j)
fprintf(fp, "%02x", pt[i + j]);
if ((i / 4 + 1) % 2 == 0)
fprintf(fp, ",\n");
else
fprintf(fp, ", ");
}
fprintf(fp, "Command buffer: 0x%08x, 0x%08x,\n",
((uint32_t *) memory.memory)[return_offset], 0);
fclose(fp);
fp = NULL;
#endif
} else {
push_data(ctx, path->path_length, path->path);
}
}
}
}
/* Setup tessellation loop. */
if(path->path_type == VG_LITE_DRAW_STROKE_PATH || path->path_type == VG_LITE_DRAW_FILL_STROKE_PATH) {
for (y = point_min.y; y < point_max.y; y += height) {
for (x = point_min.x; x < point_max.x; x += width) {
/* Tessellate path. */
VG_LITE_RETURN_ERROR(push_stall(ctx, 15));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A1B, 0x00011000));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A01, x | (y << 16)));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A39, x | (y << 16)));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A3D, tessellation_size / 64));
if (VLM_PATH_GET_UPLOAD_BIT(*path) == 1) {
VG_LITE_RETURN_ERROR(push_call(ctx, path->uploaded.address, path->uploaded.bytes));
#if (DUMP_COMMAND)
if (strncmp(filename, "Commandbuffer", 13)) {
sprintf(filename, "Commandbuffer_pid%d.txt", getpid());
}
fp = fopen(filename, "a");
if (fp == NULL)
printf("error!\n");
fprintf(fp, "Command buffer: 0x%08x, 0x%08x,\n",
((uint32_t *) memory.memory)[0], 0);
unsigned char* pt = (unsigned char*) memory.memory;
for(int i = 8; i <= return_offset * 4 - 1; i = i + 4)
{
if (i % 8 == 0)
fprintf(fp, "Command buffer: ");
if (i % 4 == 0)
fprintf(fp, "0x");
for (int j = 3; j >= 0; --j)
fprintf(fp, "%02x", pt[i + j]);
if ((i / 4 + 1) % 2 == 0)
fprintf(fp, ",\n");
else
fprintf(fp, ", ");
}
fprintf(fp, "Command buffer: 0x%08x, 0x%08x,\n",
((uint32_t *) memory.memory)[return_offset], 0);
fclose(fp);
fp = NULL;
#endif
} else {
format = convert_path_format(VG_LITE_FP32);
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A34, 0x01000200 | format | quality | tiling | 0x0));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A02, path->stroke_color));
push_data(ctx, path->stroke_path_size, path->stroke_path_data);
}
}
}
}
/* Finialize command buffer. */
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A34, 0));
vglitemDUMP_BUFFER("image", source->address, source->memory, 0, (source->stride)*(source->height));
#if DUMP_IMAGE
dump_img(source->memory, src_align_width, source->height, source->format);
#endif
#if !defined(VG_DRIVER_SINGLE_THREAD)
tls->t_context.ts_init = 1;
#endif /* not defined(VG_DRIVER_SINGLE_THREAD) */
return error;
}
vg_lite_error_t vg_lite_init_grad(vg_lite_linear_gradient_t *grad)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
/* Set the member values according to driver defaults. */
grad->image.width = VLC_GRADBUFFER_WIDTH;
grad->image.height = 1;
grad->image.stride = 0;
grad->image.format = VG_LITE_BGRA8888;
/* Allocate the image for gradient. */
error = vg_lite_allocate(&grad->image);
grad->count = 0;
return error;
}
vg_lite_error_t vg_lite_set_linear_grad(vg_lite_linear_gradient_ext_t *grad,
uint32_t count,
vg_lite_color_ramp_t *vg_color_ramp,
vg_lite_linear_gradient_parameter_t linear_gradient,
vg_lite_radial_gradient_spreadmode_t spread_mode,
uint8_t color_ramp_premultiplied)
{
int i;
static vg_lite_color_ramp_t default_ramp[] =
{
{
0.0f,
0.0f, 0.0f, 0.0f, 1.0f
},
{
1.0f,
1.0f, 1.0f, 1.0f, 1.0f
}
};
uint32_t trg_count;
vg_lite_float_t prev_stop;
vg_lite_color_ramp_ptr src_ramp;
vg_lite_color_ramp_ptr src_ramp_last;
vg_lite_color_ramp_ptr trg_ramp;
/* Reset the count. */
trg_count = 0;
if ((linear_gradient.X0 == linear_gradient.X1) && (linear_gradient.Y0 == linear_gradient.Y1))
return VG_LITE_INVALID_ARGUMENT;
grad->linear_gradient = linear_gradient;
grad->color_ramp_premultiplied = color_ramp_premultiplied;
grad->spread_mode = spread_mode;
if (!count || count > MAX_COLOR_RAMP_STOPS || vg_color_ramp == NULL)
goto Empty_sequence_handler;
for(i = 0; i < count;i++)
grad->vg_color_ramp[i] = vg_color_ramp[i];
grad->vg_color_ramp_length = count;
/* Determine the last source ramp. */
src_ramp_last
= grad->vg_color_ramp
+ grad->vg_color_ramp_length;
/* Set the initial previous stop. */
prev_stop = -1;
/* Reset the count. */
trg_count = 0;
/* Walk through the source ramp. */
for (
src_ramp = grad->vg_color_ramp, trg_ramp = grad->int_color_ramp;
(src_ramp < src_ramp_last) && (trg_count < MAX_COLOR_RAMP_STOPS + 2);
src_ramp += 1
)
{
/* Must be in increasing order. */
if (src_ramp->stop < prev_stop)
{
/* Ignore the entire sequence. */
trg_count = 0;
break;
}
/* Update the previous stop value. */
prev_stop = src_ramp->stop;
/* Must be within [0..1] range. */
if ((src_ramp->stop < 0.0f) || (src_ramp->stop > 1.0f))
{
/* Ignore. */
continue;
}
/* Clamp color. */
ClampColor(COLOR_FROM_RAMP(src_ramp),COLOR_FROM_RAMP(trg_ramp),0);
/* First stop greater then zero? */
if ((trg_count == 0) && (src_ramp->stop > 0.0f))
{
/* Force the first stop to 0.0f. */
trg_ramp->stop = 0.0f;
/* Replicate the entry. */
trg_ramp[1] = *trg_ramp;
trg_ramp[1].stop = src_ramp->stop;
/* Advance. */
trg_ramp += 2;
trg_count += 2;
}
else
{
/* Set the stop value. */
trg_ramp->stop = src_ramp->stop;
/* Advance. */
trg_ramp += 1;
trg_count += 1;
}
}
/* Empty sequence? */
if (trg_count == 0)
{
memcpy(grad->int_color_ramp,default_ramp,sizeof(default_ramp));
grad->int_color_ramp_length = sizeof(default_ramp) / 5;
}
else
{
/* The last stop must be at 1.0. */
if (trg_ramp[-1].stop != 1.0f)
{
/* Replicate the last entry. */
*trg_ramp = trg_ramp[-1];
/* Force the last stop to 1.0f. */
trg_ramp->stop = 1.0f;
/* Update the final entry count. */
trg_count += 1;
}
/* Set new length. */
grad->int_color_ramp_length = trg_count;
}
return VG_LITE_SUCCESS;
Empty_sequence_handler:
memcpy(grad->int_color_ramp,default_ramp,sizeof(default_ramp));
grad->int_color_ramp_length = sizeof(default_ramp) / 5;
return VG_LITE_SUCCESS;
}
vg_lite_error_t vg_lite_update_linear_grad(vg_lite_linear_gradient_ext_t *grad)
{
uint32_t color_ramp_length;
vg_lite_color_ramp_ptr color_ramp;
uint32_t common, stop;
uint32_t i, width;
uint8_t* bits;
vg_lite_float_t x0,y0,x1,y1,length;
vg_lite_error_t error = VG_LITE_SUCCESS;
/* Get shortcuts to the color ramp. */
color_ramp_length = grad->int_color_ramp_length;
color_ramp = grad->int_color_ramp;
x0 = grad->linear_gradient.X0;
y0 = grad->linear_gradient.Y0;
x1 = grad->linear_gradient.X1;
y1 = grad->linear_gradient.Y1;
length = (vg_lite_float_t)sqrt((x1-x0)*(x1-x0) + (y1-y0)*(y1-y0));
if(length <= 0)
return VG_LITE_INVALID_ARGUMENT;
/* Find the common denominator of the color ramp stops. */
if (length < 1)
{
common = 1;
}
else
{
common = (uint32_t)length;
}
for (i = 0; i < color_ramp_length; ++i)
{
if (color_ramp[i].stop != 0.0f)
{
vg_lite_float_t mul = common * color_ramp[i].stop;
vg_lite_float_t frac = mul - (vg_lite_float_t) floor(mul);
if (frac > 0.00013f) /* Suppose error for zero is 0.00013 */
{
common = MAX(common, (uint32_t) (1.0f / frac + 0.5f));
}
}
}
/* Compute the width of the required color array. */
width = common + 1;
/* Allocate the color ramp surface. */
memset(&grad->image, 0, sizeof(grad->image));
grad->image.width = width;
grad->image.height = 1;
grad->image.stride = 0;
grad->image.image_mode = VG_LITE_NONE_IMAGE_MODE;
grad->image.format = VG_LITE_ABGR8888;
/* Allocate the image for gradient. */
VG_LITE_RETURN_ERROR(vg_lite_allocate(&grad->image));
grad->image.width = width;
/* Set pointer to color array. */
bits = (uint8_t *)grad->image.memory;
/* Start filling the color array. */
stop = 0;
for (i = 0; i < width; ++i)
{
vg_lite_float_t gradient;
vg_lite_float_t color[4];
vg_lite_float_t color1[4];
vg_lite_float_t color2[4];
vg_lite_float_t weight;
/* Compute gradient for current color array entry. */
gradient = (vg_lite_float_t) i / (vg_lite_float_t) (width - 1);
/* Find the entry in the color ramp that matches or exceeds this
** gradient. */
while ((stop < color_ramp_length - 1) && (gradient > color_ramp[stop].stop))
{
++stop;
}
if (gradient == color_ramp[stop].stop)
{
/* Perfect match weight 1.0. */
weight = 1.0f;
/* Use color ramp color. */
color1[3] = color_ramp[stop].alpha;
color1[2] = color_ramp[stop].blue;
color1[1] = color_ramp[stop].green;
color1[0] = color_ramp[stop].red;
color2[3] =
color2[2] =
color2[1] =
color2[0] = 0.0f;
}
else
{
/* Compute weight. */
weight = (color_ramp[stop].stop - gradient)
/ (color_ramp[stop].stop - color_ramp[stop - 1].stop);
/* Grab color ramp color of previous stop. */
color1[3] = color_ramp[stop - 1].alpha;
color1[2] = color_ramp[stop - 1].blue;
color1[1] = color_ramp[stop - 1].green;
color1[0] = color_ramp[stop - 1].red;
/* Grab color ramp color of current stop. */
color2[3] = color_ramp[stop].alpha;
color2[2] = color_ramp[stop].blue;
color2[1] = color_ramp[stop].green;
color2[0] = color_ramp[stop].red;
}
if (grad->color_ramp_premultiplied)
{
/* Pre-multiply the first color. */
color1[2] *= color1[3];
color1[1] *= color1[3];
color1[0] *= color1[3];
/* Pre-multiply the second color. */
color2[2] *= color2[3];
color2[1] *= color2[3];
color2[0] *= color2[3];
}
/* Filter the colors per channel. */
color[3] = LERP(color1[3], color2[3], weight);
color[2] = LERP(color1[2], color2[2], weight);
color[1] = LERP(color1[1], color2[1], weight);
color[0] = LERP(color1[0], color2[0], weight);
/* Pack the final color. */
*bits++ = PackColorComponent(color[3]);
*bits++ = PackColorComponent(color[2]);
*bits++ = PackColorComponent(color[1]);
*bits++ = PackColorComponent(color[0]);
}
return VG_LITE_SUCCESS;
}
vg_lite_error_t vg_lite_set_rad_grad(vg_lite_radial_gradient_t *grad,
uint32_t count,
vg_lite_color_ramp_t *vgColorRamp,
vg_lite_radial_gradient_parameter_t radialGradient,
vg_lite_radial_gradient_spreadmode_t SpreadMode,
uint8_t colorRampPremultiplied)
{
int i;
static vg_lite_color_ramp_t defaultRamp[] =
{
{
0.0f,
0.0f, 0.0f, 0.0f, 1.0f
},
{
1.0f,
1.0f, 1.0f, 1.0f, 1.0f
}
};
uint32_t trgCount;
vg_lite_float_t prevStop;
vg_lite_color_ramp_ptr srcRamp;
vg_lite_color_ramp_ptr srcRampLast;
vg_lite_color_ramp_ptr trgRamp;
/* Reset the count. */
trgCount = 0;
if(radialGradient.r <= 0)
return VG_LITE_INVALID_ARGUMENT;
grad->radialGradient = radialGradient;
grad->colorRampPremultiplied = colorRampPremultiplied;
grad->SpreadMode = SpreadMode;
if (!count || count > MAX_COLOR_RAMP_STOPS || vgColorRamp == NULL)
goto Empty_sequence_handler;
for(i = 0; i < count;i++)
grad->vgColorRamp[i] = vgColorRamp[i];
grad->vgColorRampLength = count;
/* Determine the last source ramp. */
srcRampLast
= grad->vgColorRamp
+ grad->vgColorRampLength;
/* Set the initial previous stop. */
prevStop = -1;
/* Reset the count. */
trgCount = 0;
/* Walk through the source ramp. */
for (
srcRamp = grad->vgColorRamp, trgRamp = grad->intColorRamp;
(srcRamp < srcRampLast) && (trgCount < MAX_COLOR_RAMP_STOPS + 2);
srcRamp += 1
)
{
/* Must be in increasing order. */
if (srcRamp->stop < prevStop)
{
/* Ignore the entire sequence. */
trgCount = 0;
break;
}
/* Update the previous stop value. */
prevStop = srcRamp->stop;
/* Must be within [0..1] range. */
if ((srcRamp->stop < 0.0f) || (srcRamp->stop > 1.0f))
{
/* Ignore. */
continue;
}
/* Clamp color. */
ClampColor(COLOR_FROM_RAMP(srcRamp),COLOR_FROM_RAMP(trgRamp),0);
/* First stop greater then zero? */
if ((trgCount == 0) && (srcRamp->stop > 0.0f))
{
/* Force the first stop to 0.0f. */
trgRamp->stop = 0.0f;
/* Replicate the entry. */
trgRamp[1] = *trgRamp;
trgRamp[1].stop = srcRamp->stop;
/* Advance. */
trgRamp += 2;
trgCount += 2;
}
else
{
/* Set the stop value. */
trgRamp->stop = srcRamp->stop;
/* Advance. */
trgRamp += 1;
trgCount += 1;
}
}
/* Empty sequence? */
if (trgCount == 0)
{
memcpy(grad->intColorRamp,defaultRamp,sizeof(defaultRamp));
grad->intColorRampLength = sizeof(defaultRamp) / 5;
}
else
{
/* The last stop must be at 1.0. */
if (trgRamp[-1].stop != 1.0f)
{
/* Replicate the last entry. */
*trgRamp = trgRamp[-1];
/* Force the last stop to 1.0f. */
trgRamp->stop = 1.0f;
/* Update the final entry count. */
trgCount += 1;
}
/* Set new length. */
grad->intColorRampLength = trgCount;
}
return VG_LITE_SUCCESS;
Empty_sequence_handler:
memcpy(grad->intColorRamp,defaultRamp,sizeof(defaultRamp));
grad->intColorRampLength = sizeof(defaultRamp) / 5;
return VG_LITE_SUCCESS;
}
vg_lite_error_t vg_lite_update_rad_grad(vg_lite_radial_gradient_t *grad)
{
uint32_t colorRampLength;
vg_lite_color_ramp_ptr colorRamp;
uint32_t common, stop;
uint32_t i, width;
uint8_t* bits;
vg_lite_float_t r;
vg_lite_error_t error = VG_LITE_SUCCESS;
/* Get shortcuts to the color ramp. */
colorRampLength = grad->intColorRampLength;
colorRamp = grad->intColorRamp;
r = grad->radialGradient.r;
if(r <= 0)
return VG_LITE_INVALID_ARGUMENT;
/* Find the common denominator of the color ramp stops. */
if (r < 1)
{
common = 1;
}
else
{
common = (uint32_t)r;
}
for (i = 0; i < colorRampLength; ++i)
{
if (colorRamp[i].stop != 0.0f)
{
vg_lite_float_t mul = common * colorRamp[i].stop;
vg_lite_float_t frac = mul - (vg_lite_float_t) floor(mul);
if (frac > 0.00013f) /* Suppose error for zero is 0.00013 */
{
common = MAX(common, (uint32_t) (1.0f / frac + 0.5f));
}
}
}
/* Compute the width of the required color array. */
width = common + 1;
/* Allocate the color ramp surface. */
memset(&grad->image, 0, sizeof(grad->image));
grad->image.width = width;
grad->image.height = 1;
grad->image.stride = 0;
grad->image.image_mode = VG_LITE_NONE_IMAGE_MODE;
grad->image.format = VG_LITE_ABGR8888;
/* Allocate the image for gradient. */
VG_LITE_RETURN_ERROR(vg_lite_allocate(&grad->image));
grad->image.width = width;
/* Set pointer to color array. */
bits = (uint8_t *)grad->image.memory;
/* Start filling the color array. */
stop = 0;
for (i = 0; i < width; ++i)
{
vg_lite_float_t gradient;
vg_lite_float_t color[4];
vg_lite_float_t color1[4];
vg_lite_float_t color2[4];
vg_lite_float_t weight;
/* Compute gradient for current color array entry. */
gradient = (vg_lite_float_t) i / (vg_lite_float_t) (width - 1);
/* Find the entry in the color ramp that matches or exceeds this
** gradient. */
while ((stop < colorRampLength - 1) && (gradient > colorRamp[stop].stop))
{
++stop;
}
if (gradient == colorRamp[stop].stop)
{
/* Perfect match weight 1.0. */
weight = 1.0f;
/* Use color ramp color. */
color1[3] = colorRamp[stop].alpha;
color1[2] = colorRamp[stop].blue;
color1[1] = colorRamp[stop].green;
color1[0] = colorRamp[stop].red;
color2[3] =
color2[2] =
color2[1] =
color2[0] = 0.0f;
}
else
{
/* Compute weight. */
weight = (colorRamp[stop].stop - gradient)
/ (colorRamp[stop].stop - colorRamp[stop - 1].stop);
/* Grab color ramp color of previous stop. */
color1[3] = colorRamp[stop - 1].alpha;
color1[2] = colorRamp[stop - 1].blue;
color1[1] = colorRamp[stop - 1].green;
color1[0] = colorRamp[stop - 1].red;
/* Grab color ramp color of current stop. */
color2[3] = colorRamp[stop].alpha;
color2[2] = colorRamp[stop].blue;
color2[1] = colorRamp[stop].green;
color2[0] = colorRamp[stop].red;
}
if (grad->colorRampPremultiplied)
{
/* Pre-multiply the first color. */
color1[2] *= color1[3];
color1[1] *= color1[3];
color1[0] *= color1[3];
/* Pre-multiply the second color. */
color2[2] *= color2[3];
color2[1] *= color2[3];
color2[0] *= color2[3];
}
/* Filter the colors per channel. */
color[3] = LERP(color1[3], color2[3], weight);
color[2] = LERP(color1[2], color2[2], weight);
color[1] = LERP(color1[1], color2[1], weight);
color[0] = LERP(color1[0], color2[0], weight);
/* Pack the final color. */
*bits++ = PackColorComponent(color[3]);
*bits++ = PackColorComponent(color[2]);
*bits++ = PackColorComponent(color[1]);
*bits++ = PackColorComponent(color[0]);
}
return VG_LITE_SUCCESS;
}
vg_lite_error_t vg_lite_set_grad(vg_lite_linear_gradient_t *grad,
uint32_t count,
uint32_t * colors,
uint32_t * stops)
{
uint32_t i;
grad->count = 0; /* Opaque B&W gradient */
if (!count || count > VLC_MAX_GRAD || colors == NULL || stops == NULL)
return VG_LITE_SUCCESS;
/* Check stops validity */
for (i = 0; i < count; i++)
if (stops[i] <= 255) {
if (!grad->count || stops[i] > grad->stops[grad->count - 1]) {
grad->stops[grad->count] = stops[i];
grad->colors[grad->count] = colors[i];
grad->count++;
} else if (stops[i] == grad->stops[grad->count - 1]) {
/* Equal stops : use the color corresponding to the last stop
in the sequence */
grad->colors[grad->count - 1] = colors[i];
}
}
return VG_LITE_SUCCESS;
}
vg_lite_error_t vg_lite_update_grad(vg_lite_linear_gradient_t *grad)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
int32_t r0, g0, b0, a0;
int32_t r1, g1, b1, a1;
int32_t lr, lg, lb, la;
uint32_t i;
int32_t j;
int32_t ds, dr, dg, db, da;
uint32_t *buffer = (uint32_t *)grad->image.memory;
if (grad->count == 0) {
/* If no valid stops have been specified (e.g., due to an empty input
* array, out-of-range, or out-of-order stops), a stop at 0 with color
* 0xFF000000 (opaque black) and a stop at 255 with color 0xFFFFFFFF
* (opaque white) are implicitly defined. */
grad->stops[0] = 0;
grad->colors[0] = 0xFF000000; /* Opaque black */
grad->stops[1] = 255;
grad->colors[1] = 0xFFFFFFFF; /* Opaque white */
grad->count = 2;
} else if (grad->count && grad->stops[0] != 0) {
/* If at least one valid stop has been specified, but none has been
* defined with an offset of 0, an implicit stop is added with an
* offset of 0 and the same color as the first user-defined stop. */
for (i = 0; i < grad->stops[0]; i++)
buffer[i] = grad->colors[0];
}
a0 = A(grad->colors[0]);
r0 = R(grad->colors[0]);
g0 = G(grad->colors[0]);
b0 = B(grad->colors[0]);
/* Calculate the colors for each pixel of the image. */
for (i = 0; i < grad->count - 1; i++) {
buffer[grad->stops[i]] = grad->colors[i];
ds = grad->stops[i + 1] - grad->stops[i];
a1 = A(grad->colors[i + 1]);
r1 = R(grad->colors[i + 1]);
g1 = G(grad->colors[i + 1]);
b1 = B(grad->colors[i + 1]);
da = a1 - a0;
dr = r1 - r0;
dg = g1 - g0;
db = b1 - b0;
for (j = 1; j < ds; j++) {
la = a0 + da * j / ds;
lr = r0 + dr * j / ds;
lg = g0 + dg * j / ds;
lb = b0 + db * j / ds;
buffer[grad->stops[i] + j] = ARGB(la, lr, lg, lb);
}
a0 = a1;
r0 = r1;
g0 = g1;
b0 = b1;
}
/* If at least one valid stop has been specified, but none has been defined
* with an offset of 255, an implicit stop is added with an offset of 255
* and the same color as the last user-defined stop. */
for (i = grad->stops[grad->count - 1]; i < 255; i++)
buffer[i] = grad->colors[grad->count - 1];
/* Last pixel */
buffer[i] = grad->colors[grad->count - 1];
return error;
}
vg_lite_error_t vg_lite_clear_grad(vg_lite_linear_gradient_t *grad)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
grad->count = 0;
/* Release the image resource. */
if (grad->image.handle != NULL)
{
error = vg_lite_free(&grad->image);
}
return error;
}
vg_lite_error_t vg_lite_clear_rad_grad(vg_lite_radial_gradient_t *grad)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
grad->count = 0;
/* Release the image resource. */
if (grad->image.handle != NULL)
{
error = vg_lite_free(&grad->image);
}
return error;
}
vg_lite_error_t vg_lite_clear_linear_grad(vg_lite_linear_gradient_ext_t *grad)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
grad->count = 0;
/* Release the image resource. */
if (grad->image.handle != NULL)
{
error = vg_lite_free(&grad->image);
}
return error;
}
vg_lite_matrix_t * vg_lite_get_linear_grad_matrix(vg_lite_linear_gradient_ext_t *grad)
{
return &grad->matrix;
}
vg_lite_matrix_t * vg_lite_get_grad_matrix(vg_lite_linear_gradient_t *grad)
{
return &grad->matrix;
}
vg_lite_matrix_t * vg_lite_get_rad_grad_matrix(vg_lite_radial_gradient_t *grad)
{
return &grad->matrix;
}
vg_lite_error_t vg_lite_draw_gradient(vg_lite_buffer_t * target,
vg_lite_path_t * path,
vg_lite_fill_t fill_rule,
vg_lite_matrix_t * matrix,
vg_lite_linear_gradient_t * grad,
vg_lite_blend_t blend)
{
return vg_lite_draw_pattern(target, path, fill_rule, matrix,
&grad->image, &grad->matrix, blend, VG_LITE_PATTERN_PAD, 0, VG_LITE_FILTER_LINEAR);
}
vg_lite_error_t vg_lite_set_command_buffer_size(uint32_t size)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
#if defined(VG_DRIVER_SINGLE_THREAD)
vg_lite_context_t *ctx = &s_context;
#else
vg_lite_context_t *ctx;
vg_lite_tls_t* tls;
tls = (vg_lite_tls_t *) vg_lite_os_get_tls();
if(tls == NULL)
return VG_LITE_NO_CONTEXT;
ctx = &tls->t_context;
#endif /* VG_DRIVER_SINGLE_THREAD */
#if defined(VG_DRIVER_SINGLE_THREAD)
if(!ctx->init){
if(!size)
return VG_LITE_INVALID_ARGUMENT;
command_buffer_size = size;
}
else{
#else
if(CMDBUF_IN_QUEUE(&ctx->context, 0) ||
CMDBUF_IN_QUEUE(&ctx->context, 1))
return VG_LITE_INVALID_ARGUMENT;
#endif /* VG_DRIVER_SINGLE_THREAD */
VG_LITE_RETURN_ERROR(_free_command_buffer());
VG_LITE_RETURN_ERROR(_allocate_command_buffer(size));
VG_LITE_RETURN_ERROR(program_tessellation(ctx));
#if defined(VG_DRIVER_SINGLE_THREAD)
}
#endif /* VG_DRIVER_SINGLE_THREAD */
return error;
}
vg_lite_error_t vg_lite_set_scissor(int32_t x, int32_t y, int32_t width, int32_t height)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
#if defined(VG_DRIVER_SINGLE_THREAD)
vg_lite_context_t *ctx = &s_context;
/* Scissor dirty. */
ctx->scissor_dirty = 1;
#else
vg_lite_context_t *ctx;
vg_lite_tls_t* tls;
tls = (vg_lite_tls_t *) vg_lite_os_get_tls();
if(tls == NULL)
return VG_LITE_NO_CONTEXT;
ctx = &tls->t_context;
#endif /* VG_DRIVER_SINGLE_THREAD */
/* Save scissor Box States. */
ctx->scissor[0] = x;
ctx->scissor[1] = y;
ctx->scissor[2] = width;
ctx->scissor[3] = height;
return error;
}
vg_lite_error_t vg_lite_enable_scissor(void)
{
#if defined(VG_DRIVER_SINGLE_THREAD)
vg_lite_context_t *ctx = &s_context;
/* Scissor dirty. */
ctx->scissor_dirty = 1;
#else
vg_lite_context_t *ctx;
vg_lite_tls_t* tls;
tls = (vg_lite_tls_t *) vg_lite_os_get_tls();
if(tls == NULL)
return VG_LITE_NO_CONTEXT;
ctx = &tls->t_context;
#endif /* VG_DRIVER_SINGLE_THREAD */
/* Enable scissor Mode. */
ctx->scissor_enabled = 1;
return VG_LITE_SUCCESS;
}
vg_lite_error_t vg_lite_disable_scissor(void)
{
#if defined(VG_DRIVER_SINGLE_THREAD)
vg_lite_context_t *ctx = &s_context;
/* Scissor dirty. */
ctx->scissor_dirty = 1;
#else
vg_lite_context_t *ctx;
vg_lite_tls_t* tls;
tls = (vg_lite_tls_t *) vg_lite_os_get_tls();
if(tls == NULL)
return VG_LITE_NO_CONTEXT;
ctx = &tls->t_context;
#endif /* VG_DRIVER_SINGLE_THREAD */
/* disable scissor Mode. */
ctx->scissor_enabled = 0;
return VG_LITE_SUCCESS;
}
vg_lite_error_t vg_lite_mem_avail(uint32_t *size)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
vg_lite_kernel_mem_t mem;
VG_LITE_RETURN_ERROR(vg_lite_kernel(VG_LITE_QUERY_MEM,&mem));
*size = mem.bytes;
return error;
}
vg_lite_error_t vg_lite_enable_premultiply(void)
{
#if defined(VG_DRIVER_SINGLE_THREAD)
vg_lite_context_t *ctx = &s_context;
#else
vg_lite_context_t *ctx;
vg_lite_tls_t *tls;
tls = (vg_lite_tls_t *) vg_lite_os_get_tls();
if (tls == NULL)
return VG_LITE_NO_CONTEXT;
ctx = &tls->t_context;
#endif /* VG_DRIVER_SINGLE_THREAD */
if(!vg_lite_query_feature(gcFEATURE_BIT_VG_PE_PREMULTIPLY))
return VG_LITE_NOT_SUPPORT;
/* Enable premultiply Mode. */
ctx->premultiply_enabled = 1;
return VG_LITE_SUCCESS;
}
vg_lite_error_t vg_lite_disable_premultiply(void)
{
#if defined(VG_DRIVER_SINGLE_THREAD)
vg_lite_context_t *ctx = &s_context;
#else
vg_lite_context_t *ctx;
vg_lite_tls_t* tls;
tls = (vg_lite_tls_t *) vg_lite_os_get_tls();
if(tls == NULL)
return VG_LITE_NO_CONTEXT;
ctx = &tls->t_context;
#endif /* VG_DRIVER_SINGLE_THREAD */
if(!vg_lite_query_feature(gcFEATURE_BIT_VG_PE_PREMULTIPLY))
return VG_LITE_NOT_SUPPORT;
/* disable premultiply Mode. */
ctx->premultiply_enabled = 0;
return VG_LITE_SUCCESS;
}
vg_lite_error_t vg_lite_set_dither(int enable)
{
vg_lite_error_t error = VG_LITE_SUCCESS;
uint32_t table_low = 0x7B48F3C0;
uint32_t table_high = 0x596AD1E2;
int dither_enable = enable;
#if defined(VG_DRIVER_SINGLE_THREAD)
vg_lite_context_t *ctx = &s_context;
#else
vg_lite_tls_t* tls;
vg_lite_context_t *ctx;
tls = (vg_lite_tls_t *) vg_lite_os_get_tls();
if(tls == NULL)
return VG_LITE_NO_CONTEXT;
ctx = &tls->t_context;
#endif /* VG_DRIVER_SINGLE_THREAD */
if(!vg_lite_query_feature(gcFEATURE_BIT_VG_DITHER)) {
return VG_LITE_NOT_SUPPORT;
}
if(dither_enable) {
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A5A, table_low));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A5B, table_high));
}
else {
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A5A, 0xFFFFFFFF));
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A5B, 0xFFFFFFFF));
}
return error;
}
vg_lite_error_t vg_lite_set_color_key(vg_lite_color_key4_t colorkey)
{
uint8_t i;
uint32_t value_low = 0;
uint32_t value_high = 0;
uint8_t r, g, b, a, e;
vg_lite_error_t error = VG_LITE_SUCCESS;
#if defined(VG_DRIVER_SINGLE_THREAD)
vg_lite_context_t *ctx = &s_context;
#else
vg_lite_context_t *ctx;
vg_lite_tls_t* tls;
tls = (vg_lite_tls_t *) vg_lite_os_get_tls();
if(tls == NULL)
return VG_LITE_NO_CONTEXT;
ctx = &tls->t_context;
#endif /* VG_DRIVER_SINGLE_THREAD */
if(!vg_lite_query_feature(gcFEATURE_BIT_VG_COLOR_KEY))
return VG_LITE_NOT_SUPPORT;
/* Set color key states. */
for (i = 0; i < 4; i++)
{
/* Set gcregVGPEColorKeyLow. Layout "E/R/G/B". */
r = colorkey[i].low_r;
g = colorkey[i].low_g;
b = colorkey[i].low_b;
e = colorkey[i].enable;
value_low = (e << 24) | (r << 16) | (g << 8) | b;
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A90 + i , value_low));
/* Set gcregVGPEColorKeyHigh. Layout "A/R/G/B". */
r = colorkey[i].hign_r;
g = colorkey[i].hign_g;
b = colorkey[i].hign_b;
a = colorkey[i].alpha;
value_high = (a << 24) | (r << 16) | (g << 8) | b;
VG_LITE_RETURN_ERROR(push_state(ctx, 0x0A94 + i , value_high));
}
return error;
}