pixman.h

嵌入式图形库

			  int src_stride,
			  int dst_stride,
			  int src_bpp,
			  int dst_bpp,
			  int src_x, int src_y,
			  int dst_x, int dst_y,
			  int width, int height);
PIXMAN_EXPORT
pixman_bool_t pixman_fill (uint32_t *bits,
			   int stride,
			   int bpp,
			   int x,
			   int y,
			   int width,
			   int height,
			   uint32_t _xor);
/*
 * Images
 */
typedef  union pixman_image		pixman_image_t;
typedef struct pixman_indexed		pixman_indexed_t;
typedef struct pixman_gradient_stop	pixman_gradient_stop_t;

typedef uint32_t (* pixman_read_memory_func_t) (const void *src, int size);
typedef void     (* pixman_write_memory_func_t) (void *dst, uint32_t value, int size);

struct pixman_gradient_stop {
    pixman_fixed_t x;
    pixman_color_t color;
};

#define PIXMAN_MAX_INDEXED  256 /* XXX depth must be <= 8 */

#if PIXMAN_MAX_INDEXED <= 256
typedef uint8_t pixman_index_type;
#endif

struct pixman_indexed
{
    pixman_bool_t       color;
    uint32_t		rgba[PIXMAN_MAX_INDEXED];
    pixman_index_type	ent[32768];
};

/*
 * While the protocol is generous in format support, the
 * sample implementation allows only packed RGB and GBR
 * representations for data to simplify software rendering,
 */
#define PIXMAN_FORMAT(bpp,type,a,r,g,b)	(((bpp) << 24) |  \
					 ((type) << 16) | \
					 ((a) << 12) |	  \
					 ((r) << 8) |	  \
					 ((g) << 4) |	  \
					 ((b)))

#define PIXMAN_FORMAT_BPP(f)	(((f) >> 24)       )
#define PIXMAN_FORMAT_TYPE(f)	(((f) >> 16) & 0xff)
#define PIXMAN_FORMAT_A(f)	(((f) >> 12) & 0x0f)
#define PIXMAN_FORMAT_R(f)	(((f) >>  8) & 0x0f)
#define PIXMAN_FORMAT_G(f)	(((f) >>  4) & 0x0f)
#define PIXMAN_FORMAT_B(f)	(((f)      ) & 0x0f)
#define PIXMAN_FORMAT_RGB(f)	(((f)      ) & 0xfff)
#define PIXMAN_FORMAT_VIS(f)	(((f)      ) & 0xffff)
#define PIXMAN_FORMAT_DEPTH(f)	(PIXMAN_FORMAT_A(f) +	\
				 PIXMAN_FORMAT_R(f) +	\
				 PIXMAN_FORMAT_G(f) +	\
				 PIXMAN_FORMAT_B(f))

#define PIXMAN_TYPE_OTHER	0
#define PIXMAN_TYPE_A		1
#define PIXMAN_TYPE_ARGB	2
#define PIXMAN_TYPE_ABGR	3
#define PIXMAN_TYPE_COLOR	4
#define PIXMAN_TYPE_GRAY	5
#define PIXMAN_TYPE_YUY2	6
#define PIXMAN_TYPE_YV12	7

#define PIXMAN_FORMAT_COLOR(f)	(PIXMAN_FORMAT_TYPE(f) & 2)

/* 32bpp formats */
typedef enum {
    PIXMAN_a8r8g8b8 =	PIXMAN_FORMAT(32,PIXMAN_TYPE_ARGB,8,8,8,8),
    PIXMAN_x8r8g8b8 =	PIXMAN_FORMAT(32,PIXMAN_TYPE_ARGB,0,8,8,8),
    PIXMAN_a8b8g8r8 =	PIXMAN_FORMAT(32,PIXMAN_TYPE_ABGR,8,8,8,8),
    PIXMAN_x8b8g8r8 =	PIXMAN_FORMAT(32,PIXMAN_TYPE_ABGR,0,8,8,8),
    
/* 24bpp formats */
    PIXMAN_r8g8b8 =	PIXMAN_FORMAT(24,PIXMAN_TYPE_ARGB,0,8,8,8),
    PIXMAN_b8g8r8 =	PIXMAN_FORMAT(24,PIXMAN_TYPE_ABGR,0,8,8,8),
    
/* 16bpp formats */
    PIXMAN_r5g6b5 =	PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,0,5,6,5),
    PIXMAN_b5g6r5 =	PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,0,5,6,5),
    
    PIXMAN_a1r5g5b5 =	PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,1,5,5,5),
    PIXMAN_x1r5g5b5 =	PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,0,5,5,5),
    PIXMAN_a1b5g5r5 =	PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,1,5,5,5),
    PIXMAN_x1b5g5r5 =	PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,0,5,5,5),
    PIXMAN_a4r4g4b4 =	PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,4,4,4,4),
    PIXMAN_x4r4g4b4 =	PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,0,4,4,4),
    PIXMAN_a4b4g4r4 =	PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,4,4,4,4),
    PIXMAN_x4b4g4r4 =	PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,0,4,4,4),
    
