pixman-private.h File Reference

#include <float.h>
#include <retro_inline.h>
#include "pixman.h"
#include <time.h>
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <stddef.h>
#include "pixman-compiler.h"

Include dependency graph for pixman-private.h:

Go to the source code of this file.

Classes
struct	argb_t
struct	image_common
struct	solid_fill
struct	gradient
struct	linear_gradient
struct	circle
struct	radial_gradient
struct	conical_gradient
struct	bits_image
union	pixman_image
struct	pixman_iter_t
struct	pixman_iter_info_t
struct	pixman_gradient_walker_t
struct	pixman_composite_info_t
struct	pixman_fast_path_t
struct	pixman_implementation_t
struct	pixman_link_t
struct	pixman_list_t
struct	pixman_vector_48_16_t

Macros
#define	BILINEAR_INTERPOLATION_BITS   7
#define	BILINEAR_INTERPOLATION_RANGE   (1 << BILINEAR_INTERPOLATION_BITS)
#define	PIXMAN_DISABLE_DEPRECATED
#define	PIXMAN_USE_INTERNAL_API
#define	PIXMAN_IMAGE_GET_LINE(image, x, y, type, out_stride, line, mul)
#define	MAX_ALPHA(n)   ((1 << (n)) - 1)
#define	N_Y_FRAC(n)   ((n) == 1 ? 1 : (1 << ((n) / 2)) - 1)
#define	N_X_FRAC(n)   ((n) == 1 ? 1 : (1 << ((n) / 2)) + 1)
#define	STEP_Y_SMALL(n)   (pixman_fixed_1 / N_Y_FRAC (n))
#define	STEP_Y_BIG(n)   (pixman_fixed_1 - (N_Y_FRAC (n) - 1) * STEP_Y_SMALL (n))
#define	Y_FRAC_FIRST(n)   (STEP_Y_BIG (n) / 2)
#define	Y_FRAC_LAST(n)   (Y_FRAC_FIRST (n) + (N_Y_FRAC (n) - 1) * STEP_Y_SMALL (n))
#define	STEP_X_SMALL(n)   (pixman_fixed_1 / N_X_FRAC (n))
#define	STEP_X_BIG(n)   (pixman_fixed_1 - (N_X_FRAC (n) - 1) * STEP_X_SMALL (n))
#define	X_FRAC_FIRST(n)   (STEP_X_BIG (n) / 2)
#define	X_FRAC_LAST(n)   (X_FRAC_FIRST (n) + (N_X_FRAC (n) - 1) * STEP_X_SMALL (n))
#define	RENDER_SAMPLES_X(x, n)
#define	PIXMAN_COMPOSITE_ARGS(info)
#define	PIXMAN_null   PIXMAN_FORMAT (0, 0, 0, 0, 0, 0)
#define	PIXMAN_solid   PIXMAN_FORMAT (0, 1, 0, 0, 0, 0)
#define	PIXMAN_pixbuf   PIXMAN_FORMAT (0, 2, 0, 0, 0, 0)
#define	PIXMAN_rpixbuf   PIXMAN_FORMAT (0, 3, 0, 0, 0, 0)
#define	PIXMAN_unknown   PIXMAN_FORMAT (0, 4, 0, 0, 0, 0)
#define	PIXMAN_any   PIXMAN_FORMAT (0, 5, 0, 0, 0, 0)
#define	PIXMAN_OP_any   (PIXMAN_N_OPERATORS + 1)
#define	FAST_PATH_ID_TRANSFORM   (1 << 0)
#define	FAST_PATH_NO_ALPHA_MAP   (1 << 1)
#define	FAST_PATH_NO_CONVOLUTION_FILTER   (1 << 2)
#define	FAST_PATH_NO_PAD_REPEAT   (1 << 3)
#define	FAST_PATH_NO_REFLECT_REPEAT   (1 << 4)
#define	FAST_PATH_NO_ACCESSORS   (1 << 5)
#define	FAST_PATH_NARROW_FORMAT   (1 << 6)
#define	FAST_PATH_COMPONENT_ALPHA   (1 << 8)
#define	FAST_PATH_SAMPLES_OPAQUE   (1 << 7)
#define	FAST_PATH_UNIFIED_ALPHA   (1 << 9)
#define	FAST_PATH_SCALE_TRANSFORM   (1 << 10)
#define	FAST_PATH_NEAREST_FILTER   (1 << 11)
#define	FAST_PATH_HAS_TRANSFORM   (1 << 12)
#define	FAST_PATH_IS_OPAQUE   (1 << 13)
#define	FAST_PATH_NO_NORMAL_REPEAT   (1 << 14)
#define	FAST_PATH_NO_NONE_REPEAT   (1 << 15)
#define	FAST_PATH_X_UNIT_POSITIVE   (1 << 16)
#define	FAST_PATH_AFFINE_TRANSFORM   (1 << 17)
#define	FAST_PATH_Y_UNIT_ZERO   (1 << 18)
#define	FAST_PATH_BILINEAR_FILTER   (1 << 19)
#define	FAST_PATH_ROTATE_90_TRANSFORM   (1 << 20)
#define	FAST_PATH_ROTATE_180_TRANSFORM   (1 << 21)
#define	FAST_PATH_ROTATE_270_TRANSFORM   (1 << 22)
#define	FAST_PATH_SAMPLES_COVER_CLIP_NEAREST   (1 << 23)
#define	FAST_PATH_SAMPLES_COVER_CLIP_BILINEAR   (1 << 24)
#define	FAST_PATH_BITS_IMAGE   (1 << 25)
#define	FAST_PATH_SEPARABLE_CONVOLUTION_FILTER   (1 << 26)
#define	FAST_PATH_PAD_REPEAT
#define	FAST_PATH_NORMAL_REPEAT
#define	FAST_PATH_NONE_REPEAT
#define	FAST_PATH_REFLECT_REPEAT
#define	FAST_PATH_STANDARD_FLAGS
#define	FAST_PATH_STD_DEST_FLAGS
#define	SOURCE_FLAGS(format)
#define	MASK_FLAGS(format, extra)   ((PIXMAN_ ## format == PIXMAN_null) ? 0 : (SOURCE_FLAGS (format) | extra))
#define	FAST_PATH(op, src, src_flags, mask, mask_flags, dest, dest_flags, func)
#define	PIXMAN_STD_FAST_PATH(op, src, mask, dest, func)
#define	PIXMAN_STD_FAST_PATH_CA(op, src, mask, dest, func)
#define	FALSE   0
#define	TRUE   1
#define	MIN(a, b)   ((a < b) ? a : b)
#define	MAX(a, b)   ((a > b) ? a : b)
#define	DIV(a, b)
#define	MOD(a, b)   ((a) < 0 ? ((b) - ((-(a) - 1) % (b))) - 1 : (a) % (b))
#define	CLIP(v, low, high)   ((v) < (low) ? (low) : ((v) > (high) ? (high) : (v)))
#define	FLOAT_IS_ZERO(f)   (-FLT_MIN < (f) && (f) < FLT_MIN)
#define	PIXMAN_FORMAT_IS_WIDE(f)
#define	SCREEN_SHIFT_LEFT(x, n)   ((x) >> (n))
#define	SCREEN_SHIFT_RIGHT(x, n)   ((x) << (n))
#define	REPLICATE()
#define	COMPILE_TIME_ASSERT(x)   do { typedef int compile_time_assertion [(x)?1:-1]; } while (0)
#define	return_if_fail(expr)
#define	return_val_if_fail(expr, retval)
#define	critical_if_fail(expr)
#define	TIMER_BEGIN(tname)
#define	TIMER_END(tname)

