svn merge ^/branches/released .

9 files changed, 2991 insertions, 3070 deletions

diff --git a/pixman/pixman/pixman-bits-image.c b/pixman/pixman/pixman-bits-image.c
index a865d719a..88c2f0eea 100644
--- a/pixman/pixman/pixman-bits-image.c
+++ b/pixman/pixman/pixman-bits-image.c
@@ -1,1608 +1,1602 @@
-/*
- * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc.
- *             2005 Lars Knoll & Zack Rusin, Trolltech
- *             2008 Aaron Plattner, NVIDIA Corporation
- * Copyright © 2000 SuSE, Inc.
- * Copyright © 2007, 2009 Red Hat, Inc.
- * Copyright © 2008 André Tupinambá <andrelrt@gmail.com>
- *
- * 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 <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "pixman-private.h"
-#include "pixman-combine32.h"
-
-/*
- * By default, just evaluate the image at 32bpp and expand.  Individual image
- * types can plug in a better scanline getter if they want to. For example
- * we  could produce smoother gradients by evaluating them at higher color
- * depth, but that's a project for the future.
- */
-static void
-_pixman_image_get_scanline_generic_64 (pixman_image_t * image,
-                                       int              x,
-                                       int              y,
-                                       int              width,
-                                       uint32_t *       buffer,
-                                       const uint32_t * mask)
-{
-    uint32_t *mask8 = NULL;
-
-    /* Contract the mask image, if one exists, so that the 32-bit fetch
-     * function can use it.
-     */
-    if (mask)
-    {
-	mask8 = pixman_malloc_ab (width, sizeof(uint32_t));
-	if (!mask8)
-	    return;
-
-	pixman_contract (mask8, (uint64_t *)mask, width);
-    }
-
-    /* Fetch the source image into the first half of buffer. */
-    image->bits.get_scanline_32 (image, x, y, width, (uint32_t*)buffer, mask8);
-
-    /* Expand from 32bpp to 64bpp in place. */
-    pixman_expand ((uint64_t *)buffer, buffer, PIXMAN_a8r8g8b8, width);
-
-    free (mask8);
-}
-
-/* Fetch functions */
-
-static force_inline uint32_t
-fetch_pixel_no_alpha (bits_image_t *image,
-		      int x, int y, pixman_bool_t check_bounds)
-{
-    if (check_bounds &&
-	(x < 0 || x >= image->width || y < 0 || y >= image->height))
-    {
-	return 0;
-    }
-
-    return image->fetch_pixel_32 (image, x, y);
-}
-
-typedef uint32_t (* get_pixel_t) (bits_image_t *image,
-				  int x, int y, pixman_bool_t check_bounds);
-
-static force_inline void
-repeat (pixman_repeat_t repeat, int size, int *coord)
-{
-    switch (repeat)
-    {
-    case PIXMAN_REPEAT_NORMAL:
-	*coord = MOD (*coord, size);
-	break;
-
-    case PIXMAN_REPEAT_PAD:
-	*coord = CLIP (*coord, 0, size - 1);
-	break;
-
-    case PIXMAN_REPEAT_REFLECT:
-	*coord = MOD (*coord, size * 2);
-
-	if (*coord >= size)
-	    *coord = size * 2 - *coord - 1;
-	break;
-
-    case PIXMAN_REPEAT_NONE:
-	break;
-
-    default:
-        break;
-    }
-}
-
-static force_inline uint32_t
-bits_image_fetch_pixel_nearest (bits_image_t   *image,
-				pixman_fixed_t  x,
-				pixman_fixed_t  y,
-				get_pixel_t	get_pixel)
-{
-    int x0 = pixman_fixed_to_int (x - pixman_fixed_e);
-    int y0 = pixman_fixed_to_int (y - pixman_fixed_e);
-
-    if (image->common.repeat != PIXMAN_REPEAT_NONE)
-    {
-	repeat (image->common.repeat, image->width, &x0);
-	repeat (image->common.repeat, image->height, &y0);
-
-	return get_pixel (image, x0, y0, FALSE);
-    }
-    else
-    {
-	return get_pixel (image, x0, y0, TRUE);
-    }
-}
-
-#if SIZEOF_LONG > 4
-
-static force_inline uint32_t
-bilinear_interpolation (uint32_t tl, uint32_t tr,
-			uint32_t bl, uint32_t br,
-			int distx, int disty)
-{
-    uint64_t distxy, distxiy, distixy, distixiy;
-    uint64_t tl64, tr64, bl64, br64;
-    uint64_t f, r;
-
-    distxy = distx * disty;
-    distxiy = distx * (256 - disty);
-    distixy = (256 - distx) * disty;
-    distixiy = (256 - distx) * (256 - disty);
-
-    /* Alpha and Blue */
-    tl64 = tl & 0xff0000ff;
-    tr64 = tr & 0xff0000ff;
-    bl64 = bl & 0xff0000ff;
-    br64 = br & 0xff0000ff;
-
-    f = tl64 * distixiy + tr64 * distxiy + bl64 * distixy + br64 * distxy;
-    r = f & 0x0000ff0000ff0000ull;
-
-    /* Red and Green */
-    tl64 = tl;
-    tl64 = ((tl64 << 16) & 0x000000ff00000000ull) | (tl64 & 0x0000ff00ull);
-
-    tr64 = tr;
-    tr64 = ((tr64 << 16) & 0x000000ff00000000ull) | (tr64 & 0x0000ff00ull);
-
-    bl64 = bl;
-    bl64 = ((bl64 << 16) & 0x000000ff00000000ull) | (bl64 & 0x0000ff00ull);
-
-    br64 = br;
-    br64 = ((br64 << 16) & 0x000000ff00000000ull) | (br64 & 0x0000ff00ull);
-
-    f = tl64 * distixiy + tr64 * distxiy + bl64 * distixy + br64 * distxy;
-    r |= ((f >> 16) & 0x000000ff00000000ull) | (f & 0xff000000ull);
-
-    return (uint32_t)(r >> 16);
-}
-
-#else
-
-static force_inline uint32_t
-bilinear_interpolation (uint32_t tl, uint32_t tr,
-			uint32_t bl, uint32_t br,
-			int distx, int disty)
-{
-    int distxy, distxiy, distixy, distixiy;
-    uint32_t f, r;
-
-    distxy = distx * disty;
-    distxiy = (distx << 8) - distxy;	/* distx * (256 - disty) */
-    distixy = (disty << 8) - distxy;	/* disty * (256 - distx) */
-    distixiy =
-	256 * 256 - (disty << 8) -
-	(distx << 8) + distxy;		/* (256 - distx) * (256 - disty) */
-
-    /* Blue */
-    r = (tl & 0x000000ff) * distixiy + (tr & 0x000000ff) * distxiy
-      + (bl & 0x000000ff) * distixy  + (br & 0x000000ff) * distxy;
-
-    /* Green */
-    f = (tl & 0x0000ff00) * distixiy + (tr & 0x0000ff00) * distxiy
-      + (bl & 0x0000ff00) * distixy  + (br & 0x0000ff00) * distxy;
-    r |= f & 0xff000000;
-
-    tl >>= 16;
-    tr >>= 16;
-    bl >>= 16;
-    br >>= 16;
-    r >>= 16;
-
-    /* Red */
-    f = (tl & 0x000000ff) * distixiy + (tr & 0x000000ff) * distxiy
-      + (bl & 0x000000ff) * distixy  + (br & 0x000000ff) * distxy;
-    r |= f & 0x00ff0000;
-
-    /* Alpha */
-    f = (tl & 0x0000ff00) * distixiy + (tr & 0x0000ff00) * distxiy
-      + (bl & 0x0000ff00) * distixy  + (br & 0x0000ff00) * distxy;
-    r |= f & 0xff000000;
-
-    return r;
-}
-
-#endif
-
-static force_inline uint32_t
-bits_image_fetch_pixel_bilinear (bits_image_t   *image,
-				 pixman_fixed_t  x,
-				 pixman_fixed_t  y,
-				 get_pixel_t	 get_pixel)
-{
-    pixman_repeat_t repeat_mode = image->common.repeat;
-    int width = image->width;
-    int height = image->height;
-    int x1, y1, x2, y2;
-    uint32_t tl, tr, bl, br;
-    int32_t distx, disty;
-
-    x1 = x - pixman_fixed_1 / 2;
-    y1 = y - pixman_fixed_1 / 2;
-
-    distx = (x1 >> 8) & 0xff;
-    disty = (y1 >> 8) & 0xff;
-
-    x1 = pixman_fixed_to_int (x1);
-    y1 = pixman_fixed_to_int (y1);
-    x2 = x1 + 1;
-    y2 = y1 + 1;
-
-    if (repeat_mode != PIXMAN_REPEAT_NONE)
-    {
-	repeat (repeat_mode, width, &x1);
-	repeat (repeat_mode, height, &y1);
-	repeat (repeat_mode, width, &x2);
-	repeat (repeat_mode, height, &y2);
-
-	tl = get_pixel (image, x1, y1, FALSE);
-	bl = get_pixel (image, x1, y2, FALSE);
-	tr = get_pixel (image, x2, y1, FALSE);
-	br = get_pixel (image, x2, y2, FALSE);
-    }
-    else
-    {
-	tl = get_pixel (image, x1, y1, TRUE);
-	tr = get_pixel (image, x2, y1, TRUE);
-	bl = get_pixel (image, x1, y2, TRUE);
-	br = get_pixel (image, x2, y2, TRUE);
-    }
-
-    return bilinear_interpolation (tl, tr, bl, br, distx, disty);
-}
-
-static void
-bits_image_fetch_bilinear_no_repeat_8888 (pixman_image_t * ima,
-					  int              offset,
-					  int              line,
-					  int              width,
-					  uint32_t *       buffer,
-					  const uint32_t * mask)
-{
-    bits_image_t *bits = &ima->bits;
-    pixman_fixed_t x_top, x_bottom, x;
-    pixman_fixed_t ux_top, ux_bottom, ux;
-    pixman_vector_t v;
-    uint32_t top_mask, bottom_mask;
-    uint32_t *top_row;
-    uint32_t *bottom_row;
-    uint32_t *end;
-    uint32_t zero[2] = { 0, 0 };
-    uint32_t one = 1;
-    int y, y1, y2;
-    int disty;
-    int mask_inc;
-    int w;
-
-    /* reference point is the center of the pixel */
-    v.vector[0] = pixman_int_to_fixed (offset) + pixman_fixed_1 / 2;
-    v.vector[1] = pixman_int_to_fixed (line) + pixman_fixed_1 / 2;
-    v.vector[2] = pixman_fixed_1;
-
-    if (!pixman_transform_point_3d (bits->common.transform, &v))
-	return;
-
-    ux = ux_top = ux_bottom = bits->common.transform->matrix[0][0];
-    x = x_top = x_bottom = v.vector[0] - pixman_fixed_1/2;
-
-    y = v.vector[1] - pixman_fixed_1/2;
-    disty = (y >> 8) & 0xff;
-
-    /* Load the pointers to the first and second lines from the source
-     * image that bilinear code must read.
-     *
-     * The main trick in this code is about the check if any line are
-     * outside of the image;
-     *
-     * When I realize that a line (any one) is outside, I change
-     * the pointer to a dummy area with zeros. Once I change this, I
-     * must be sure the pointer will not change, so I set the
-     * variables to each pointer increments inside the loop.
-     */
-    y1 = pixman_fixed_to_int (y);
-    y2 = y1 + 1;
-
-    if (y1 < 0 || y1 >= bits->height)
-    {
-	top_row = zero;
-	x_top = 0;
-	ux_top = 0;
-    }
-    else
-    {
-	top_row = bits->bits + y1 * bits->rowstride;
-	x_top = x;
-	ux_top = ux;
-    }
-
-    if (y2 < 0 || y2 >= bits->height)
-    {
-	bottom_row = zero;
-	x_bottom = 0;
-	ux_bottom = 0;
-    }
-    else
-    {
-	bottom_row = bits->bits + y2 * bits->rowstride;
-	x_bottom = x;
-	ux_bottom = ux;
-    }
-
-    /* Instead of checking whether the operation uses the mast in
-     * each loop iteration, verify this only once and prepare the
-     * variables to make the code smaller inside the loop.
-     */
-    if (!mask)
-    {
-        mask_inc = 0;
-        mask = &one;
-    }
-    else
-    {
-        /* If have a mask, prepare the variables to check it */
-        mask_inc = 1;
-    }
-
-    /* If both are zero, then the whole thing is zero */
-    if (top_row == zero && bottom_row == zero)
-    {
-	memset (buffer, 0, width * sizeof (uint32_t));
-	return;
-    }
-    else if (bits->format == PIXMAN_x8r8g8b8)
-    {
-	if (top_row == zero)
-	{
-	    top_mask = 0;
-	    bottom_mask = 0xff000000;
-	}
-	else if (bottom_row == zero)
-	{
-	    top_mask = 0xff000000;
-	    bottom_mask = 0;
-	}
-	else
-	{
-	    top_mask = 0xff000000;
-	    bottom_mask = 0xff000000;
-	}
-    }
-    else
-    {
-	top_mask = 0;
-	bottom_mask = 0;
-    }
-
-    end = buffer + width;
-
-    /* Zero fill to the left of the image */
-    while (buffer < end && x < pixman_fixed_minus_1)
-    {
-	*buffer++ = 0;
-	x += ux;
-	x_top += ux_top;
-	x_bottom += ux_bottom;
-	mask += mask_inc;
-    }
-
-    /* Left edge
-     */
-    while (buffer < end && x < 0)
-    {
-	uint32_t tr, br;
-	int32_t distx;
-
-	tr = top_row[pixman_fixed_to_int (x_top) + 1] | top_mask;
-	br = bottom_row[pixman_fixed_to_int (x_bottom) + 1] | bottom_mask;
-
-	distx = (x >> 8) & 0xff;
-
-	*buffer++ = bilinear_interpolation (0, tr, 0, br, distx, disty);
-
-	x += ux;
-	x_top += ux_top;
-	x_bottom += ux_bottom;
-	mask += mask_inc;
-    }
-
-    /* Main part */
-    w = pixman_int_to_fixed (bits->width - 1);
-
-    while (buffer < end  &&  x < w)
-    {
-	if (*mask)
-	{
-	    uint32_t tl, tr, bl, br;
-	    int32_t distx;
-
-	    tl = top_row [pixman_fixed_to_int (x_top)] | top_mask;
-	    tr = top_row [pixman_fixed_to_int (x_top) + 1] | top_mask;
-	    bl = bottom_row [pixman_fixed_to_int (x_bottom)] | bottom_mask;
-	    br = bottom_row [pixman_fixed_to_int (x_bottom) + 1] | bottom_mask;
-
-	    distx = (x >> 8) & 0xff;
-
-	    *buffer = bilinear_interpolation (tl, tr, bl, br, distx, disty);
-	}
-
-	buffer++;
-	x += ux;
-	x_top += ux_top;
-	x_bottom += ux_bottom;
-	mask += mask_inc;
-    }
-
-    /* Right Edge */
-    w = pixman_int_to_fixed (bits->width);
-    while (buffer < end  &&  x < w)
-    {
-	if (*mask)
-	{
-	    uint32_t tl, bl;
-	    int32_t distx;
-
-	    tl = top_row [pixman_fixed_to_int (x_top)] | top_mask;
-	    bl = bottom_row [pixman_fixed_to_int (x_bottom)] | bottom_mask;
-
-	    distx = (x >> 8) & 0xff;
-
-	    *buffer = bilinear_interpolation (tl, 0, bl, 0, distx, disty);
-	}
-
-	buffer++;
-	x += ux;
-	x_top += ux_top;
-	x_bottom += ux_bottom;
-	mask += mask_inc;
-    }
-
-    /* Zero fill to the left of the image */
-    while (buffer < end)
-	*buffer++ = 0;
-}
-
-static force_inline uint32_t
-bits_image_fetch_pixel_convolution (bits_image_t   *image,
-				    pixman_fixed_t  x,
-				    pixman_fixed_t  y,
-				    get_pixel_t     get_pixel)
-{
-    pixman_fixed_t *params = image->common.filter_params;
-    int x_off = (params[0] - pixman_fixed_1) >> 1;
-    int y_off = (params[1] - pixman_fixed_1) >> 1;
-    int32_t cwidth = pixman_fixed_to_int (params[0]);
-    int32_t cheight = pixman_fixed_to_int (params[1]);
-    int32_t srtot, sgtot, sbtot, satot;
-    int32_t i, j, x1, x2, y1, y2;
-    pixman_repeat_t repeat_mode = image->common.repeat;
-    int width = image->width;
-    int height = image->height;
-
-    params += 2;
-
-    x1 = pixman_fixed_to_int (x - pixman_fixed_e - x_off);
-    y1 = pixman_fixed_to_int (y - pixman_fixed_e - y_off);
-    x2 = x1 + cwidth;
-    y2 = y1 + cheight;
-
-    srtot = sgtot = sbtot = satot = 0;
-
-    for (i = y1; i < y2; ++i)
-    {
-	for (j = x1; j < x2; ++j)
-	{
-	    int rx = j;
-	    int ry = i;
-
-	    pixman_fixed_t f = *params;
-
-	    if (f)
-	    {
-		uint32_t pixel;
-
-		if (repeat_mode != PIXMAN_REPEAT_NONE)
-		{
-		    repeat (repeat_mode, width, &rx);
-		    repeat (repeat_mode, height, &ry);
-
-		    pixel = get_pixel (image, rx, ry, FALSE);
-		}
-		else
-		{
-		    pixel = get_pixel (image, rx, ry, TRUE);
-		}
-
-		srtot += RED_8 (pixel) * f;
-		sgtot += GREEN_8 (pixel) * f;
-		sbtot += BLUE_8 (pixel) * f;
-		satot += ALPHA_8 (pixel) * f;
-	    }
-
-	    params++;
-	}
-    }
-
-    satot >>= 16;
-    srtot >>= 16;
-    sgtot >>= 16;
-    sbtot >>= 16;
-
-    satot = CLIP (satot, 0, 0xff);
-    srtot = CLIP (srtot, 0, 0xff);
-    sgtot = CLIP (sgtot, 0, 0xff);
-    sbtot = CLIP (sbtot, 0, 0xff);
-
-    return ((satot << 24) | (srtot << 16) | (sgtot <<  8) | (sbtot));
-}
-
-static force_inline uint32_t
-bits_image_fetch_pixel_filtered (bits_image_t *image,
-				 pixman_fixed_t x,
-				 pixman_fixed_t y,
-				 get_pixel_t    get_pixel)
-{
-    switch (image->common.filter)
-    {
-    case PIXMAN_FILTER_NEAREST:
-    case PIXMAN_FILTER_FAST:
-	return bits_image_fetch_pixel_nearest (image, x, y, get_pixel);
-	break;
-
-    case PIXMAN_FILTER_BILINEAR:
-    case PIXMAN_FILTER_GOOD:
-    case PIXMAN_FILTER_BEST:
-	return bits_image_fetch_pixel_bilinear (image, x, y, get_pixel);
-	break;
-
-    case PIXMAN_FILTER_CONVOLUTION:
-	return bits_image_fetch_pixel_convolution (image, x, y, get_pixel);
-	break;
-
-    default:
-        break;
-    }
-
-    return 0;
-}
-
-static void
-bits_image_fetch_affine_no_alpha (pixman_image_t * image,
-				  int              offset,
-				  int              line,
-				  int              width,
-				  uint32_t *       buffer,
-				  const uint32_t * mask)
-{
-    pixman_fixed_t x, y;
-    pixman_fixed_t ux, uy;
-    pixman_vector_t v;
-    int i;
-
-    /* reference point is the center of the pixel */
-    v.vector[0] = pixman_int_to_fixed (offset) + pixman_fixed_1 / 2;
-    v.vector[1] = pixman_int_to_fixed (line) + pixman_fixed_1 / 2;
-    v.vector[2] = pixman_fixed_1;
-
-    if (image->common.transform)
-    {
-	if (!pixman_transform_point_3d (image->common.transform, &v))
-	    return;
-
-	ux = image->common.transform->matrix[0][0];
-	uy = image->common.transform->matrix[1][0];
-    }
-    else
-    {
-	ux = pixman_fixed_1;
-	uy = 0;
-    }
-
-    x = v.vector[0];
-    y = v.vector[1];
-
-    for (i = 0; i < width; ++i)
-    {
-	if (!mask || mask[i])
-	{
-	    buffer[i] = bits_image_fetch_pixel_filtered (
-		&image->bits, x, y, fetch_pixel_no_alpha);
-	}
-
-	x += ux;
-	y += uy;
-    }
-}
-
-/* General fetcher */
-static force_inline uint32_t
-fetch_pixel_general (bits_image_t *image, int x, int y, pixman_bool_t check_bounds)
-{
-    uint32_t pixel;
-
-    if (check_bounds &&
-	(x < 0 || x >= image->width || y < 0 || y >= image->height))
-    {
-	return 0;
-    }
-
-    pixel = image->fetch_pixel_32 (image, x, y);
-
-    if (image->common.alpha_map)
-    {
-	uint32_t pixel_a;
-
-	x -= image->common.alpha_origin_x;
-	y -= image->common.alpha_origin_y;
-
-	if (x < 0 || x >= image->common.alpha_map->width ||
-	    y < 0 || y >= image->common.alpha_map->height)
-	{
-	    pixel_a = 0;
-	}
-	else
-	{
-	    pixel_a = image->common.alpha_map->fetch_pixel_32 (
-		image->common.alpha_map, x, y);
-
-	    pixel_a = ALPHA_8 (pixel_a);
-	}
-
-	pixel &= 0x00ffffff;
-	pixel |= (pixel_a << 24);
-    }
-
-    return pixel;
-}
-
-static void
-bits_image_fetch_general (pixman_image_t * image,
-			  int              offset,
-			  int              line,
-			  int              width,
-			  uint32_t *       buffer,
-			  const uint32_t * mask)
-{
-    pixman_fixed_t x, y, w;
-    pixman_fixed_t ux, uy, uw;
-    pixman_vector_t v;
-    int i;
-
-    /* reference point is the center of the pixel */
-    v.vector[0] = pixman_int_to_fixed (offset) + pixman_fixed_1 / 2;
-    v.vector[1] = pixman_int_to_fixed (line) + pixman_fixed_1 / 2;
-    v.vector[2] = pixman_fixed_1;
-
-    if (image->common.transform)
-    {
-	if (!pixman_transform_point_3d (image->common.transform, &v))
-	    return;
-
-	ux = image->common.transform->matrix[0][0];
-	uy = image->common.transform->matrix[1][0];
-	uw = image->common.transform->matrix[2][0];
-    }
-    else
-    {
-	ux = pixman_fixed_1;
-	uy = 0;
-	uw = 0;
-    }
-
-    x = v.vector[0];
-    y = v.vector[1];
-    w = v.vector[2];
-
-    for (i = 0; i < width; ++i)
-    {
-	pixman_fixed_t x0, y0;
-
-	if (!mask || mask[i])
-	{
-	    if (w != 0)
-	    {
-		x0 = ((pixman_fixed_48_16_t)x << 16) / w;
-		y0 = ((pixman_fixed_48_16_t)y << 16) / w;
-	    }
-	    else
-	    {
-		x0 = 0;
-		y0 = 0;
-	    }
-
-	    buffer[i] = bits_image_fetch_pixel_filtered (
-		&image->bits, x0, y0, fetch_pixel_general);
-	}
-
-	x += ux;
-	y += uy;
-	w += uw;
-    }
-}
-
-static const uint8_t zero[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
-
-typedef uint32_t (* convert_pixel_t) (const uint8_t *row, int x);
-
-static force_inline void
-bits_image_fetch_bilinear_affine (pixman_image_t * image,
-				  int              offset,
-				  int              line,
-				  int              width,
-				  uint32_t *       buffer,
-				  const uint32_t * mask,
-
-				  convert_pixel_t	convert_pixel,
-				  pixman_format_code_t	format,
-				  pixman_repeat_t	repeat_mode)
-{
-    pixman_fixed_t x, y;
-    pixman_fixed_t ux, uy;
-    pixman_vector_t v;
-    bits_image_t *bits = &image->bits;
-    int i;
-
-    /* reference point is the center of the pixel */
-    v.vector[0] = pixman_int_to_fixed (offset) + pixman_fixed_1 / 2;
-    v.vector[1] = pixman_int_to_fixed (line) + pixman_fixed_1 / 2;
-    v.vector[2] = pixman_fixed_1;
-
-    if (!pixman_transform_point_3d (image->common.transform, &v))
-	return;
-
-    ux = image->common.transform->matrix[0][0];
-    uy = image->common.transform->matrix[1][0];
-
-    x = v.vector[0];
-    y = v.vector[1];
-
-    for (i = 0; i < width; ++i)
-    {
-	int x1, y1, x2, y2;
-	uint32_t tl, tr, bl, br;
-	int32_t distx, disty;
-	int width = image->bits.width;
-	int height = image->bits.height;
-	const uint8_t *row1;
-	const uint8_t *row2;
-
-	if (mask && !mask[i])
-	    goto next;
-
-	x1 = x - pixman_fixed_1 / 2;
-	y1 = y - pixman_fixed_1 / 2;
-
-	distx = (x1 >> 8) & 0xff;
-	disty = (y1 >> 8) & 0xff;
-
-	y1 = pixman_fixed_to_int (y1);
-	y2 = y1 + 1;
-	x1 = pixman_fixed_to_int (x1);
-	x2 = x1 + 1;
-
-	if (repeat_mode != PIXMAN_REPEAT_NONE)
-	{
-	    uint32_t mask;
-
-	    mask = PIXMAN_FORMAT_A (format)? 0 : 0xff000000;
-
-	    repeat (repeat_mode, width, &x1);
-	    repeat (repeat_mode, height, &y1);
-	    repeat (repeat_mode, width, &x2);
-	    repeat (repeat_mode, height, &y2);
-
-	    row1 = (uint8_t *)bits->bits + bits->rowstride * 4 * y1;
-	    row2 = (uint8_t *)bits->bits + bits->rowstride * 4 * y2;
-
-	    tl = convert_pixel (row1, x1) | mask;
-	    tr = convert_pixel (row1, x2) | mask;
-	    bl = convert_pixel (row2, x1) | mask;
-	    br = convert_pixel (row2, x2) | mask;
-	}
-	else
-	{
-	    uint32_t mask1, mask2;
-	    int bpp;
-
-	    /* Note: PIXMAN_FORMAT_BPP() returns an unsigned value,
-	     * which means if you use it in expressions, those
-	     * expressions become unsigned themselves. Since
-	     * the variables below can be negative in some cases,
-	     * that will lead to crashes on 64 bit architectures.
-	     *
-	     * So this line makes sure bpp is signed
-	     */
-	    bpp = PIXMAN_FORMAT_BPP (format);
-
-	    if (x1 >= width || x2 < 0 || y1 >= height || y2 < 0)
-	    {
-		buffer[i] = 0;
-		goto next;
-	    }
-
-	    if (y2 == 0)
-	    {
-		row1 = zero;
-		mask1 = 0;
-	    }
-	    else
-	    {
-		row1 = (uint8_t *)bits->bits + bits->rowstride * 4 * y1;
-		row1 += bpp / 8 * x1;
-
-		mask1 = PIXMAN_FORMAT_A (format)? 0 : 0xff000000;
-	    }
-
-	    if (y1 == height - 1)
-	    {
-		row2 = zero;
-		mask2 = 0;
-	    }
-	    else
-	    {
-		row2 = (uint8_t *)bits->bits + bits->rowstride * 4 * y2;
-		row2 += bpp / 8 * x1;
-
-		mask2 = PIXMAN_FORMAT_A (format)? 0 : 0xff000000;
-	    }
-
-	    if (x2 == 0)
-	    {
-		tl = 0;
-		bl = 0;
-	    }
-	    else
-	    {
-		tl = convert_pixel (row1, 0) | mask1;
-		bl = convert_pixel (row2, 0) | mask2;
-	    }
-
-	    if (x1 == width - 1)
-	    {
-		tr = 0;
-		br = 0;
-	    }
-	    else
-	    {
-		tr = convert_pixel (row1, 1) | mask1;
-		br = convert_pixel (row2, 1) | mask2;
-	    }
-	}
-
-	buffer[i] = bilinear_interpolation (
-	    tl, tr, bl, br, distx, disty);
-
-    next:
-	x += ux;
-	y += uy;
-    }
-}
-
-static force_inline void
-bits_image_fetch_nearest_affine (pixman_image_t * image,
-				 int              offset,
-				 int              line,
-				 int              width,
-				 uint32_t *       buffer,
-				 const uint32_t * mask,
-				 
-				 convert_pixel_t	convert_pixel,
-				 pixman_format_code_t	format,
-				 pixman_repeat_t	repeat_mode)
-{
-    pixman_fixed_t x, y;
-    pixman_fixed_t ux, uy;
-    pixman_vector_t v;
-    bits_image_t *bits = &image->bits;
-    int i;
-
-    /* reference point is the center of the pixel */
-    v.vector[0] = pixman_int_to_fixed (offset) + pixman_fixed_1 / 2;
-    v.vector[1] = pixman_int_to_fixed (line) + pixman_fixed_1 / 2;
-    v.vector[2] = pixman_fixed_1;
-
-    if (!pixman_transform_point_3d (image->common.transform, &v))
-	return;
-
-    ux = image->common.transform->matrix[0][0];
-    uy = image->common.transform->matrix[1][0];
-
-    x = v.vector[0];
-    y = v.vector[1];
-
-    for (i = 0; i < width; ++i)
-    {
-	int width, height, x0, y0;
-	const uint8_t *row;
-
-	if (mask && !mask[i])
-	    goto next;
-	
-	width = image->bits.width;
-	height = image->bits.height;
-	x0 = pixman_fixed_to_int (x - pixman_fixed_e);
-	y0 = pixman_fixed_to_int (y - pixman_fixed_e);
-
-	if (repeat_mode == PIXMAN_REPEAT_NONE &&
-	    (y0 < 0 || y0 >= height || x0 < 0 || x0 >= width))
-	{
-	    buffer[i] = 0;
-	}
-	else
-	{
-	    uint32_t mask = PIXMAN_FORMAT_A (format)? 0 : 0xff000000;
-
-	    if (repeat_mode != PIXMAN_REPEAT_NONE)
-	    {
-		repeat (repeat_mode, width, &x0);
-		repeat (repeat_mode, height, &y0);
-	    }
-
-	    row = (uint8_t *)bits->bits + bits->rowstride * 4 * y0;
-
-	    buffer[i] = convert_pixel (row, x0) | mask;
-	}
-
-    next:
-	x += ux;
-	y += uy;
-    }
-}
-
-static force_inline uint32_t
-convert_a8r8g8b8 (const uint8_t *row, int x)
-{
-    return *(((uint32_t *)row) + x);
-}
-
-static force_inline uint32_t
-convert_x8r8g8b8 (const uint8_t *row, int x)
-{
-    return *(((uint32_t *)row) + x);
-}
-
-static force_inline uint32_t
-convert_a8 (const uint8_t *row, int x)
-{
-    return *(row + x) << 24;
-}
-
-static force_inline uint32_t
-convert_r5g6b5 (const uint8_t *row, int x)
-{
-    return CONVERT_0565_TO_0888 (*((uint16_t *)row + x));
-}
-
-#define MAKE_BILINEAR_FETCHER(name, format, repeat_mode)		\
-    static void								\
-    bits_image_fetch_bilinear_affine_ ## name (pixman_image_t *image,	\
-					       int              offset,	\
-					       int              line,	\
-					       int              width,	\
-					       uint32_t *       buffer,	\
-					       const uint32_t * mask)	\
-    {									\
-	bits_image_fetch_bilinear_affine (image, offset, line,		\
-					  width, buffer, mask,		\
-					  convert_ ## format,		\
-					  PIXMAN_ ## format,		\
-					  repeat_mode);			\
-    }
-
-#define MAKE_NEAREST_FETCHER(name, format, repeat_mode)			\
-    static void								\
-    bits_image_fetch_nearest_affine_ ## name (pixman_image_t *image,	\
-					      int              offset,	\
-					      int              line,	\
-					      int              width,	\
-					      uint32_t *       buffer,	\
-					      const uint32_t * mask)	\
-    {									\
-	bits_image_fetch_nearest_affine (image, offset, line,		\
-					 width, buffer, mask,		\
-					 convert_ ## format,		\
-					 PIXMAN_ ## format,		\
-					 repeat_mode);			\
-    }
-
-#define MAKE_FETCHERS(name, format, repeat_mode)			\
-    MAKE_NEAREST_FETCHER (name, format, repeat_mode)			\
-    MAKE_BILINEAR_FETCHER (name, format, repeat_mode)
-
-MAKE_FETCHERS (pad_a8r8g8b8,     a8r8g8b8, PIXMAN_REPEAT_PAD)
-MAKE_FETCHERS (none_a8r8g8b8,    a8r8g8b8, PIXMAN_REPEAT_NONE)
-MAKE_FETCHERS (reflect_a8r8g8b8, a8r8g8b8, PIXMAN_REPEAT_REFLECT)
-MAKE_FETCHERS (normal_a8r8g8b8,  a8r8g8b8, PIXMAN_REPEAT_NORMAL)
-MAKE_FETCHERS (pad_x8r8g8b8,     x8r8g8b8, PIXMAN_REPEAT_PAD)
-MAKE_FETCHERS (none_x8r8g8b8,    x8r8g8b8, PIXMAN_REPEAT_NONE)
-MAKE_FETCHERS (reflect_x8r8g8b8, x8r8g8b8, PIXMAN_REPEAT_REFLECT)
-MAKE_FETCHERS (normal_x8r8g8b8,  x8r8g8b8, PIXMAN_REPEAT_NORMAL)
-MAKE_FETCHERS (pad_a8,           a8,       PIXMAN_REPEAT_PAD)
-MAKE_FETCHERS (none_a8,          a8,       PIXMAN_REPEAT_NONE)
-MAKE_FETCHERS (reflect_a8,	 a8,       PIXMAN_REPEAT_REFLECT)
-MAKE_FETCHERS (normal_a8,	 a8,       PIXMAN_REPEAT_NORMAL)
-MAKE_FETCHERS (pad_r5g6b5,       r5g6b5,   PIXMAN_REPEAT_PAD)
-MAKE_FETCHERS (none_r5g6b5,      r5g6b5,   PIXMAN_REPEAT_NONE)
-MAKE_FETCHERS (reflect_r5g6b5,   r5g6b5,   PIXMAN_REPEAT_REFLECT)
-MAKE_FETCHERS (normal_r5g6b5,    r5g6b5,   PIXMAN_REPEAT_NORMAL)
-
-static void
-bits_image_fetch_solid_32 (pixman_image_t * image,
-                           int              x,
-                           int              y,
-                           int              width,
-                           uint32_t *       buffer,
-                           const uint32_t * mask)
-{
-    uint32_t color;
-    uint32_t *end;
-
-    color = image->bits.fetch_pixel_32 (&image->bits, 0, 0);
-
-    end = buffer + width;
-    while (buffer < end)
-	*(buffer++) = color;
-}
-
-static void
-bits_image_fetch_solid_64 (pixman_image_t * image,
-                           int              x,
-                           int              y,
-                           int              width,
-                           uint32_t *       b,
-                           const uint32_t * unused)
-{
-    uint64_t color;
-    uint64_t *buffer = (uint64_t *)b;
-    uint64_t *end;
-
-    color = image->bits.fetch_pixel_64 (&image->bits, 0, 0);
-
-    end = buffer + width;
-    while (buffer < end)
-	*(buffer++) = color;
-}
-
-static void
-bits_image_fetch_untransformed_repeat_none (bits_image_t *image,
-                                            pixman_bool_t wide,
-                                            int           x,
-                                            int           y,
-                                            int           width,
-                                            uint32_t *    buffer)
-{
-    uint32_t w;
-
-    if (y < 0 || y >= image->height)
-    {
-	memset (buffer, 0, width * (wide? 8 : 4));
-	return;
-    }
-
-    if (x < 0)
-    {
-	w = MIN (width, -x);
-
-	memset (buffer, 0, w * (wide ? 8 : 4));
-
-	width -= w;
-	buffer += w * (wide? 2 : 1);
-	x += w;
-    }
-
-    if (x < image->width)
-    {
-	w = MIN (width, image->width - x);
-
-	if (wide)
-	    image->fetch_scanline_64 ((pixman_image_t *)image, x, y, w, buffer, NULL);
-	else
-	    image->fetch_scanline_32 ((pixman_image_t *)image, x, y, w, buffer, NULL);
-
-	width -= w;
-	buffer += w * (wide? 2 : 1);
-	x += w;
-    }
-
-    memset (buffer, 0, width * (wide ? 8 : 4));
-}
-
-static void
-bits_image_fetch_untransformed_repeat_normal (bits_image_t *image,
-                                              pixman_bool_t wide,
-                                              int           x,
-                                              int           y,
-                                              int           width,
-                                              uint32_t *    buffer)
-{
-    uint32_t w;
-
-    while (y < 0)
-	y += image->height;
-
-    while (y >= image->height)
-	y -= image->height;
-
-    while (width)
-    {
-	while (x < 0)
-	    x += image->width;
-	while (x >= image->width)
-	    x -= image->width;
-
-	w = MIN (width, image->width - x);
-
-	if (wide)
-	    image->fetch_scanline_64 ((pixman_image_t *)image, x, y, w, buffer, NULL);
-	else
-	    image->fetch_scanline_32 ((pixman_image_t *)image, x, y, w, buffer, NULL);
-
-	buffer += w * (wide? 2 : 1);
-	x += w;
-	width -= w;
-    }
-}
-
-static void
-bits_image_fetch_untransformed_32 (pixman_image_t * image,
-                                   int              x,
-                                   int              y,
-                                   int              width,
-                                   uint32_t *       buffer,
-                                   const uint32_t * mask)
-{
-    if (image->common.repeat == PIXMAN_REPEAT_NONE)
-    {
-	bits_image_fetch_untransformed_repeat_none (
-	    &image->bits, FALSE, x, y, width, buffer);
-    }
-    else
-    {
-	bits_image_fetch_untransformed_repeat_normal (
-	    &image->bits, FALSE, x, y, width, buffer);
-    }
-}
-
-static void
-bits_image_fetch_untransformed_64 (pixman_image_t * image,
-                                   int              x,
-                                   int              y,
-                                   int              width,
-                                   uint32_t *       buffer,
-                                   const uint32_t * unused)
-{
-    if (image->common.repeat == PIXMAN_REPEAT_NONE)
-    {
-	bits_image_fetch_untransformed_repeat_none (
-	    &image->bits, TRUE, x, y, width, buffer);
-    }
-    else
-    {
-	bits_image_fetch_untransformed_repeat_normal (
-	    &image->bits, TRUE, x, y, width, buffer);
-    }
-}
-
-typedef struct
-{
-    pixman_format_code_t	format;
-    uint32_t			flags;
-    fetch_scanline_t		fetch_32;
-    fetch_scanline_t		fetch_64;
-} fetcher_info_t;
-
-static const fetcher_info_t fetcher_info[] =
-{
-    { PIXMAN_solid,
-      FAST_PATH_NO_ALPHA_MAP,
-      bits_image_fetch_solid_32,
-      bits_image_fetch_solid_64
-    },
-
-    { PIXMAN_any,
-      (FAST_PATH_NO_ALPHA_MAP			|
-       FAST_PATH_ID_TRANSFORM			|
-       FAST_PATH_NO_CONVOLUTION_FILTER		|
-       FAST_PATH_NO_PAD_REPEAT			|
-       FAST_PATH_NO_REFLECT_REPEAT),
-      bits_image_fetch_untransformed_32,
-      bits_image_fetch_untransformed_64
-    },
-
-#define FAST_BILINEAR_FLAGS						\
-    (FAST_PATH_NO_ALPHA_MAP		|				\
-     FAST_PATH_NO_ACCESSORS		|				\
-     FAST_PATH_HAS_TRANSFORM		|				\
-     FAST_PATH_AFFINE_TRANSFORM		|				\
-     FAST_PATH_X_UNIT_POSITIVE		|				\
-     FAST_PATH_Y_UNIT_ZERO		|				\
-     FAST_PATH_NONE_REPEAT		|				\
-     FAST_PATH_BILINEAR_FILTER)
-
-    { PIXMAN_a8r8g8b8,
-      FAST_BILINEAR_FLAGS,
-      bits_image_fetch_bilinear_no_repeat_8888,
-      _pixman_image_get_scanline_generic_64
-    },
-
-    { PIXMAN_x8r8g8b8,
-      FAST_BILINEAR_FLAGS,
-      bits_image_fetch_bilinear_no_repeat_8888,
-      _pixman_image_get_scanline_generic_64
-    },
-
-#define GENERAL_BILINEAR_FLAGS						\
-    (FAST_PATH_NO_ALPHA_MAP		|				\
-     FAST_PATH_NO_ACCESSORS		|				\
-     FAST_PATH_HAS_TRANSFORM		|				\
-     FAST_PATH_AFFINE_TRANSFORM		|				\
-     FAST_PATH_BILINEAR_FILTER)
-
-#define GENERAL_NEAREST_FLAGS						\
-    (FAST_PATH_NO_ALPHA_MAP		|				\
-     FAST_PATH_NO_ACCESSORS		|				\
-     FAST_PATH_HAS_TRANSFORM		|				\
-     FAST_PATH_AFFINE_TRANSFORM		|				\
-     FAST_PATH_NEAREST_FILTER)
-
-#define BILINEAR_AFFINE_FAST_PATH(name, format, repeat)			\
-    { PIXMAN_ ## format,						\
-      GENERAL_BILINEAR_FLAGS | FAST_PATH_ ## repeat ## _REPEAT,		\
-      bits_image_fetch_bilinear_affine_ ## name,			\
-      _pixman_image_get_scanline_generic_64				\
-    },
-
-#define NEAREST_AFFINE_FAST_PATH(name, format, repeat)			\
-    { PIXMAN_ ## format,						\
-      GENERAL_NEAREST_FLAGS | FAST_PATH_ ## repeat ## _REPEAT,		\
-      bits_image_fetch_nearest_affine_ ## name,			\
-      _pixman_image_get_scanline_generic_64				\
-    },
-
-#define AFFINE_FAST_PATHS(name, format, repeat)				\
-    BILINEAR_AFFINE_FAST_PATH(name, format, repeat)			\
-    NEAREST_AFFINE_FAST_PATH(name, format, repeat)
-    
-    AFFINE_FAST_PATHS (pad_a8r8g8b8, a8r8g8b8, PAD)
-    AFFINE_FAST_PATHS (none_a8r8g8b8, a8r8g8b8, NONE)
-    AFFINE_FAST_PATHS (reflect_a8r8g8b8, a8r8g8b8, REFLECT)
-    AFFINE_FAST_PATHS (normal_a8r8g8b8, a8r8g8b8, NORMAL)
-    AFFINE_FAST_PATHS (pad_x8r8g8b8, x8r8g8b8, PAD)
-    AFFINE_FAST_PATHS (none_x8r8g8b8, x8r8g8b8, NONE)
-    AFFINE_FAST_PATHS (reflect_x8r8g8b8, x8r8g8b8, REFLECT)
-    AFFINE_FAST_PATHS (normal_x8r8g8b8, x8r8g8b8, NORMAL)
-    AFFINE_FAST_PATHS (pad_a8, a8, PAD)
-    AFFINE_FAST_PATHS (none_a8, a8, NONE)
-    AFFINE_FAST_PATHS (reflect_a8, a8, REFLECT)
-    AFFINE_FAST_PATHS (normal_a8, a8, NORMAL)
-    AFFINE_FAST_PATHS (pad_r5g6b5, r5g6b5, PAD)
-    AFFINE_FAST_PATHS (none_r5g6b5, r5g6b5, NONE)
-    AFFINE_FAST_PATHS (reflect_r5g6b5, r5g6b5, REFLECT)
-    AFFINE_FAST_PATHS (normal_r5g6b5, r5g6b5, NORMAL)
-
-    /* Affine, no alpha */
-    { PIXMAN_any,
-      (FAST_PATH_NO_ALPHA_MAP | FAST_PATH_HAS_TRANSFORM | FAST_PATH_AFFINE_TRANSFORM),
-      bits_image_fetch_affine_no_alpha,
-      _pixman_image_get_scanline_generic_64
-    },
-
-    /* General */
-    { PIXMAN_any, 0, bits_image_fetch_general, _pixman_image_get_scanline_generic_64 },
-
-    { PIXMAN_null },
-};
-
-static void
-bits_image_property_changed (pixman_image_t *image)
-{
-    uint32_t flags = image->common.flags;
-    pixman_format_code_t format = image->common.extended_format_code;
-    const fetcher_info_t *info;
-
-    _pixman_bits_image_setup_accessors (&image->bits);
-
-    info = fetcher_info;
-    while (info->format != PIXMAN_null)
-    {
-	if ((info->format == format || info->format == PIXMAN_any)	&&
-	    (info->flags & flags) == info->flags)
-	{
-	    image->bits.get_scanline_32 = info->fetch_32;
-	    image->bits.get_scanline_64 = info->fetch_64;
-	    break;
-	}
-
-	info++;
-    }
-}
-
-static uint32_t *
-src_get_scanline_narrow (pixman_iter_t *iter, const uint32_t *mask)
-{
-    iter->image->bits.get_scanline_32 (
-	iter->image, iter->x, iter->y++, iter->width, iter->buffer, mask);
-
-    return iter->buffer;
-}
-
-static uint32_t *
-src_get_scanline_wide (pixman_iter_t *iter, const uint32_t *mask)
-{
-    iter->image->bits.get_scanline_64 (
-	iter->image, iter->x, iter->y++, iter->width, iter->buffer, mask);
-
-    return iter->buffer;
-}
-
-void
-_pixman_bits_image_src_iter_init (pixman_image_t *image,
-				  pixman_iter_t *iter,
-				  int x, int y, int width, int height,
-				  uint8_t *buffer, iter_flags_t flags)
-{
-    if (flags & ITER_NARROW)
-	iter->get_scanline = src_get_scanline_narrow;
-    else
-	iter->get_scanline = src_get_scanline_wide;
-}
-
-static uint32_t *
-dest_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;
-
-    image->bits.fetch_scanline_32 (image, x, y, width, buffer, mask);
-    if (image->common.alpha_map)
-    {
-	x -= image->common.alpha_origin_x;
-	y -= image->common.alpha_origin_y;
-
-	image->common.alpha_map->fetch_scanline_32 (
-	    (pixman_image_t *)image->common.alpha_map,
-	    x, y, width, buffer, mask);
-    }
-
-    return iter->buffer;
-}
-
-static uint32_t *
-dest_get_scanline_wide (pixman_iter_t *iter, const uint32_t *mask)
-{
-    bits_image_t *  image  = &iter->image->bits;
-    int             x      = iter->x;
-    int             y      = iter->y;
-    int             width  = iter->width;
-    uint32_t *	    buffer = iter->buffer;
-
-    image->fetch_scanline_64 (
-	(pixman_image_t *)image, x, y, width, buffer, mask);
-    if (image->common.alpha_map)
-    {
-	x -= image->common.alpha_origin_x;
-	y -= image->common.alpha_origin_y;
-
-	image->common.alpha_map->fetch_scanline_64 (
-	    (pixman_image_t *)image->common.alpha_map, x, y, width, buffer, mask);
-    }
-
-    return iter->buffer;
-}
-
-static void
-dest_write_back_narrow (pixman_iter_t *iter)
-{
-    bits_image_t *  image  = &iter->image->bits;
-    int             x      = iter->x;
-    int             y      = iter->y;
-    int             width  = iter->width;
-    const uint32_t *buffer = iter->buffer;
-
-    image->store_scanline_32 (image, x, y, width, buffer);
-
-    if (image->common.alpha_map)
-    {
-	x -= image->common.alpha_origin_x;
-	y -= image->common.alpha_origin_y;
-
-	image->common.alpha_map->store_scanline_32 (
-	    image->common.alpha_map, x, y, width, buffer);
-    }
-
-    iter->y++;
-}
-
-static void
-dest_write_back_wide (pixman_iter_t *iter)
-{
-    bits_image_t *  image  = &iter->image->bits;
-    int             x      = iter->x;
-    int             y      = iter->y;
-    int             width  = iter->width;
-    const uint32_t *buffer = iter->buffer;
-
-    image->store_scanline_64 (image, x, y, width, buffer);
-
-    if (image->common.alpha_map)
-    {
-	x -= image->common.alpha_origin_x;
-	y -= image->common.alpha_origin_y;
-
-	image->common.alpha_map->store_scanline_64 (
-	    image->common.alpha_map, x, y, width, buffer);
-    }
-
-    iter->y++;
-}
-
-static void
-dest_write_back_direct (pixman_iter_t *iter)
-{
-    iter->buffer += iter->image->bits.rowstride;
-}
-
-void
-_pixman_bits_image_dest_iter_init (pixman_image_t *image,
-				   pixman_iter_t *iter,
-				   int x, int y, int width, int height,
-				   uint8_t *buffer, iter_flags_t flags)
-{
-    if (flags & ITER_NARROW)
-    {
-	if (((image->common.flags &
-	      (FAST_PATH_NO_ALPHA_MAP | FAST_PATH_NO_ACCESSORS)) ==
-	     (FAST_PATH_NO_ALPHA_MAP | FAST_PATH_NO_ACCESSORS)) &&
-	    (image->bits.format == PIXMAN_a8r8g8b8	||
-	     (image->bits.format == PIXMAN_x8r8g8b8	&&
-	      (flags & ITER_LOCALIZED_ALPHA))))
-	{
-	    iter->buffer = image->bits.bits + y * image->bits.rowstride + x;
-
-	    iter->get_scanline = _pixman_iter_get_scanline_noop;
-	    iter->write_back = dest_write_back_direct;
-	}
-	else
-	{
-	    if ((flags & (ITER_IGNORE_RGB | ITER_IGNORE_ALPHA)) ==
-		(ITER_IGNORE_RGB | ITER_IGNORE_ALPHA))
-	    {
-		iter->get_scanline = _pixman_iter_get_scanline_noop;
-	    }
-	    else
-	    {
-		iter->get_scanline = dest_get_scanline_narrow;
-	    }
-
-	    iter->write_back = dest_write_back_narrow;
-	}
-    }
-    else
-    {
-	iter->get_scanline = dest_get_scanline_wide;
-	iter->write_back = dest_write_back_wide;
-    }
-}
-
-static uint32_t *
-create_bits (pixman_format_code_t format,
-             int                  width,
-             int                  height,
-             int *                rowstride_bytes)
-{
-    int stride;
-    int buf_size;
-    int bpp;
-
-    /* what follows is a long-winded way, avoiding any possibility of integer
-     * overflows, of saying:
-     * stride = ((width * bpp + 0x1f) >> 5) * sizeof (uint32_t);
-     */
-
-    bpp = PIXMAN_FORMAT_BPP (format);
-    if (pixman_multiply_overflows_int (width, bpp))
-	return NULL;
-
-    stride = width * bpp;
-    if (pixman_addition_overflows_int (stride, 0x1f))
-	return NULL;
-
-    stride += 0x1f;
-    stride >>= 5;
-
-    stride *= sizeof (uint32_t);
-
-    if (pixman_multiply_overflows_int (height, stride))
-	return NULL;
-
-    buf_size = height * stride;
-
-    if (rowstride_bytes)
-	*rowstride_bytes = stride;
-
-    return calloc (buf_size, 1);
-}
-
-PIXMAN_EXPORT pixman_image_t *
-pixman_image_create_bits (pixman_format_code_t format,
-                          int                  width,
-                          int                  height,
-                          uint32_t *           bits,
-                          int                  rowstride_bytes)
-{
-    pixman_image_t *image;
-    uint32_t *free_me = NULL;
-
-    /* must be a whole number of uint32_t's
-     */
-    return_val_if_fail (
-	bits == NULL || (rowstride_bytes % sizeof (uint32_t)) == 0, NULL);
-
-    return_val_if_fail (PIXMAN_FORMAT_BPP (format) >= PIXMAN_FORMAT_DEPTH (format), NULL);
-
-    if (!bits && width && height)
-    {
-	free_me = bits = create_bits (format, width, height, &rowstride_bytes);
-	if (!bits)
-	    return NULL;
-    }
-
-    image = _pixman_image_allocate ();
-
-    if (!image)
-    {
-	if (free_me)
-	    free (free_me);
-
-	return NULL;
-    }
-
-    image->type = BITS;
-    image->bits.format = format;
-    image->bits.width = width;
-    image->bits.height = height;
-    image->bits.bits = bits;
-    image->bits.free_me = free_me;
-    image->bits.read_func = NULL;
-    image->bits.write_func = NULL;
-
-    /* The rowstride is stored in number of uint32_t */
-    image->bits.rowstride = rowstride_bytes / (int) sizeof (uint32_t);
-
-    image->bits.indexed = NULL;
-
-    image->common.property_changed = bits_image_property_changed;
-
-    _pixman_image_reset_clip_region (image);
-
-    return image;
-}
+/*

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

+ *             2005 Lars Knoll & Zack Rusin, Trolltech

+ *             2008 Aaron Plattner, NVIDIA Corporation

+ * Copyright © 2000 SuSE, Inc.

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

+ * Copyright © 2008 André Tupinambá <andrelrt@gmail.com>

+ *

+ * 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 <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+#include "pixman-private.h"

+#include "pixman-combine32.h"

+

+/*

+ * By default, just evaluate the image at 32bpp and expand.  Individual image

+ * types can plug in a better scanline getter if they want to. For example

+ * we  could produce smoother gradients by evaluating them at higher color

+ * depth, but that's a project for the future.

+ */