/* 8bpp formats */
    PIXMAN_a8 =		PIXMAN_FORMAT(8,PIXMAN_TYPE_A,8,0,0,0),
    PIXMAN_r3g3b2 =	PIXMAN_FORMAT(8,PIXMAN_TYPE_ARGB,0,3,3,2),
    PIXMAN_b2g3r3 =	PIXMAN_FORMAT(8,PIXMAN_TYPE_ABGR,0,3,3,2),
    PIXMAN_a2r2g2b2 =	PIXMAN_FORMAT(8,PIXMAN_TYPE_ARGB,2,2,2,2),
    PIXMAN_a2b2g2r2 =	PIXMAN_FORMAT(8,PIXMAN_TYPE_ABGR,2,2,2,2),
    
    PIXMAN_c8 =		PIXMAN_FORMAT(8,PIXMAN_TYPE_COLOR,0,0,0,0),
    PIXMAN_g8 =		PIXMAN_FORMAT(8,PIXMAN_TYPE_GRAY,0,0,0,0),
    
    PIXMAN_x4a4 =	PIXMAN_FORMAT(8,PIXMAN_TYPE_A,4,0,0,0),
    
    PIXMAN_x4c4 =	PIXMAN_FORMAT(8,PIXMAN_TYPE_COLOR,0,0,0,0),
    PIXMAN_x4g4 =	PIXMAN_FORMAT(8,PIXMAN_TYPE_GRAY,0,0,0,0),
    
/* 4bpp formats */
    PIXMAN_a4 =		PIXMAN_FORMAT(4,PIXMAN_TYPE_A,4,0,0,0),
    PIXMAN_r1g2b1 =	PIXMAN_FORMAT(4,PIXMAN_TYPE_ARGB,0,1,2,1),
    PIXMAN_b1g2r1 =	PIXMAN_FORMAT(4,PIXMAN_TYPE_ABGR,0,1,2,1),
    PIXMAN_a1r1g1b1 =	PIXMAN_FORMAT(4,PIXMAN_TYPE_ARGB,1,1,1,1),
    PIXMAN_a1b1g1r1 =	PIXMAN_FORMAT(4,PIXMAN_TYPE_ABGR,1,1,1,1),
    
    PIXMAN_c4 =		PIXMAN_FORMAT(4,PIXMAN_TYPE_COLOR,0,0,0,0),
    PIXMAN_g4 =		PIXMAN_FORMAT(4,PIXMAN_TYPE_GRAY,0,0,0,0),
    
/* 1bpp formats */
    PIXMAN_a1 =		PIXMAN_FORMAT(1,PIXMAN_TYPE_A,1,0,0,0),
    
    PIXMAN_g1 =		PIXMAN_FORMAT(1,PIXMAN_TYPE_GRAY,0,0,0,0),

/* YUV formats */
    PIXMAN_yuy2 =	PIXMAN_FORMAT(16,PIXMAN_TYPE_YUY2,0,0,0,0),
    PIXMAN_yv12 =	PIXMAN_FORMAT(12,PIXMAN_TYPE_YV12,0,0,0,0),
} pixman_format_code_t;

/* Querying supported format values. */
PIXMAN_EXPORT
pixman_bool_t	pixman_format_supported_destination (pixman_format_code_t format);

PIXMAN_EXPORT
pixman_bool_t	pixman_format_supported_source (pixman_format_code_t format);