Typedefs
typedef struct image_common	image_common_t
typedef struct solid_fill	solid_fill_t
typedef struct gradient	gradient_t
typedef struct linear_gradient	linear_gradient_t
typedef struct horizontal_gradient	horizontal_gradient_t
typedef struct vertical_gradient	vertical_gradient_t
typedef struct conical_gradient	conical_gradient_t
typedef struct radial_gradient	radial_gradient_t
typedef struct bits_image	bits_image_t
typedef struct circle	circle_t
typedef struct argb_t	argb_t
typedef void(*	fetch_scanline_t) (bits_image_t *image, int x, int y, int width, uint32_t *buffer, const uint32_t *mask)
typedef uint32_t(*	fetch_pixel_32_t) (bits_image_t *image, int x, int y)
typedef argb_t(*	fetch_pixel_float_t) (bits_image_t *image, int x, int y)
typedef void(*	store_scanline_t) (bits_image_t *image, int x, int y, int width, const uint32_t *values)
typedef void(*	property_changed_func_t) (pixman_image_t *image)
typedef struct pixman_iter_t	pixman_iter_t
typedef uint32_t *(*	pixman_iter_get_scanline_t) (pixman_iter_t *iter, const uint32_t *mask)
typedef void(*	pixman_iter_write_back_t) (pixman_iter_t *iter)
typedef void(*	pixman_iter_fini_t) (pixman_iter_t *iter)
typedef struct pixman_iter_info_t	pixman_iter_info_t
typedef void(*	pixman_iter_initializer_t) (pixman_iter_t *iter, const pixman_iter_info_t *info)
typedef struct pixman_implementation_t	pixman_implementation_t
typedef void(*	pixman_combine_32_func_t) (pixman_implementation_t *imp, pixman_op_t op, uint32_t *dest, const uint32_t *src, const uint32_t *mask, int width)
typedef void(*	pixman_combine_float_func_t) (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels)
typedef void(*	pixman_composite_func_t) (pixman_implementation_t *imp, pixman_composite_info_t *info)
typedef pixman_bool_t(*	pixman_blt_func_t) (pixman_implementation_t *imp, uint32_t *src_bits, uint32_t *dst_bits, int src_stride, int dst_stride, int src_bpp, int dst_bpp, int src_x, int src_y, int dest_x, int dest_y, int width, int height)
typedef pixman_bool_t(*	pixman_fill_func_t) (pixman_implementation_t *imp, uint32_t *bits, int stride, int bpp, int x, int y, int width, int height, uint32_t filler)
typedef struct pixman_link_t	pixman_link_t
typedef struct pixman_list_t	pixman_list_t

Enumerations
enum	image_type_t {   BITS, LINEAR, CONICAL, RADIAL,   SOLID }
enum	iter_flags_t {   ITER_NARROW = (1 << 0), ITER_WIDE = (1 << 1), ITER_LOCALIZED_ALPHA = (1 << 2), ITER_IGNORE_ALPHA = (1 << 3),   ITER_IGNORE_RGB = (1 << 4), ITER_SRC = (1 << 5), ITER_DEST = (1 << 6) }

