fontconfig libX11 libXft mesa pixman xserver xkeyboard-config git update 4

May 2012

12 files changed, 628 insertions, 633 deletions

diff --git a/pixman/pixman/pixman-bits-image.c b/pixman/pixman/pixman-bits-image.c
index 1f6897c2c..3ba6739d1 100644
--- a/pixman/pixman/pixman-bits-image.c
+++ b/pixman/pixman/pixman-bits-image.c
@@ -1248,7 +1248,7 @@ src_get_scanline_wide (pixman_iter_t *iter, const uint32_t *mask)
 void
 _pixman_bits_image_src_iter_init (pixman_image_t *image, pixman_iter_t *iter)
 {
-    if (iter->flags & ITER_NARROW)
+    if (iter->iter_flags & ITER_NARROW)
 	iter->get_scanline = src_get_scanline_narrow;
     else
 	iter->get_scanline = src_get_scanline_wide;
@@ -1380,9 +1380,9 @@ dest_write_back_wide (pixman_iter_t *iter)
 void
 _pixman_bits_image_dest_iter_init (pixman_image_t *image, pixman_iter_t *iter)
 {
-    if (iter->flags & ITER_NARROW)
+    if (iter->iter_flags & ITER_NARROW)
     {
-	if ((iter->flags & (ITER_IGNORE_RGB | ITER_IGNORE_ALPHA)) ==
+	if ((iter->iter_flags & (ITER_IGNORE_RGB | ITER_IGNORE_ALPHA)) ==
 	    (ITER_IGNORE_RGB | ITER_IGNORE_ALPHA))
 	{
 	    iter->get_scanline = _pixman_iter_get_scanline_noop;
diff --git a/pixman/pixman/pixman-conical-gradient.c b/pixman/pixman/pixman-conical-gradient.c
index e3f230262..8b52176e4 100644
--- a/pixman/pixman/pixman-conical-gradient.c
+++ b/pixman/pixman/pixman-conical-gradient.c
@@ -1,211 +1,211 @@
-/*

- * Copyright © 2000 SuSE, Inc.

- * Copyright © 2007 Red Hat, Inc.

- * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc.

- *             2005 Lars Knoll & Zack Rusin, Trolltech

- *

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

- * documentation for any purpose is hereby granted without fee, provided that

- * the above copyright notice appear in all copies and that both that

- * copyright notice and this permission notice appear in supporting

- * documentation, and that the name of Keith Packard not be used in

- * advertising or publicity pertaining to distribution of the software without

- * specific, written prior permission.  Keith Packard makes no

- * representations about the suitability of this software for any purpose.  It

- * is provided "as is" without express or implied warranty.

- *

- * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS

- * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND

- * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY

- * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN

- * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING

- * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS

- * SOFTWARE.

- */

-

-#ifdef HAVE_CONFIG_H

-#include <config.h>

-#endif

-

-#include <stdlib.h>

-#include <math.h>

-#include "pixman-private.h"

-

-static force_inline double

-coordinates_to_parameter (double x, double y, double angle)

-{

-    double t;

-

-    t = atan2 (y, x) + angle;

-

-    while (t < 0)

-	t += 2 * M_PI;

-

-    while (t >= 2 * M_PI)

-	t -= 2 * M_PI;

-

-    return 1 - t * (1 / (2 * M_PI)); /* Scale t to [0, 1] and

-				      * make rotation CCW

-				      */

-}

-

-static uint32_t *

-conical_get_scanline_narrow (pixman_iter_t *iter, const uint32_t *mask)

-{

-    pixman_image_t *image = iter->image;

-    int x = iter->x;

-    int y = iter->y;

-    int width = iter->width;

-    uint32_t *buffer = iter->buffer;

-

-    gradient_t *gradient = (gradient_t *)image;

-    conical_gradient_t *conical = (conical_gradient_t *)image;

-    uint32_t       *end = buffer + width;

-    pixman_gradient_walker_t walker;

-    pixman_bool_t affine = TRUE;

-    double cx = 1.;

-    double cy = 0.;

-    double cz = 0.;

-    double rx = x + 0.5;

-    double ry = y + 0.5;

-    double rz = 1.;

-

-    _pixman_gradient_walker_init (&walker, gradient, image->common.repeat);

-

-    if (image->common.transform)

-    {

-	pixman_vector_t v;

-

-	/* reference point is the center of the pixel */

-	v.vector[0] = pixman_int_to_fixed (x) + pixman_fixed_1 / 2;

-	v.vector[1] = pixman_int_to_fixed (y) + pixman_fixed_1 / 2;

-	v.vector[2] = pixman_fixed_1;

-

-	if (!pixman_transform_point_3d (image->common.transform, &v))

-	    return iter->buffer;

-

-	cx = image->common.transform->matrix[0][0] / 65536.;

-	cy = image->common.transform->matrix[1][0] / 65536.;

-	cz = image->common.transform->matrix[2][0] / 65536.;

-

-	rx = v.vector[0] / 65536.;

-	ry = v.vector[1] / 65536.;

-	rz = v.vector[2] / 65536.;

-

-	affine =

-	    image->common.transform->matrix[2][0] == 0 &&

-	    v.vector[2] == pixman_fixed_1;

-    }

-

-    if (affine)

-    {

-	rx -= conical->center.x / 65536.;

-	ry -= conical->center.y / 65536.;

-

-	while (buffer < end)

-	{

-	    if (!mask || *mask++)

-	    {

-		double t = coordinates_to_parameter (rx, ry, conical->angle);

-

-		*buffer = _pixman_gradient_walker_pixel (

-		    &walker, (pixman_fixed_48_16_t)pixman_double_to_fixed (t));

-	    }

-

-	    ++buffer;

-

-	    rx += cx;

-	    ry += cy;

-	}

-    }

-    else

-    {

-	while (buffer < end)

-	{

-	    double x, y;

-

-	    if (!mask || *mask++)

-	    {

-		double t;

-

-		if (rz != 0)

-		{

-		    x = rx / rz;

-		    y = ry / rz;

-		}

-		else

-		{

-		    x = y = 0.;

-		}

-

-		x -= conical->center.x / 65536.;

-		y -= conical->center.y / 65536.;

-

-		t = coordinates_to_parameter (x, y, conical->angle);

-

-		*buffer = _pixman_gradient_walker_pixel (

-		    &walker, (pixman_fixed_48_16_t)pixman_double_to_fixed (t));

-	    }

-

-	    ++buffer;

-

-	    rx += cx;

-	    ry += cy;

-	    rz += cz;

-	}

-    }

-

-    iter->y++;

-    return iter->buffer;

-}

-

-static uint32_t *

-conical_get_scanline_wide (pixman_iter_t *iter, const uint32_t *mask)

-{

-    uint32_t *buffer = conical_get_scanline_narrow (iter, NULL);

-

-    pixman_expand ((uint64_t *)buffer, buffer, PIXMAN_a8r8g8b8, iter->width);

-

-    return buffer;

-}

-

-void

-_pixman_conical_gradient_iter_init (pixman_image_t *image, pixman_iter_t *iter)

-{

-    if (iter->flags & ITER_NARROW)

-	iter->get_scanline = conical_get_scanline_narrow;

-    else

-	iter->get_scanline = conical_get_scanline_wide;

-}

-

-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_image_t *image = _pixman_image_allocate ();

-    conical_gradient_t *conical;

-

-    if (!image)

-	return NULL;

-

-    conical = &image->conical;

-

-    if (!_pixman_init_gradient (&conical->common, stops, n_stops))

-    {

-	free (image);

-	return NULL;

-    }

-

-    angle = MOD (angle, pixman_int_to_fixed (360));

-

-    image->type = CONICAL;

-

-    conical->center = *center;

-    conical->angle = (pixman_fixed_to_double (angle) / 180.0) * M_PI;

-

-    return image;

-}

-

+/*
+ * Copyright © 2000 SuSE, Inc.
+ * Copyright © 2007 Red Hat, Inc.
+ * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc.
+ *             2005 Lars Knoll & Zack Rusin, Trolltech
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
+ * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
+ * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
+ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+ * SOFTWARE.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdlib.h>
+#include <math.h>
+#include "pixman-private.h"
+
+static force_inline double
+coordinates_to_parameter (double x, double y, double angle)
+{
+    double t;
+
+    t = atan2 (y, x) + angle;
+
+    while (t < 0)
+	t += 2 * M_PI;
+
+    while (t >= 2 * M_PI)
+	t -= 2 * M_PI;
+
+    return 1 - t * (1 / (2 * M_PI)); /* Scale t to [0, 1] and
+				      * make rotation CCW
+				      */
+}
+
+static uint32_t *
+conical_get_scanline_narrow (pixman_iter_t *iter, const uint32_t *mask)
+{
+    pixman_image_t *image = iter->image;
+    int x = iter->x;
+    int y = iter->y;
+    int width = iter->width;
+    uint32_t *buffer = iter->buffer;
+
+    gradient_t *gradient = (gradient_t *)image;
+    conical_gradient_t *conical = (conical_gradient_t *)image;
+    uint32_t       *end = buffer + width;
+    pixman_gradient_walker_t walker;
+    pixman_bool_t affine = TRUE;
+    double cx = 1.;
+    double cy = 0.;
+    double cz = 0.;
+    double rx = x + 0.5;
+    double ry = y + 0.5;
+    double rz = 1.;
+
+    _pixman_gradient_walker_init (&walker, gradient, image->common.repeat);
+
+    if (image->common.transform)
+    {
+	pixman_vector_t v;
+
+	/* reference point is the center of the pixel */
+	v.vector[0] = pixman_int_to_fixed (x) + pixman_fixed_1 / 2;
+	v.vector[1] = pixman_int_to_fixed (y) + pixman_fixed_1 / 2;
+	v.vector[2] = pixman_fixed_1;
+
+	if (!pixman_transform_point_3d (image->common.transform, &v))
+	    return iter->buffer;
+
+	cx = image->common.transform->matrix[0][0] / 65536.;
+	cy = image->common.transform->matrix[1][0] / 65536.;
+	cz = image->common.transform->matrix[2][0] / 65536.;
+
+	rx = v.vector[0] / 65536.;
+	ry = v.vector[1] / 65536.;
+	rz = v.vector[2] / 65536.;
+
+	affine =
+	    image->common.transform->matrix[2][0] == 0 &&
+	    v.vector[2] == pixman_fixed_1;
+    }
+
+    if (affine)
+    {
+	rx -= conical->center.x / 65536.;
+	ry -= conical->center.y / 65536.;
+
+	while (buffer < end)
+	{
+	    if (!mask || *mask++)
+	    {
+		double t = coordinates_to_parameter (rx, ry, conical->angle);
+
+		*buffer = _pixman_gradient_walker_pixel (
+		    &walker, (pixman_fixed_48_16_t)pixman_double_to_fixed (t));
+	    }
+
+	    ++buffer;
+
+	    rx += cx;
+	    ry += cy;
+	}
+    }
+    else
+    {
+	while (buffer < end)
+	{
+	    double x, y;
+
+	    if (!mask || *mask++)
+	    {
+		double t;
+
+		if (rz != 0)
+		{
+		    x = rx / rz;
+		    y = ry / rz;
+		}
+		else
+		{
+		    x = y = 0.;
+		}
+
+		x -= conical->center.x / 65536.;
+		y -= conical->center.y / 65536.;
+
+		t = coordinates_to_parameter (x, y, conical->angle);
+
+		*buffer = _pixman_gradient_walker_pixel (
+		    &walker, (pixman_fixed_48_16_t)pixman_double_to_fixed (t));
+	    }
+
+	    ++buffer;
+
+	    rx += cx;
+	    ry += cy;
+	    rz += cz;
+	}
+    }
+
+    iter->y++;
+    return iter->buffer;
+}
+
+static uint32_t *
+conical_get_scanline_wide (pixman_iter_t *iter, const uint32_t *mask)
+{
+    uint32_t *buffer = conical_get_scanline_narrow (iter, NULL);
+
+    pixman_expand ((uint64_t *)buffer, buffer, PIXMAN_a8r8g8b8, iter->width);
+
+    return buffer;
+}
+
+void
+_pixman_conical_gradient_iter_init (pixman_image_t *image, pixman_iter_t *iter)
+{
+    if (iter->iter_flags & ITER_NARROW)
+	iter->get_scanline = conical_get_scanline_narrow;
+    else
+	iter->get_scanline = conical_get_scanline_wide;
+}
+
+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_image_t *image = _pixman_image_allocate ();
+    conical_gradient_t *conical;
+
+    if (!image)
+	return NULL;
+
+    conical = &image->conical;
+
+    if (!_pixman_init_gradient (&conical->common, stops, n_stops))
+    {
+	free (image);
+	return NULL;
+    }
+
+    angle = MOD (angle, pixman_int_to_fixed (360));
+
+    image->type = CONICAL;
+
+    conical->center = *center;
+    conical->angle = (pixman_fixed_to_double (angle) / 180.0) * M_PI;
+
+    return image;
+}
+
diff --git a/pixman/pixman/pixman-general.c b/pixman/pixman/pixman-general.c
index 27fa3abe5..d4b2daa37 100644
--- a/pixman/pixman/pixman-general.c
+++ b/pixman/pixman/pixman-general.c
@@ -110,7 +110,7 @@ general_composite_rect  (pixman_implementation_t *imp,
     pixman_iter_t src_iter, mask_iter, dest_iter;
     pixman_combine_32_func_t compose;
     pixman_bool_t component_alpha;
-    iter_flags_t narrow, src_flags;
+    iter_flags_t narrow, src_iter_flags;
     int Bpp;
     int i;
 
@@ -140,14 +140,14 @@ general_composite_rect  (pixman_implementation_t *imp,
     dest_buffer = mask_buffer + width * Bpp;
 
     /* src iter */
-    src_flags = narrow | op_flags[op].src;
+    src_iter_flags = narrow | op_flags[op].src;
 
     _pixman_implementation_src_iter_init (imp->toplevel, &src_iter, src_image,
 					  src_x, src_y, width, height,
-					  src_buffer, src_flags);
+					  src_buffer, src_iter_flags, info->src_flags);
 
     /* mask iter */
-    if ((src_flags & (ITER_IGNORE_ALPHA | ITER_IGNORE_RGB)) ==
+    if ((src_iter_flags & (ITER_IGNORE_ALPHA | ITER_IGNORE_RGB)) ==
 	(ITER_IGNORE_ALPHA | ITER_IGNORE_RGB))
     {
 	/* If it doesn't matter what the source is, then it doesn't matter
@@ -164,12 +164,12 @@ general_composite_rect  (pixman_implementation_t *imp,
 
     _pixman_implementation_src_iter_init (
 	imp->toplevel, &mask_iter, mask_image, mask_x, mask_y, width, height,
-	mask_buffer, narrow | (component_alpha? 0 : ITER_IGNORE_RGB));
+	mask_buffer, narrow | (component_alpha? 0 : ITER_IGNORE_RGB), info->mask_flags);
 
     /* dest iter */
     _pixman_implementation_dest_iter_init (
 	imp->toplevel, &dest_iter, dest_image, dest_x, dest_y, width, height,
-	dest_buffer, narrow | op_flags[op].dst);
+	dest_buffer, narrow | op_flags[op].dst, info->dest_flags);
 
     compose = _pixman_implementation_lookup_combiner (
 	imp->toplevel, op, component_alpha, narrow);
diff --git a/pixman/pixman/pixman-image.c b/pixman/pixman/pixman-image.c
index 8599a1eb1..6a965e462 100644
--- a/pixman/pixman/pixman-image.c
+++ b/pixman/pixman/pixman-image.c
@@ -883,7 +883,7 @@ _pixman_image_get_solid (pixman_implementation_t *imp,
 
     _pixman_implementation_src_iter_init (
 	imp, &iter, image, 0, 0, 1, 1,
-	(uint8_t *)&result, ITER_NARROW);
+	(uint8_t *)&result, ITER_NARROW, image->common.flags);
 
     result = *iter.get_scanline (&iter, NULL);
 
diff --git a/pixman/pixman/pixman-implementation.c b/pixman/pixman/pixman-implementation.c
index b0a295939..c769ab8cb 100644
--- a/pixman/pixman/pixman-implementation.c
+++ b/pixman/pixman/pixman-implementation.c
@@ -185,7 +185,8 @@ _pixman_implementation_src_iter_init (pixman_implementation_t	*imp,
 				      int			 width,
 				      int			 height,
 				      uint8_t			*buffer,
-				      iter_flags_t		 flags)
+				      iter_flags_t		 iter_flags,
+				      uint32_t                   image_flags)
 {
     iter->image = image;
     iter->buffer = (uint32_t *)buffer;
@@ -193,7 +194,8 @@ _pixman_implementation_src_iter_init (pixman_implementation_t	*imp,
     iter->y = y;
     iter->width = width;
     iter->height = height;
-    iter->flags = flags;
+    iter->iter_flags = iter_flags;
+    iter->image_flags = image_flags;
 
     (*imp->src_iter_init) (imp, iter);
 }
@@ -207,7 +209,8 @@ _pixman_implementation_dest_iter_init (pixman_implementation_t	*imp,
 				       int			 width,
 				       int			 height,
 				       uint8_t			*buffer,
-				       iter_flags_t		 flags)
+				       iter_flags_t		 iter_flags,
+				       uint32_t                  image_flags)
 {
     iter->image = image;
     iter->buffer = (uint32_t *)buffer;
@@ -215,7 +218,8 @@ _pixman_implementation_dest_iter_init (pixman_implementation_t	*imp,
     iter->y = y;
     iter->width = width;
     iter->height = height;
-    iter->flags = flags;
+    iter->iter_flags = iter_flags;
+    iter->image_flags = image_flags;
 
     (*imp->dest_iter_init) (imp, iter);
 }
diff --git a/pixman/pixman/pixman-linear-gradient.c b/pixman/pixman/pixman-linear-gradient.c
index 3d5bbf63d..32b8ba786 100644
--- a/pixman/pixman/pixman-linear-gradient.c
+++ b/pixman/pixman/pixman-linear-gradient.c
@@ -1,286 +1,286 @@
-/* -*- Mode: c; c-basic-offset: 4; tab-width: 8; indent-tabs-mode: t; -*- */

-/*

- * Copyright © 2000 SuSE, Inc.

- * Copyright © 2007 Red Hat, Inc.

- * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc.

- *             2005 Lars Knoll & Zack Rusin, Trolltech

- *

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

- * documentation for any purpose is hereby granted without fee, provided that

- * the above copyright notice appear in all copies and that both that

- * copyright notice and this permission notice appear in supporting

- * documentation, and that the name of Keith Packard not be used in

- * advertising or publicity pertaining to distribution of the software without

- * specific, written prior permission.  Keith Packard makes no

- * representations about the suitability of this software for any purpose.  It

- * is provided "as is" without express or implied warranty.

- *

- * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS

- * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND

- * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY

- * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN

- * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING

- * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS

- * SOFTWARE.

- */

-

-#ifdef HAVE_CONFIG_H

-#include <config.h>

-#endif

-#include <stdlib.h>

-#include "pixman-private.h"

-

-static pixman_bool_t

-linear_gradient_is_horizontal (pixman_image_t *image,

-			       int             x,

-			       int             y,

-			       int             width,

-			       int             height)

-{

-    linear_gradient_t *linear = (linear_gradient_t *)image;

-    pixman_vector_t v;

-    pixman_fixed_32_32_t l;

-    pixman_fixed_48_16_t dx, dy;

-    double inc;

-

-    if (image->common.transform)

-    {

-	/* projective transformation */

-	if (image->common.transform->matrix[2][0] != 0 ||

-	    image->common.transform->matrix[2][1] != 0 ||

-	    image->common.transform->matrix[2][2] == 0)

-	{

-	    return FALSE;

-	}

-

-	v.vector[0] = image->common.transform->matrix[0][1];

-	v.vector[1] = image->common.transform->matrix[1][1];

-	v.vector[2] = image->common.transform->matrix[2][2];

-    }

-    else

-    {

-	v.vector[0] = 0;

-	v.vector[1] = pixman_fixed_1;

-	v.vector[2] = pixman_fixed_1;

-    }

-

-    dx = linear->p2.x - linear->p1.x;

-    dy = linear->p2.y - linear->p1.y;

-

-    l = dx * dx + dy * dy;

-

-    if (l == 0)

-	return FALSE;

-

-    /*

-     * compute how much the input of the gradient walked changes

-     * when moving vertically through the whole image

-     */

-    inc = height * (double) pixman_fixed_1 * pixman_fixed_1 *

-	(dx * v.vector[0] + dy * v.vector[1]) /

-	(v.vector[2] * (double) l);

-

-    /* check that casting to integer would result in 0 */

-    if (-1 < inc && inc < 1)

-	return TRUE;

-

-    return FALSE;

-}

-

-static uint32_t *

-linear_get_scanline_narrow (pixman_iter_t  *iter,

-			    const uint32_t *mask)

-{

-    pixman_image_t *image  = iter->image;

-    int             x      = iter->x;

-    int             y      = iter->y;

-    int             width  = iter->width;

-    uint32_t *      buffer = iter->buffer;

-

-    pixman_vector_t v, unit;

-    pixman_fixed_32_32_t l;

-    pixman_fixed_48_16_t dx, dy;

-    gradient_t *gradient = (gradient_t *)image;

-    linear_gradient_t *linear = (linear_gradient_t *)image;

-    uint32_t *end = buffer + width;

-    pixman_gradient_walker_t walker;

-

-    _pixman_gradient_walker_init (&walker, gradient, image->common.repeat);

-

-    /* reference point is the center of the pixel */

-    v.vector[0] = pixman_int_to_fixed (x) + pixman_fixed_1 / 2;

-    v.vector[1] = pixman_int_to_fixed (y) + pixman_fixed_1 / 2;

-    v.vector[2] = pixman_fixed_1;

-

-    if (image->common.transform)

-    {

-	if (!pixman_transform_point_3d (image->common.transform, &v))

-	    return iter->buffer;

-

-	unit.vector[0] = image->common.transform->matrix[0][0];

-	unit.vector[1] = image->common.transform->matrix[1][0];

-	unit.vector[2] = image->common.transform->matrix[2][0];

-    }

-    else

-    {

-	unit.vector[0] = pixman_fixed_1;

-	unit.vector[1] = 0;

-	unit.vector[2] = 0;

-    }

-

-    dx = linear->p2.x - linear->p1.x;

-    dy = linear->p2.y - linear->p1.y;

-

-    l = dx * dx + dy * dy;

-

-    if (l == 0 || unit.vector[2] == 0)

-    {

-	/* affine transformation only */

-        pixman_fixed_32_32_t t, next_inc;

-	double inc;

-

-	if (l == 0 || v.vector[2] == 0)

-	{

-	    t = 0;

-	    inc = 0;

-	}

-	else

-	{

-	    double invden, v2;

-

-	    invden = pixman_fixed_1 * (double) pixman_fixed_1 /

-		(l * (double) v.vector[2]);

-	    v2 = v.vector[2] * (1. / pixman_fixed_1);

-	    t = ((dx * v.vector[0] + dy * v.vector[1]) - 

-		 (dx * linear->p1.x + dy * linear->p1.y) * v2) * invden;

-	    inc = (dx * unit.vector[0] + dy * unit.vector[1]) * invden;

-	}

-	next_inc = 0;

-

-	if (((pixman_fixed_32_32_t )(inc * width)) == 0)

-	{

-	    register uint32_t color;

-

-	    color = _pixman_gradient_walker_pixel (&walker, t);

-	    while (buffer < end)

-		*buffer++ = color;

-	}

-	else

-	{

-	    int i;

-

-	    i = 0;

-	    while (buffer < end)

-	    {

-		if (!mask || *mask++)

-		{

-		    *buffer = _pixman_gradient_walker_pixel (&walker,

-							     t + next_inc);

-		}

-		i++;

-		next_inc = inc * i;

-		buffer++;

-	    }

-	}

-    }

-    else

-    {

-	/* projective transformation */

-        double t;

-

-	t = 0;

-

-	while (buffer < end)

-	{

-	    if (!mask || *mask++)

-	    {

-	        if (v.vector[2] != 0)

-		{

-		    double invden, v2;

-

-		    invden = pixman_fixed_1 * (double) pixman_fixed_1 /

-			(l * (double) v.vector[2]);

-		    v2 = v.vector[2] * (1. / pixman_fixed_1);

-		    t = ((dx * v.vector[0] + dy * v.vector[1]) - 

-			 (dx * linear->p1.x + dy * linear->p1.y) * v2) * invden;

-		}

-

-		*buffer = _pixman_gradient_walker_pixel (&walker, t);

-	    }

-

-	    ++buffer;

-

-	    v.vector[0] += unit.vector[0];

-	    v.vector[1] += unit.vector[1];

-	    v.vector[2] += unit.vector[2];

-	}

-    }

-

-    iter->y++;

-

-    return iter->buffer;

-}

-

-static uint32_t *

-linear_get_scanline_wide (pixman_iter_t *iter, const uint32_t *mask)

-{

-    uint32_t *buffer = linear_get_scanline_narrow (iter, NULL);

-

-    pixman_expand ((uint64_t *)buffer, buffer, PIXMAN_a8r8g8b8, iter->width);

-

-    return buffer;

-}

-

-void

-_pixman_linear_gradient_iter_init (pixman_image_t *image, pixman_iter_t  *iter)

-{

-    if (linear_gradient_is_horizontal (

-	    iter->image, iter->x, iter->y, iter->width, iter->height))

-    {

-	if (iter->flags & ITER_NARROW)

-	    linear_get_scanline_narrow (iter, NULL);

-	else

-	    linear_get_scanline_wide (iter, NULL);

-

-	iter->get_scanline = _pixman_iter_get_scanline_noop;

-    }

-    else

-    {

-	if (iter->flags & ITER_NARROW)

-	    iter->get_scanline = linear_get_scanline_narrow;

-	else

-	    iter->get_scanline = linear_get_scanline_wide;

-    }

-}

-

-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_image_t *image;

-    linear_gradient_t *linear;

-

-    image = _pixman_image_allocate ();

-

-    if (!image)

-	return NULL;

-

-    linear = &image->linear;

-

-    if (!_pixman_init_gradient (&linear->common, stops, n_stops))

-    {

-	free (image);

-	return NULL;

-    }

-

-    linear->p1 = *p1;

-    linear->p2 = *p2;

-

-    image->type = LINEAR;

-

-    return image;

-}

-

+/* -*- Mode: c; c-basic-offset: 4; tab-width: 8; indent-tabs-mode: t; -*- */
+/*
+ * Copyright © 2000 SuSE, Inc.
+ * Copyright © 2007 Red Hat, Inc.
+ * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc.
+ *             2005 Lars Knoll & Zack Rusin, Trolltech
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
+ * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
+ * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
+ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+ * SOFTWARE.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <stdlib.h>
+#include "pixman-private.h"
+
+static pixman_bool_t
+linear_gradient_is_horizontal (pixman_image_t *image,
+			       int             x,
+			       int             y,
+			       int             width,
+			       int             height)
+{
+    linear_gradient_t *linear = (linear_gradient_t *)image;
+    pixman_vector_t v;
+    pixman_fixed_32_32_t l;
+    pixman_fixed_48_16_t dx, dy;
+    double inc;
+
+    if (image->common.transform)
+    {
+	/* projective transformation */
+	if (image->common.transform->matrix[2][0] != 0 ||
+	    image->common.transform->matrix[2][1] != 0 ||
+	    image->common.transform->matrix[2][2] == 0)
+	{
+	    return FALSE;
+	}
+
+	v.vector[0] = image->common.transform->matrix[0][1];
+	v.vector[1] = image->common.transform->matrix[1][1];
+	v.vector[2] = image->common.transform->matrix[2][2];
+    }
+    else
+    {
+	v.vector[0] = 0;
+	v.vector[1] = pixman_fixed_1;
+	v.vector[2] = pixman_fixed_1;
+    }
+
+    dx = linear->p2.x - linear->p1.x;
+    dy = linear->p2.y - linear->p1.y;
+
+    l = dx * dx + dy * dy;
+
+    if (l == 0)
+	return FALSE;
+
+    /*
+     * compute how much the input of the gradient walked changes
+     * when moving vertically through the whole image
+     */
+    inc = height * (double) pixman_fixed_1 * pixman_fixed_1 *
+	(dx * v.vector[0] + dy * v.vector[1]) /
+	(v.vector[2] * (double) l);
+
+    /* check that casting to integer would result in 0 */
+    if (-1 < inc && inc < 1)
+	return TRUE;
+
+    return FALSE;
+}
+
+static uint32_t *
+linear_get_scanline_narrow (pixman_iter_t  *iter,
+			    const uint32_t *mask)
+{
+    pixman_image_t *image  = iter->image;
+    int             x      = iter->x;
+    int             y      = iter->y;
+    int             width  = iter->width;
+    uint32_t *      buffer = iter->buffer;
+
+    pixman_vector_t v, unit;
+    pixman_fixed_32_32_t l;
+    pixman_fixed_48_16_t dx, dy;
+    gradient_t *gradient = (gradient_t *)image;
+    linear_gradient_t *linear = (linear_gradient_t *)image;
+    uint32_t *end = buffer + width;
+    pixman_gradient_walker_t walker;
+
+    _pixman_gradient_walker_init (&walker, gradient, image->common.repeat);
+
+    /* reference point is the center of the pixel */
+    v.vector[0] = pixman_int_to_fixed (x) + pixman_fixed_1 / 2;
+    v.vector[1] = pixman_int_to_fixed (y) + pixman_fixed_1 / 2;
+    v.vector[2] = pixman_fixed_1;
+
+    if (image->common.transform)
+    {
+	if (!pixman_transform_point_3d (image->common.transform, &v))
+	    return iter->buffer;
+
+	unit.vector[0] = image->common.transform->matrix[0][0];
+	unit.vector[1] = image->common.transform->matrix[1][0];
+	unit.vector[2] = image->common.transform->matrix[2][0];
+    }
+    else
+    {
+	unit.vector[0] = pixman_fixed_1;
+	unit.vector[1] = 0;
+	unit.vector[2] = 0;
+    }
+
+    dx = linear->p2.x - linear->p1.x;
+    dy = linear->p2.y - linear->p1.y;
+
+    l = dx * dx + dy * dy;
+
+    if (l == 0 || unit.vector[2] == 0)
+    {
+	/* affine transformation only */
+        pixman_fixed_32_32_t t, next_inc;
+	double inc;
+
+	if (l == 0 || v.vector[2] == 0)
+	{
+	    t = 0;
+	    inc = 0;
+	}
+	else
+	{
+	    double invden, v2;
+
+	    invden = pixman_fixed_1 * (double) pixman_fixed_1 /
+		(l * (double) v.vector[2]);
+	    v2 = v.vector[2] * (1. / pixman_fixed_1);
+	    t = ((dx * v.vector[0] + dy * v.vector[1]) - 
+		 (dx * linear->p1.x + dy * linear->p1.y) * v2) * invden;
+	    inc = (dx * unit.vector[0] + dy * unit.vector[1]) * invden;
+	}
+	next_inc = 0;
+
+	if (((pixman_fixed_32_32_t )(inc * width)) == 0)
+	{
+	    register uint32_t color;
+
+	    color = _pixman_gradient_walker_pixel (&walker, t);
+	    while (buffer < end)
+		*buffer++ = color;
+	}
+	else
+	{
+	    int i;
+
+	    i = 0;
+	    while (buffer < end)
+	    {
+		if (!mask || *mask++)
+		{
+		    *buffer = _pixman_gradient_walker_pixel (&walker,
+							     t + next_inc);
+		}
+		i++;
+		next_inc = inc * i;
+		buffer++;
+	    }
+	}
+    }
+    else
+    {
+	/* projective transformation */
+        double t;
+
+	t = 0;
+
+	while (buffer < end)
+	{
+	    if (!mask || *mask++)
+	    {
+	        if (v.vector[2] != 0)
+		{
+		    double invden, v2;
+
+		    invden = pixman_fixed_1 * (double) pixman_fixed_1 /
+			(l * (double) v.vector[2]);
+		    v2 = v.vector[2] * (1. / pixman_fixed_1);
+		    t = ((dx * v.vector[0] + dy * v.vector[1]) - 
+			 (dx * linear->p1.x + dy * linear->p1.y) * v2) * invden;
+		}
+
+		*buffer = _pixman_gradient_walker_pixel (&walker, t);
+	    }
+
+	    ++buffer;
+
+	    v.vector[0] += unit.vector[0];
+	    v.vector[1] += unit.vector[1];
+	    v.vector[2] += unit.vector[2];
+	}
+    }
+
+    iter->y++;
+
+    return iter->buffer;
+}
+
+static uint32_t *
+linear_get_scanline_wide (pixman_iter_t *iter, const uint32_t *mask)
+{
+    uint32_t *buffer = linear_get_scanline_narrow (iter, NULL);
+
+    pixman_expand ((uint64_t *)buffer, buffer, PIXMAN_a8r8g8b8, iter->width);
+
+    return buffer;
+}
+
+void
+_pixman_linear_gradient_iter_init (pixman_image_t *image, pixman_iter_t  *iter)
+{
+    if (linear_gradient_is_horizontal (
+	    iter->image, iter->x, iter->y, iter->width, iter->height))
+    {
+	if (iter->iter_flags & ITER_NARROW)
+	    linear_get_scanline_narrow (iter, NULL);
+	else
+	    linear_get_scanline_wide (iter, NULL);
+
+	iter->get_scanline = _pixman_iter_get_scanline_noop;
+    }
+    else
+    {
+	if (iter->iter_flags & ITER_NARROW)
+	    iter->get_scanline = linear_get_scanline_narrow;
+	else
+	    iter->get_scanline = linear_get_scanline_wide;
+    }
+}
+
+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_image_t *image;
+    linear_gradient_t *linear;
+
+    image = _pixman_image_allocate ();
+
+    if (!image)
+	return NULL;
+
+    linear = &image->linear;
+
+    if (!_pixman_init_gradient (&linear->common, stops, n_stops))
+    {
+	free (image);
+	return NULL;
+    }
+
+    linear->p1 = *p1;
+    linear->p2 = *p2;
+
+    image->type = LINEAR;
+
+    return image;
+}
+
diff --git a/pixman/pixman/pixman-mmx.c b/pixman/pixman/pixman-mmx.c
index 6e292c6b2..d869c04c6 100644
--- a/pixman/pixman/pixman-mmx.c
+++ b/pixman/pixman/pixman-mmx.c
@@ -3656,19 +3656,13 @@ static void
 mmx_src_iter_init (pixman_implementation_t *imp, pixman_iter_t *iter)
 {
     pixman_image_t *image = iter->image;
-    int x = iter->x;
-    int y = iter->y;
-    int width = iter->width;
-    int height = iter->height;
 
 #define FLAGS								\
-    (FAST_PATH_STANDARD_FLAGS | FAST_PATH_ID_TRANSFORM | FAST_PATH_BITS_IMAGE)
+    (FAST_PATH_STANDARD_FLAGS | FAST_PATH_ID_TRANSFORM |		\
+     FAST_PATH_BITS_IMAGE | FAST_PATH_SAMPLES_COVER_CLIP_NEAREST)
 
-    if ((iter->flags & ITER_NARROW)				&&
-	(image->common.flags & FLAGS) == FLAGS			&&
-	x >= 0 && y >= 0					&&
-	x + width <= image->bits.width				&&
-	y + height <= image->bits.height)
+    if ((iter->iter_flags & ITER_NARROW)			&&
+	(iter->image_flags & FLAGS) == FLAGS)
     {
 	const fetcher_info_t *f;
 
@@ -3679,7 +3673,7 @@ mmx_src_iter_init (pixman_implementation_t *imp, pixman_iter_t *iter)
 		uint8_t *b = (uint8_t *)image->bits.bits;
 		int s = image->bits.rowstride * 4;
 
-		iter->bits = b + s * iter->y + x * PIXMAN_FORMAT_BPP (f->format) / 8;
+		iter->bits = b + s * iter->y + iter->x * PIXMAN_FORMAT_BPP (f->format) / 8;
 		iter->stride = s;
 
 		iter->get_scanline = f->get_scanline;
diff --git a/pixman/pixman/pixman-noop.c b/pixman/pixman/pixman-noop.c
index d835de64f..7b017e8ec 100644
--- a/pixman/pixman/pixman-noop.c
+++ b/pixman/pixman/pixman-noop.c
@@ -71,18 +71,18 @@ noop_src_iter_init (pixman_implementation_t *imp, pixman_iter_t *iter)
     {
 	iter->get_scanline = get_scanline_null;
     }
-    else if ((iter->flags & (ITER_IGNORE_ALPHA | ITER_IGNORE_RGB)) ==
+    else if ((iter->iter_flags & (ITER_IGNORE_ALPHA | ITER_IGNORE_RGB)) ==
 	     (ITER_IGNORE_ALPHA | ITER_IGNORE_RGB))
     {
 	iter->get_scanline = _pixman_iter_get_scanline_noop;
     }
     else if (image->common.extended_format_code == PIXMAN_solid		&&
-	     ((image->common.flags & (FAST_PATH_BITS_IMAGE | FAST_PATH_NO_ALPHA_MAP)) ==
+	     ((iter->image_flags & (FAST_PATH_BITS_IMAGE | FAST_PATH_NO_ALPHA_MAP)) ==
 	      (FAST_PATH_BITS_IMAGE | FAST_PATH_NO_ALPHA_MAP)))
     {
 	bits_image_t *bits = &image->bits;
 
-	if (iter->flags & ITER_NARROW)
+	if (iter->iter_flags & ITER_NARROW)
 	{
 	    uint32_t color = bits->fetch_pixel_32 (bits, 0, 0);
 	    uint32_t *buffer = iter->buffer;
@@ -104,8 +104,8 @@ noop_src_iter_init (pixman_implementation_t *imp, pixman_iter_t *iter)
 	iter->get_scanline = _pixman_iter_get_scanline_noop;
     }
     else if (image->common.extended_format_code == PIXMAN_a8r8g8b8	&&
-	     (iter->flags & ITER_NARROW)				&&
-	     (image->common.flags & FLAGS) == FLAGS			&&
+	     (iter->iter_flags & ITER_NARROW)				&&
+	     (iter->image_flags & FLAGS) == FLAGS			&&
 	     iter->x >= 0 && iter->y >= 0				&&
 	     iter->x + iter->width <= image->bits.width			&&
 	     iter->y + iter->height <= image->bits.height)
@@ -125,8 +125,8 @@ static void
 noop_dest_iter_init (pixman_implementation_t *imp, pixman_iter_t *iter)
 {
     pixman_image_t *image = iter->image;
-    uint32_t image_flags = image->common.flags;
-    uint32_t iter_flags = iter->flags;
+    uint32_t image_flags = iter->image_flags;
+    uint32_t iter_flags = iter->iter_flags;
     
     if ((image_flags & FAST_PATH_STD_DEST_FLAGS) == FAST_PATH_STD_DEST_FLAGS	&&
 	(iter_flags & ITER_NARROW) == ITER_NARROW				&&
diff --git a/pixman/pixman/pixman-private.h b/pixman/pixman/pixman-private.h
index f456bbd33..f4ca63216 100644
--- a/pixman/pixman/pixman-private.h
+++ b/pixman/pixman/pixman-private.h
@@ -218,7 +218,8 @@ struct pixman_iter_t
     int				x, y;
     int				width;
     int				height;
-    iter_flags_t		flags;
+    iter_flags_t		iter_flags;
+    uint32_t			image_flags;
 
     /* These function pointers are initialized by the implementation */
     pixman_iter_get_scanline_t	get_scanline;
@@ -516,7 +517,8 @@ _pixman_implementation_src_iter_init (pixman_implementation_t       *imp,
 				      int                            width,
 				      int                            height,
 				      uint8_t                       *buffer,
-				      iter_flags_t                   flags);
+				      iter_flags_t                   flags,
+				      uint32_t                       image_flags);
 
 void
 _pixman_implementation_dest_iter_init (pixman_implementation_t       *imp,
@@ -527,7 +529,8 @@ _pixman_implementation_dest_iter_init (pixman_implementation_t       *imp,
 				       int                            width,
 				       int                            height,
 				       uint8_t                       *buffer,
-				       iter_flags_t                   flags);
+				       iter_flags_t                   flags,
+				       uint32_t                       image_flags);
 
 /* Specific implementations */
 pixman_implementation_t *
diff --git a/pixman/pixman/pixman-radial-gradient.c b/pixman/pixman/pixman-radial-gradient.c
index b6dd6b2c7..715711fd6 100644
--- a/pixman/pixman/pixman-radial-gradient.c
+++ b/pixman/pixman/pixman-radial-gradient.c
@@ -413,7 +413,7 @@ radial_get_scanline_wide (pixman_iter_t *iter, const uint32_t *mask)
 void
 _pixman_radial_gradient_iter_init (pixman_image_t *image, pixman_iter_t *iter)
 {
-    if (iter->flags & ITER_NARROW)
+    if (iter->iter_flags & ITER_NARROW)
 	iter->get_scanline = radial_get_scanline_narrow;
     else
 	iter->get_scanline = radial_get_scanline_wide;
diff --git a/pixman/pixman/pixman-solid-fill.c b/pixman/pixman/pixman-solid-fill.c
index fcda3abb5..8b25d5d08 100644
--- a/pixman/pixman/pixman-solid-fill.c
+++ b/pixman/pixman/pixman-solid-fill.c
@@ -1,89 +1,89 @@
-/*

- * Copyright © 2000 SuSE, Inc.

- * Copyright © 2007, 2009 Red Hat, Inc.

- * Copyright © 2009 Soren Sandmann

- *

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

- * documentation for any purpose is hereby granted without fee, provided that

- * the above copyright notice appear in all copies and that both that

- * copyright notice and this permission notice appear in supporting

- * documentation, and that the name of SuSE not be used in advertising or

- * publicity pertaining to distribution of the software without specific,

- * written prior permission.  SuSE makes no representations about the

- * suitability of this software for any purpose.  It is provided "as is"

- * without express or implied warranty.

- *

- * SuSE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL

- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL SuSE

- * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION

- * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN

- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

- */

-

-#ifdef HAVE_CONFIG_H

-#include <config.h>

-#endif

-#include "pixman-private.h"

-

-void

-_pixman_solid_fill_iter_init (pixman_image_t *image, pixman_iter_t  *iter)

-{

-    if (iter->flags & ITER_NARROW)

-    {

-	uint32_t *b = (uint32_t *)iter->buffer;

-	uint32_t *e = b + iter->width;

-	uint32_t color = iter->image->solid.color_32;

-

-	while (b < e)

-	    *(b++) = color;

-    }

-    else

-    {

-	uint64_t *b = (uint64_t *)iter->buffer;

-	uint64_t *e = b + iter->width;

-	uint64_t color = image->solid.color_64;

-

-	while (b < e)

-	    *(b++) = color;

-    }

-

-    iter->get_scanline = _pixman_iter_get_scanline_noop;

-}

-

-static uint32_t

-color_to_uint32 (const pixman_color_t *color)

-{

-    return

-        (color->alpha >> 8 << 24) |

-        (color->red >> 8 << 16) |

-        (color->green & 0xff00) |

-        (color->blue >> 8);

-}

-

-static uint64_t

-color_to_uint64 (const pixman_color_t *color)

-{

-    return

-        ((uint64_t)color->alpha << 48) |

-        ((uint64_t)color->red << 32) |

-        ((uint64_t)color->green << 16) |

-        ((uint64_t)color->blue);

-}

-

-PIXMAN_EXPORT pixman_image_t *

-pixman_image_create_solid_fill (pixman_color_t *color)

-{

-    pixman_image_t *img = _pixman_image_allocate ();

-

-    if (!img)

-	return NULL;

-

-    img->type = SOLID;

-    img->solid.color = *color;

-    img->solid.color_32 = color_to_uint32 (color);

-    img->solid.color_64 = color_to_uint64 (color);

-

-    return img;

-}

-

+/*
+ * Copyright © 2000 SuSE, Inc.
+ * Copyright © 2007, 2009 Red Hat, Inc.
+ * Copyright © 2009 Soren Sandmann
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of SuSE not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  SuSE makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ * SuSE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL SuSE
+ * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "pixman-private.h"
+
+void
+_pixman_solid_fill_iter_init (pixman_image_t *image, pixman_iter_t  *iter)
+{
+    if (iter->iter_flags & ITER_NARROW)
+    {
+	uint32_t *b = (uint32_t *)iter->buffer;
+	uint32_t *e = b + iter->width;
+	uint32_t color = iter->image->solid.color_32;
+
+	while (b < e)
+	    *(b++) = color;
+    }
+    else
+    {
+	uint64_t *b = (uint64_t *)iter->buffer;
+	uint64_t *e = b + iter->width;
+	uint64_t color = image->solid.color_64;
+
+	while (b < e)
+	    *(b++) = color;
+    }
+
+    iter->get_scanline = _pixman_iter_get_scanline_noop;
+}
+
+static uint32_t
+color_to_uint32 (const pixman_color_t *color)
+{
+    return
+        (color->alpha >> 8 << 24) |
+        (color->red >> 8 << 16) |
+        (color->green & 0xff00) |
+        (color->blue >> 8);
+}
+
+static uint64_t
+color_to_uint64 (const pixman_color_t *color)
+{
+    return
+        ((uint64_t)color->alpha << 48) |
+        ((uint64_t)color->red << 32) |
+        ((uint64_t)color->green << 16) |
+        ((uint64_t)color->blue);
+}
+
+PIXMAN_EXPORT pixman_image_t *
+pixman_image_create_solid_fill (pixman_color_t *color)
+{
+    pixman_image_t *img = _pixman_image_allocate ();
+
+    if (!img)
+	return NULL;
+
+    img->type = SOLID;
+    img->solid.color = *color;
+    img->solid.color_32 = color_to_uint32 (color);
+    img->solid.color_64 = color_to_uint64 (color);
+
+    return img;
+}
+
diff --git a/pixman/pixman/pixman-sse2.c b/pixman/pixman/pixman-sse2.c
index e217ca339..70f8b77c4 100644
--- a/pixman/pixman/pixman-sse2.c
+++ b/pixman/pixman/pixman-sse2.c
@@ -5976,19 +5976,13 @@ static void
 sse2_src_iter_init (pixman_implementation_t *imp, pixman_iter_t *iter)
 {
     pixman_image_t *image = iter->image;
-    int x = iter->x;
-    int y = iter->y;
-    int width = iter->width;
-    int height = iter->height;
 
 #define FLAGS								\
-    (FAST_PATH_STANDARD_FLAGS | FAST_PATH_ID_TRANSFORM | FAST_PATH_BITS_IMAGE)
+    (FAST_PATH_STANDARD_FLAGS | FAST_PATH_ID_TRANSFORM |		\
+     FAST_PATH_BITS_IMAGE | FAST_PATH_SAMPLES_COVER_CLIP_NEAREST)
 
-    if ((iter->flags & ITER_NARROW)				&&
-	(image->common.flags & FLAGS) == FLAGS			&&
-	x >= 0 && y >= 0					&&
-	x + width <= image->bits.width				&&
-	y + height <= image->bits.height)
+    if ((iter->iter_flags & ITER_NARROW)			&&
+	(iter->image_flags & FLAGS) == FLAGS)
     {
 	const fetcher_info_t *f;
 
@@ -5999,7 +5993,7 @@ sse2_src_iter_init (pixman_implementation_t *imp, pixman_iter_t *iter)
 		uint8_t *b = (uint8_t *)image->bits.bits;
 		int s = image->bits.rowstride * 4;
 
-		iter->bits = b + s * iter->y + x * PIXMAN_FORMAT_BPP (f->format) / 8;
+		iter->bits = b + s * iter->y + iter->x * PIXMAN_FORMAT_BPP (f->format) / 8;
 		iter->stride = s;
 
 		iter->get_scanline = f->get_scanline;