+static void

+_pixman_image_get_scanline_generic_64 (pixman_image_t * image,

+                                       int              x,

+                                       int              y,

+                                       int              width,

+                                       uint32_t *       buffer,

+                                       const uint32_t * mask)

+{

+    uint32_t *mask8 = NULL;

+

+    /* Contract the mask image, if one exists, so that the 32-bit fetch

+     * function can use it.

+     */

+    if (mask)

+    {

+	mask8 = pixman_malloc_ab (width, sizeof(uint32_t));

+	if (!mask8)

+	    return;

+

+	pixman_contract (mask8, (uint64_t *)mask, width);

+    }

+

+    /* Fetch the source image into the first half of buffer. */

+    image->bits.get_scanline_32 (image, x, y, width, (uint32_t*)buffer, mask8);

+

+    /* Expand from 32bpp to 64bpp in place. */

+    pixman_expand ((uint64_t *)buffer, buffer, PIXMAN_a8r8g8b8, width);

+

+    free (mask8);

+}

+

+/* Fetch functions */

+

+static force_inline uint32_t

+fetch_pixel_no_alpha (bits_image_t *image,

+		      int x, int y, pixman_bool_t check_bounds)

+{

+    if (check_bounds &&

+	(x < 0 || x >= image->width || y < 0 || y >= image->height))

+    {

+	return 0;

+    }

+

+    return image->fetch_pixel_32 (image, x, y);

+}