Functions
void	_pixman_bits_image_setup_accessors (bits_image_t *image)
void	_pixman_bits_image_src_iter_init (pixman_image_t *image, pixman_iter_t *iter)
void	_pixman_bits_image_dest_iter_init (pixman_image_t *image, pixman_iter_t *iter)
void	_pixman_linear_gradient_iter_init (pixman_image_t *image, pixman_iter_t *iter)
void	_pixman_radial_gradient_iter_init (pixman_image_t *image, pixman_iter_t *iter)
void	_pixman_conical_gradient_iter_init (pixman_image_t *image, pixman_iter_t *iter)
void	_pixman_image_init (pixman_image_t *image)
pixman_bool_t	_pixman_bits_image_init (pixman_image_t *image, pixman_format_code_t format, int width, int height, uint32_t *bits, int rowstride, pixman_bool_t clear)
pixman_bool_t	_pixman_image_fini (pixman_image_t *image)
pixman_image_t *	_pixman_image_allocate (void)
pixman_bool_t	_pixman_init_gradient (gradient_t *gradient, const pixman_gradient_stop_t *stops, int n_stops)
void	_pixman_image_reset_clip_region (pixman_image_t *image)
void	_pixman_image_validate (pixman_image_t *image)
void	_pixman_gradient_walker_init (pixman_gradient_walker_t *walker, gradient_t *gradient, pixman_repeat_t repeat)
void	_pixman_gradient_walker_reset (pixman_gradient_walker_t *walker, pixman_fixed_48_16_t pos)
uint32_t	_pixman_gradient_walker_pixel (pixman_gradient_walker_t *walker, pixman_fixed_48_16_t x)
void	pixman_rasterize_edges_accessors (pixman_image_t *image, pixman_edge_t *l, pixman_edge_t *r, pixman_fixed_t t, pixman_fixed_t b)
void	_pixman_setup_combiner_functions_32 (pixman_implementation_t *imp)
void	_pixman_setup_combiner_functions_float (pixman_implementation_t *imp)
uint32_t	_pixman_image_get_solid (pixman_implementation_t *imp, pixman_image_t *image, pixman_format_code_t format)
pixman_implementation_t *	_pixman_implementation_create (pixman_implementation_t *fallback, const pixman_fast_path_t *fast_paths)
void	_pixman_implementation_lookup_composite (pixman_implementation_t *toplevel, pixman_op_t op, pixman_format_code_t src_format, uint32_t src_flags, pixman_format_code_t mask_format, uint32_t mask_flags, pixman_format_code_t dest_format, uint32_t dest_flags, pixman_implementation_t **out_imp, pixman_composite_func_t *out_func)
pixman_combine_32_func_t	_pixman_implementation_lookup_combiner (pixman_implementation_t *imp, pixman_op_t op, pixman_bool_t component_alpha, pixman_bool_t wide)
pixman_bool_t	_pixman_implementation_blt (pixman_implementation_t *imp, uint32_t *src_bits, uint32_t *dst_bits, int src_stride, int dst_stride, int src_bpp, int dst_bpp, int src_x, int src_y, int dest_x, int dest_y, int width, int height)
pixman_bool_t	_pixman_implementation_fill (pixman_implementation_t *imp, uint32_t *bits, int stride, int bpp, int x, int y, int width, int height, uint32_t filler)
void	_pixman_implementation_iter_init (pixman_implementation_t *imp, pixman_iter_t *iter, pixman_image_t *image, int x, int y, int width, int height, uint8_t *buffer, iter_flags_t flags, uint32_t image_flags)
pixman_implementation_t *	_pixman_implementation_create_general (void)
pixman_implementation_t *	_pixman_implementation_create_fast_path (pixman_implementation_t *fallback)
pixman_implementation_t *	_pixman_implementation_create_noop (pixman_implementation_t *fallback)
pixman_bool_t	_pixman_implementation_disabled (const char *name)
pixman_implementation_t *	_pixman_x86_get_implementations (pixman_implementation_t *imp)
pixman_implementation_t *	_pixman_arm_get_implementations (pixman_implementation_t *imp)
pixman_implementation_t *	_pixman_ppc_get_implementations (pixman_implementation_t *imp)
pixman_implementation_t *	_pixman_mips_get_implementations (pixman_implementation_t *imp)
pixman_implementation_t *	_pixman_choose_implementation (void)
pixman_bool_t	_pixman_disabled (const char *name)
pixman_bool_t	_pixman_compute_composite_region32 (pixman_region32_t *region, pixman_image_t *src_image, pixman_image_t *mask_image, pixman_image_t *dest_image, int32_t src_x, int32_t src_y, int32_t mask_x, int32_t mask_y, int32_t dest_x, int32_t dest_y, int32_t width, int32_t height)
uint32_t *	_pixman_iter_get_scanline_noop (pixman_iter_t *iter, const uint32_t *mask)
void	_pixman_iter_init_bits_stride (pixman_iter_t *iter, const pixman_iter_info_t *info)
static INLINE pixman_implementation_t *	get_implementation (void)
PIXMAN_EXPORT pixman_implementation_t *	_pixman_internal_only_get_implementation (void)
void *	pixman_malloc_ab (unsigned int n, unsigned int b)
void *	pixman_malloc_abc (unsigned int a, unsigned int b, unsigned int c)
void *	pixman_malloc_ab_plus_c (unsigned int a, unsigned int b, unsigned int c)
pixman_bool_t	_pixman_multiply_overflows_size (size_t a, size_t b)
pixman_bool_t	_pixman_multiply_overflows_int (unsigned int a, unsigned int b)
pixman_bool_t	_pixman_addition_overflows_int (unsigned int a, unsigned int b)
void	pixman_expand_to_float (argb_t *dst, const uint32_t *src, pixman_format_code_t format, int width)
void	pixman_contract_from_float (uint32_t *dst, const argb_t *src, int width)
pixman_bool_t	pixman_region32_copy_from_region16 (pixman_region32_t *dst, pixman_region16_t *src)
pixman_bool_t	pixman_region16_copy_from_region32 (pixman_region16_t *dst, pixman_region32_t *src)
static INLINE void	pixman_list_init (pixman_list_t *list)
static INLINE void	pixman_list_prepend (pixman_list_t *list, pixman_link_t *link)
static INLINE void	pixman_list_unlink (pixman_link_t *link)
static INLINE void	pixman_list_move_to_front (pixman_list_t *list, pixman_link_t *link)
static INLINE uint16_t	convert_8888_to_0565 (uint32_t s)
static INLINE uint32_t	convert_0565_to_0888 (uint16_t s)
static INLINE uint32_t	convert_0565_to_8888 (uint16_t s)
static INLINE uint32_t	convert_8888_to_8888 (uint32_t s)
static INLINE uint32_t	convert_x888_to_8888 (uint32_t s)
static INLINE uint16_t	convert_0565_to_0565 (uint16_t s)
static INLINE uint32_t	unorm_to_unorm (uint32_t val, int from_bits, int to_bits)
uint16_t	pixman_float_to_unorm (float f, int n_bits)
float	pixman_unorm_to_float (uint16_t u, int n_bits)
void	_pixman_log_error (const char *function, const char *message)
pixman_bool_t	pixman_transform_point_31_16 (const pixman_transform_t *t, const pixman_vector_48_16_t *v, pixman_vector_48_16_t *result)
void	pixman_transform_point_31_16_3d (const pixman_transform_t *t, const pixman_vector_48_16_t *v, pixman_vector_48_16_t *result)
void	pixman_transform_point_31_16_affine (const pixman_transform_t *t, const pixman_vector_48_16_t *v, pixman_vector_48_16_t *result)

Variables
pixman_implementation_t *	global_implementation

Macro Definition Documentation

BILINEAR_INTERPOLATION_BITS

#define BILINEAR_INTERPOLATION_BITS   7

BILINEAR_INTERPOLATION_RANGE