/* Constructors */
PIXMAN_EXPORT
pixman_image_t *pixman_image_create_solid_fill       (pixman_color_t               *color);
PIXMAN_EXPORT
pixman_image_t *pixman_image_create_linear_gradient  (pixman_point_fixed_t         *p1,
						      pixman_point_fixed_t         *p2,
						      const pixman_gradient_stop_t *stops,
						      int                           n_stops);
PIXMAN_EXPORT
pixman_image_t *pixman_image_create_radial_gradient  (pixman_point_fixed_t         *inner,
						      pixman_point_fixed_t         *outer,
						      pixman_fixed_t                inner_radius,
						      pixman_fixed_t                outer_radius,
						      const pixman_gradient_stop_t *stops,
						      int                           n_stops);
PIXMAN_EXPORT
pixman_image_t *pixman_image_create_conical_gradient (pixman_point_fixed_t         *center,
						      pixman_fixed_t                angle,
						      const pixman_gradient_stop_t *stops,
						      int                           n_stops);
PIXMAN_EXPORT
pixman_image_t *pixman_image_create_bits             (pixman_format_code_t          format,
						      int                           width,
						      int                           height,
						      uint32_t                     *bits,
						      int                           rowstride_bytes);

/* Destructor */
PIXMAN_EXPORT
pixman_image_t *pixman_image_ref                     (pixman_image_t               *image);
PIXMAN_EXPORT
pixman_bool_t   pixman_image_unref                   (pixman_image_t               *image);


/* Set properties */
PIXMAN_EXPORT
pixman_bool_t   pixman_image_set_clip_region         (pixman_image_t               *image,
						      pixman_region16_t            *region);
PIXMAN_EXPORT
void		pixman_image_set_has_client_clip     (pixman_image_t               *image,
						      pixman_bool_t		    clien_clip);
PIXMAN_EXPORT
pixman_bool_t   pixman_image_set_transform           (pixman_image_t               *image,
						      const pixman_transform_t     *transform);
PIXMAN_EXPORT
void            pixman_image_set_repeat              (pixman_image_t               *image,
						      pixman_repeat_t               repeat);
PIXMAN_EXPORT
pixman_bool_t   pixman_image_set_filter              (pixman_image_t               *image,
						      pixman_filter_t               filter,
						      const pixman_fixed_t         *filter_params,
						      int                           n_filter_params);
PIXMAN_EXPORT
void            pixman_image_set_filter_params       (pixman_image_t               *image,
						      pixman_fixed_t               *params,
						      int                           n_params);
PIXMAN_EXPORT
void		pixman_image_set_source_clipping     (pixman_image_t		   *image,
						      pixman_bool_t                 source_clipping);
PIXMAN_EXPORT
void            pixman_image_set_alpha_map           (pixman_image_t               *image,
						      pixman_image_t               *alpha_map,
						      int16_t                       x,
						      int16_t                       y);
PIXMAN_EXPORT
void            pixman_image_set_component_alpha     (pixman_image_t               *image,
						      pixman_bool_t                 component_alpha);
PIXMAN_EXPORT
void		pixman_image_set_accessors	     (pixman_image_t		   *image,
						      pixman_read_memory_func_t	    read_func,
						      pixman_write_memory_func_t    write_func);
PIXMAN_EXPORT
void		pixman_image_set_indexed	     (pixman_image_t		   *image,
						      const pixman_indexed_t	   *indexed);
PIXMAN_EXPORT
uint32_t       *pixman_image_get_data                (pixman_image_t               *image);
PIXMAN_EXPORT
int		pixman_image_get_width               (pixman_image_t               *image);
PIXMAN_EXPORT
int             pixman_image_get_height              (pixman_image_t               *image);
PIXMAN_EXPORT
int		pixman_image_get_stride              (pixman_image_t               *image);
PIXMAN_EXPORT
int		pixman_image_get_depth               (pixman_image_t		   *image);
PIXMAN_EXPORT
pixman_bool_t	pixman_image_fill_rectangles	     (pixman_op_t		    op,
						      pixman_image_t		   *image,
						      pixman_color_t		   *color,
						      int			    n_rects,
						      const pixman_rectangle16_t	   *rects);