+

+typedef uint32_t (* get_pixel_t) (bits_image_t *image,

+				  int x, int y, pixman_bool_t check_bounds);

+

+static force_inline void

+repeat (pixman_repeat_t repeat, int size, int *coord)

+{

+    switch (repeat)

+    {

+    case PIXMAN_REPEAT_NORMAL:

+	*coord = MOD (*coord, size);

+	break;

+

+    case PIXMAN_REPEAT_PAD:

+	*coord = CLIP (*coord, 0, size - 1);

+	break;

+

+    case PIXMAN_REPEAT_REFLECT:

+	*coord = MOD (*coord, size * 2);

+

+	if (*coord >= size)

+	    *coord = size * 2 - *coord - 1;

+	break;

+

+    case PIXMAN_REPEAT_NONE:

+	break;

+

+    default:

+        break;

+    }

+}

+

+static force_inline uint32_t

+bits_image_fetch_pixel_nearest (bits_image_t   *image,

+				pixman_fixed_t  x,

+				pixman_fixed_t  y,

+				get_pixel_t	get_pixel)

+{

+    int x0 = pixman_fixed_to_int (x - pixman_fixed_e);

+    int y0 = pixman_fixed_to_int (y - pixman_fixed_e);

+

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

+    {

+	repeat (image->common.repeat, image->width, &x0);

+	repeat (image->common.repeat, image->height, &y0);

+

+	return get_pixel (image, x0, y0, FALSE);

+    }

+    else

+    {

+	return get_pixel (image, x0, y0, TRUE);

+    }

+}

+

+#if SIZEOF_LONG > 4

+

+static force_inline uint32_t

+bilinear_interpolation (uint32_t tl, uint32_t tr,

+			uint32_t bl, uint32_t br,

+			int distx, int disty)

+{

+    uint64_t distxy, distxiy, distixy, distixiy;

+    uint64_t tl64, tr64, bl64, br64;

+    uint64_t f, r;

+

+    distxy = distx * disty;

+    distxiy = distx * (256 - disty);

+    distixy = (256 - distx) * disty;

+    distixiy = (256 - distx) * (256 - disty);

+

+    /* Alpha and Blue */

+    tl64 = tl & 0xff0000ff;

+    tr64 = tr & 0xff0000ff;

+    bl64 = bl & 0xff0000ff;

+    br64 = br & 0xff0000ff;

+

+    f = tl64 * distixiy + tr64 * distxiy + bl64 * distixy + br64 * distxy;

+    r = f & 0x0000ff0000ff0000ull;

+

+    /* Red and Green */

+    tl64 = tl;

+    tl64 = ((tl64 << 16) & 0x000000ff00000000ull) | (tl64 & 0x0000ff00ull);

+

+    tr64 = tr;

+    tr64 = ((tr64 << 16) & 0x000000ff00000000ull) | (tr64 & 0x0000ff00ull);

+

+    bl64 = bl;

+    bl64 = ((bl64 << 16) & 0x000000ff00000000ull) | (bl64 & 0x0000ff00ull);

+

+    br64 = br;

+    br64 = ((br64 << 16) & 0x000000ff00000000ull) | (br64 & 0x0000ff00ull);

+

+    f = tl64 * distixiy + tr64 * distxiy + bl64 * distixy + br64 * distxy;

+    r |= ((f >> 16) & 0x000000ff00000000ull) | (f & 0xff000000ull);

+

+    return (uint32_t)(r >> 16);

+}