#define BILINEAR_INTERPOLATION_RANGE   (1 << BILINEAR_INTERPOLATION_BITS)

CLIP

#define CLIP	(		v,
			low,
			high
	)		((v) < (low) ? (low) : ((v) > (high) ? (high) : (v)))

COMPILE_TIME_ASSERT

#define COMPILE_TIME_ASSERT

(

x

)

do { typedef int compile_time_assertion [(x)?1:-1]; } while (0)

critical_if_fail

#define critical_if_fail

(

expr

)

Value:

do                                  \
    {                                   \
    if (unlikely (!(expr)))                                         \
        _pixman_log_error (FUNC, "The expression " # expr " was false"); \
    }                                   \
    while (0)

DIV

#define DIV	(		a,
			b
	)

Value:

((((a) < 0) == ((b) < 0)) ? (a) / (b) :                \
     ((a) - (b) + 1 - (((b) < 0) << 1)) / (b))

FALSE

#define FALSE   0

FAST_PATH

#define FAST_PATH	(		op,
			src,
			src_flags,
			mask,
			mask_flags,
			dest,
			dest_flags,
			func
	)

Value:

PIXMAN_OP_ ## op,                           \
    PIXMAN_ ## src,                         \
    src_flags,                                  \
    PIXMAN_ ## mask,                                \
    mask_flags,                                 \
    PIXMAN_ ## dest,                                                    \
    dest_flags,                                 \
    func

FAST_PATH_AFFINE_TRANSFORM

#define FAST_PATH_AFFINE_TRANSFORM   (1 << 17)

FAST_PATH_BILINEAR_FILTER

#define FAST_PATH_BILINEAR_FILTER   (1 << 19)

FAST_PATH_BITS_IMAGE

#define FAST_PATH_BITS_IMAGE   (1 << 25)

FAST_PATH_COMPONENT_ALPHA

#define FAST_PATH_COMPONENT_ALPHA   (1 << 8)

FAST_PATH_HAS_TRANSFORM

#define FAST_PATH_HAS_TRANSFORM   (1 << 12)

FAST_PATH_ID_TRANSFORM

#define FAST_PATH_ID_TRANSFORM   (1 << 0)

FAST_PATH_IS_OPAQUE

#define FAST_PATH_IS_OPAQUE   (1 << 13)

FAST_PATH_NARROW_FORMAT

#define FAST_PATH_NARROW_FORMAT   (1 << 6)

FAST_PATH_NEAREST_FILTER

#define FAST_PATH_NEAREST_FILTER   (1 << 11)

FAST_PATH_NO_ACCESSORS

#define FAST_PATH_NO_ACCESSORS   (1 << 5)

FAST_PATH_NO_ALPHA_MAP

#define FAST_PATH_NO_ALPHA_MAP   (1 << 1)

FAST_PATH_NO_CONVOLUTION_FILTER

#define FAST_PATH_NO_CONVOLUTION_FILTER   (1 << 2)

FAST_PATH_NO_NONE_REPEAT

#define FAST_PATH_NO_NONE_REPEAT   (1 << 15)

FAST_PATH_NO_NORMAL_REPEAT

#define FAST_PATH_NO_NORMAL_REPEAT   (1 << 14)

FAST_PATH_NO_PAD_REPEAT

#define FAST_PATH_NO_PAD_REPEAT   (1 << 3)

FAST_PATH_NO_REFLECT_REPEAT

#define FAST_PATH_NO_REFLECT_REPEAT   (1 << 4)

FAST_PATH_NONE_REPEAT

#define FAST_PATH_NONE_REPEAT

Value:

(FAST_PATH_NO_NORMAL_REPEAT     |               \
     FAST_PATH_NO_PAD_REPEAT        |               \
     FAST_PATH_NO_REFLECT_REPEAT)

FAST_PATH_NORMAL_REPEAT

#define FAST_PATH_NORMAL_REPEAT

Value:

(FAST_PATH_NO_NONE_REPEAT       |               \
     FAST_PATH_NO_PAD_REPEAT        |               \
     FAST_PATH_NO_REFLECT_REPEAT)

FAST_PATH_PAD_REPEAT

#define FAST_PATH_PAD_REPEAT

Value:

(FAST_PATH_NO_NONE_REPEAT       |               \
     FAST_PATH_NO_NORMAL_REPEAT     |               \
     FAST_PATH_NO_REFLECT_REPEAT)

FAST_PATH_REFLECT_REPEAT

#define FAST_PATH_REFLECT_REPEAT

Value:

(FAST_PATH_NO_NONE_REPEAT       |               \
     FAST_PATH_NO_NORMAL_REPEAT     |               \
     FAST_PATH_NO_PAD_REPEAT)

FAST_PATH_ROTATE_180_TRANSFORM

#define FAST_PATH_ROTATE_180_TRANSFORM   (1 << 21)

FAST_PATH_ROTATE_270_TRANSFORM

#define FAST_PATH_ROTATE_270_TRANSFORM   (1 << 22)

FAST_PATH_ROTATE_90_TRANSFORM

#define FAST_PATH_ROTATE_90_TRANSFORM   (1 << 20)

FAST_PATH_SAMPLES_COVER_CLIP_BILINEAR

#define FAST_PATH_SAMPLES_COVER_CLIP_BILINEAR   (1 << 24)

FAST_PATH_SAMPLES_COVER_CLIP_NEAREST

#define FAST_PATH_SAMPLES_COVER_CLIP_NEAREST   (1 << 23)

FAST_PATH_SAMPLES_OPAQUE

#define FAST_PATH_SAMPLES_OPAQUE   (1 << 7)

FAST_PATH_SCALE_TRANSFORM

#define FAST_PATH_SCALE_TRANSFORM   (1 << 10)

FAST_PATH_SEPARABLE_CONVOLUTION_FILTER

#define FAST_PATH_SEPARABLE_CONVOLUTION_FILTER   (1 << 26)

FAST_PATH_STANDARD_FLAGS

#define FAST_PATH_STANDARD_FLAGS

Value:

(FAST_PATH_NO_CONVOLUTION_FILTER    |               \
     FAST_PATH_NO_ACCESSORS     |               \
     FAST_PATH_NO_ALPHA_MAP     |               \
     FAST_PATH_NARROW_FORMAT)