/* Composite */
PIXMAN_EXPORT
pixman_bool_t   pixman_compute_composite_region (pixman_region16_t *	pRegion,
						 pixman_image_t *	pSrc,
						 pixman_image_t *	pMask,
						 pixman_image_t *	pDst,
						 int16_t		xSrc,
						 int16_t		ySrc,
						 int16_t		xMask,
						 int16_t		yMask,
						 int16_t		xDst,
						 int16_t		yDst,
						 uint16_t		width,
						 uint16_t		height);
PIXMAN_EXPORT
void		pixman_image_composite          (pixman_op_t		    op,
						 pixman_image_t		   *src,
						 pixman_image_t               *mask,
						 pixman_image_t               *dest,
						 int16_t                       src_x,
						 int16_t                       src_y,
						 int16_t                       mask_x,
						 int16_t                       mask_y,
						 int16_t                       dest_x,
						 int16_t                       dest_y,
						 uint16_t                      width,
						 uint16_t                      height);

/*
 * Trapezoids
 */
typedef struct pixman_edge pixman_edge_t;
typedef struct pixman_trapezoid pixman_trapezoid_t;
typedef struct pixman_trap pixman_trap_t;
typedef struct pixman_span_fix pixman_span_fix_t;

/*
 * An edge structure.  This represents a single polygon edge
 * and can be quickly stepped across small or large gaps in the
 * sample grid
 */
struct pixman_edge
{
    pixman_fixed_t	x;
    pixman_fixed_t	e;
    pixman_fixed_t   stepx;
    pixman_fixed_t   signdx;
    pixman_fixed_t   dy;
    pixman_fixed_t   dx;

    pixman_fixed_t   stepx_small;
    pixman_fixed_t   stepx_big;
    pixman_fixed_t   dx_small;
    pixman_fixed_t   dx_big;
};

struct pixman_trapezoid
{
    pixman_fixed_t  top, bottom;
    pixman_line_fixed_t	left, right;
};


/* whether 't' is a well defined not obviously empty trapezoid */
#define pixman_trapezoid_valid(t)				\
    ((t)->left.p1.y != (t)->left.p2.y &&			   \
     (t)->right.p1.y != (t)->right.p2.y &&			   \
     (int) ((t)->bottom - (t)->top) > 0)

struct pixman_span_fix
{
    pixman_fixed_t	l, r, y;
};

struct pixman_trap
{
    pixman_span_fix_t	top, bot;
};

PIXMAN_EXPORT
pixman_fixed_t pixman_sample_ceil_y        (pixman_fixed_t       y,
					    int                  bpp);
PIXMAN_EXPORT
pixman_fixed_t pixman_sample_floor_y       (pixman_fixed_t       y,
					    int                  bpp);
PIXMAN_EXPORT
void           pixman_edge_step            (pixman_edge_t       *e,
					    int                  n);
PIXMAN_EXPORT
void           pixman_edge_init            (pixman_edge_t       *e,
					    int                  bpp,
					    pixman_fixed_t       y_start,
					    pixman_fixed_t       x_top,
					    pixman_fixed_t       y_top,
					    pixman_fixed_t       x_bot,
					    pixman_fixed_t       y_bot);
PIXMAN_EXPORT
void           pixman_line_fixed_edge_init (pixman_edge_t       *e,
					    int                  bpp,
					    pixman_fixed_t       y,
					    const pixman_line_fixed_t *line,
					    int                  x_off,
					    int                  y_off);
PIXMAN_EXPORT
void           pixman_rasterize_edges      (pixman_image_t      *image,
					    pixman_edge_t       *l,
					    pixman_edge_t       *r,
					    pixman_fixed_t       t,
					    pixman_fixed_t       b);
PIXMAN_EXPORT
void           pixman_add_traps            (pixman_image_t      *image,
					    int16_t              x_off,
					    int16_t              y_off,
					    int                  ntrap,
					    pixman_trap_t       *traps);
PIXMAN_EXPORT
void	       pixman_add_trapezoids       (pixman_image_t      *image,
					    int16_t              x_off,
					    int                  y_off,
					    int                  ntraps,
					    const pixman_trapezoid_t  *traps);
PIXMAN_EXPORT
void           pixman_rasterize_trapezoid  (pixman_image_t      *image,
					    const pixman_trapezoid_t  *trap,
					    int                  x_off,
					    int                  y_off);

#endif /* PIXMAN_H__ */