+

+#else

+

+static force_inline uint32_t

+bilinear_interpolation (uint32_t tl, uint32_t tr,

+			uint32_t bl, uint32_t br,

+			int distx, int disty)

+{

+    int distxy, distxiy, distixy, distixiy;

+    uint32_t f, r;

+

+    distxy = distx * disty;

+    distxiy = (distx << 8) - distxy;	/* distx * (256 - disty) */

+    distixy = (disty << 8) - distxy;	/* disty * (256 - distx) */

+    distixiy =

+	256 * 256 - (disty << 8) -

+	(distx << 8) + distxy;		/* (256 - distx) * (256 - disty) */

+

+    /* Blue */

+    r = (tl & 0x000000ff) * distixiy + (tr & 0x000000ff) * distxiy

+      + (bl & 0x000000ff) * distixy  + (br & 0x000000ff) * distxy;

+

+    /* Green */

+    f = (tl & 0x0000ff00) * distixiy + (tr & 0x0000ff00) * distxiy

+      + (bl & 0x0000ff00) * distixy  + (br & 0x0000ff00) * distxy;

+    r |= f & 0xff000000;

+

+    tl >>= 16;

+    tr >>= 16;

+    bl >>= 16;

+    br >>= 16;

+    r >>= 16;

+

+    /* Red */

+    f = (tl & 0x000000ff) * distixiy + (tr & 0x000000ff) * distxiy

+      + (bl & 0x000000ff) * distixy  + (br & 0x000000ff) * distxy;

+    r |= f & 0x00ff0000;

+

+    /* Alpha */

+    f = (tl & 0x0000ff00) * distixiy + (tr & 0x0000ff00) * distxiy

+      + (bl & 0x0000ff00) * distixy  + (br & 0x0000ff00) * distxy;

+    r |= f & 0xff000000;

+

+    return r;

+}

+

+#endif

+

+static force_inline uint32_t

+bits_image_fetch_pixel_bilinear (bits_image_t   *image,

+				 pixman_fixed_t  x,

+				 pixman_fixed_t  y,

+				 get_pixel_t	 get_pixel)

+{

+    pixman_repeat_t repeat_mode = image->common.repeat;

+    int width = image->width;

+    int height = image->height;

+    int x1, y1, x2, y2;

+    uint32_t tl, tr, bl, br;

+    int32_t distx, disty;

+

+    x1 = x - pixman_fixed_1 / 2;

+    y1 = y - pixman_fixed_1 / 2;

+

+    distx = (x1 >> 8) & 0xff;

+    disty = (y1 >> 8) & 0xff;

+

+    x1 = pixman_fixed_to_int (x1);

+    y1 = pixman_fixed_to_int (y1);

+    x2 = x1 + 1;

+    y2 = y1 + 1;

+

+    if (repeat_mode != PIXMAN_REPEAT_NONE)

+    {

+	repeat (repeat_mode, width, &x1);

+	repeat (repeat_mode, height, &y1);

+	repeat (repeat_mode, width, &x2);

+	repeat (repeat_mode, height, &y2);

+

+	tl = get_pixel (image, x1, y1, FALSE);

+	bl = get_pixel (image, x1, y2, FALSE);

+	tr = get_pixel (image, x2, y1, FALSE);

+	br = get_pixel (image, x2, y2, FALSE);

+    }

+    else

+    {

+	tl = get_pixel (image, x1, y1, TRUE);

+	tr = get_pixel (image, x2, y1, TRUE);

+	bl = get_pixel (image, x1, y2, TRUE);

+	br = get_pixel (image, x2, y2, TRUE);

+    }

+

+    return bilinear_interpolation (tl, tr, bl, br, distx, disty);

+}

+

+static void

+bits_image_fetch_bilinear_no_repeat_8888 (pixman_image_t * ima,

+					  int              offset,

+					  int              line,

+					  int              width,

+					  uint32_t *       buffer,

+					  const uint32_t * mask)

+{

+    bits_image_t *bits = &ima->bits;

+    pixman_fixed_t x_top, x_bottom, x;

+    pixman_fixed_t ux_top, ux_bottom, ux;

+    pixman_vector_t v;

+    uint32_t top_mask, bottom_mask;

+    uint32_t *top_row;

+    uint32_t *bottom_row;

+    uint32_t *end;

+    uint32_t zero[2] = { 0, 0 };

+    uint32_t one = 1;

+    int y, y1, y2;

+    int disty;

+    int mask_inc;

+    int w;

+

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

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

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

+    v.vector[2] = pixman_fixed_1;

+

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

+	return;

+

+    ux = ux_top = ux_bottom = bits->common.transform->matrix[0][0];

+    x = x_top = x_bottom = v.vector[0] - pixman_fixed_1/2;

+

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

+    disty = (y >> 8) & 0xff;

+

+    /* Load the pointers to the first and second lines from the source

+     * image that bilinear code must read.

+     *

+     * The main trick in this code is about the check if any line are

+     * outside of the image;

+     *

+     * When I realize that a line (any one) is outside, I change

+     * the pointer to a dummy area with zeros. Once I change this, I

+     * must be sure the pointer will not change, so I set the

+     * variables to each pointer increments inside the loop.

+     */

+    y1 = pixman_fixed_to_int (y);

+    y2 = y1 + 1;

+

+    if (y1 < 0 || y1 >= bits->height)

+    {

+	top_row = zero;

+	x_top = 0;

+	ux_top = 0;

+    }

+    else

+    {

+	top_row = bits->bits + y1 * bits->rowstride;

+	x_top = x;

+	ux_top = ux;

+    }

+

+    if (y2 < 0 || y2 >= bits->height)

+    {

+	bottom_row = zero;

+	x_bottom = 0;

+	ux_bottom = 0;

+    }

+    else

+    {

+	bottom_row = bits->bits + y2 * bits->rowstride;

+	x_bottom = x;

+	ux_bottom = ux;

+    }

+

+    /* Instead of checking whether the operation uses the mast in

+     * each loop iteration, verify this only once and prepare the

+     * variables to make the code smaller inside the loop.

+     */

+    if (!mask)

+    {

+        mask_inc = 0;

+        mask = &one;

+    }

+    else

+    {

+        /* If have a mask, prepare the variables to check it */

+        mask_inc = 1;

+    }

+

+    /* If both are zero, then the whole thing is zero */

+    if (top_row == zero && bottom_row == zero)

+    {

+	memset (buffer, 0, width * sizeof (uint32_t));

+	return;

+    }

+    else if (bits->format == PIXMAN_x8r8g8b8)

+    {

+	if (top_row == zero)

+	{

+	    top_mask = 0;

+	    bottom_mask = 0xff000000;

+	}

+	else if (bottom_row == zero)

+	{

+	    top_mask = 0xff000000;

+	    bottom_mask = 0;

+	}

+	else

+	{

+	    top_mask = 0xff000000;

+	    bottom_mask = 0xff000000;

+	}

+    }

+    else

+    {

+	top_mask = 0;

+	bottom_mask = 0;

+    }

+

+    end = buffer + width;

+

+    /* Zero fill to the left of the image */

+    while (buffer < end && x < pixman_fixed_minus_1)

+    {

+	*buffer++ = 0;

+	x += ux;

+	x_top += ux_top;

+	x_bottom += ux_bottom;

+	mask += mask_inc;

+    }

+

+    /* Left edge

+     */

+    while (buffer < end && x < 0)

+    {

+	uint32_t tr, br;

+	int32_t distx;

+

+	tr = top_row[pixman_fixed_to_int (x_top) + 1] | top_mask;

+	br = bottom_row[pixman_fixed_to_int (x_bottom) + 1] | bottom_mask;

+

+	distx = (x >> 8) & 0xff;

+

+	*buffer++ = bilinear_interpolation (0, tr, 0, br, distx, disty);

+

+	x += ux;

+	x_top += ux_top;

+	x_bottom += ux_bottom;

+	mask += mask_inc;

+    }

+

+    /* Main part */

+    w = pixman_int_to_fixed (bits->width - 1);

+

+    while (buffer < end  &&  x < w)

+    {

+	if (*mask)

+	{

+	    uint32_t tl, tr, bl, br;

+	    int32_t distx;

+

+	    tl = top_row [pixman_fixed_to_int (x_top)] | top_mask;

+	    tr = top_row [pixman_fixed_to_int (x_top) + 1] | top_mask;

+	    bl = bottom_row [pixman_fixed_to_int (x_bottom)] | bottom_mask;

+	    br = bottom_row [pixman_fixed_to_int (x_bottom) + 1] | bottom_mask;

+

+	    distx = (x >> 8) & 0xff;

+

+	    *buffer = bilinear_interpolation (tl, tr, bl, br, distx, disty);

+	}

+

+	buffer++;

+	x += ux;

+	x_top += ux_top;

+	x_bottom += ux_bottom;

+	mask += mask_inc;

+    }

+

+    /* Right Edge */

+    w = pixman_int_to_fixed (bits->width);

+    while (buffer < end  &&  x < w)

+    {

+	if (*mask)

+	{

+	    uint32_t tl, bl;

+	    int32_t distx;

+

+	    tl = top_row [pixman_fixed_to_int (x_top)] | top_mask;

+	    bl = bottom_row [pixman_fixed_to_int (x_bottom)] | bottom_mask;

+

+	    distx = (x >> 8) & 0xff;

+

+	    *buffer = bilinear_interpolation (tl, 0, bl, 0, distx, disty);

+	}

+

+	buffer++;

+	x += ux;

+	x_top += ux_top;

+	x_bottom += ux_bottom;

+	mask += mask_inc;

+    }

+

+    /* Zero fill to the left of the image */

+    while (buffer < end)

+	*buffer++ = 0;

+}

+

+static force_inline uint32_t

+bits_image_fetch_pixel_convolution (bits_image_t   *image,

+				    pixman_fixed_t  x,

+				    pixman_fixed_t  y,

+				    get_pixel_t     get_pixel)

+{

+    pixman_fixed_t *params = image->common.filter_params;

+    int x_off = (params[0] - pixman_fixed_1) >> 1;

+    int y_off = (params[1] - pixman_fixed_1) >> 1;

+    int32_t cwidth = pixman_fixed_to_int (params[0]);

+    int32_t cheight = pixman_fixed_to_int (params[1]);

+    int32_t srtot, sgtot, sbtot, satot;

+    int32_t i, j, x1, x2, y1, y2;

+    pixman_repeat_t repeat_mode = image->common.repeat;

+    int width = image->width;

+    int height = image->height;

+

+    params += 2;

+

+    x1 = pixman_fixed_to_int (x - pixman_fixed_e - x_off);

+    y1 = pixman_fixed_to_int (y - pixman_fixed_e - y_off);

+    x2 = x1 + cwidth;

+    y2 = y1 + cheight;

+

+    srtot = sgtot = sbtot = satot = 0;

+

+    for (i = y1; i < y2; ++i)

+    {

+	for (j = x1; j < x2; ++j)

+	{

+	    int rx = j;

+	    int ry = i;

+

+	    pixman_fixed_t f = *params;

+

+	    if (f)

+	    {

+		uint32_t pixel;

+

+		if (repeat_mode != PIXMAN_REPEAT_NONE)

+		{

+		    repeat (repeat_mode, width, &rx);

+		    repeat (repeat_mode, height, &ry);

+

+		    pixel = get_pixel (image, rx, ry, FALSE);

+		}

+		else

+		{

+		    pixel = get_pixel (image, rx, ry, TRUE);

+		}

+

+		srtot += RED_8 (pixel) * f;

+		sgtot += GREEN_8 (pixel) * f;

+		sbtot += BLUE_8 (pixel) * f;

+		satot += ALPHA_8 (pixel) * f;

+	    }

+

+	    params++;

+	}

+    }

+

+    satot >>= 16;

+    srtot >>= 16;

+    sgtot >>= 16;

+    sbtot >>= 16;

+

+    satot = CLIP (satot, 0, 0xff);

+    srtot = CLIP (srtot, 0, 0xff);

+    sgtot = CLIP (sgtot, 0, 0xff);

+    sbtot = CLIP (sbtot, 0, 0xff);

+

+    return ((satot << 24) | (srtot << 16) | (sgtot <<  8) | (sbtot));

+}

+

+static force_inline uint32_t

+bits_image_fetch_pixel_filtered (bits_image_t *image,

+				 pixman_fixed_t x,

+				 pixman_fixed_t y,

+				 get_pixel_t    get_pixel)

+{

+    switch (image->common.filter)

+    {

+    case PIXMAN_FILTER_NEAREST:

+    case PIXMAN_FILTER_FAST:

+	return bits_image_fetch_pixel_nearest (image, x, y, get_pixel);

+	break;

+

+    case PIXMAN_FILTER_BILINEAR:

+    case PIXMAN_FILTER_GOOD:

+    case PIXMAN_FILTER_BEST:

+	return bits_image_fetch_pixel_bilinear (image, x, y, get_pixel);

+	break;

+

+    case PIXMAN_FILTER_CONVOLUTION:

+	return bits_image_fetch_pixel_convolution (image, x, y, get_pixel);

+	break;

+

+    default:

+        break;

+    }

+

+    return 0;

+}

+

+static void

+bits_image_fetch_affine_no_alpha (pixman_image_t * image,

+				  int              offset,

+				  int              line,

+				  int              width,

+				  uint32_t *       buffer,

+				  const uint32_t * mask)

+{

+    pixman_fixed_t x, y;

+    pixman_fixed_t ux, uy;

+    pixman_vector_t v;

+    int i;

+

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

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

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

+    v.vector[2] = pixman_fixed_1;

+

+    if (image->common.transform)

+    {

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

+	    return;

+

+	ux = image->common.transform->matrix[0][0];

+	uy = image->common.transform->matrix[1][0];

+    }

+    else

+    {

+	ux = pixman_fixed_1;

+	uy = 0;

+    }

+

+    x = v.vector[0];

+    y = v.vector[1];

+

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

+    {

+	if (!mask || mask[i])

+	{

+	    buffer[i] = bits_image_fetch_pixel_filtered (

+		&image->bits, x, y, fetch_pixel_no_alpha);

+	}

+

+	x += ux;

+	y += uy;

+    }

+}

+

+/* General fetcher */

+static force_inline uint32_t

+fetch_pixel_general (bits_image_t *image, int x, int y, pixman_bool_t check_bounds)

+{

+    uint32_t pixel;

+

+    if (check_bounds &&

+	(x < 0 || x >= image->width || y < 0 || y >= image->height))

+    {

+	return 0;

+    }

+

+    pixel = image->fetch_pixel_32 (image, x, y);

+

+    if (image->common.alpha_map)

+    {

+	uint32_t pixel_a;

+

+	x -= image->common.alpha_origin_x;

+	y -= image->common.alpha_origin_y;

+

+	if (x < 0 || x >= image->common.alpha_map->width ||

+	    y < 0 || y >= image->common.alpha_map->height)

+	{

+	    pixel_a = 0;

+	}

+	else

+	{

+	    pixel_a = image->common.alpha_map->fetch_pixel_32 (

+		image->common.alpha_map, x, y);

+

+	    pixel_a = ALPHA_8 (pixel_a);

+	}

+

+	pixel &= 0x00ffffff;

+	pixel |= (pixel_a << 24);

+    }

+

+    return pixel;

+}

+

+static void

+bits_image_fetch_general (pixman_image_t * image,

+			  int              offset,

+			  int              line,

+			  int              width,

+			  uint32_t *       buffer,

+			  const uint32_t * mask)

+{

+    pixman_fixed_t x, y, w;

+    pixman_fixed_t ux, uy, uw;

+    pixman_vector_t v;

+    int i;

+

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

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

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

+    v.vector[2] = pixman_fixed_1;

+

+    if (image->common.transform)

+    {

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

+	    return;

+

+	ux = image->common.transform->matrix[0][0];

+	uy = image->common.transform->matrix[1][0];

+	uw = image->common.transform->matrix[2][0];

+    }

+    else

+    {

+	ux = pixman_fixed_1;

+	uy = 0;

+	uw = 0;

+    }

+

+    x = v.vector[0];

+    y = v.vector[1];

+    w = v.vector[2];

+

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

+    {

+	pixman_fixed_t x0, y0;

+

+	if (!mask || mask[i])

+	{

+	    if (w != 0)

+	    {

+		x0 = ((pixman_fixed_48_16_t)x << 16) / w;

+		y0 = ((pixman_fixed_48_16_t)y << 16) / w;

+	    }

+	    else

+	    {

+		x0 = 0;

+		y0 = 0;

+	    }

+

+	    buffer[i] = bits_image_fetch_pixel_filtered (

+		&image->bits, x0, y0, fetch_pixel_general);

+	}

+

+	x += ux;

+	y += uy;

+	w += uw;

+    }

+}

+

+static const uint8_t zero[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };

+

+typedef uint32_t (* convert_pixel_t) (const uint8_t *row, int x);

+

+static force_inline void

+bits_image_fetch_bilinear_affine (pixman_image_t * image,

+				  int              offset,

+				  int              line,

+				  int              width,

+				  uint32_t *       buffer,

+				  const uint32_t * mask,

+

+				  convert_pixel_t	convert_pixel,

+				  pixman_format_code_t	format,

+				  pixman_repeat_t	repeat_mode)