FAST_PATH_STD_DEST_FLAGS

#define FAST_PATH_STD_DEST_FLAGS

Value:

(FAST_PATH_NO_ACCESSORS     |               \
     FAST_PATH_NO_ALPHA_MAP     |               \
     FAST_PATH_NARROW_FORMAT)

FAST_PATH_UNIFIED_ALPHA

#define FAST_PATH_UNIFIED_ALPHA   (1 << 9)

FAST_PATH_X_UNIT_POSITIVE

#define FAST_PATH_X_UNIT_POSITIVE   (1 << 16)

FAST_PATH_Y_UNIT_ZERO

#define FAST_PATH_Y_UNIT_ZERO   (1 << 18)

FLOAT_IS_ZERO

#define FLOAT_IS_ZERO

(

f

)

(-FLT_MIN < (f) && (f) < FLT_MIN)

MASK_FLAGS

#define MASK_FLAGS	(		format,
			extra
	)		((PIXMAN_ ## format == PIXMAN_null) ? 0 : (SOURCE_FLAGS (format) | extra))

MAX

#define MAX	(		a,
			b
	)		((a > b) ? a : b)

MAX_ALPHA

#define MAX_ALPHA

(

n

)

((1 << (n)) - 1)

MIN

#define MIN	(		a,
			b
	)		((a < b) ? a : b)

MOD

#define MOD	(		a,
			b
	)		((a) < 0 ? ((b) - ((-(a) - 1) % (b))) - 1 : (a) % (b))

N_X_FRAC

#define N_X_FRAC

(

n

)

((n) == 1 ? 1 : (1 << ((n) / 2)) + 1)

N_Y_FRAC

#define N_Y_FRAC

(

n

)

((n) == 1 ? 1 : (1 << ((n) / 2)) - 1)

PIXMAN_any

#define PIXMAN_any   PIXMAN_FORMAT (0, 5, 0, 0, 0, 0)

PIXMAN_COMPOSITE_ARGS

#define PIXMAN_COMPOSITE_ARGS

(

info

)

Value:

MAYBE_UNUSED pixman_op_t        op = info->op;          \
    MAYBE_UNUSED pixman_image_t *   src_image = info->src_image;    \
    MAYBE_UNUSED pixman_image_t *   mask_image = info->mask_image;  \
    MAYBE_UNUSED pixman_image_t *   dest_image = info->dest_image;  \
    MAYBE_UNUSED int32_t            src_x = info->src_x;        \
    MAYBE_UNUSED int32_t            src_y = info->src_y;        \
    MAYBE_UNUSED int32_t            mask_x = info->mask_x;      \
    MAYBE_UNUSED int32_t            mask_y = info->mask_y;      \
    MAYBE_UNUSED int32_t            dest_x = info->dest_x;      \
    MAYBE_UNUSED int32_t            dest_y = info->dest_y;      \
    MAYBE_UNUSED int32_t            width = info->width;        \
    MAYBE_UNUSED int32_t            height = info->height

PIXMAN_DISABLE_DEPRECATED

#define PIXMAN_DISABLE_DEPRECATED

PIXMAN_FORMAT_IS_WIDE

#define PIXMAN_FORMAT_IS_WIDE

(

f

)

Value:

(PIXMAN_FORMAT_A (f) > 8 ||                     \
     PIXMAN_FORMAT_R (f) > 8 ||                     \
     PIXMAN_FORMAT_G (f) > 8 ||                     \
     PIXMAN_FORMAT_B (f) > 8 ||                     \
     PIXMAN_FORMAT_TYPE (f) == PIXMAN_TYPE_ARGB_SRGB)

PIXMAN_IMAGE_GET_LINE

#define PIXMAN_IMAGE_GET_LINE	(		image,
			x,
			y,
			type,
			out_stride,
			line,
			mul
	)

Value:

do                                  \
    {                                   \
    uint32_t *__bits__;                     \
    int       __stride__;                       \
                                        \
    __bits__ = image->bits.bits;                    \
    __stride__ = image->bits.rowstride;             \
    (out_stride) =                          \
        __stride__ * (int) sizeof (uint32_t) / (int) sizeof (type); \
    (line) =                            \
        ((type *) __bits__) + (out_stride) * (y) + (mul) * (x); \
    } while (0)

PIXMAN_null

#define PIXMAN_null   PIXMAN_FORMAT (0, 0, 0, 0, 0, 0)

PIXMAN_OP_any

#define PIXMAN_OP_any   (PIXMAN_N_OPERATORS + 1)

PIXMAN_pixbuf

#define PIXMAN_pixbuf   PIXMAN_FORMAT (0, 2, 0, 0, 0, 0)

PIXMAN_rpixbuf

#define PIXMAN_rpixbuf   PIXMAN_FORMAT (0, 3, 0, 0, 0, 0)

PIXMAN_solid

#define PIXMAN_solid   PIXMAN_FORMAT (0, 1, 0, 0, 0, 0)

PIXMAN_STD_FAST_PATH

#define PIXMAN_STD_FAST_PATH	(		op,
			src,
			mask,
			dest,
			func
	)

Value:

{ FAST_PATH (                           \
        op,                             \
        src,  SOURCE_FLAGS (src),                   \
        mask, MASK_FLAGS (mask, FAST_PATH_UNIFIED_ALPHA),       \
        dest, FAST_PATH_STD_DEST_FLAGS,             \
        func) }

PIXMAN_STD_FAST_PATH_CA

#define PIXMAN_STD_FAST_PATH_CA	(		op,
			src,
			mask,
			dest,
			func
	)

Value:

{ FAST_PATH (                           \
        op,                             \
        src,  SOURCE_FLAGS (src),                   \
        mask, MASK_FLAGS (mask, FAST_PATH_COMPONENT_ALPHA),     \
        dest, FAST_PATH_STD_DEST_FLAGS,             \
        func) }

PIXMAN_unknown

#define PIXMAN_unknown   PIXMAN_FORMAT (0, 4, 0, 0, 0, 0)

PIXMAN_USE_INTERNAL_API

#define PIXMAN_USE_INTERNAL_API

RENDER_SAMPLES_X

#define RENDER_SAMPLES_X	(		x,
			n
	)

Value:

((n) == 1? 0 : (pixman_fixed_frac (x) +             \
            X_FRAC_FIRST (n)) / STEP_X_SMALL (n))

REPLICATE

#define REPLICATE

(

)

Value:

do                                  \
    {                                   \
    if (from_bits < to_bits)                    \
    {                               \
        result |= result >> from_bits;              \
                                    \
        from_bits *= 2;                     \
    }                               \
    }                                   \
    while (0)

return_if_fail

#define return_if_fail

(

expr

)

Value:

do                                                                  \
    {                                                                   \
    if (unlikely (!(expr)))                                         \
    {                               \
        _pixman_log_error (FUNC, "The expression " # expr " was false"); \
        return;                         \
    }                               \
    }                                                                   \
    while (0)

return_val_if_fail

#define return_val_if_fail	(		expr,
			retval
	)

Value:

do                                                                  \
    {                                                                   \
    if (unlikely (!(expr)))                                         \
    {                               \
        _pixman_log_error (FUNC, "The expression " # expr " was false"); \
        return (retval);                        \
    }                               \
    }                                                                   \
    while (0)

SCREEN_SHIFT_LEFT

#define SCREEN_SHIFT_LEFT	(		x,
			n
	)		((x) >> (n))

SCREEN_SHIFT_RIGHT

#define SCREEN_SHIFT_RIGHT	(		x,
			n
	)		((x) << (n))

SOURCE_FLAGS

#define SOURCE_FLAGS

(

format

)

Value:

(FAST_PATH_STANDARD_FLAGS |                     \
     ((PIXMAN_ ## format == PIXMAN_solid) ?             \
      0 : (FAST_PATH_SAMPLES_COVER_CLIP_NEAREST | FAST_PATH_NEAREST_FILTER | FAST_PATH_ID_TRANSFORM)))

STEP_X_BIG

#define STEP_X_BIG

(

n

)

(pixman_fixed_1 - (N_X_FRAC (n) - 1) * STEP_X_SMALL (n))

STEP_X_SMALL

#define STEP_X_SMALL

(

n

)

(pixman_fixed_1 / N_X_FRAC (n))

STEP_Y_BIG

#define STEP_Y_BIG

(

n

)

(pixman_fixed_1 - (N_Y_FRAC (n) - 1) * STEP_Y_SMALL (n))

STEP_Y_SMALL

#define STEP_Y_SMALL

(

n

)

(pixman_fixed_1 / N_Y_FRAC (n))

TIMER_BEGIN

#define TIMER_BEGIN

(

tname

)

TIMER_END

#define TIMER_END

(

tname

)

TRUE

#define TRUE   1

X_FRAC_FIRST

#define X_FRAC_FIRST

(

n

)

(STEP_X_BIG (n) / 2)

X_FRAC_LAST

#define X_FRAC_LAST

(

n

)

(X_FRAC_FIRST (n) + (N_X_FRAC (n) - 1) * STEP_X_SMALL (n))

Y_FRAC_FIRST

#define Y_FRAC_FIRST

(

n

)

(STEP_Y_BIG (n) / 2)

Y_FRAC_LAST

#define Y_FRAC_LAST

(

n

)

(Y_FRAC_FIRST (n) + (N_Y_FRAC (n) - 1) * STEP_Y_SMALL (n))

Typedef Documentation

argb_t

typedef struct argb_t argb_t

bits_image_t

typedef struct bits_image bits_image_t

circle_t

typedef struct circle circle_t

conical_gradient_t

typedef struct conical_gradient conical_gradient_t

fetch_pixel_32_t

typedef uint32_t(* fetch_pixel_32_t) (bits_image_t *image, int x, int y)

fetch_pixel_float_t

typedef argb_t(* fetch_pixel_float_t) (bits_image_t *image, int x, int y)

fetch_scanline_t

typedef void(* fetch_scanline_t) (bits_image_t *image, int x, int y, int width, uint32_t *buffer, const uint32_t *mask)

gradient_t

typedef struct gradient gradient_t

horizontal_gradient_t

typedef struct horizontal_gradient horizontal_gradient_t

image_common_t

typedef struct image_common image_common_t

linear_gradient_t

typedef struct linear_gradient linear_gradient_t

pixman_blt_func_t

typedef pixman_bool_t(* pixman_blt_func_t) (pixman_implementation_t *imp, uint32_t *src_bits, uint32_t *dst_bits, int src_stride, int dst_stride, int src_bpp, int dst_bpp, int src_x, int src_y, int dest_x, int dest_y, int width, int height)

pixman_combine_32_func_t

typedef void(* pixman_combine_32_func_t) (pixman_implementation_t *imp, pixman_op_t op, uint32_t *dest, const uint32_t *src, const uint32_t *mask, int width)

pixman_combine_float_func_t

typedef void(* pixman_combine_float_func_t) (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels)

pixman_composite_func_t

typedef void(* pixman_composite_func_t) (pixman_implementation_t *imp, pixman_composite_info_t *info)

pixman_fill_func_t

typedef pixman_bool_t(* pixman_fill_func_t) (pixman_implementation_t *imp, uint32_t *bits, int stride, int bpp, int x, int y, int width, int height, uint32_t filler)

pixman_implementation_t

typedef struct pixman_implementation_t pixman_implementation_t

pixman_iter_fini_t

typedef void(* pixman_iter_fini_t) (pixman_iter_t *iter)

pixman_iter_get_scanline_t

typedef uint32_t*(* pixman_iter_get_scanline_t) (pixman_iter_t *iter, const uint32_t *mask)

pixman_iter_info_t

typedef struct pixman_iter_info_t pixman_iter_info_t

pixman_iter_initializer_t

typedef void(* pixman_iter_initializer_t) (pixman_iter_t *iter, const pixman_iter_info_t *info)

pixman_iter_t

typedef struct pixman_iter_t pixman_iter_t

pixman_iter_write_back_t

typedef void(* pixman_iter_write_back_t) (pixman_iter_t *iter)

pixman_link_t

typedef struct pixman_link_t pixman_link_t

pixman_list_t

typedef struct pixman_list_t pixman_list_t

property_changed_func_t

typedef void(* property_changed_func_t) (pixman_image_t *image)

radial_gradient_t

typedef struct radial_gradient radial_gradient_t

solid_fill_t

typedef struct solid_fill solid_fill_t

store_scanline_t

typedef void(* store_scanline_t) (bits_image_t *image, int x, int y, int width, const uint32_t *values)

vertical_gradient_t

typedef struct vertical_gradient vertical_gradient_t

Enumeration Type Documentation

image_type_t

enum image_type_t

Enumerator
BITS
LINEAR
CONICAL
RADIAL
SOLID

iter_flags_t

enum iter_flags_t

Enumerator
ITER_NARROW
ITER_WIDE
ITER_LOCALIZED_ALPHA
ITER_IGNORE_ALPHA
ITER_IGNORE_RGB
ITER_SRC
ITER_DEST

Function Documentation

_pixman_addition_overflows_int()

pixman_bool_t _pixman_addition_overflows_int	(	unsigned int	a,
		unsigned int	b
	)

_pixman_arm_get_implementations()

pixman_implementation_t* _pixman_arm_get_implementations

(

pixman_implementation_t *

imp

)

_pixman_bits_image_dest_iter_init()

void _pixman_bits_image_dest_iter_init	(	pixman_image_t *	image,
		pixman_iter_t *	iter
	)

_pixman_bits_image_init()

pixman_bool_t _pixman_bits_image_init	(	pixman_image_t *	image,
		pixman_format_code_t	format,
		int	width,
		int	height,
		uint32_t *	bits,
		int	rowstride,
		pixman_bool_t	clear
	)

_pixman_bits_image_setup_accessors()

void _pixman_bits_image_setup_accessors

(

bits_image_t *

image

)

_pixman_bits_image_src_iter_init()

void _pixman_bits_image_src_iter_init	(	pixman_image_t *	image,
		pixman_iter_t *	iter
	)

_pixman_choose_implementation()

pixman_implementation_t* _pixman_choose_implementation

(

void

)

Here is the caller graph for this function:

_pixman_compute_composite_region32()

pixman_bool_t _pixman_compute_composite_region32	(	pixman_region32_t *	region,
		pixman_image_t *	src_image,
		pixman_image_t *	mask_image,
		pixman_image_t *	dest_image,
		int32_t	src_x,
		int32_t	src_y,
		int32_t	mask_x,
		int32_t	mask_y,
		int32_t	dest_x,
		int32_t	dest_y,
		int32_t	width,
		int32_t	height
	)

_pixman_conical_gradient_iter_init()

void _pixman_conical_gradient_iter_init	(	pixman_image_t *	image,
		pixman_iter_t *	iter
	)

_pixman_disabled()

pixman_bool_t _pixman_disabled

(

const char *

name

)

_pixman_gradient_walker_init()

void _pixman_gradient_walker_init	(	pixman_gradient_walker_t *	walker,
		gradient_t *	gradient,
		pixman_repeat_t	repeat
	)

_pixman_gradient_walker_pixel()

uint32_t _pixman_gradient_walker_pixel	(	pixman_gradient_walker_t *	walker,
		pixman_fixed_48_16_t	x
	)

_pixman_gradient_walker_reset()

void _pixman_gradient_walker_reset	(	pixman_gradient_walker_t *	walker,
		pixman_fixed_48_16_t	pos
	)

_pixman_image_allocate()

pixman_image_t* _pixman_image_allocate

(

void

)

_pixman_image_fini()

pixman_bool_t _pixman_image_fini

(

pixman_image_t *

image

)

_pixman_image_get_solid()

uint32_t _pixman_image_get_solid	(	pixman_implementation_t *	imp,
		pixman_image_t *	image,
		pixman_format_code_t	format
	)

_pixman_image_init()

void _pixman_image_init

(

pixman_image_t *

image

)

_pixman_image_reset_clip_region()

void _pixman_image_reset_clip_region

(

pixman_image_t *

image

)

_pixman_image_validate()

void _pixman_image_validate

(

pixman_image_t *

image

)

_pixman_implementation_blt()

pixman_bool_t _pixman_implementation_blt	(	pixman_implementation_t *	imp,
		uint32_t *	src_bits,
		uint32_t *	dst_bits,
		int	src_stride,
		int	dst_stride,
		int	src_bpp,
		int	dst_bpp,
		int	src_x,
		int	src_y,
		int	dest_x,
		int	dest_y,
		int	width,
		int	height
	)

_pixman_implementation_create()

pixman_implementation_t* _pixman_implementation_create	(	pixman_implementation_t *	fallback,
		const pixman_fast_path_t *	fast_paths
	)

_pixman_implementation_create_fast_path()

pixman_implementation_t* _pixman_implementation_create_fast_path

(

pixman_implementation_t *

fallback

)

_pixman_implementation_create_general()

pixman_implementation_t* _pixman_implementation_create_general

(

void

)

_pixman_implementation_create_noop()

pixman_implementation_t* _pixman_implementation_create_noop

(

pixman_implementation_t *

fallback

)

_pixman_implementation_disabled()

pixman_bool_t _pixman_implementation_disabled

(

const char *

name

)

_pixman_implementation_fill()

pixman_bool_t _pixman_implementation_fill	(	pixman_implementation_t *	imp,
		uint32_t *	bits,
		int	stride,
		int	bpp,
		int	x,
		int	y,
		int	width,
		int	height,
		uint32_t	filler
	)

_pixman_implementation_iter_init()

void _pixman_implementation_iter_init	(	pixman_implementation_t *	imp,
		pixman_iter_t *	iter,
		pixman_image_t *	image,
		int	x,
		int	y,
		int	width,
		int	height,
		uint8_t *	buffer,
		iter_flags_t	flags,
		uint32_t	image_flags
	)

_pixman_implementation_lookup_combiner()

pixman_combine_32_func_t _pixman_implementation_lookup_combiner	(	pixman_implementation_t *	imp,
		pixman_op_t	op,
		pixman_bool_t	component_alpha,
		pixman_bool_t	wide
	)

_pixman_implementation_lookup_composite()

void _pixman_implementation_lookup_composite	(	pixman_implementation_t *	toplevel,
		pixman_op_t	op,
		pixman_format_code_t	src_format,
		uint32_t	src_flags,
		pixman_format_code_t	mask_format,
		uint32_t	mask_flags,
		pixman_format_code_t	dest_format,
		uint32_t	dest_flags,
		pixman_implementation_t **	out_imp,
		pixman_composite_func_t *	out_func
	)

_pixman_init_gradient()

pixman_bool_t _pixman_init_gradient	(	gradient_t *	gradient,
		const pixman_gradient_stop_t *	stops,
		int	n_stops
	)

_pixman_internal_only_get_implementation()

PIXMAN_EXPORT pixman_implementation_t* _pixman_internal_only_get_implementation

(

void

)

_pixman_iter_get_scanline_noop()

uint32_t* _pixman_iter_get_scanline_noop	(	pixman_iter_t *	iter,
		const uint32_t *	mask
	)

_pixman_iter_init_bits_stride()

void _pixman_iter_init_bits_stride	(	pixman_iter_t *	iter,
		const pixman_iter_info_t *	info
	)

_pixman_linear_gradient_iter_init()

void _pixman_linear_gradient_iter_init	(	pixman_image_t *	image,
		pixman_iter_t *	iter
	)

_pixman_log_error()

void _pixman_log_error	(	const char *	function,
		const char *	message
	)

_pixman_mips_get_implementations()

pixman_implementation_t* _pixman_mips_get_implementations

(

pixman_implementation_t *

imp

)

_pixman_multiply_overflows_int()

pixman_bool_t _pixman_multiply_overflows_int	(	unsigned int	a,
		unsigned int	b
	)

_pixman_multiply_overflows_size()

pixman_bool_t _pixman_multiply_overflows_size	(	size_t	a,
		size_t	b
	)

_pixman_ppc_get_implementations()

pixman_implementation_t* _pixman_ppc_get_implementations

(

pixman_implementation_t *

imp

)

_pixman_radial_gradient_iter_init()

void _pixman_radial_gradient_iter_init	(	pixman_image_t *	image,
		pixman_iter_t *	iter
	)

_pixman_setup_combiner_functions_32()

void _pixman_setup_combiner_functions_32

(

pixman_implementation_t *

imp

)

_pixman_setup_combiner_functions_float()

void _pixman_setup_combiner_functions_float

(

pixman_implementation_t *

imp

)

_pixman_x86_get_implementations()

pixman_implementation_t* _pixman_x86_get_implementations

(

pixman_implementation_t *

imp

)

convert_0565_to_0565()

static INLINE uint16_t convert_0565_to_0565 ( uint16_t  s )

static

convert_0565_to_0888()

static INLINE uint32_t convert_0565_to_0888 ( uint16_t  s )

static

Here is the caller graph for this function:

convert_0565_to_8888()

static INLINE uint32_t convert_0565_to_8888 ( uint16_t  s )

static

Here is the call graph for this function:

convert_8888_to_0565()

static INLINE uint16_t convert_8888_to_0565 ( uint32_t  s )

static

convert_8888_to_8888()

static INLINE uint32_t convert_8888_to_8888 ( uint32_t  s )

static

convert_x888_to_8888()

static INLINE uint32_t convert_x888_to_8888 ( uint32_t  s )

static

get_implementation()

static INLINE pixman_implementation_t* get_implementation ( void  )

static

Here is the call graph for this function:

pixman_contract_from_float()

void pixman_contract_from_float	(	uint32_t *	dst,
		const argb_t *	src,
		int	width
	)

pixman_expand_to_float()

void pixman_expand_to_float	(	argb_t *	dst,
		const uint32_t *	src,
		pixman_format_code_t	format,
		int	width
	)

pixman_float_to_unorm()

uint16_t pixman_float_to_unorm	(	float	f,
		int	n_bits
	)

pixman_list_init()

static INLINE void pixman_list_init ( pixman_list_t *  list )

static

pixman_list_move_to_front()

static INLINE void pixman_list_move_to_front ( pixman_list_t *  list, pixman_link_t *  link  )

static

Here is the call graph for this function:

pixman_list_prepend()

static INLINE void pixman_list_prepend ( pixman_list_t *  list, pixman_link_t *  link  )

static

Here is the call graph for this function:

Here is the caller graph for this function:

pixman_list_unlink()

static INLINE void pixman_list_unlink ( pixman_link_t *  link )

static

Here is the call graph for this function:

Here is the caller graph for this function:

pixman_malloc_ab()

void* pixman_malloc_ab	(	unsigned int	n,
		unsigned int	b
	)

pixman_malloc_ab_plus_c()

void* pixman_malloc_ab_plus_c	(	unsigned int	a,
		unsigned int	b,
		unsigned int	c
	)

pixman_malloc_abc()

void* pixman_malloc_abc	(	unsigned int	a,
		unsigned int	b,
		unsigned int	c
	)

pixman_rasterize_edges_accessors()

void pixman_rasterize_edges_accessors	(	pixman_image_t *	image,
		pixman_edge_t *	l,
		pixman_edge_t *	r,
		pixman_fixed_t	t,
		pixman_fixed_t	b
	)

pixman_region16_copy_from_region32()

pixman_bool_t pixman_region16_copy_from_region32	(	pixman_region16_t *	dst,
		pixman_region32_t *	src
	)

pixman_region32_copy_from_region16()

pixman_bool_t pixman_region32_copy_from_region16	(	pixman_region32_t *	dst,
		pixman_region16_t *	src
	)

pixman_transform_point_31_16()

pixman_bool_t pixman_transform_point_31_16	(	const pixman_transform_t *	t,
		const pixman_vector_48_16_t *	v,
		pixman_vector_48_16_t *	result
	)

pixman_transform_point_31_16_3d()

void pixman_transform_point_31_16_3d	(	const pixman_transform_t *	t,
		const pixman_vector_48_16_t *	v,
		pixman_vector_48_16_t *	result
	)

pixman_transform_point_31_16_affine()

void pixman_transform_point_31_16_affine	(	const pixman_transform_t *	t,
		const pixman_vector_48_16_t *	v,
		pixman_vector_48_16_t *	result
	)

pixman_unorm_to_float()

float pixman_unorm_to_float	(	uint16_t	u,
		int	n_bits
	)

unorm_to_unorm()

static INLINE uint32_t unorm_to_unorm ( uint32_t  val, int  from_bits, int  to_bits  )

static

Variable Documentation

global_implementation

pixman_implementation_t* global_implementation