xserver xkeyboard-config libX11 pixman mesa git update 2011

3 files changed, 320 insertions, 1 deletions

diff --git a/pixman/pixman/pixman-image.c b/pixman/pixman/pixman-image.c
index beda4b423..306692fe0 100644
--- a/pixman/pixman/pixman-image.c
+++ b/pixman/pixman/pixman-image.c
@@ -502,7 +502,7 @@ pixman_image_set_transform (pixman_image_t *          image,
     if (common->transform == transform)

 	return TRUE;

 

-    if (memcmp (&id, transform, sizeof (pixman_transform_t)) == 0)

+    if (!transform || memcmp (&id, transform, sizeof (pixman_transform_t)) == 0)

     {

 	free (common->transform);

 	common->transform = NULL;

@@ -511,6 +511,12 @@ pixman_image_set_transform (pixman_image_t *          image,
 	goto out;

     }

 

+    if (common->transform &&

+	memcmp (common->transform, transform, sizeof (pixman_transform_t) == 0))

+    {

+	return TRUE;

+    }

+

     if (common->transform == NULL)

 	common->transform = malloc (sizeof (pixman_transform_t));

 

@@ -535,6 +541,9 @@ PIXMAN_EXPORT void
 pixman_image_set_repeat (pixman_image_t *image,

                          pixman_repeat_t repeat)

 {

+    if (image->common.repeat == repeat)

+	return;

+

     image->common.repeat = repeat;

 

     image_property_changed (image);

@@ -579,6 +588,9 @@ PIXMAN_EXPORT void
 pixman_image_set_source_clipping (pixman_image_t *image,

                                   pixman_bool_t   clip_sources)

 {

+    if (image->common.clip_sources == clip_sources)

+	return;

+

     image->common.clip_sources = clip_sources;

 

     image_property_changed (image);

@@ -594,6 +606,9 @@ pixman_image_set_indexed (pixman_image_t *        image,
 {

     bits_image_t *bits = (bits_image_t *)image;

 

+    if (bits->indexed == indexed)

+	return;

+

     bits->indexed = indexed;

 

     image_property_changed (image);

@@ -656,6 +671,9 @@ PIXMAN_EXPORT void
 pixman_image_set_component_alpha   (pixman_image_t *image,

                                     pixman_bool_t   component_alpha)

 {

+    if (image->common.component_alpha == component_alpha)

+	return;

+

     image->common.component_alpha = component_alpha;

 

     image_property_changed (image);

diff --git a/pixman/pixman/pixman-trap.c b/pixman/pixman/pixman-trap.c
index 787093a85..6e85acd49 100644
--- a/pixman/pixman/pixman-trap.c
+++ b/pixman/pixman/pixman-trap.c
@@ -1,4 +1,5 @@
 /*

+ * Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc.

  * Copyright © 2004 Keith Packard

  *

  * Permission to use, copy, modify, distribute, and sell this software and its

@@ -25,6 +26,7 @@
 #endif

 

 #include <stdio.h>

+#include <stdlib.h>

 #include "pixman-private.h"

 

 /*

@@ -384,3 +386,272 @@ pixman_rasterize_trapezoid (pixman_image_t *          image,
 	pixman_rasterize_edges (image, &l, &r, t, b);

     }

 }

+

+PIXMAN_EXPORT void

+pixman_composite_trapezoids (pixman_op_t		op,

+			     pixman_image_t *		src,

+			     pixman_image_t *		dst,

+			     pixman_format_code_t	mask_format,

+			     int			x_src,

+			     int			y_src,

+			     int			x_dst,

+			     int			y_dst,

+			     int			n_traps,

+			     const pixman_trapezoid_t *	traps)

+{

+    int i;

+

+    if (n_traps <= 0)

+	return;

+

+    _pixman_image_validate (src);

+    _pixman_image_validate (dst);

+

+    if (op == PIXMAN_OP_ADD &&

+	(src->common.flags & FAST_PATH_IS_OPAQUE)		&&

+	(mask_format == dst->common.extended_format_code)	&&

+	!(dst->common.have_clip_region))

+    {

+	for (i = 0; i < n_traps; ++i)

+	{

+	    const pixman_trapezoid_t *trap = &(traps[i]);

+	    

+	    if (!pixman_trapezoid_valid (trap))

+		continue;

+	    

+	    pixman_rasterize_trapezoid (dst, trap, 0, 0);

+	}

+    }

+    else

+    {

+	pixman_image_t *tmp;

+	pixman_box32_t box;

+	int x_rel, y_rel;

+	

+	box.x1 = INT32_MAX;

+	box.y1 = INT32_MAX;

+	box.x2 = INT32_MIN;

+	box.y2 = INT32_MIN;

+	

+	for (i = 0; i < n_traps; ++i)

+	{

+	    const pixman_trapezoid_t *trap = &(traps[i]);

+	    int y1, y2;

+	    

+	    if (!pixman_trapezoid_valid (trap))

+		continue;

+	    

+	    y1 = pixman_fixed_to_int (trap->top);

+	    if (y1 < box.y1)

+		box.y1 = y1;

+	    

+	    y2 = pixman_fixed_to_int (pixman_fixed_ceil (trap->bottom));

+	    if (y2 > box.y2)

+		box.y2 = y2;

+	    

+#define EXTEND_MIN(x)							\

+	    if (pixman_fixed_to_int ((x)) < box.x1)			\

+		box.x1 = pixman_fixed_to_int ((x));

+#define EXTEND_MAX(x)							\

+	    if (pixman_fixed_to_int (pixman_fixed_ceil ((x))) > box.x2)	\

+		box.x2 = pixman_fixed_to_int (pixman_fixed_ceil ((x)));

+	    

+#define EXTEND(x)							\

+	    EXTEND_MIN(x);						\

+	    EXTEND_MAX(x);

+	    

+	    EXTEND(trap->left.p1.x);

+	    EXTEND(trap->left.p2.x);

+	    EXTEND(trap->right.p1.x);

+	    EXTEND(trap->right.p2.x);

+	}

+	

+	if (box.x1 >= box.x2 || box.y1 >= box.y2)

+	    return;

+	

+	tmp = pixman_image_create_bits (

+	    mask_format, box.x2 - box.x1, box.y2 - box.y1, NULL, -1);

+	

+	for (i = 0; i < n_traps; ++i)

+	{

+	    const pixman_trapezoid_t *trap = &(traps[i]);

+	    

+	    if (!pixman_trapezoid_valid (trap))

+		continue;

+	    

+	    pixman_rasterize_trapezoid (tmp, trap, - box.x1, - box.y1);

+	}

+	

+	x_rel = box.x1 + x_src - x_dst;

+	y_rel = box.y1 + y_src - y_dst;

+	

+	pixman_image_composite (op, src, tmp, dst,

+				x_rel, y_rel, 0, 0, box.x1, box.y1,

+				box.x2 - box.x1, box.y2 - box.y1);

+	

+	pixman_image_unref (tmp);

+    }

+}

+

+static int

+greater_y (const pixman_point_fixed_t *a, const pixman_point_fixed_t *b)

+{

+    if (a->y == b->y)

+	return a->x > b->x;

+    return a->y > b->y;

+}

+

+/*

+ * Note that the definition of this function is a bit odd because

+ * of the X coordinate space (y increasing downwards).

+ */

+static int

+clockwise (const pixman_point_fixed_t *ref,

+	   const pixman_point_fixed_t *a,

+	   const pixman_point_fixed_t *b)

+{

+    pixman_point_fixed_t	ad, bd;

+

+    ad.x = a->x - ref->x;

+    ad.y = a->y - ref->y;

+    bd.x = b->x - ref->x;

+    bd.y = b->y - ref->y;

+

+    return ((pixman_fixed_32_32_t) bd.y * ad.x -

+	    (pixman_fixed_32_32_t) ad.y * bd.x) < 0;

+}

+

+static void

+triangle_to_trapezoids (const pixman_triangle_t *tri, pixman_trapezoid_t *traps)

+{

+    const pixman_point_fixed_t *top, *left, *right, *tmp;

+

+    top = &tri->p1;

+    left = &tri->p2;

+    right = &tri->p3;

+

+    if (greater_y (top, left))

+    {

+	tmp = left;

+	left = top;

+	top = tmp;

+    }

+

+    if (greater_y (top, right))

+    {

+	tmp = right;

+	right = top;

+	top = tmp;

+    }

+

+    if (clockwise (top, right, left))

+    {

+	tmp = right;

+	right = left;

+	left = tmp;

+    }

+    

+    /*

+     * Two cases:

+     *

+     *		+		+

+     *	       / \             / \

+     *	      /   \           /	  \

+     *	     /     +         +	   \

+     *      /    --           --    \

+     *     /   --               --   \

+     *    / ---                   --- \

+     *	 +--                         --+

+     */

+

+    traps->top = top->y;

+    traps->left.p1 = *top;

+    traps->left.p2 = *left;

+    traps->right.p1 = *top;

+    traps->right.p2 = *right;

+

+    if (right->y < left->y)

+	traps->bottom = right->y;

+    else

+	traps->bottom = left->y;

+

+    traps++;

+

+    *traps = *(traps - 1);

+    

+    if (right->y < left->y)

+    {

+	traps->top = right->y;

+	traps->bottom = left->y;

+	traps->right.p1 = *right;

+	traps->right.p2 = *left;

+    }

+    else

+    {

+	traps->top = left->y;

+	traps->bottom = right->y;

+	traps->left.p1 = *left;

+	traps->left.p2 = *right;

+    }

+}

+

+static pixman_trapezoid_t *

+convert_triangles (int n_tris, const pixman_triangle_t *tris)

+{

+    pixman_trapezoid_t *traps;

+    int i;

+

+    if (n_tris <= 0)

+	return NULL;

+    

+    traps = pixman_malloc_ab (n_tris, 2 * sizeof (pixman_trapezoid_t));

+    if (!traps)

+	return NULL;

+

+    for (i = 0; i < n_tris; ++i)

+	triangle_to_trapezoids (&(tris[i]), traps + 2 * i);

+

+    return traps;

+}

+

+PIXMAN_EXPORT void

+pixman_composite_triangles (pixman_op_t			op,

+			    pixman_image_t *		src,

+			    pixman_image_t *		dst,

+			    pixman_format_code_t	mask_format,

+			    int				x_src,

+			    int				y_src,

+			    int				x_dst,

+			    int				y_dst,

+			    int				n_tris,

+			    const pixman_triangle_t *	tris)

+{

+    pixman_trapezoid_t *traps;

+

+    if ((traps = convert_triangles (n_tris, tris)))

+    {

+	pixman_composite_trapezoids (op, src, dst, mask_format,

+				     x_src, y_src, x_dst, y_dst,

+				     n_tris * 2, traps);

+	

+	free (traps);

+    }

+}

+

+PIXMAN_EXPORT void

+pixman_add_triangles (pixman_image_t          *image,

+		      int32_t	               x_off,

+		      int32_t	               y_off,

+		      int	               n_tris,

+		      const pixman_triangle_t *tris)

+{

+    pixman_trapezoid_t *traps;

+

+    if ((traps = convert_triangles (n_tris, tris)))

+    {

+	pixman_add_trapezoids (image, x_off, y_off,

+			       n_tris * 2, traps);

+

+	free (traps);

+    }

+}

diff --git a/pixman/pixman/pixman.h b/pixman/pixman/pixman.h
index 27eeeee4e..855575a30 100644
--- a/pixman/pixman/pixman.h
+++ b/pixman/pixman/pixman.h
@@ -868,6 +868,7 @@ 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;

+typedef struct pixman_triangle pixman_triangle_t;

 

 /*

  * An edge structure.  This represents a single polygon edge

@@ -895,6 +896,10 @@ struct pixman_trapezoid
     pixman_line_fixed_t	left, right;

 };

 

+struct pixman_triangle

+{

+    pixman_point_fixed_t p1, p2, p3;

+};

 

 /* whether 't' is a well defined not obviously empty trapezoid */

 #define pixman_trapezoid_valid(t)				   \

@@ -950,6 +955,31 @@ void           pixman_rasterize_trapezoid  (pixman_image_t            *image,
 					    const pixman_trapezoid_t  *trap,

 					    int                        x_off,

 					    int                        y_off);

+void          pixman_composite_trapezoids (pixman_op_t		       op,

+					   pixman_image_t *	       src,

+					   pixman_image_t *	       dst,

+					   pixman_format_code_t	       mask_format,

+					   int			       x_src,

+					   int			       y_src,

+					   int			       x_dst,

+					   int			       y_dst,

+					   int			       n_traps,

+					   const pixman_trapezoid_t *  traps);

+void          pixman_composite_triangles (pixman_op_t		       op,

+					  pixman_image_t *	       src,

+					  pixman_image_t *	       dst,

+					  pixman_format_code_t	       mask_format,

+					  int			       x_src,

+					  int			       y_src,

+					  int			       x_dst,

+					  int			       y_dst,

+					  int			       n_tris,

+					  const pixman_triangle_t *    tris);

+void	      pixman_add_triangles       (pixman_image_t              *image,

+					  int32_t	               x_off,

+					  int32_t	               y_off,

+					  int	                       n_tris,

+					  const pixman_triangle_t     *tris);

 

 PIXMAN_END_DECLS