+{

+    pixman_fixed_t x, y;

+    pixman_fixed_t ux, uy;

+    pixman_vector_t v;

+    bits_image_t *bits = &image->bits;

+    int i;

+

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

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

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

+    v.vector[2] = pixman_fixed_1;

+

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

+	return;

+

+    ux = image->common.transform->matrix[0][0];

+    uy = image->common.transform->matrix[1][0];

+

+    x = v.vector[0];

+    y = v.vector[1];

+

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

+    {

+	int x1, y1, x2, y2;

+	uint32_t tl, tr, bl, br;

+	int32_t distx, disty;

+	int width = image->bits.width;

+	int height = image->bits.height;

+	const uint8_t *row1;

+	const uint8_t *row2;

+

+	if (mask && !mask[i])

+	    goto next;

+

+	x1 = x - pixman_fixed_1 / 2;

+	y1 = y - pixman_fixed_1 / 2;

+

+	distx = (x1 >> 8) & 0xff;

+	disty = (y1 >> 8) & 0xff;

+

+	y1 = pixman_fixed_to_int (y1);

+	y2 = y1 + 1;

+	x1 = pixman_fixed_to_int (x1);

+	x2 = x1 + 1;

+

+	if (repeat_mode != PIXMAN_REPEAT_NONE)

+	{

+	    uint32_t mask;

+

+	    mask = PIXMAN_FORMAT_A (format)? 0 : 0xff000000;

+

+	    repeat (repeat_mode, width, &x1);

+	    repeat (repeat_mode, height, &y1);

+	    repeat (repeat_mode, width, &x2);

+	    repeat (repeat_mode, height, &y2);

+

+	    row1 = (uint8_t *)bits->bits + bits->rowstride * 4 * y1;

+	    row2 = (uint8_t *)bits->bits + bits->rowstride * 4 * y2;

+

+	    tl = convert_pixel (row1, x1) | mask;

+	    tr = convert_pixel (row1, x2) | mask;

+	    bl = convert_pixel (row2, x1) | mask;

+	    br = convert_pixel (row2, x2) | mask;

+	}

+	else

+	{

+	    uint32_t mask1, mask2;

+	    int bpp;

+

+	    /* Note: PIXMAN_FORMAT_BPP() returns an unsigned value,

+	     * which means if you use it in expressions, those

+	     * expressions become unsigned themselves. Since

+	     * the variables below can be negative in some cases,

+	     * that will lead to crashes on 64 bit architectures.

+	     *

+	     * So this line makes sure bpp is signed

+	     */

+	    bpp = PIXMAN_FORMAT_BPP (format);

+

+	    if (x1 >= width || x2 < 0 || y1 >= height || y2 < 0)

+	    {

+		buffer[i] = 0;

+		goto next;

+	    }

+

+	    if (y2 == 0)

+	    {

+		row1 = zero;

+		mask1 = 0;

+	    }

+	    else

+	    {

+		row1 = (uint8_t *)bits->bits + bits->rowstride * 4 * y1;

+		row1 += bpp / 8 * x1;

+

+		mask1 = PIXMAN_FORMAT_A (format)? 0 : 0xff000000;

+	    }

+

+	    if (y1 == height - 1)

+	    {

+		row2 = zero;

+		mask2 = 0;

+	    }

+	    else

+	    {

+		row2 = (uint8_t *)bits->bits + bits->rowstride * 4 * y2;

+		row2 += bpp / 8 * x1;

+

+		mask2 = PIXMAN_FORMAT_A (format)? 0 : 0xff000000;

+	    }

+

+	    if (x2 == 0)

+	    {

+		tl = 0;

+		bl = 0;

+	    }

+	    else

+	    {

+		tl = convert_pixel (row1, 0) | mask1;

+		bl = convert_pixel (row2, 0) | mask2;

+	    }

+

+	    if (x1 == width - 1)

+	    {

+		tr = 0;

+		br = 0;

+	    }

+	    else

+	    {

+		tr = convert_pixel (row1, 1) | mask1;

+		br = convert_pixel (row2, 1) | mask2;

+	    }

+	}

+

+	buffer[i] = bilinear_interpolation (

+	    tl, tr, bl, br, distx, disty);

+

+    next:

+	x += ux;

+	y += uy;

+    }

+}

+

+static force_inline void

+bits_image_fetch_nearest_affine (pixman_image_t * image,

+				 int              offset,

+				 int              line,

+				 int              width,

+				 uint32_t *       buffer,

+				 const uint32_t * mask,

+				 

+				 convert_pixel_t	convert_pixel,

+				 pixman_format_code_t	format,

+				 pixman_repeat_t	repeat_mode)

+{

+    pixman_fixed_t x, y;

+    pixman_fixed_t ux, uy;

+    pixman_vector_t v;

+    bits_image_t *bits = &image->bits;

+    int i;

+

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

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

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

+    v.vector[2] = pixman_fixed_1;

+

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

+	return;

+

+    ux = image->common.transform->matrix[0][0];

+    uy = image->common.transform->matrix[1][0];

+

+    x = v.vector[0];

+    y = v.vector[1];

+

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

+    {

+	int width, height, x0, y0;

+	const uint8_t *row;

+

+	if (mask && !mask[i])

+	    goto next;

+	

+	width = image->bits.width;

+	height = image->bits.height;

+	x0 = pixman_fixed_to_int (x - pixman_fixed_e);

+	y0 = pixman_fixed_to_int (y - pixman_fixed_e);

+

+	if (repeat_mode == PIXMAN_REPEAT_NONE &&

+	    (y0 < 0 || y0 >= height || x0 < 0 || x0 >= width))

+	{

+	    buffer[i] = 0;

+	}

+	else

+	{

+	    uint32_t mask = PIXMAN_FORMAT_A (format)? 0 : 0xff000000;

+

+	    if (repeat_mode != PIXMAN_REPEAT_NONE)

+	    {

+		repeat (repeat_mode, width, &x0);

+		repeat (repeat_mode, height, &y0);

+	    }

+

+	    row = (uint8_t *)bits->bits + bits->rowstride * 4 * y0;

+

+	    buffer[i] = convert_pixel (row, x0) | mask;

+	}

+

+    next:

+	x += ux;

+	y += uy;

+    }

+}

+

+static force_inline uint32_t

+convert_a8r8g8b8 (const uint8_t *row, int x)

+{

+    return *(((uint32_t *)row) + x);

+}

+

+static force_inline uint32_t

+convert_x8r8g8b8 (const uint8_t *row, int x)

+{

+    return *(((uint32_t *)row) + x);

+}

+

+static force_inline uint32_t

+convert_a8 (const uint8_t *row, int x)

+{

+    return *(row + x) << 24;

+}

+

+static force_inline uint32_t

+convert_r5g6b5 (const uint8_t *row, int x)

+{

+    return CONVERT_0565_TO_0888 (*((uint16_t *)row + x));

+}

+

+#define MAKE_BILINEAR_FETCHER(name, format, repeat_mode)		\

+    static void								\

+    bits_image_fetch_bilinear_affine_ ## name (pixman_image_t *image,	\

+					       int              offset,	\

+					       int              line,	\

+					       int              width,	\

+					       uint32_t *       buffer,	\

+					       const uint32_t * mask)	\

+    {									\

+	bits_image_fetch_bilinear_affine (image, offset, line,		\

+					  width, buffer, mask,		\

+					  convert_ ## format,		\

+					  PIXMAN_ ## format,		\

+					  repeat_mode);			\

+    }

+

+#define MAKE_NEAREST_FETCHER(name, format, repeat_mode)			\

+    static void								\

+    bits_image_fetch_nearest_affine_ ## name (pixman_image_t *image,	\

+					      int              offset,	\

+					      int              line,	\

+					      int              width,	\

+					      uint32_t *       buffer,	\

+					      const uint32_t * mask)	\

+    {									\

+	bits_image_fetch_nearest_affine (image, offset, line,		\

+					 width, buffer, mask,		\

+					 convert_ ## format,		\

+					 PIXMAN_ ## format,		\

+					 repeat_mode);			\

+    }

+

+#define MAKE_FETCHERS(name, format, repeat_mode)			\

+    MAKE_NEAREST_FETCHER (name, format, repeat_mode)			\

+    MAKE_BILINEAR_FETCHER (name, format, repeat_mode)

+

+MAKE_FETCHERS (pad_a8r8g8b8,     a8r8g8b8, PIXMAN_REPEAT_PAD)

+MAKE_FETCHERS (none_a8r8g8b8,    a8r8g8b8, PIXMAN_REPEAT_NONE)

+MAKE_FETCHERS (reflect_a8r8g8b8, a8r8g8b8, PIXMAN_REPEAT_REFLECT)

+MAKE_FETCHERS (normal_a8r8g8b8,  a8r8g8b8, PIXMAN_REPEAT_NORMAL)

+MAKE_FETCHERS (pad_x8r8g8b8,     x8r8g8b8, PIXMAN_REPEAT_PAD)

+MAKE_FETCHERS (none_x8r8g8b8,    x8r8g8b8, PIXMAN_REPEAT_NONE)

+MAKE_FETCHERS (reflect_x8r8g8b8, x8r8g8b8, PIXMAN_REPEAT_REFLECT)

+MAKE_FETCHERS (normal_x8r8g8b8,  x8r8g8b8, PIXMAN_REPEAT_NORMAL)

+MAKE_FETCHERS (pad_a8,           a8,       PIXMAN_REPEAT_PAD)

+MAKE_FETCHERS (none_a8,          a8,       PIXMAN_REPEAT_NONE)

+MAKE_FETCHERS (reflect_a8,	 a8,       PIXMAN_REPEAT_REFLECT)

+MAKE_FETCHERS (normal_a8,	 a8,       PIXMAN_REPEAT_NORMAL)

+MAKE_FETCHERS (pad_r5g6b5,       r5g6b5,   PIXMAN_REPEAT_PAD)

+MAKE_FETCHERS (none_r5g6b5,      r5g6b5,   PIXMAN_REPEAT_NONE)

+MAKE_FETCHERS (reflect_r5g6b5,   r5g6b5,   PIXMAN_REPEAT_REFLECT)

+MAKE_FETCHERS (normal_r5g6b5,    r5g6b5,   PIXMAN_REPEAT_NORMAL)

+

+static void

+bits_image_fetch_solid_32 (pixman_image_t * image,

+                           int              x,

+                           int              y,

+                           int              width,

+                           uint32_t *       buffer,

+                           const uint32_t * mask)

+{

+    uint32_t color;

+    uint32_t *end;

+

+    color = image->bits.fetch_pixel_32 (&image->bits, 0, 0);

+

+    end = buffer + width;

+    while (buffer < end)

+	*(buffer++) = color;

+}

+

+static void

+bits_image_fetch_solid_64 (pixman_image_t * image,

+                           int              x,

+                           int              y,

+                           int              width,

+                           uint32_t *       b,

+                           const uint32_t * unused)

+{

+    uint64_t color;

+    uint64_t *buffer = (uint64_t *)b;

+    uint64_t *end;

+

+    color = image->bits.fetch_pixel_64 (&image->bits, 0, 0);

+

+    end = buffer + width;

+    while (buffer < end)

+	*(buffer++) = color;

+}

+

+static void

+bits_image_fetch_untransformed_repeat_none (bits_image_t *image,

+                                            pixman_bool_t wide,

+                                            int           x,

+                                            int           y,

+                                            int           width,

+                                            uint32_t *    buffer)

+{

+    uint32_t w;

+

+    if (y < 0 || y >= image->height)

+    {

+	memset (buffer, 0, width * (wide? 8 : 4));

+	return;

+    }

+

+    if (x < 0)

+    {

+	w = MIN (width, -x);

+

+	memset (buffer, 0, w * (wide ? 8 : 4));

+

+	width -= w;

+	buffer += w * (wide? 2 : 1);

+	x += w;

+    }

+

+    if (x < image->width)

+    {

+	w = MIN (width, image->width - x);

+

+	if (wide)

+	    image->fetch_scanline_64 ((pixman_image_t *)image, x, y, w, buffer, NULL);

+	else

+	    image->fetch_scanline_32 ((pixman_image_t *)image, x, y, w, buffer, NULL);

+

+	width -= w;

+	buffer += w * (wide? 2 : 1);

+	x += w;

+    }

+

+    memset (buffer, 0, width * (wide ? 8 : 4));

+}

+

+static void

+bits_image_fetch_untransformed_repeat_normal (bits_image_t *image,

+                                              pixman_bool_t wide,

+                                              int           x,

+                                              int           y,

+                                              int           width,

+                                              uint32_t *    buffer)

+{

+    uint32_t w;

+

+    while (y < 0)

+	y += image->height;

+

+    while (y >= image->height)

+	y -= image->height;

+

+    while (width)

+    {

+	while (x < 0)

+	    x += image->width;

+	while (x >= image->width)

+	    x -= image->width;

+

+	w = MIN (width, image->width - x);

+

+	if (wide)

+	    image->fetch_scanline_64 ((pixman_image_t *)image, x, y, w, buffer, NULL);

+	else

+	    image->fetch_scanline_32 ((pixman_image_t *)image, x, y, w, buffer, NULL);

+

+	buffer += w * (wide? 2 : 1);

+	x += w;

+	width -= w;

+    }

+}

+

+static void

+bits_image_fetch_untransformed_32 (pixman_image_t * image,

+                                   int              x,

+                                   int              y,

+                                   int              width,

+                                   uint32_t *       buffer,

+                                   const uint32_t * mask)

+{

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

+    {

+	bits_image_fetch_untransformed_repeat_none (

+	    &image->bits, FALSE, x, y, width, buffer);

+    }

+    else

+    {

+	bits_image_fetch_untransformed_repeat_normal (

+	    &image->bits, FALSE, x, y, width, buffer);

+    }

+}

+

+static void

+bits_image_fetch_untransformed_64 (pixman_image_t * image,

+                                   int              x,

+                                   int              y,

+                                   int              width,

+                                   uint32_t *       buffer,

+                                   const uint32_t * unused)

+{

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

+    {

+	bits_image_fetch_untransformed_repeat_none (

+	    &image->bits, TRUE, x, y, width, buffer);

+    }

+    else

+    {

+	bits_image_fetch_untransformed_repeat_normal (

+	    &image->bits, TRUE, x, y, width, buffer);

+    }

+}

+

+typedef struct

+{

+    pixman_format_code_t	format;

+    uint32_t			flags;

+    fetch_scanline_t		fetch_32;

+    fetch_scanline_t		fetch_64;

+} fetcher_info_t;

+

+static const fetcher_info_t fetcher_info[] =

+{

+    { PIXMAN_solid,

+      FAST_PATH_NO_ALPHA_MAP,

+      bits_image_fetch_solid_32,

+      bits_image_fetch_solid_64

+    },

+

+    { PIXMAN_any,

+      (FAST_PATH_NO_ALPHA_MAP			|

+       FAST_PATH_ID_TRANSFORM			|

+       FAST_PATH_NO_CONVOLUTION_FILTER		|

+       FAST_PATH_NO_PAD_REPEAT			|

+       FAST_PATH_NO_REFLECT_REPEAT),

+      bits_image_fetch_untransformed_32,

+      bits_image_fetch_untransformed_64

+    },

+

+#define FAST_BILINEAR_FLAGS						\

+    (FAST_PATH_NO_ALPHA_MAP		|				\

+     FAST_PATH_NO_ACCESSORS		|				\

+     FAST_PATH_HAS_TRANSFORM		|				\

+     FAST_PATH_AFFINE_TRANSFORM		|				\

+     FAST_PATH_X_UNIT_POSITIVE		|				\

+     FAST_PATH_Y_UNIT_ZERO		|				\

+     FAST_PATH_NONE_REPEAT		|				\

+     FAST_PATH_BILINEAR_FILTER)

+

+    { PIXMAN_a8r8g8b8,

+      FAST_BILINEAR_FLAGS,

+      bits_image_fetch_bilinear_no_repeat_8888,

+      _pixman_image_get_scanline_generic_64

+    },

+

+    { PIXMAN_x8r8g8b8,

+      FAST_BILINEAR_FLAGS,

+      bits_image_fetch_bilinear_no_repeat_8888,

+      _pixman_image_get_scanline_generic_64

+    },

+

+#define GENERAL_BILINEAR_FLAGS						\

+    (FAST_PATH_NO_ALPHA_MAP		|				\

+     FAST_PATH_NO_ACCESSORS		|				\

+     FAST_PATH_HAS_TRANSFORM		|				\

+     FAST_PATH_AFFINE_TRANSFORM		|				\

+     FAST_PATH_BILINEAR_FILTER)

+

+#define GENERAL_NEAREST_FLAGS						\

+    (FAST_PATH_NO_ALPHA_MAP		|				\

+     FAST_PATH_NO_ACCESSORS		|				\

+     FAST_PATH_HAS_TRANSFORM		|				\

+     FAST_PATH_AFFINE_TRANSFORM		|				\

+     FAST_PATH_NEAREST_FILTER)

+

+#define BILINEAR_AFFINE_FAST_PATH(name, format, repeat)			\

+    { PIXMAN_ ## format,						\

+      GENERAL_BILINEAR_FLAGS | FAST_PATH_ ## repeat ## _REPEAT,		\

+      bits_image_fetch_bilinear_affine_ ## name,			\

+      _pixman_image_get_scanline_generic_64				\

+    },

+

+#define NEAREST_AFFINE_FAST_PATH(name, format, repeat)			\

+    { PIXMAN_ ## format,						\

+      GENERAL_NEAREST_FLAGS | FAST_PATH_ ## repeat ## _REPEAT,		\

+      bits_image_fetch_nearest_affine_ ## name,			\

+      _pixman_image_get_scanline_generic_64				\

+    },

+

+#define AFFINE_FAST_PATHS(name, format, repeat)				\

+    BILINEAR_AFFINE_FAST_PATH(name, format, repeat)			\

+    NEAREST_AFFINE_FAST_PATH(name, format, repeat)

+    

+    AFFINE_FAST_PATHS (pad_a8r8g8b8, a8r8g8b8, PAD)

+    AFFINE_FAST_PATHS (none_a8r8g8b8, a8r8g8b8, NONE)

+    AFFINE_FAST_PATHS (reflect_a8r8g8b8, a8r8g8b8, REFLECT)

+    AFFINE_FAST_PATHS (normal_a8r8g8b8, a8r8g8b8, NORMAL)

+    AFFINE_FAST_PATHS (pad_x8r8g8b8, x8r8g8b8, PAD)

+    AFFINE_FAST_PATHS (none_x8r8g8b8, x8r8g8b8, NONE)

+    AFFINE_FAST_PATHS (reflect_x8r8g8b8, x8r8g8b8, REFLECT)

+    AFFINE_FAST_PATHS (normal_x8r8g8b8, x8r8g8b8, NORMAL)

+    AFFINE_FAST_PATHS (pad_a8, a8, PAD)

+    AFFINE_FAST_PATHS (none_a8, a8, NONE)

+    AFFINE_FAST_PATHS (reflect_a8, a8, REFLECT)

+    AFFINE_FAST_PATHS (normal_a8, a8, NORMAL)

+    AFFINE_FAST_PATHS (pad_r5g6b5, r5g6b5, PAD)

+    AFFINE_FAST_PATHS (none_r5g6b5, r5g6b5, NONE)

+    AFFINE_FAST_PATHS (reflect_r5g6b5, r5g6b5, REFLECT)

+    AFFINE_FAST_PATHS (normal_r5g6b5, r5g6b5, NORMAL)

+

+    /* Affine, no alpha */

+    { PIXMAN_any,

+      (FAST_PATH_NO_ALPHA_MAP | FAST_PATH_HAS_TRANSFORM | FAST_PATH_AFFINE_TRANSFORM),

+      bits_image_fetch_affine_no_alpha,

+      _pixman_image_get_scanline_generic_64

+    },

+

+    /* General */

+    { PIXMAN_any, 0, bits_image_fetch_general, _pixman_image_get_scanline_generic_64 },

+

+    { PIXMAN_null },

+};

+

+static void

+bits_image_property_changed (pixman_image_t *image)

+{

+    uint32_t flags = image->common.flags;

+    pixman_format_code_t format = image->common.extended_format_code;

+    const fetcher_info_t *info;

+

+    _pixman_bits_image_setup_accessors (&image->bits);

+

+    info = fetcher_info;

+    while (info->format != PIXMAN_null)

+    {

+	if ((info->format == format || info->format == PIXMAN_any)	&&

+	    (info->flags & flags) == info->flags)

+	{

+	    image->bits.get_scanline_32 = info->fetch_32;

+	    image->bits.get_scanline_64 = info->fetch_64;

+	    break;

+	}

+

+	info++;

+    }

+}

+

+static uint32_t *

+src_get_scanline_narrow (pixman_iter_t *iter, const uint32_t *mask)

+{

+    iter->image->bits.get_scanline_32 (

+	iter->image, iter->x, iter->y++, iter->width, iter->buffer, mask);

+

+    return iter->buffer;

+}

+

+static uint32_t *

+src_get_scanline_wide (pixman_iter_t *iter, const uint32_t *mask)

+{

+    iter->image->bits.get_scanline_64 (

+	iter->image, iter->x, iter->y++, iter->width, iter->buffer, mask);

+

+    return iter->buffer;

+}

+

+void

+_pixman_bits_image_src_iter_init (pixman_image_t *image, pixman_iter_t *iter)

+{

+    if (iter->flags & ITER_NARROW)

+	iter->get_scanline = src_get_scanline_narrow;

+    else

+	iter->get_scanline = src_get_scanline_wide;

+}

+

+static uint32_t *

+dest_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;

+

+    image->bits.fetch_scanline_32 (image, x, y, width, buffer, mask);

+    if (image->common.alpha_map)

+    {

+	x -= image->common.alpha_origin_x;

+	y -= image->common.alpha_origin_y;

+

+	image->common.alpha_map->fetch_scanline_32 (

+	    (pixman_image_t *)image->common.alpha_map,

+	    x, y, width, buffer, mask);

+    }

+

+    return iter->buffer;

+}

+

+static uint32_t *

+dest_get_scanline_wide (pixman_iter_t *iter, const uint32_t *mask)

+{

+    bits_image_t *  image  = &iter->image->bits;

+    int             x      = iter->x;

+    int             y      = iter->y;

+    int             width  = iter->width;

+    uint32_t *	    buffer = iter->buffer;

+

+    image->fetch_scanline_64 (

+	(pixman_image_t *)image, x, y, width, buffer, mask);

+    if (image->common.alpha_map)

+    {

+	x -= image->common.alpha_origin_x;

+	y -= image->common.alpha_origin_y;

+

+	image->common.alpha_map->fetch_scanline_64 (

+	    (pixman_image_t *)image->common.alpha_map, x, y, width, buffer, mask);

+    }

+

+    return iter->buffer;

+}

+

+static void

+dest_write_back_narrow (pixman_iter_t *iter)

+{

+    bits_image_t *  image  = &iter->image->bits;

+    int             x      = iter->x;

+    int             y      = iter->y;

+    int             width  = iter->width;

+    const uint32_t *buffer = iter->buffer;

+

+    image->store_scanline_32 (image, x, y, width, buffer);

+

+    if (image->common.alpha_map)

+    {

+	x -= image->common.alpha_origin_x;

+	y -= image->common.alpha_origin_y;

+

+	image->common.alpha_map->store_scanline_32 (

+	    image->common.alpha_map, x, y, width, buffer);

+    }

+

+    iter->y++;

+}

+

+static void

+dest_write_back_wide (pixman_iter_t *iter)

+{

+    bits_image_t *  image  = &iter->image->bits;

+    int             x      = iter->x;

+    int             y      = iter->y;

+    int             width  = iter->width;

+    const uint32_t *buffer = iter->buffer;

+

+    image->store_scanline_64 (image, x, y, width, buffer);

+

+    if (image->common.alpha_map)

+    {

+	x -= image->common.alpha_origin_x;

+	y -= image->common.alpha_origin_y;

+

+	image->common.alpha_map->store_scanline_64 (

+	    image->common.alpha_map, x, y, width, buffer);

+    }

+

+    iter->y++;

+}

+

+static void

+dest_write_back_direct (pixman_iter_t *iter)

+{

+    iter->buffer += iter->image->bits.rowstride;

+}

+

+void

+_pixman_bits_image_dest_iter_init (pixman_image_t *image, pixman_iter_t *iter)

+{

+    if (iter->flags & ITER_NARROW)

+    {

+	if (((image->common.flags &

+	      (FAST_PATH_NO_ALPHA_MAP | FAST_PATH_NO_ACCESSORS)) ==

+	     (FAST_PATH_NO_ALPHA_MAP | FAST_PATH_NO_ACCESSORS)) &&

+	    (image->bits.format == PIXMAN_a8r8g8b8	||

+	     (image->bits.format == PIXMAN_x8r8g8b8	&&

+	      (iter->flags & ITER_LOCALIZED_ALPHA))))

+	{

+	    iter->buffer = image->bits.bits + iter->y * image->bits.rowstride + iter->x;

+

+	    iter->get_scanline = _pixman_iter_get_scanline_noop;

+	    iter->write_back = dest_write_back_direct;

+	}

+	else

+	{

+	    if ((iter->flags & (ITER_IGNORE_RGB | ITER_IGNORE_ALPHA)) ==

+		(ITER_IGNORE_RGB | ITER_IGNORE_ALPHA))

+	    {

+		iter->get_scanline = _pixman_iter_get_scanline_noop;

+	    }

+	    else

+	    {

+		iter->get_scanline = dest_get_scanline_narrow;

+	    }

+

+	    iter->write_back = dest_write_back_narrow;

+	}

+    }

+    else

+    {

+	iter->get_scanline = dest_get_scanline_wide;

+	iter->write_back = dest_write_back_wide;

+    }

+}

+

+static uint32_t *

+create_bits (pixman_format_code_t format,

+             int                  width,

+             int                  height,

+             int *                rowstride_bytes)

+{

+    int stride;

+    int buf_size;

+    int bpp;

+

+    /* what follows is a long-winded way, avoiding any possibility of integer

+     * overflows, of saying:

+     * stride = ((width * bpp + 0x1f) >> 5) * sizeof (uint32_t);

+     */

+

+    bpp = PIXMAN_FORMAT_BPP (format);

+    if (pixman_multiply_overflows_int (width, bpp))

+	return NULL;

+

+    stride = width * bpp;

+    if (pixman_addition_overflows_int (stride, 0x1f))

+	return NULL;

+

+    stride += 0x1f;

+    stride >>= 5;

+

+    stride *= sizeof (uint32_t);

+

+    if (pixman_multiply_overflows_int (height, stride))

+	return NULL;

+

+    buf_size = height * stride;

+

+    if (rowstride_bytes)

+	*rowstride_bytes = stride;

+

+    return calloc (buf_size, 1);

+}

+

+PIXMAN_EXPORT pixman_image_t *

+pixman_image_create_bits (pixman_format_code_t format,

+                          int                  width,

+                          int                  height,

+                          uint32_t *           bits,

+                          int                  rowstride_bytes)

+{

+    pixman_image_t *image;

+    uint32_t *free_me = NULL;

+

+    /* must be a whole number of uint32_t's

+     */

+    return_val_if_fail (

+	bits == NULL || (rowstride_bytes % sizeof (uint32_t)) == 0, NULL);

+

+    return_val_if_fail (PIXMAN_FORMAT_BPP (format) >= PIXMAN_FORMAT_DEPTH (format), NULL);

+

+    if (!bits && width && height)

+    {

+	free_me = bits = create_bits (format, width, height, &rowstride_bytes);

+	if (!bits)

+	    return NULL;

+    }

+

+    image = _pixman_image_allocate ();

+

+    if (!image)

+    {

+	if (free_me)

+	    free (free_me);

+

+	return NULL;

+    }

+

+    image->type = BITS;

+    image->bits.format = format;

+    image->bits.width = width;

+    image->bits.height = height;

+    image->bits.bits = bits;

+    image->bits.free_me = free_me;

+    image->bits.read_func = NULL;

+    image->bits.write_func = NULL;

+

+    /* The rowstride is stored in number of uint32_t */

+    image->bits.rowstride = rowstride_bytes / (int) sizeof (uint32_t);

+

+    image->bits.indexed = NULL;

+

+    image->common.property_changed = bits_image_property_changed;

+

+    _pixman_image_reset_clip_region (image);

+

+    return image;

+}

diff --git a/pixman/pixman/pixman-conical-gradient.c b/pixman/pixman/pixman-conical-gradient.c
index 9d7d2e8b5..e3f230262 100644
--- a/pixman/pixman/pixman-conical-gradient.c
+++ b/pixman/pixman/pixman-conical-gradient.c
@@ -1,214 +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,
-				    int x, int y, int width, int height,
-				    uint8_t *buffer, iter_flags_t flags)
-{
-    if (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->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 1e0091094..5bac6c65a 100644
--- a/pixman/pixman/pixman-general.c
+++ b/pixman/pixman/pixman-general.c
@@ -38,66 +38,30 @@
 #include "pixman-private.h"

 

 static void

-general_src_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)

+general_src_iter_init (pixman_implementation_t *imp, pixman_iter_t *iter)

 {

-    iter->image = image;

-    iter->x = x;

-    iter->y = y;

-    iter->width = width;

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

+    pixman_image_t *image = iter->image;

 

     if (image->type == SOLID)

-    {

-	_pixman_solid_fill_iter_init (

-	    image, iter, x, y, width, height, buffer, flags);

-    }

+	_pixman_solid_fill_iter_init (image, iter);

     else if (image->type == LINEAR)

-    {

-	_pixman_linear_gradient_iter_init (

-	    image, iter, x, y, width, height, buffer, flags);

-    }

+	_pixman_linear_gradient_iter_init (image, iter);

     else if (image->type == RADIAL)

-    {

-	_pixman_radial_gradient_iter_init (

-	    image, iter, x, y, width, height, buffer, flags);

-    }

+	_pixman_radial_gradient_iter_init (image, iter);

     else if (image->type == CONICAL)

-    {

-	_pixman_conical_gradient_iter_init (

-	    image, iter, x, y, width, height, buffer, flags);

-    }

+	_pixman_conical_gradient_iter_init (image, iter);

     else if (image->type == BITS)

-    {

-	_pixman_bits_image_src_iter_init (

-	    image, iter, x, y, width, height, buffer, flags);

-    }

+	_pixman_bits_image_src_iter_init (image, iter);

     else

-    {

 	_pixman_log_error (FUNC, "Pixman bug: unknown image type\n");

-    }

 }

 

 static void

-general_dest_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)

+general_dest_iter_init (pixman_implementation_t *imp, pixman_iter_t *iter)

 {

-    iter->image = image;

-    iter->x = x;

-    iter->y = y;

-    iter->width = width;

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

-

-    if (image->type == BITS)

+    if (iter->image->type == BITS)

     {

-	_pixman_bits_image_dest_iter_init (

-	    image, iter, x, y, width, height, buffer, flags);

+	_pixman_bits_image_dest_iter_init (iter->image, iter);

     }

     else

     {

diff --git a/pixman/pixman/pixman-implementation.c b/pixman/pixman/pixman-implementation.c
index adaf9c61e..caade9332 100644
--- a/pixman/pixman/pixman-implementation.c
+++ b/pixman/pixman/pixman-implementation.c
@@ -1,306 +1,304 @@
-/*
- * Copyright © 2009 Red Hat, Inc.
- *
- * 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 Red Hat not be used in advertising or
- * publicity pertaining to distribution of the software without specific,
- * written prior permission.  Red Hat 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 void
-delegate_combine_32 (pixman_implementation_t * imp,
-                     pixman_op_t               op,
-                     uint32_t *                dest,
-                     const uint32_t *          src,
-                     const uint32_t *          mask,
-                     int                       width)
-{
-    _pixman_implementation_combine_32 (imp->delegate,
-                                       op, dest, src, mask, width);
-}
-
-static void
-delegate_combine_64 (pixman_implementation_t * imp,
-                     pixman_op_t               op,
-                     uint64_t *                dest,
-                     const uint64_t *          src,
-                     const uint64_t *          mask,
-                     int                       width)
-{
-    _pixman_implementation_combine_64 (imp->delegate,
-                                       op, dest, src, mask, width);
-}
-
-static void
-delegate_combine_32_ca (pixman_implementation_t * imp,
-                        pixman_op_t               op,
-                        uint32_t *                dest,
-                        const uint32_t *          src,
-                        const uint32_t *          mask,
-                        int                       width)
-{
-    _pixman_implementation_combine_32_ca (imp->delegate,
-                                          op, dest, src, mask, width);
-}
-
-static void
-delegate_combine_64_ca (pixman_implementation_t * imp,
-                        pixman_op_t               op,
-                        uint64_t *                dest,
-                        const uint64_t *          src,
-                        const uint64_t *          mask,
-                        int                       width)
-{
-    _pixman_implementation_combine_64_ca (imp->delegate,
-                                          op, dest, src, mask, width);
-}
-
-static pixman_bool_t
-delegate_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                       dst_x,
-              int                       dst_y,
-              int                       width,
-              int                       height)
-{
-    return _pixman_implementation_blt (
-	imp->delegate, src_bits, dst_bits, src_stride, dst_stride,
-	src_bpp, dst_bpp, src_x, src_y, dst_x, dst_y,
-	width, height);
-}
-
-static pixman_bool_t
-delegate_fill (pixman_implementation_t *imp,
-               uint32_t *               bits,
-               int                      stride,
-               int                      bpp,
-               int                      x,
-               int                      y,
-               int                      width,
-               int                      height,
-               uint32_t                 xor)
-{
-    return _pixman_implementation_fill (
-	imp->delegate, bits, stride, bpp, x, y, width, height, xor);
-}
-
-static void
-delegate_src_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)
-{
-    _pixman_implementation_src_iter_init (
-	imp->delegate, iter, image, x, y, width, height, buffer, flags);
-}
-
-static void
-delegate_dest_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)
-{
-    _pixman_implementation_dest_iter_init (
-	imp->delegate, iter, image, x, y, width, height, buffer, flags);
-}
-
-pixman_implementation_t *
-_pixman_implementation_create (pixman_implementation_t *delegate,
-			       const pixman_fast_path_t *fast_paths)
-{
-    pixman_implementation_t *imp = malloc (sizeof (pixman_implementation_t));
-    pixman_implementation_t *d;
-    int i;
-
-    if (!imp)
-	return NULL;
-
-    assert (fast_paths);
-
-    /* Make sure the whole delegate chain has the right toplevel */
-    imp->delegate = delegate;
-    for (d = imp; d != NULL; d = d->delegate)
-	d->toplevel = imp;
-
-    /* Fill out function pointers with ones that just delegate
-     */
-    imp->blt = delegate_blt;
-    imp->fill = delegate_fill;
-    imp->src_iter_init = delegate_src_iter_init;
-    imp->dest_iter_init = delegate_dest_iter_init;
-
-    for (i = 0; i < PIXMAN_N_OPERATORS; ++i)
-    {
-	imp->combine_32[i] = delegate_combine_32;
-	imp->combine_64[i] = delegate_combine_64;
-	imp->combine_32_ca[i] = delegate_combine_32_ca;
-	imp->combine_64_ca[i] = delegate_combine_64_ca;
-    }
-
-    imp->fast_paths = fast_paths;
-
-    return imp;
-}
-
-void
-_pixman_implementation_combine_32 (pixman_implementation_t * imp,
-                                   pixman_op_t               op,
-                                   uint32_t *                dest,
-                                   const uint32_t *          src,
-                                   const uint32_t *          mask,
-                                   int                       width)
-{
-    (*imp->combine_32[op]) (imp, op, dest, src, mask, width);
-}
-
-void
-_pixman_implementation_combine_64 (pixman_implementation_t * imp,
-                                   pixman_op_t               op,
-                                   uint64_t *                dest,
-                                   const uint64_t *          src,
-                                   const uint64_t *          mask,
-                                   int                       width)
-{
-    (*imp->combine_64[op]) (imp, op, dest, src, mask, width);
-}
-
-void
-_pixman_implementation_combine_32_ca (pixman_implementation_t * imp,
-                                      pixman_op_t               op,
-                                      uint32_t *                dest,
-                                      const uint32_t *          src,
-                                      const uint32_t *          mask,
-                                      int                       width)
-{
-    (*imp->combine_32_ca[op]) (imp, op, dest, src, mask, width);
-}
-
-void
-_pixman_implementation_combine_64_ca (pixman_implementation_t * imp,
-                                      pixman_op_t               op,
-                                      uint64_t *                dest,
-                                      const uint64_t *          src,
-                                      const uint64_t *          mask,
-                                      int                       width)
-{
-    (*imp->combine_64_ca[op]) (imp, op, dest, src, mask, width);
-}
-
-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                       dst_x,
-                            int                       dst_y,
-                            int                       width,
-                            int                       height)
-{
-    return (*imp->blt) (imp, src_bits, dst_bits, src_stride, dst_stride,
-			src_bpp, dst_bpp, src_x, src_y, dst_x, dst_y,
-			width, 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                 xor)
-{
-    return (*imp->fill) (imp, bits, stride, bpp, x, y, width, height, xor);
-}
-
-static uint32_t *
-get_scanline_null (pixman_iter_t *iter, const uint32_t *mask)
-{
-    return NULL;
-}
-
-void
-_pixman_implementation_src_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)
-{
-    if (!image)
-    {
-	iter->get_scanline = get_scanline_null;
-    }
-    else if ((flags & (ITER_IGNORE_ALPHA | ITER_IGNORE_RGB)) ==
-	     (ITER_IGNORE_ALPHA | ITER_IGNORE_RGB))
-    {
-	iter->get_scanline = _pixman_iter_get_scanline_noop;
-    }
-    else
-    {
-	(*imp->src_iter_init) (
-	    imp, iter, image, x, y, width, height, buffer, flags);
-    }
-}
-
-void
-_pixman_implementation_dest_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)
-{
-    (*imp->dest_iter_init) (
-	imp, iter, image, x, y, width, height, buffer, flags);
-}
+/*

+ * Copyright © 2009 Red Hat, Inc.

+ *

+ * 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 Red Hat not be used in advertising or

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

+ * written prior permission.  Red Hat 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 void

+delegate_combine_32 (pixman_implementation_t * imp,

+                     pixman_op_t               op,

+                     uint32_t *                dest,

+                     const uint32_t *          src,

+                     const uint32_t *          mask,

+                     int                       width)

+{

+    _pixman_implementation_combine_32 (imp->delegate,

+                                       op, dest, src, mask, width);

+}

+

+static void

+delegate_combine_64 (pixman_implementation_t * imp,

+                     pixman_op_t               op,

+                     uint64_t *                dest,

+                     const uint64_t *          src,

+                     const uint64_t *          mask,

+                     int                       width)

+{

+    _pixman_implementation_combine_64 (imp->delegate,

+                                       op, dest, src, mask, width);

+}

+

+static void

+delegate_combine_32_ca (pixman_implementation_t * imp,

+                        pixman_op_t               op,

+                        uint32_t *                dest,

+                        const uint32_t *          src,

+                        const uint32_t *          mask,

+                        int                       width)

+{

+    _pixman_implementation_combine_32_ca (imp->delegate,

+                                          op, dest, src, mask, width);

+}

+

+static void

+delegate_combine_64_ca (pixman_implementation_t * imp,

+                        pixman_op_t               op,

+                        uint64_t *                dest,

+                        const uint64_t *          src,

+                        const uint64_t *          mask,

+                        int                       width)

+{

+    _pixman_implementation_combine_64_ca (imp->delegate,

+                                          op, dest, src, mask, width);

+}

+

+static pixman_bool_t

+delegate_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                       dst_x,

+              int                       dst_y,

+              int                       width,

+              int                       height)

+{

+    return _pixman_implementation_blt (

+	imp->delegate, src_bits, dst_bits, src_stride, dst_stride,

+	src_bpp, dst_bpp, src_x, src_y, dst_x, dst_y,

+	width, height);

+}

+

+static pixman_bool_t

+delegate_fill (pixman_implementation_t *imp,

+               uint32_t *               bits,

+               int                      stride,

+               int                      bpp,

+               int                      x,

+               int                      y,

+               int                      width,

+               int                      height,

+               uint32_t                 xor)

+{

+    return _pixman_implementation_fill (

+	imp->delegate, bits, stride, bpp, x, y, width, height, xor);

+}

+

+static void

+delegate_src_iter_init (pixman_implementation_t *imp,

+			pixman_iter_t *	         iter)

+{

+    imp->delegate->src_iter_init (imp->delegate, iter);

+}

+

+static void

+delegate_dest_iter_init (pixman_implementation_t *imp,

+			 pixman_iter_t *	  iter)

+{

+    imp->delegate->dest_iter_init (imp->delegate, iter);

+}

+

+pixman_implementation_t *

+_pixman_implementation_create (pixman_implementation_t *delegate,

+			       const pixman_fast_path_t *fast_paths)

+{

+    pixman_implementation_t *imp = malloc (sizeof (pixman_implementation_t));

+    pixman_implementation_t *d;

+    int i;

+

+    if (!imp)

+	return NULL;

+

+    assert (fast_paths);

+

+    /* Make sure the whole delegate chain has the right toplevel */

+    imp->delegate = delegate;

+    for (d = imp; d != NULL; d = d->delegate)

+	d->toplevel = imp;

+

+    /* Fill out function pointers with ones that just delegate

+     */

+    imp->blt = delegate_blt;

+    imp->fill = delegate_fill;

+    imp->src_iter_init = delegate_src_iter_init;

+    imp->dest_iter_init = delegate_dest_iter_init;

+

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

+    {

+	imp->combine_32[i] = delegate_combine_32;

+	imp->combine_64[i] = delegate_combine_64;

+	imp->combine_32_ca[i] = delegate_combine_32_ca;

+	imp->combine_64_ca[i] = delegate_combine_64_ca;

+    }

+

+    imp->fast_paths = fast_paths;

+

+    return imp;

+}

+

+void

+_pixman_implementation_combine_32 (pixman_implementation_t * imp,

+                                   pixman_op_t               op,

+                                   uint32_t *                dest,

+                                   const uint32_t *          src,

+                                   const uint32_t *          mask,

+                                   int                       width)

+{

+    (*imp->combine_32[op]) (imp, op, dest, src, mask, width);

+}

+

+void

+_pixman_implementation_combine_64 (pixman_implementation_t * imp,

+                                   pixman_op_t               op,

+                                   uint64_t *                dest,

+                                   const uint64_t *          src,

+                                   const uint64_t *          mask,

+                                   int                       width)

+{

+    (*imp->combine_64[op]) (imp, op, dest, src, mask, width);

+}

+

+void

+_pixman_implementation_combine_32_ca (pixman_implementation_t * imp,

+                                      pixman_op_t               op,

+                                      uint32_t *                dest,

+                                      const uint32_t *          src,

+                                      const uint32_t *          mask,

+                                      int                       width)

+{

+    (*imp->combine_32_ca[op]) (imp, op, dest, src, mask, width);

+}

+

+void

+_pixman_implementation_combine_64_ca (pixman_implementation_t * imp,

+                                      pixman_op_t               op,

+                                      uint64_t *                dest,

+                                      const uint64_t *          src,

+                                      const uint64_t *          mask,

+                                      int                       width)

+{

+    (*imp->combine_64_ca[op]) (imp, op, dest, src, mask, width);

+}

+

+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                       dst_x,

+                            int                       dst_y,

+                            int                       width,

+                            int                       height)

+{

+    return (*imp->blt) (imp, src_bits, dst_bits, src_stride, dst_stride,

+			src_bpp, dst_bpp, src_x, src_y, dst_x, dst_y,

+			width, 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                 xor)

+{

+    return (*imp->fill) (imp, bits, stride, bpp, x, y, width, height, xor);

+}

+

+static uint32_t *

+get_scanline_null (pixman_iter_t *iter, const uint32_t *mask)

+{

+    return NULL;

+}

+

+void

+_pixman_implementation_src_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)

+{

+    iter->image = image;

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

+    iter->x = x;

+    iter->y = y;

+    iter->width = width;

+    iter->height = height;

+    iter->flags = flags;

+

+    if (!image)

+    {

+	iter->get_scanline = get_scanline_null;

+    }

+    else if ((flags & (ITER_IGNORE_ALPHA | ITER_IGNORE_RGB)) ==

+	     (ITER_IGNORE_ALPHA | ITER_IGNORE_RGB))

+    {

+	iter->get_scanline = _pixman_iter_get_scanline_noop;

+    }

+    else

+    {

+	(*imp->src_iter_init) (imp, iter);

+    }

+}

+

+void

+_pixman_implementation_dest_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)

+{

+    iter->image = image;

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

+    iter->x = x;

+    iter->y = y;

+    iter->width = width;

+    iter->height = height;

+    iter->flags = flags;

+

+    (*imp->dest_iter_init) (imp, iter);

+}

diff --git a/pixman/pixman/pixman-linear-gradient.c b/pixman/pixman/pixman-linear-gradient.c
index 07303fc03..3d5bbf63d 100644
--- a/pixman/pixman/pixman-linear-gradient.c
+++ b/pixman/pixman/pixman-linear-gradient.c
@@ -1,292 +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,
-				   int             x,
-				   int             y,
-				   int             width,
-				   int             height,
-				   uint8_t        *buffer,
-				   iter_flags_t    flags)
-{
-    if (linear_gradient_is_horizontal (image, x, y, width, height))
-    {
-	if (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 (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->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;

+}

+

diff --git a/pixman/pixman/pixman-private.h b/pixman/pixman/pixman-private.h
index ee7f4d676..658aeea8a 100644
--- a/pixman/pixman/pixman-private.h
+++ b/pixman/pixman/pixman-private.h
@@ -212,14 +212,19 @@ typedef enum
 

 struct pixman_iter_t

 {

-    pixman_iter_get_scanline_t	get_scanline;

-    pixman_iter_write_back_t	write_back;

-

+    /* These are initialized by _pixman_implementation_{src,dest}_init */

     pixman_image_t *		image;

     uint32_t *			buffer;

     int				x, y;

     int				width;

+    int				height;

+    iter_flags_t		flags;

 

+    /* These function pointers are initialized by the implementation */

+    pixman_iter_get_scanline_t	get_scanline;

+    pixman_iter_write_back_t	write_back;

+

+    /* These fields are scratch data that implementations can use */

     uint8_t *			bits;

     int				stride;

 };

@@ -228,39 +233,22 @@ 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,

-				  int x, int y, int width, int height,

-				  uint8_t *buffer, iter_flags_t flags);

+_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,

-				   int x, int y, int width, int height,

-				   uint8_t *buffer, iter_flags_t flags);

+_pixman_bits_image_dest_iter_init (pixman_image_t *image, pixman_iter_t *iter);

 

 void

-_pixman_solid_fill_iter_init (pixman_image_t *image,

-			      pixman_iter_t  *iter,

-			      int x, int y, int width, int height,

-			      uint8_t *buffer, iter_flags_t flags);

+_pixman_solid_fill_iter_init (pixman_image_t *image, pixman_iter_t  *iter);

 

 void

-_pixman_linear_gradient_iter_init (pixman_image_t *image,

-				   pixman_iter_t  *iter,

-				   int x, int y, int width, int height,

-				   uint8_t *buffer, iter_flags_t flags);

+_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,

-				   int x, int y, int width, int height,

-				   uint8_t *buffer, iter_flags_t flags);

+_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,

-				    int x, int y, int width, int height,

-				    uint8_t *buffer, iter_flags_t flags);

+_pixman_conical_gradient_iter_init (pixman_image_t *image, pixman_iter_t *iter);

 

 pixman_image_t *

 _pixman_image_allocate (void);

@@ -408,14 +396,7 @@ typedef pixman_bool_t (*pixman_fill_func_t) (pixman_implementation_t *imp,
 					     int                      height,

 					     uint32_t                 xor);

 typedef void (*pixman_iter_init_func_t) (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);

+                                         pixman_iter_t           *iter);

 

 void _pixman_setup_combiner_functions_32 (pixman_implementation_t *imp);

 void _pixman_setup_combiner_functions_64 (pixman_implementation_t *imp);

diff --git a/pixman/pixman/pixman-radial-gradient.c b/pixman/pixman/pixman-radial-gradient.c
index 6523b8259..63c712cc2 100644
--- a/pixman/pixman/pixman-radial-gradient.c
+++ b/pixman/pixman/pixman-radial-gradient.c
@@ -1,463 +1,460 @@
-/* -*- Mode: c; c-basic-offset: 4; tab-width: 8; indent-tabs-mode: t; -*- */
-/*
- *
- * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc.
- * Copyright © 2000 SuSE, Inc.
- *             2005 Lars Knoll & Zack Rusin, Trolltech
- * Copyright © 2007 Red Hat, Inc.
- *
- *
- * 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 inline pixman_fixed_32_32_t
-dot (pixman_fixed_48_16_t x1,
-     pixman_fixed_48_16_t y1,
-     pixman_fixed_48_16_t z1,
-     pixman_fixed_48_16_t x2,
-     pixman_fixed_48_16_t y2,
-     pixman_fixed_48_16_t z2)
-{
-    /*
-     * Exact computation, assuming that the input values can
-     * be represented as pixman_fixed_16_16_t
-     */
-    return x1 * x2 + y1 * y2 + z1 * z2;
-}
-
-static inline double
-fdot (double x1,
-      double y1,
-      double z1,
-      double x2,
-      double y2,
-      double z2)
-{
-    /*
-     * Error can be unbound in some special cases.
-     * Using clever dot product algorithms (for example compensated
-     * dot product) would improve this but make the code much less
-     * obvious
-     */
-    return x1 * x2 + y1 * y2 + z1 * z2;
-}
-
-static uint32_t
-radial_compute_color (double                    a,
-		      double                    b,
-		      double                    c,
-		      double                    inva,
-		      double                    dr,
-		      double                    mindr,
-		      pixman_gradient_walker_t *walker,
-		      pixman_repeat_t           repeat)
-{
-    /*
-     * In this function error propagation can lead to bad results:
-     *  - det can have an unbound error (if b*b-a*c is very small),
-     *    potentially making it the opposite sign of what it should have been
-     *    (thus clearing a pixel that would have been colored or vice-versa)
-     *    or propagating the error to sqrtdet;
-     *    if det has the wrong sign or b is very small, this can lead to bad
-     *    results
-     *
-     *  - the algorithm used to compute the solutions of the quadratic
-     *    equation is not numerically stable (but saves one division compared
-     *    to the numerically stable one);
-     *    this can be a problem if a*c is much smaller than b*b
-     *
-     *  - the above problems are worse if a is small (as inva becomes bigger)
-     */
-    double det;
-
-    if (a == 0)
-    {
-	double t;
-
-	if (b == 0)
-	    return 0;
-
-	t = pixman_fixed_1 / 2 * c / b;
-	if (repeat == PIXMAN_REPEAT_NONE)
-	{
-	    if (0 <= t && t <= pixman_fixed_1)
-		return _pixman_gradient_walker_pixel (walker, t);
-	}
-	else
-	{
-	    if (t * dr > mindr)
-		return _pixman_gradient_walker_pixel (walker, t);
-	}
-
-	return 0;
-    }
-
-    det = fdot (b, a, 0, b, -c, 0);
-    if (det >= 0)
-    {
-	double sqrtdet, t0, t1;
-
-	sqrtdet = sqrt (det);
-	t0 = (b + sqrtdet) * inva;
-	t1 = (b - sqrtdet) * inva;
-
-	if (repeat == PIXMAN_REPEAT_NONE)
-	{
-	    if (0 <= t0 && t0 <= pixman_fixed_1)
-		return _pixman_gradient_walker_pixel (walker, t0);
-	    else if (0 <= t1 && t1 <= pixman_fixed_1)
-		return _pixman_gradient_walker_pixel (walker, t1);
-	}
-	else
-	{
-	    if (t0 * dr > mindr)
-		return _pixman_gradient_walker_pixel (walker, t0);
-	    else if (t1 * dr > mindr)
-		return _pixman_gradient_walker_pixel (walker, t1);
-	}
-    }
-
-    return 0;
-}
-
-static uint32_t *
-radial_get_scanline_narrow (pixman_iter_t *iter, const uint32_t *mask)
-{
-    /*
-     * Implementation of radial gradients following the PDF specification.
-     * See section 8.7.4.5.4 Type 3 (Radial) Shadings of the PDF Reference
-     * Manual (PDF 32000-1:2008 at the time of this writing).
-     * 
-     * In the radial gradient problem we are given two circles (c₁,r₁) and
-     * (c₂,r₂) that define the gradient itself.
-     *
-     * Mathematically the gradient can be defined as the family of circles
-     *
-     *     ((1-t)·c₁ + t·(c₂), (1-t)·r₁ + t·r₂)
-     *
-     * excluding those circles whose radius would be < 0. When a point
-     * belongs to more than one circle, the one with a bigger t is the only
-     * one that contributes to its color. When a point does not belong
-     * to any of the circles, it is transparent black, i.e. RGBA (0, 0, 0, 0).
-     * Further limitations on the range of values for t are imposed when
-     * the gradient is not repeated, namely t must belong to [0,1].
-     *
-     * The graphical result is the same as drawing the valid (radius > 0)
-     * circles with increasing t in [-inf, +inf] (or in [0,1] if the gradient
-     * is not repeated) using SOURCE operatior composition.
-     *
-     * It looks like a cone pointing towards the viewer if the ending circle
-     * is smaller than the starting one, a cone pointing inside the page if
-     * the starting circle is the smaller one and like a cylinder if they
-     * have the same radius.
-     *
-     * What we actually do is, given the point whose color we are interested
-     * in, compute the t values for that point, solving for t in:
-     *
-     *     length((1-t)·c₁ + t·(c₂) - p) = (1-t)·r₁ + t·r₂
-     * 
-     * Let's rewrite it in a simpler way, by defining some auxiliary
-     * variables:
-     *
-     *     cd = c₂ - c₁
-     *     pd = p - c₁
-     *     dr = r₂ - r₁
-     *     lenght(t·cd - pd) = r₁ + t·dr
-     *
-     * which actually means
-     *
-     *     hypot(t·cdx - pdx, t·cdy - pdy) = r₁ + t·dr
-     *
-     * or
-     *
-     *     ⎷((t·cdx - pdx)² + (t·cdy - pdy)²) = r₁ + t·dr.
-     *
-     * If we impose (as stated earlier) that r₁ + t·dr >= 0, it becomes:
-     *
-     *     (t·cdx - pdx)² + (t·cdy - pdy)² = (r₁ + t·dr)²
-     *
-     * where we can actually expand the squares and solve for t:
-     *
-     *     t²cdx² - 2t·cdx·pdx + pdx² + t²cdy² - 2t·cdy·pdy + pdy² =
-     *       = r₁² + 2·r₁·t·dr + t²·dr²
-     *
-     *     (cdx² + cdy² - dr²)t² - 2(cdx·pdx + cdy·pdy + r₁·dr)t +
-     *         (pdx² + pdy² - r₁²) = 0
-     *
-     *     A = cdx² + cdy² - dr²
-     *     B = pdx·cdx + pdy·cdy + r₁·dr
-     *     C = pdx² + pdy² - r₁²
-     *     At² - 2Bt + C = 0
-     * 
-     * The solutions (unless the equation degenerates because of A = 0) are:
-     *
-     *     t = (B ± ⎷(B² - A·C)) / A
-     *
-     * The solution we are going to prefer is the bigger one, unless the
-     * radius associated to it is negative (or it falls outside the valid t
-     * range).
-     *
-     * Additional observations (useful for optimizations):
-     * A does not depend on p
-     *
-     * A < 0 <=> one of the two circles completely contains the other one
-     *   <=> for every p, the radiuses associated with the two t solutions
-     *       have opposite sign
-     */
-    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;
-    radial_gradient_t *radial = (radial_gradient_t *)image;
-    uint32_t *end = buffer + width;
-    pixman_gradient_walker_t walker;
-    pixman_vector_t v, unit;
-
-    /* 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;
-
-    _pixman_gradient_walker_init (&walker, gradient, image->common.repeat);
-
-    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;
-    }
-
-    if (unit.vector[2] == 0 && v.vector[2] == pixman_fixed_1)
-    {
-	/*
-	 * Given:
-	 *
-	 * t = (B ± ⎷(B² - A·C)) / A
-	 *
-	 * where
-	 *
-	 * A = cdx² + cdy² - dr²
-	 * B = pdx·cdx + pdy·cdy + r₁·dr
-	 * C = pdx² + pdy² - r₁²
-	 * det = B² - A·C
-	 *
-	 * Since we have an affine transformation, we know that (pdx, pdy)
-	 * increase linearly with each pixel,
-	 *
-	 * pdx = pdx₀ + n·ux,
-	 * pdy = pdy₀ + n·uy,
-	 *
-	 * we can then express B, C and det through multiple differentiation.
-	 */
-	pixman_fixed_32_32_t b, db, c, dc, ddc;
-
-	/* warning: this computation may overflow */
-	v.vector[0] -= radial->c1.x;
-	v.vector[1] -= radial->c1.y;
-
-	/*
-	 * B and C are computed and updated exactly.
-	 * If fdot was used instead of dot, in the worst case it would
-	 * lose 11 bits of precision in each of the multiplication and
-	 * summing up would zero out all the bit that were preserved,
-	 * thus making the result 0 instead of the correct one.
-	 * This would mean a worst case of unbound relative error or
-	 * about 2^10 absolute error
-	 */
-	b = dot (v.vector[0], v.vector[1], radial->c1.radius,
-		 radial->delta.x, radial->delta.y, radial->delta.radius);
-	db = dot (unit.vector[0], unit.vector[1], 0,
-		  radial->delta.x, radial->delta.y, 0);
-
-	c = dot (v.vector[0], v.vector[1],
-		 -((pixman_fixed_48_16_t) radial->c1.radius),
-		 v.vector[0], v.vector[1], radial->c1.radius);
-	dc = dot (2 * (pixman_fixed_48_16_t) v.vector[0] + unit.vector[0],
-		  2 * (pixman_fixed_48_16_t) v.vector[1] + unit.vector[1],
-		  0,
-		  unit.vector[0], unit.vector[1], 0);
-	ddc = 2 * dot (unit.vector[0], unit.vector[1], 0,
-		       unit.vector[0], unit.vector[1], 0);
-
-	while (buffer < end)
-	{
-	    if (!mask || *mask++)
-	    {
-		*buffer = radial_compute_color (radial->a, b, c,
-						radial->inva,
-						radial->delta.radius,
-						radial->mindr,
-						&walker,
-						image->common.repeat);
-	    }
-
-	    b += db;
-	    c += dc;
-	    dc += ddc;
-	    ++buffer;
-	}
-    }
-    else
-    {
-	/* projective */
-	/* Warning:
-	 * error propagation guarantees are much looser than in the affine case
-	 */
-	while (buffer < end)
-	{
-	    if (!mask || *mask++)
-	    {
-		if (v.vector[2] != 0)
-		{
-		    double pdx, pdy, invv2, b, c;
-
-		    invv2 = 1. * pixman_fixed_1 / v.vector[2];
-
-		    pdx = v.vector[0] * invv2 - radial->c1.x;
-		    /*    / pixman_fixed_1 */
-
-		    pdy = v.vector[1] * invv2 - radial->c1.y;
-		    /*    / pixman_fixed_1 */
-
-		    b = fdot (pdx, pdy, radial->c1.radius,
-			      radial->delta.x, radial->delta.y,
-			      radial->delta.radius);
-		    /*  / pixman_fixed_1 / pixman_fixed_1 */
-
-		    c = fdot (pdx, pdy, -radial->c1.radius,
-			      pdx, pdy, radial->c1.radius);
-		    /*  / pixman_fixed_1 / pixman_fixed_1 */
-
-		    *buffer = radial_compute_color (radial->a, b, c,
-						    radial->inva,
-						    radial->delta.radius,
-						    radial->mindr,
-						    &walker,
-						    image->common.repeat);
-		}
-		else
-		{
-		    *buffer = 0;
-		}
-	    }
-
-	    ++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 *
-radial_get_scanline_wide (pixman_iter_t *iter, const uint32_t *mask)
-{
-    uint32_t *buffer = radial_get_scanline_narrow (iter, NULL);
-
-    pixman_expand ((uint64_t *)buffer, buffer, PIXMAN_a8r8g8b8, iter->width);
-
-    return buffer;
-}
-
-void
-_pixman_radial_gradient_iter_init (pixman_image_t *image,
-				   pixman_iter_t *iter,
-				   int x, int y, int width, int height,
-				   uint8_t *buffer, iter_flags_t flags)
-{
-    if (flags & ITER_NARROW)
-	iter->get_scanline = radial_get_scanline_narrow;
-    else
-	iter->get_scanline = radial_get_scanline_wide;
-}
-
-PIXMAN_EXPORT pixman_image_t *
-pixman_image_create_radial_gradient (pixman_point_fixed_t *        inner,
-                                     pixman_point_fixed_t *        outer,
-                                     pixman_fixed_t                inner_radius,
-                                     pixman_fixed_t                outer_radius,
-                                     const pixman_gradient_stop_t *stops,
-                                     int                           n_stops)
-{
-    pixman_image_t *image;
-    radial_gradient_t *radial;
-
-    image = _pixman_image_allocate ();
-
-    if (!image)
-	return NULL;
-
-    radial = &image->radial;
-
-    if (!_pixman_init_gradient (&radial->common, stops, n_stops))
-    {
-	free (image);
-	return NULL;
-    }
-
-    image->type = RADIAL;
-
-    radial->c1.x = inner->x;
-    radial->c1.y = inner->y;
-    radial->c1.radius = inner_radius;
-    radial->c2.x = outer->x;
-    radial->c2.y = outer->y;
-    radial->c2.radius = outer_radius;
-
-    /* warning: this computations may overflow */
-    radial->delta.x = radial->c2.x - radial->c1.x;
-    radial->delta.y = radial->c2.y - radial->c1.y;
-    radial->delta.radius = radial->c2.radius - radial->c1.radius;
-
-    /* computed exactly, then cast to double -> every bit of the double
-       representation is correct (53 bits) */
-    radial->a = dot (radial->delta.x, radial->delta.y, -radial->delta.radius,
-		     radial->delta.x, radial->delta.y, radial->delta.radius);
-    if (radial->a != 0)
-	radial->inva = 1. * pixman_fixed_1 / radial->a;
-
-    radial->mindr = -1. * pixman_fixed_1 * radial->c1.radius;
-
-    return image;
-}
-
+/* -*- Mode: c; c-basic-offset: 4; tab-width: 8; indent-tabs-mode: t; -*- */

+/*

+ *

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

+ * Copyright © 2000 SuSE, Inc.

+ *             2005 Lars Knoll & Zack Rusin, Trolltech

+ * Copyright © 2007 Red Hat, Inc.

+ *

+ *

+ * 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 inline pixman_fixed_32_32_t

+dot (pixman_fixed_48_16_t x1,

+     pixman_fixed_48_16_t y1,

+     pixman_fixed_48_16_t z1,

+     pixman_fixed_48_16_t x2,

+     pixman_fixed_48_16_t y2,

+     pixman_fixed_48_16_t z2)

+{

+    /*

+     * Exact computation, assuming that the input values can

+     * be represented as pixman_fixed_16_16_t

+     */

+    return x1 * x2 + y1 * y2 + z1 * z2;

+}

+

+static inline double

+fdot (double x1,

+      double y1,

+      double z1,

+      double x2,

+      double y2,

+      double z2)

+{

+    /*

+     * Error can be unbound in some special cases.

+     * Using clever dot product algorithms (for example compensated

+     * dot product) would improve this but make the code much less

+     * obvious

+     */

+    return x1 * x2 + y1 * y2 + z1 * z2;

+}

+

+static uint32_t

+radial_compute_color (double                    a,

+		      double                    b,

+		      double                    c,

+		      double                    inva,

+		      double                    dr,

+		      double                    mindr,

+		      pixman_gradient_walker_t *walker,

+		      pixman_repeat_t           repeat)

+{

+    /*

+     * In this function error propagation can lead to bad results:

+     *  - det can have an unbound error (if b*b-a*c is very small),

+     *    potentially making it the opposite sign of what it should have been

+     *    (thus clearing a pixel that would have been colored or vice-versa)

+     *    or propagating the error to sqrtdet;

+     *    if det has the wrong sign or b is very small, this can lead to bad

+     *    results

+     *

+     *  - the algorithm used to compute the solutions of the quadratic

+     *    equation is not numerically stable (but saves one division compared

+     *    to the numerically stable one);

+     *    this can be a problem if a*c is much smaller than b*b

+     *

+     *  - the above problems are worse if a is small (as inva becomes bigger)

+     */

+    double det;

+

+    if (a == 0)

+    {

+	double t;

+

+	if (b == 0)

+	    return 0;

+

+	t = pixman_fixed_1 / 2 * c / b;

+	if (repeat == PIXMAN_REPEAT_NONE)

+	{

+	    if (0 <= t && t <= pixman_fixed_1)

+		return _pixman_gradient_walker_pixel (walker, t);

+	}

+	else

+	{

+	    if (t * dr > mindr)

+		return _pixman_gradient_walker_pixel (walker, t);

+	}

+

+	return 0;

+    }

+

+    det = fdot (b, a, 0, b, -c, 0);

+    if (det >= 0)

+    {

+	double sqrtdet, t0, t1;

+

+	sqrtdet = sqrt (det);

+	t0 = (b + sqrtdet) * inva;

+	t1 = (b - sqrtdet) * inva;

+

+	if (repeat == PIXMAN_REPEAT_NONE)

+	{

+	    if (0 <= t0 && t0 <= pixman_fixed_1)

+		return _pixman_gradient_walker_pixel (walker, t0);

+	    else if (0 <= t1 && t1 <= pixman_fixed_1)

+		return _pixman_gradient_walker_pixel (walker, t1);

+	}

+	else

+	{

+	    if (t0 * dr > mindr)

+		return _pixman_gradient_walker_pixel (walker, t0);

+	    else if (t1 * dr > mindr)

+		return _pixman_gradient_walker_pixel (walker, t1);

+	}

+    }

+

+    return 0;

+}

+

+static uint32_t *

+radial_get_scanline_narrow (pixman_iter_t *iter, const uint32_t *mask)

+{

+    /*

+     * Implementation of radial gradients following the PDF specification.

+     * See section 8.7.4.5.4 Type 3 (Radial) Shadings of the PDF Reference

+     * Manual (PDF 32000-1:2008 at the time of this writing).

+     * 

+     * In the radial gradient problem we are given two circles (c₁,r₁) and

+     * (c₂,r₂) that define the gradient itself.

+     *

+     * Mathematically the gradient can be defined as the family of circles

+     *

+     *     ((1-t)·c₁ + t·(c₂), (1-t)·r₁ + t·r₂)

+     *

+     * excluding those circles whose radius would be < 0. When a point

+     * belongs to more than one circle, the one with a bigger t is the only

+     * one that contributes to its color. When a point does not belong

+     * to any of the circles, it is transparent black, i.e. RGBA (0, 0, 0, 0).

+     * Further limitations on the range of values for t are imposed when

+     * the gradient is not repeated, namely t must belong to [0,1].

+     *

+     * The graphical result is the same as drawing the valid (radius > 0)

+     * circles with increasing t in [-inf, +inf] (or in [0,1] if the gradient

+     * is not repeated) using SOURCE operatior composition.

+     *

+     * It looks like a cone pointing towards the viewer if the ending circle

+     * is smaller than the starting one, a cone pointing inside the page if

+     * the starting circle is the smaller one and like a cylinder if they

+     * have the same radius.

+     *

+     * What we actually do is, given the point whose color we are interested

+     * in, compute the t values for that point, solving for t in:

+     *

+     *     length((1-t)·c₁ + t·(c₂) - p) = (1-t)·r₁ + t·r₂

+     * 

+     * Let's rewrite it in a simpler way, by defining some auxiliary

+     * variables:

+     *

+     *     cd = c₂ - c₁

+     *     pd = p - c₁

+     *     dr = r₂ - r₁

+     *     lenght(t·cd - pd) = r₁ + t·dr

+     *

+     * which actually means

+     *

+     *     hypot(t·cdx - pdx, t·cdy - pdy) = r₁ + t·dr

+     *

+     * or

+     *

+     *     ⎷((t·cdx - pdx)² + (t·cdy - pdy)²) = r₁ + t·dr.

+     *

+     * If we impose (as stated earlier) that r₁ + t·dr >= 0, it becomes:

+     *

+     *     (t·cdx - pdx)² + (t·cdy - pdy)² = (r₁ + t·dr)²

+     *

+     * where we can actually expand the squares and solve for t:

+     *

+     *     t²cdx² - 2t·cdx·pdx + pdx² + t²cdy² - 2t·cdy·pdy + pdy² =

+     *       = r₁² + 2·r₁·t·dr + t²·dr²

+     *

+     *     (cdx² + cdy² - dr²)t² - 2(cdx·pdx + cdy·pdy + r₁·dr)t +

+     *         (pdx² + pdy² - r₁²) = 0

+     *

+     *     A = cdx² + cdy² - dr²

+     *     B = pdx·cdx + pdy·cdy + r₁·dr

+     *     C = pdx² + pdy² - r₁²

+     *     At² - 2Bt + C = 0

+     * 

+     * The solutions (unless the equation degenerates because of A = 0) are:

+     *

+     *     t = (B ± ⎷(B² - A·C)) / A

+     *

+     * The solution we are going to prefer is the bigger one, unless the

+     * radius associated to it is negative (or it falls outside the valid t

+     * range).

+     *

+     * Additional observations (useful for optimizations):

+     * A does not depend on p

+     *

+     * A < 0 <=> one of the two circles completely contains the other one

+     *   <=> for every p, the radiuses associated with the two t solutions

+     *       have opposite sign

+     */

+    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;

+    radial_gradient_t *radial = (radial_gradient_t *)image;

+    uint32_t *end = buffer + width;

+    pixman_gradient_walker_t walker;

+    pixman_vector_t v, unit;

+

+    /* 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;

+

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

+

+    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;

+    }

+

+    if (unit.vector[2] == 0 && v.vector[2] == pixman_fixed_1)

+    {

+	/*

+	 * Given:

+	 *

+	 * t = (B ± ⎷(B² - A·C)) / A

+	 *

+	 * where

+	 *

+	 * A = cdx² + cdy² - dr²

+	 * B = pdx·cdx + pdy·cdy + r₁·dr

+	 * C = pdx² + pdy² - r₁²

+	 * det = B² - A·C

+	 *

+	 * Since we have an affine transformation, we know that (pdx, pdy)

+	 * increase linearly with each pixel,

+	 *

+	 * pdx = pdx₀ + n·ux,

+	 * pdy = pdy₀ + n·uy,

+	 *

+	 * we can then express B, C and det through multiple differentiation.

+	 */

+	pixman_fixed_32_32_t b, db, c, dc, ddc;

+

+	/* warning: this computation may overflow */

+	v.vector[0] -= radial->c1.x;

+	v.vector[1] -= radial->c1.y;

+

+	/*

+	 * B and C are computed and updated exactly.

+	 * If fdot was used instead of dot, in the worst case it would

+	 * lose 11 bits of precision in each of the multiplication and

+	 * summing up would zero out all the bit that were preserved,

+	 * thus making the result 0 instead of the correct one.

+	 * This would mean a worst case of unbound relative error or

+	 * about 2^10 absolute error

+	 */

+	b = dot (v.vector[0], v.vector[1], radial->c1.radius,

+		 radial->delta.x, radial->delta.y, radial->delta.radius);

+	db = dot (unit.vector[0], unit.vector[1], 0,

+		  radial->delta.x, radial->delta.y, 0);

+

+	c = dot (v.vector[0], v.vector[1],

+		 -((pixman_fixed_48_16_t) radial->c1.radius),

+		 v.vector[0], v.vector[1], radial->c1.radius);

+	dc = dot (2 * (pixman_fixed_48_16_t) v.vector[0] + unit.vector[0],

+		  2 * (pixman_fixed_48_16_t) v.vector[1] + unit.vector[1],

+		  0,

+		  unit.vector[0], unit.vector[1], 0);

+	ddc = 2 * dot (unit.vector[0], unit.vector[1], 0,

+		       unit.vector[0], unit.vector[1], 0);

+

+	while (buffer < end)

+	{

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

+	    {

+		*buffer = radial_compute_color (radial->a, b, c,

+						radial->inva,

+						radial->delta.radius,

+						radial->mindr,

+						&walker,

+						image->common.repeat);

+	    }

+

+	    b += db;

+	    c += dc;

+	    dc += ddc;

+	    ++buffer;

+	}

+    }

+    else

+    {

+	/* projective */

+	/* Warning:

+	 * error propagation guarantees are much looser than in the affine case

+	 */

+	while (buffer < end)

+	{

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

+	    {

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

+		{

+		    double pdx, pdy, invv2, b, c;

+

+		    invv2 = 1. * pixman_fixed_1 / v.vector[2];

+

+		    pdx = v.vector[0] * invv2 - radial->c1.x;

+		    /*    / pixman_fixed_1 */

+

+		    pdy = v.vector[1] * invv2 - radial->c1.y;

+		    /*    / pixman_fixed_1 */

+

+		    b = fdot (pdx, pdy, radial->c1.radius,

+			      radial->delta.x, radial->delta.y,

+			      radial->delta.radius);

+		    /*  / pixman_fixed_1 / pixman_fixed_1 */

+

+		    c = fdot (pdx, pdy, -radial->c1.radius,

+			      pdx, pdy, radial->c1.radius);

+		    /*  / pixman_fixed_1 / pixman_fixed_1 */

+

+		    *buffer = radial_compute_color (radial->a, b, c,

+						    radial->inva,

+						    radial->delta.radius,

+						    radial->mindr,

+						    &walker,

+						    image->common.repeat);

+		}

+		else

+		{

+		    *buffer = 0;

+		}

+	    }

+

+	    ++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 *

+radial_get_scanline_wide (pixman_iter_t *iter, const uint32_t *mask)

+{

+    uint32_t *buffer = radial_get_scanline_narrow (iter, NULL);

+

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

+

+    return buffer;

+}

+

+void

+_pixman_radial_gradient_iter_init (pixman_image_t *image, pixman_iter_t *iter)

+{

+    if (iter->flags & ITER_NARROW)

+	iter->get_scanline = radial_get_scanline_narrow;

+    else

+	iter->get_scanline = radial_get_scanline_wide;

+}

+

+PIXMAN_EXPORT pixman_image_t *

+pixman_image_create_radial_gradient (pixman_point_fixed_t *        inner,

+                                     pixman_point_fixed_t *        outer,

+                                     pixman_fixed_t                inner_radius,

+                                     pixman_fixed_t                outer_radius,

+                                     const pixman_gradient_stop_t *stops,

+                                     int                           n_stops)

+{

+    pixman_image_t *image;

+    radial_gradient_t *radial;

+

+    image = _pixman_image_allocate ();

+

+    if (!image)

+	return NULL;

+

+    radial = &image->radial;

+

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

+    {

+	free (image);

+	return NULL;

+    }

+

+    image->type = RADIAL;

+

+    radial->c1.x = inner->x;

+    radial->c1.y = inner->y;

+    radial->c1.radius = inner_radius;

+    radial->c2.x = outer->x;

+    radial->c2.y = outer->y;

+    radial->c2.radius = outer_radius;

+

+    /* warning: this computations may overflow */

+    radial->delta.x = radial->c2.x - radial->c1.x;

+    radial->delta.y = radial->c2.y - radial->c1.y;

+    radial->delta.radius = radial->c2.radius - radial->c1.radius;

+

+    /* computed exactly, then cast to double -> every bit of the double

+       representation is correct (53 bits) */

+    radial->a = dot (radial->delta.x, radial->delta.y, -radial->delta.radius,

+		     radial->delta.x, radial->delta.y, radial->delta.radius);

+    if (radial->a != 0)

+	radial->inva = 1. * pixman_fixed_1 / radial->a;

+

+    radial->mindr = -1. * pixman_fixed_1 * radial->c1.radius;

+

+    return image;

+}

+

diff --git a/pixman/pixman/pixman-solid-fill.c b/pixman/pixman/pixman-solid-fill.c
index 67681f2c0..fcda3abb5 100644
--- a/pixman/pixman/pixman-solid-fill.c
+++ b/pixman/pixman/pixman-solid-fill.c
@@ -1,92 +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,
-			      int x, int y, int width, int height,
-			      uint8_t *buffer, iter_flags_t flags)
-{
-    if (flags & ITER_NARROW)
-    {
-	uint32_t *b = (uint32_t *)buffer;
-	uint32_t *e = b + width;
-	uint32_t color = image->solid.color_32;
-
-	while (b < e)
-	    *(b++) = color;
-    }
-    else
-    {
-	uint64_t *b = (uint64_t *)buffer;
-	uint64_t *e = b + 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->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 a983164d4..a52a959f5 100644
--- a/pixman/pixman/pixman-sse2.c
+++ b/pixman/pixman/pixman-sse2.c
@@ -5978,19 +5978,21 @@ static const fetcher_info_t fetchers[] =
 };

 

 static void

-sse2_src_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)

+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)

 

-    if ((flags & ITER_NARROW)				&&

-	(image->common.flags & FLAGS) == FLAGS		&&

-	x >= 0 && y >= 0				&&

-	x + width <= image->bits.width			&&

+    if ((iter->flags & ITER_NARROW)				&&

+	(image->common.flags & FLAGS) == FLAGS			&&

+	x >= 0 && y >= 0					&&

+	x + width <= image->bits.width				&&

 	y + height <= image->bits.height)

     {

 	const fetcher_info_t *f;

@@ -6002,10 +6004,8 @@ sse2_src_iter_init (pixman_implementation_t *imp,
 		uint8_t *b = (uint8_t *)image->bits.bits;

 		int s = image->bits.rowstride * 4;

 

-		iter->bits = b + s * y + x * PIXMAN_FORMAT_BPP (f->format) / 8;

+		iter->bits = b + s * iter->y + x * PIXMAN_FORMAT_BPP (f->format) / 8;

 		iter->stride = s;

-		iter->width = width;

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

 

 		iter->get_scanline = f->get_scanline;

 		return;

@@ -6013,8 +6013,7 @@ sse2_src_iter_init (pixman_implementation_t *imp,
 	}

     }

 

-    _pixman_implementation_src_iter_init (

-	imp->delegate, iter, image, x, y, width, height, buffer, flags);

+    imp->delegate->src_iter_init (imp->delegate, iter);

 }

 

 #if defined(__GNUC__) && !defined(__x86_64__) && !defined(__amd64__)