pixman mesalib git update 26 jan 2011

7 files changed, 3115 insertions, 3117 deletions

diff --git a/pixman/pixman/pixman-fast-path.c b/pixman/pixman/pixman-fast-path.c
index 868175f60..736e302c6 100644
--- a/pixman/pixman/pixman-fast-path.c
+++ b/pixman/pixman/pixman-fast-path.c
@@ -1,1937 +1,1936 @@
-/* -*- Mode: c; c-basic-offset: 4; tab-width: 8; indent-tabs-mode: t; -*- */
-/*
- * Copyright © 2000 SuSE, Inc.
- * 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 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.
- *
- * Author:  Keith Packard, SuSE, Inc.
- */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-#include <string.h>
-#include <stdlib.h>
-#include "pixman-private.h"
-#include "pixman-combine32.h"
-#include "pixman-fast-path.h"
-
-static force_inline uint32_t
-fetch_24 (uint8_t *a)
-{
-    if (((unsigned long)a) & 1)
-    {
-#ifdef WORDS_BIGENDIAN
-	return (*a << 16) | (*(uint16_t *)(a + 1));
-#else
-	return *a | (*(uint16_t *)(a + 1) << 8);
-#endif
-    }
-    else
-    {
-#ifdef WORDS_BIGENDIAN
-	return (*(uint16_t *)a << 8) | *(a + 2);
-#else
-	return *(uint16_t *)a | (*(a + 2) << 16);
-#endif
-    }
-}
-
-static force_inline void
-store_24 (uint8_t *a,
-          uint32_t v)
-{
-    if (((unsigned long)a) & 1)
-    {
-#ifdef WORDS_BIGENDIAN
-	*a = (uint8_t) (v >> 16);
-	*(uint16_t *)(a + 1) = (uint16_t) (v);
-#else
-	*a = (uint8_t) (v);
-	*(uint16_t *)(a + 1) = (uint16_t) (v >> 8);
-#endif
-    }
-    else
-    {
-#ifdef WORDS_BIGENDIAN
-	*(uint16_t *)a = (uint16_t)(v >> 8);
-	*(a + 2) = (uint8_t)v;
-#else
-	*(uint16_t *)a = (uint16_t)v;
-	*(a + 2) = (uint8_t)(v >> 16);
-#endif
-    }
-}
-
-static force_inline uint32_t
-over (uint32_t src,
-      uint32_t dest)
-{
-    uint32_t a = ~src >> 24;
-
-    UN8x4_MUL_UN8_ADD_UN8x4 (dest, a, src);
-
-    return dest;
-}
-
-static uint32_t
-in (uint32_t x,
-    uint8_t  y)
-{
-    uint16_t a = y;
-
-    UN8x4_MUL_UN8 (x, a);
-
-    return x;
-}
-
-/*
- * Naming convention:
- *
- *  op_src_mask_dest
- */
-static void
-fast_composite_over_x888_8_8888 (pixman_implementation_t *imp,
-                                 pixman_op_t              op,
-                                 pixman_image_t *         src_image,
-                                 pixman_image_t *         mask_image,
-                                 pixman_image_t *         dst_image,
-                                 int32_t                  src_x,
-                                 int32_t                  src_y,
-                                 int32_t                  mask_x,
-                                 int32_t                  mask_y,
-                                 int32_t                  dest_x,
-                                 int32_t                  dest_y,
-                                 int32_t                  width,
-                                 int32_t                  height)
-{
-    uint32_t    *src, *src_line;
-    uint32_t    *dst, *dst_line;
-    uint8_t     *mask, *mask_line;
-    int src_stride, mask_stride, dst_stride;
-    uint8_t m;
-    uint32_t s, d;
-    int32_t w;
-
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
-    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
-    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
-
-    while (height--)
-    {
-	src = src_line;
-	src_line += src_stride;
-	dst = dst_line;
-	dst_line += dst_stride;
-	mask = mask_line;
-	mask_line += mask_stride;
-
-	w = width;
-	while (w--)
-	{
-	    m = *mask++;
-	    if (m)
-	    {
-		s = *src | 0xff000000;
-
-		if (m == 0xff)
-		{
-		    *dst = s;
-		}
-		else
-		{
-		    d = in (s, m);
-		    *dst = over (d, *dst);
-		}
-	    }
-	    src++;
-	    dst++;
-	}
-    }
-}
-
-static void
-fast_composite_in_n_8_8 (pixman_implementation_t *imp,
-                         pixman_op_t              op,
-                         pixman_image_t *         src_image,
-                         pixman_image_t *         mask_image,
-                         pixman_image_t *         dest_image,
-                         int32_t                  src_x,
-                         int32_t                  src_y,
-                         int32_t                  mask_x,
-                         int32_t                  mask_y,
-                         int32_t                  dest_x,
-                         int32_t                  dest_y,
-                         int32_t                  width,
-                         int32_t                  height)
-{
-    uint32_t src, srca;
-    uint8_t     *dst_line, *dst;
-    uint8_t     *mask_line, *mask, m;
-    int dst_stride, mask_stride;
-    int32_t w;
-    uint16_t t;
-
-    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
-
-    srca = src >> 24;
-
-    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
-    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
-
-    if (srca == 0xff)
-    {
-	while (height--)
-	{
-	    dst = dst_line;
-	    dst_line += dst_stride;
-	    mask = mask_line;
-	    mask_line += mask_stride;
-	    w = width;
-
-	    while (w--)
-	    {
-		m = *mask++;
-
-		if (m == 0)
-		    *dst = 0;
-		else if (m != 0xff)
-		    *dst = MUL_UN8 (m, *dst, t);
-
-		dst++;
-	    }
-	}
-    }
-    else
-    {
-	while (height--)
-	{
-	    dst = dst_line;
-	    dst_line += dst_stride;
-	    mask = mask_line;
-	    mask_line += mask_stride;
-	    w = width;
-
-	    while (w--)
-	    {
-		m = *mask++;
-		m = MUL_UN8 (m, srca, t);
-
-		if (m == 0)
-		    *dst = 0;
-		else if (m != 0xff)
-		    *dst = MUL_UN8 (m, *dst, t);
-
-		dst++;
-	    }
-	}
-    }
-}
-
-static void
-fast_composite_in_8_8 (pixman_implementation_t *imp,
-                       pixman_op_t              op,
-                       pixman_image_t *         src_image,
-                       pixman_image_t *         mask_image,
-                       pixman_image_t *         dest_image,
-                       int32_t                  src_x,
-                       int32_t                  src_y,
-                       int32_t                  mask_x,
-                       int32_t                  mask_y,
-                       int32_t                  dest_x,
-                       int32_t                  dest_y,
-                       int32_t                  width,
-                       int32_t                  height)
-{
-    uint8_t     *dst_line, *dst;
-    uint8_t     *src_line, *src;
-    int dst_stride, src_stride;
-    int32_t w;
-    uint8_t s;
-    uint16_t t;
-
-    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint8_t, src_stride, src_line, 1);
-    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	src = src_line;
-	src_line += src_stride;
-	w = width;
-
-	while (w--)
-	{
-	    s = *src++;
-
-	    if (s == 0)
-		*dst = 0;
-	    else if (s != 0xff)
-		*dst = MUL_UN8 (s, *dst, t);
-
-	    dst++;
-	}
-    }
-}
-
-static void
-fast_composite_over_n_8_8888 (pixman_implementation_t *imp,
-                              pixman_op_t              op,
-                              pixman_image_t *         src_image,
-                              pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
-                              int32_t                  src_x,
-                              int32_t                  src_y,
-                              int32_t                  mask_x,
-                              int32_t                  mask_y,
-                              int32_t                  dest_x,
-                              int32_t                  dest_y,
-                              int32_t                  width,
-                              int32_t                  height)
-{
-    uint32_t src, srca;
-    uint32_t    *dst_line, *dst, d;
-    uint8_t     *mask_line, *mask, m;
-    int dst_stride, mask_stride;
-    int32_t w;
-
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
-
-    srca = src >> 24;
-    if (src == 0)
-	return;
-
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
-    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	mask = mask_line;
-	mask_line += mask_stride;
-	w = width;
-
-	while (w--)
-	{
-	    m = *mask++;
-	    if (m == 0xff)
-	    {
-		if (srca == 0xff)
-		    *dst = src;
-		else
-		    *dst = over (src, *dst);
-	    }
-	    else if (m)
-	    {
-		d = in (src, m);
-		*dst = over (d, *dst);
-	    }
-	    dst++;
-	}
-    }
-}
-
-static void
-fast_composite_add_n_8888_8888_ca (pixman_implementation_t *imp,
-				   pixman_op_t              op,
-				   pixman_image_t *         src_image,
-				   pixman_image_t *         mask_image,
-				   pixman_image_t *         dst_image,
-				   int32_t                  src_x,
-				   int32_t                  src_y,
-				   int32_t                  mask_x,
-				   int32_t                  mask_y,
-				   int32_t                  dest_x,
-				   int32_t                  dest_y,
-				   int32_t                  width,
-				   int32_t                  height)
-{
-    uint32_t src, srca, s;
-    uint32_t    *dst_line, *dst, d;
-    uint32_t    *mask_line, *mask, ma;
-    int dst_stride, mask_stride;
-    int32_t w;
-
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
-
-    srca = src >> 24;
-    if (src == 0)
-	return;
-
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
-    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint32_t, mask_stride, mask_line, 1);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	mask = mask_line;
-	mask_line += mask_stride;
-	w = width;
-
-	while (w--)
-	{
-	    ma = *mask++;
-
-	    if (ma)
-	    {
-		d = *dst;
-		s = src;
-
-		UN8x4_MUL_UN8x4_ADD_UN8x4 (s, ma, d);
-
-		*dst = s;
-	    }
-
-	    dst++;
-	}
-    }
-}
-
-static void
-fast_composite_over_n_8888_8888_ca (pixman_implementation_t *imp,
-                                    pixman_op_t              op,
-                                    pixman_image_t *         src_image,
-                                    pixman_image_t *         mask_image,
-                                    pixman_image_t *         dst_image,
-                                    int32_t                  src_x,
-                                    int32_t                  src_y,
-                                    int32_t                  mask_x,
-                                    int32_t                  mask_y,
-                                    int32_t                  dest_x,
-                                    int32_t                  dest_y,
-                                    int32_t                  width,
-                                    int32_t                  height)
-{
-    uint32_t src, srca, s;
-    uint32_t    *dst_line, *dst, d;
-    uint32_t    *mask_line, *mask, ma;
-    int dst_stride, mask_stride;
-    int32_t w;
-
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
-
-    srca = src >> 24;
-    if (src == 0)
-	return;
-
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
-    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint32_t, mask_stride, mask_line, 1);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	mask = mask_line;
-	mask_line += mask_stride;
-	w = width;
-
-	while (w--)
-	{
-	    ma = *mask++;
-	    if (ma == 0xffffffff)
-	    {
-		if (srca == 0xff)
-		    *dst = src;
-		else
-		    *dst = over (src, *dst);
-	    }
-	    else if (ma)
-	    {
-		d = *dst;
-		s = src;
-
-		UN8x4_MUL_UN8x4 (s, ma);
-		UN8x4_MUL_UN8 (ma, srca);
-		ma = ~ma;
-		UN8x4_MUL_UN8x4_ADD_UN8x4 (d, ma, s);
-
-		*dst = d;
-	    }
-
-	    dst++;
-	}
-    }
-}
-
-static void
-fast_composite_over_n_8_0888 (pixman_implementation_t *imp,
-                              pixman_op_t              op,
-                              pixman_image_t *         src_image,
-                              pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
-                              int32_t                  src_x,
-                              int32_t                  src_y,
-                              int32_t                  mask_x,
-                              int32_t                  mask_y,
-                              int32_t                  dest_x,
-                              int32_t                  dest_y,
-                              int32_t                  width,
-                              int32_t                  height)
-{
-    uint32_t src, srca;
-    uint8_t     *dst_line, *dst;
-    uint32_t d;
-    uint8_t     *mask_line, *mask, m;
-    int dst_stride, mask_stride;
-    int32_t w;
-
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
-
-    srca = src >> 24;
-    if (src == 0)
-	return;
-
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 3);
-    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	mask = mask_line;
-	mask_line += mask_stride;
-	w = width;
-
-	while (w--)
-	{
-	    m = *mask++;
-	    if (m == 0xff)
-	    {
-		if (srca == 0xff)
-		{
-		    d = src;
-		}
-		else
-		{
-		    d = fetch_24 (dst);
-		    d = over (src, d);
-		}
-		store_24 (dst, d);
-	    }
-	    else if (m)
-	    {
-		d = over (in (src, m), fetch_24 (dst));
-		store_24 (dst, d);
-	    }
-	    dst += 3;
-	}
-    }
-}
-
-static void
-fast_composite_over_n_8_0565 (pixman_implementation_t *imp,
-                              pixman_op_t              op,
-                              pixman_image_t *         src_image,
-                              pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
-                              int32_t                  src_x,
-                              int32_t                  src_y,
-                              int32_t                  mask_x,
-                              int32_t                  mask_y,
-                              int32_t                  dest_x,
-                              int32_t                  dest_y,
-                              int32_t                  width,
-                              int32_t                  height)
-{
-    uint32_t src, srca;
-    uint16_t    *dst_line, *dst;
-    uint32_t d;
-    uint8_t     *mask_line, *mask, m;
-    int dst_stride, mask_stride;
-    int32_t w;
-
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
-
-    srca = src >> 24;
-    if (src == 0)
-	return;
-
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
-    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	mask = mask_line;
-	mask_line += mask_stride;
-	w = width;
-
-	while (w--)
-	{
-	    m = *mask++;
-	    if (m == 0xff)
-	    {
-		if (srca == 0xff)
-		{
-		    d = src;
-		}
-		else
-		{
-		    d = *dst;
-		    d = over (src, CONVERT_0565_TO_0888 (d));
-		}
-		*dst = CONVERT_8888_TO_0565 (d);
-	    }
-	    else if (m)
-	    {
-		d = *dst;
-		d = over (in (src, m), CONVERT_0565_TO_0888 (d));
-		*dst = CONVERT_8888_TO_0565 (d);
-	    }
-	    dst++;
-	}
-    }
-}
-
-static void
-fast_composite_over_n_8888_0565_ca (pixman_implementation_t *imp,
-                                    pixman_op_t              op,
-                                    pixman_image_t *         src_image,
-                                    pixman_image_t *         mask_image,
-                                    pixman_image_t *         dst_image,
-                                    int32_t                  src_x,
-                                    int32_t                  src_y,
-                                    int32_t                  mask_x,
-                                    int32_t                  mask_y,
-                                    int32_t                  dest_x,
-                                    int32_t                  dest_y,
-                                    int32_t                  width,
-                                    int32_t                  height)
-{
-    uint32_t  src, srca, s;
-    uint16_t  src16;
-    uint16_t *dst_line, *dst;
-    uint32_t  d;
-    uint32_t *mask_line, *mask, ma;
-    int dst_stride, mask_stride;
-    int32_t w;
-
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
-
-    srca = src >> 24;
-    if (src == 0)
-	return;
-
-    src16 = CONVERT_8888_TO_0565 (src);
-
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
-    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint32_t, mask_stride, mask_line, 1);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	mask = mask_line;
-	mask_line += mask_stride;
-	w = width;
-
-	while (w--)
-	{
-	    ma = *mask++;
-	    if (ma == 0xffffffff)
-	    {
-		if (srca == 0xff)
-		{
-		    *dst = src16;
-		}
-		else
-		{
-		    d = *dst;
-		    d = over (src, CONVERT_0565_TO_0888 (d));
-		    *dst = CONVERT_8888_TO_0565 (d);
-		}
-	    }
-	    else if (ma)
-	    {
-		d = *dst;
-		d = CONVERT_0565_TO_0888 (d);
-
-		s = src;
-
-		UN8x4_MUL_UN8x4 (s, ma);
-		UN8x4_MUL_UN8 (ma, srca);
-		ma = ~ma;
-		UN8x4_MUL_UN8x4_ADD_UN8x4 (d, ma, s);
-
-		*dst = CONVERT_8888_TO_0565 (d);
-	    }
-	    dst++;
-	}
-    }
-}
-
-static void
-fast_composite_over_8888_8888 (pixman_implementation_t *imp,
-                               pixman_op_t              op,
-                               pixman_image_t *         src_image,
-                               pixman_image_t *         mask_image,
-                               pixman_image_t *         dst_image,
-                               int32_t                  src_x,
-                               int32_t                  src_y,
-                               int32_t                  mask_x,
-                               int32_t                  mask_y,
-                               int32_t                  dest_x,
-                               int32_t                  dest_y,
-                               int32_t                  width,
-                               int32_t                  height)
-{
-    uint32_t    *dst_line, *dst;
-    uint32_t    *src_line, *src, s;
-    int dst_stride, src_stride;
-    uint8_t a;
-    int32_t w;
-
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
-    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	src = src_line;
-	src_line += src_stride;
-	w = width;
-
-	while (w--)
-	{
-	    s = *src++;
-	    a = s >> 24;
-	    if (a == 0xff)
-		*dst = s;
-	    else if (s)
-		*dst = over (s, *dst);
-	    dst++;
-	}
-    }
-}
-
-static void
-fast_composite_src_x888_8888 (pixman_implementation_t *imp,
-			      pixman_op_t              op,
-			      pixman_image_t *         src_image,
-			      pixman_image_t *         mask_image,
-			      pixman_image_t *         dst_image,
-			      int32_t                  src_x,
-			      int32_t                  src_y,
-			      int32_t                  mask_x,
-			      int32_t                  mask_y,
-			      int32_t                  dest_x,
-			      int32_t                  dest_y,
-			      int32_t                  width,
-			      int32_t                  height)
-{
-    uint32_t    *dst_line, *dst;
-    uint32_t    *src_line, *src;
-    int dst_stride, src_stride;
-    int32_t w;
-
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
-    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	src = src_line;
-	src_line += src_stride;
-	w = width;
-
-	while (w--)
-	    *dst++ = (*src++) | 0xff000000;
-    }
-}
-
-#if 0
-static void
-fast_composite_over_8888_0888 (pixman_implementation_t *imp,
-			       pixman_op_t              op,
-			       pixman_image_t *         src_image,
-			       pixman_image_t *         mask_image,
-			       pixman_image_t *         dst_image,
-			       int32_t                  src_x,
-			       int32_t                  src_y,
-			       int32_t                  mask_x,
-			       int32_t                  mask_y,
-			       int32_t                  dest_x,
-			       int32_t                  dest_y,
-			       int32_t                  width,
-			       int32_t                  height)
-{
-    uint8_t     *dst_line, *dst;
-    uint32_t d;
-    uint32_t    *src_line, *src, s;
-    uint8_t a;
-    int dst_stride, src_stride;
-    int32_t w;
-
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 3);
-    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	src = src_line;
-	src_line += src_stride;
-	w = width;
-
-	while (w--)
-	{
-	    s = *src++;
-	    a = s >> 24;
-	    if (a)
-	    {
-		if (a == 0xff)
-		    d = s;
-		else
-		    d = over (s, fetch_24 (dst));
-
-		store_24 (dst, d);
-	    }
-	    dst += 3;
-	}
-    }
-}
-#endif
-
-static void
-fast_composite_over_8888_0565 (pixman_implementation_t *imp,
-                               pixman_op_t              op,
-                               pixman_image_t *         src_image,
-                               pixman_image_t *         mask_image,
-                               pixman_image_t *         dst_image,
-                               int32_t                  src_x,
-                               int32_t                  src_y,
-                               int32_t                  mask_x,
-                               int32_t                  mask_y,
-                               int32_t                  dest_x,
-                               int32_t                  dest_y,
-                               int32_t                  width,
-                               int32_t                  height)
-{
-    uint16_t    *dst_line, *dst;
-    uint32_t d;
-    uint32_t    *src_line, *src, s;
-    uint8_t a;
-    int dst_stride, src_stride;
-    int32_t w;
-
-    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	src = src_line;
-	src_line += src_stride;
-	w = width;
-
-	while (w--)
-	{
-	    s = *src++;
-	    a = s >> 24;
-	    if (s)
-	    {
-		if (a == 0xff)
-		{
-		    d = s;
-		}
-		else
-		{
-		    d = *dst;
-		    d = over (s, CONVERT_0565_TO_0888 (d));
-		}
-		*dst = CONVERT_8888_TO_0565 (d);
-	    }
-	    dst++;
-	}
-    }
-}
-
-static void
-fast_composite_src_x888_0565 (pixman_implementation_t *imp,
-                              pixman_op_t              op,
-                              pixman_image_t *         src_image,
-                              pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
-                              int32_t                  src_x,
-                              int32_t                  src_y,
-                              int32_t                  mask_x,
-                              int32_t                  mask_y,
-                              int32_t                  dest_x,
-                              int32_t                  dest_y,
-                              int32_t                  width,
-                              int32_t                  height)
-{
-    uint16_t    *dst_line, *dst;
-    uint32_t    *src_line, *src, s;
-    int dst_stride, src_stride;
-    int32_t w;
-
-    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	src = src_line;
-	src_line += src_stride;
-	w = width;
-
-	while (w--)
-	{
-	    s = *src++;
-	    *dst = CONVERT_8888_TO_0565 (s);
-	    dst++;
-	}
-    }
-}
-
-static void
-fast_composite_add_8_8 (pixman_implementation_t *imp,
-			pixman_op_t              op,
-			pixman_image_t *         src_image,
-			pixman_image_t *         mask_image,
-			pixman_image_t *         dst_image,
-			int32_t                  src_x,
-			int32_t                  src_y,
-			int32_t                  mask_x,
-			int32_t                  mask_y,
-			int32_t                  dest_x,
-			int32_t                  dest_y,
-			int32_t                  width,
-			int32_t                  height)
-{
-    uint8_t     *dst_line, *dst;
-    uint8_t     *src_line, *src;
-    int dst_stride, src_stride;
-    int32_t w;
-    uint8_t s, d;
-    uint16_t t;
-
-    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint8_t, src_stride, src_line, 1);
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	src = src_line;
-	src_line += src_stride;
-	w = width;
-
-	while (w--)
-	{
-	    s = *src++;
-	    if (s)
-	    {
-		if (s != 0xff)
-		{
-		    d = *dst;
-		    t = d + s;
-		    s = t | (0 - (t >> 8));
-		}
-		*dst = s;
-	    }
-	    dst++;
-	}
-    }
-}
-
-static void
-fast_composite_add_8888_8888 (pixman_implementation_t *imp,
-                              pixman_op_t              op,
-                              pixman_image_t *         src_image,
-                              pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
-                              int32_t                  src_x,
-                              int32_t                  src_y,
-                              int32_t                  mask_x,
-                              int32_t                  mask_y,
-                              int32_t                  dest_x,
-                              int32_t                  dest_y,
-                              int32_t                  width,
-                              int32_t                  height)
-{
-    uint32_t    *dst_line, *dst;
-    uint32_t    *src_line, *src;
-    int dst_stride, src_stride;
-    int32_t w;
-    uint32_t s, d;
-
-    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	src = src_line;
-	src_line += src_stride;
-	w = width;
-
-	while (w--)
-	{
-	    s = *src++;
-	    if (s)
-	    {
-		if (s != 0xffffffff)
-		{
-		    d = *dst;
-		    if (d)
-			UN8x4_ADD_UN8x4 (s, d);
-		}
-		*dst = s;
-	    }
-	    dst++;
-	}
-    }
-}
-
-static void
-fast_composite_add_n_8_8 (pixman_implementation_t *imp,
-			  pixman_op_t              op,
-			  pixman_image_t *         src_image,
-			  pixman_image_t *         mask_image,
-			  pixman_image_t *         dst_image,
-			  int32_t                  src_x,
-			  int32_t                  src_y,
-			  int32_t                  mask_x,
-			  int32_t                  mask_y,
-			  int32_t                  dest_x,
-			  int32_t                  dest_y,
-			  int32_t                  width,
-			  int32_t                  height)
-{
-    uint8_t     *dst_line, *dst;
-    uint8_t     *mask_line, *mask;
-    int dst_stride, mask_stride;
-    int32_t w;
-    uint32_t src;
-    uint8_t sa;
-
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
-    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
-    sa = (src >> 24);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	mask = mask_line;
-	mask_line += mask_stride;
-	w = width;
-
-	while (w--)
-	{
-	    uint16_t tmp;
-	    uint16_t a;
-	    uint32_t m, d;
-	    uint32_t r;
-
-	    a = *mask++;
-	    d = *dst;
-
-	    m = MUL_UN8 (sa, a, tmp);
-	    r = ADD_UN8 (m, d, tmp);
-
-	    *dst++ = r;
-	}
-    }
-}
-
-#ifdef WORDS_BIGENDIAN
-#define CREATE_BITMASK(n) (0x80000000 >> (n))
-#define UPDATE_BITMASK(n) ((n) >> 1)
-#else
-#define CREATE_BITMASK(n) (1 << (n))
-#define UPDATE_BITMASK(n) ((n) << 1)
-#endif
-
-#define TEST_BIT(p, n)					\
-    (*((p) + ((n) >> 5)) & CREATE_BITMASK ((n) & 31))
-#define SET_BIT(p, n)							\
-    do { *((p) + ((n) >> 5)) |= CREATE_BITMASK ((n) & 31); } while (0);
-
-static void
-fast_composite_add_1000_1000 (pixman_implementation_t *imp,
-                              pixman_op_t              op,
-                              pixman_image_t *         src_image,
-                              pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
-                              int32_t                  src_x,
-                              int32_t                  src_y,
-                              int32_t                  mask_x,
-                              int32_t                  mask_y,
-                              int32_t                  dest_x,
-                              int32_t                  dest_y,
-                              int32_t                  width,
-                              int32_t                  height)
-{
-    uint32_t     *dst_line, *dst;
-    uint32_t     *src_line, *src;
-    int           dst_stride, src_stride;
-    int32_t       w;
-
-    PIXMAN_IMAGE_GET_LINE (src_image, 0, src_y, uint32_t,
-                           src_stride, src_line, 1);
-    PIXMAN_IMAGE_GET_LINE (dst_image, 0, dest_y, uint32_t,
-                           dst_stride, dst_line, 1);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	src = src_line;
-	src_line += src_stride;
-	w = width;
-
-	while (w--)
-	{
-	    /*
-	     * TODO: improve performance by processing uint32_t data instead
-	     *       of individual bits
-	     */
-	    if (TEST_BIT (src, src_x + w))
-		SET_BIT (dst, dest_x + w);
-	}
-    }
-}
-
-static void
-fast_composite_over_n_1_8888 (pixman_implementation_t *imp,
-                              pixman_op_t              op,
-                              pixman_image_t *         src_image,
-                              pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
-                              int32_t                  src_x,
-                              int32_t                  src_y,
-                              int32_t                  mask_x,
-                              int32_t                  mask_y,
-                              int32_t                  dest_x,
-                              int32_t                  dest_y,
-                              int32_t                  width,
-                              int32_t                  height)
-{
-    uint32_t     src, srca;
-    uint32_t    *dst, *dst_line;
-    uint32_t    *mask, *mask_line;
-    int          mask_stride, dst_stride;
-    uint32_t     bitcache, bitmask;
-    int32_t      w;
-
-    if (width <= 0)
-	return;
-
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
-    srca = src >> 24;
-    if (src == 0)
-	return;
-
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t,
-                           dst_stride, dst_line, 1);
-    PIXMAN_IMAGE_GET_LINE (mask_image, 0, mask_y, uint32_t,
-                           mask_stride, mask_line, 1);
-    mask_line += mask_x >> 5;
-
-    if (srca == 0xff)
-    {
-	while (height--)
-	{
-	    dst = dst_line;
-	    dst_line += dst_stride;
-	    mask = mask_line;
-	    mask_line += mask_stride;
-	    w = width;
-
-	    bitcache = *mask++;
-	    bitmask = CREATE_BITMASK (mask_x & 31);
-
-	    while (w--)
-	    {
-		if (bitmask == 0)
-		{
-		    bitcache = *mask++;
-		    bitmask = CREATE_BITMASK (0);
-		}
-		if (bitcache & bitmask)
-		    *dst = src;
-		bitmask = UPDATE_BITMASK (bitmask);
-		dst++;
-	    }
-	}
-    }
-    else
-    {
-	while (height--)
-	{
-	    dst = dst_line;
-	    dst_line += dst_stride;
-	    mask = mask_line;
-	    mask_line += mask_stride;
-	    w = width;
-
-	    bitcache = *mask++;
-	    bitmask = CREATE_BITMASK (mask_x & 31);
-
-	    while (w--)
-	    {
-		if (bitmask == 0)
-		{
-		    bitcache = *mask++;
-		    bitmask = CREATE_BITMASK (0);
-		}
-		if (bitcache & bitmask)
-		    *dst = over (src, *dst);
-		bitmask = UPDATE_BITMASK (bitmask);
-		dst++;
-	    }
-	}
-    }
-}
-
-static void
-fast_composite_over_n_1_0565 (pixman_implementation_t *imp,
-                              pixman_op_t              op,
-                              pixman_image_t *         src_image,
-                              pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
-                              int32_t                  src_x,
-                              int32_t                  src_y,
-                              int32_t                  mask_x,
-                              int32_t                  mask_y,
-                              int32_t                  dest_x,
-                              int32_t                  dest_y,
-                              int32_t                  width,
-                              int32_t                  height)
-{
-    uint32_t     src, srca;
-    uint16_t    *dst, *dst_line;
-    uint32_t    *mask, *mask_line;
-    int          mask_stride, dst_stride;
-    uint32_t     bitcache, bitmask;
-    int32_t      w;
-    uint32_t     d;
-    uint16_t     src565;
-
-    if (width <= 0)
-	return;
-
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
-    srca = src >> 24;
-    if (src == 0)
-	return;
-
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t,
-                           dst_stride, dst_line, 1);
-    PIXMAN_IMAGE_GET_LINE (mask_image, 0, mask_y, uint32_t,
-                           mask_stride, mask_line, 1);
-    mask_line += mask_x >> 5;
-
-    if (srca == 0xff)
-    {
-	src565 = CONVERT_8888_TO_0565 (src);
-	while (height--)
-	{
-	    dst = dst_line;
-	    dst_line += dst_stride;
-	    mask = mask_line;
-	    mask_line += mask_stride;
-	    w = width;
-
-	    bitcache = *mask++;
-	    bitmask = CREATE_BITMASK (mask_x & 31);
-
-	    while (w--)
-	    {
-		if (bitmask == 0)
-		{
-		    bitcache = *mask++;
-		    bitmask = CREATE_BITMASK (0);
-		}
-		if (bitcache & bitmask)
-		    *dst = src565;
-		bitmask = UPDATE_BITMASK (bitmask);
-		dst++;
-	    }
-	}
-    }
-    else
-    {
-	while (height--)
-	{
-	    dst = dst_line;
-	    dst_line += dst_stride;
-	    mask = mask_line;
-	    mask_line += mask_stride;
-	    w = width;
-
-	    bitcache = *mask++;
-	    bitmask = CREATE_BITMASK (mask_x & 31);
-
-	    while (w--)
-	    {
-		if (bitmask == 0)
-		{
-		    bitcache = *mask++;
-		    bitmask = CREATE_BITMASK (0);
-		}
-		if (bitcache & bitmask)
-		{
-		    d = over (src, CONVERT_0565_TO_0888 (*dst));
-		    *dst = CONVERT_8888_TO_0565 (d);
-		}
-		bitmask = UPDATE_BITMASK (bitmask);
-		dst++;
-	    }
-	}
-    }
-}
-
-/*
- * Simple bitblt
- */
-
-static void
-fast_composite_solid_fill (pixman_implementation_t *imp,
-                           pixman_op_t              op,
-                           pixman_image_t *         src_image,
-                           pixman_image_t *         mask_image,
-                           pixman_image_t *         dst_image,
-                           int32_t                  src_x,
-                           int32_t                  src_y,
-                           int32_t                  mask_x,
-                           int32_t                  mask_y,
-                           int32_t                  dest_x,
-                           int32_t                  dest_y,
-                           int32_t                  width,
-                           int32_t                  height)
-{
-    uint32_t src;
-
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
-
-    if (dst_image->bits.format == PIXMAN_a1)
-    {
-	src = src >> 31;
-    }
-    else if (dst_image->bits.format == PIXMAN_a8)
-    {
-	src = src >> 24;
-    }
-    else if (dst_image->bits.format == PIXMAN_r5g6b5 ||
-             dst_image->bits.format == PIXMAN_b5g6r5)
-    {
-	src = CONVERT_8888_TO_0565 (src);
-    }
-
-    pixman_fill (dst_image->bits.bits, dst_image->bits.rowstride,
-                 PIXMAN_FORMAT_BPP (dst_image->bits.format),
-                 dest_x, dest_y,
-                 width, height,
-                 src);
-}
-
-static void
-fast_composite_src_memcpy (pixman_implementation_t *imp,
-			   pixman_op_t              op,
-			   pixman_image_t *         src_image,
-			   pixman_image_t *         mask_image,
-			   pixman_image_t *         dst_image,
-			   int32_t                  src_x,
-			   int32_t                  src_y,
-			   int32_t                  mask_x,
-			   int32_t                  mask_y,
-			   int32_t                  dest_x,
-			   int32_t                  dest_y,
-			   int32_t                  width,
-			   int32_t                  height)
-{
-    int bpp = PIXMAN_FORMAT_BPP (dst_image->bits.format) / 8;
-    uint32_t n_bytes = width * bpp;
-    int dst_stride, src_stride;
-    uint8_t    *dst;
-    uint8_t    *src;
-
-    src_stride = src_image->bits.rowstride * 4;
-    dst_stride = dst_image->bits.rowstride * 4;
-
-    src = (uint8_t *)src_image->bits.bits + src_y * src_stride + src_x * bpp;
-    dst = (uint8_t *)dst_image->bits.bits + dest_y * dst_stride + dest_x * bpp;
-
-    while (height--)
-    {
-	memcpy (dst, src, n_bytes);
-
-	dst += dst_stride;
-	src += src_stride;
-    }
-}
-
-FAST_NEAREST (8888_8888_cover, 8888, 8888, uint32_t, uint32_t, SRC, COVER)
-FAST_NEAREST (8888_8888_none, 8888, 8888, uint32_t, uint32_t, SRC, NONE)
-FAST_NEAREST (8888_8888_pad, 8888, 8888, uint32_t, uint32_t, SRC, PAD)
-FAST_NEAREST (8888_8888_normal, 8888, 8888, uint32_t, uint32_t, SRC, NORMAL)
-FAST_NEAREST (8888_8888_cover, 8888, 8888, uint32_t, uint32_t, OVER, COVER)
-FAST_NEAREST (8888_8888_none, 8888, 8888, uint32_t, uint32_t, OVER, NONE)
-FAST_NEAREST (8888_8888_pad, 8888, 8888, uint32_t, uint32_t, OVER, PAD)
-FAST_NEAREST (8888_8888_normal, 8888, 8888, uint32_t, uint32_t, OVER, NORMAL)
-FAST_NEAREST (8888_565_cover, 8888, 0565, uint32_t, uint16_t, SRC, COVER)
-FAST_NEAREST (8888_565_none, 8888, 0565, uint32_t, uint16_t, SRC, NONE)
-FAST_NEAREST (8888_565_pad, 8888, 0565, uint32_t, uint16_t, SRC, PAD)
-FAST_NEAREST (8888_565_normal, 8888, 0565, uint32_t, uint16_t, SRC, NORMAL)
-FAST_NEAREST (565_565_normal, 0565, 0565, uint16_t, uint16_t, SRC, NORMAL)
-FAST_NEAREST (8888_565_cover, 8888, 0565, uint32_t, uint16_t, OVER, COVER)
-FAST_NEAREST (8888_565_none, 8888, 0565, uint32_t, uint16_t, OVER, NONE)
-FAST_NEAREST (8888_565_pad, 8888, 0565, uint32_t, uint16_t, OVER, PAD)
-FAST_NEAREST (8888_565_normal, 8888, 0565, uint32_t, uint16_t, OVER, NORMAL)
-
-/* Use more unrolling for src_0565_0565 because it is typically CPU bound */
-static force_inline void
-scaled_nearest_scanline_565_565_SRC (uint16_t *      dst,
-				     uint16_t *      src,
-				     int32_t         w,
-				     pixman_fixed_t  vx,
-				     pixman_fixed_t  unit_x,
-				     pixman_fixed_t  max_vx)
-{
-    uint16_t tmp1, tmp2, tmp3, tmp4;
-    while ((w -= 4) >= 0)
-    {
-	tmp1 = src[pixman_fixed_to_int (vx)];
-	vx += unit_x;
-	tmp2 = src[pixman_fixed_to_int (vx)];
-	vx += unit_x;
-	tmp3 = src[pixman_fixed_to_int (vx)];
-	vx += unit_x;
-	tmp4 = src[pixman_fixed_to_int (vx)];
-	vx += unit_x;
-	*dst++ = tmp1;
-	*dst++ = tmp2;
-	*dst++ = tmp3;
-	*dst++ = tmp4;
-    }
-    if (w & 2)
-    {
-	tmp1 = src[pixman_fixed_to_int (vx)];
-	vx += unit_x;
-	tmp2 = src[pixman_fixed_to_int (vx)];
-	vx += unit_x;
-	*dst++ = tmp1;
-	*dst++ = tmp2;
-    }
-    if (w & 1)
-	*dst++ = src[pixman_fixed_to_int (vx)];
-}
-
-FAST_NEAREST_MAINLOOP (565_565_cover_SRC,
-		       scaled_nearest_scanline_565_565_SRC,
-		       uint16_t, uint16_t, COVER)
-FAST_NEAREST_MAINLOOP (565_565_none_SRC,
-		       scaled_nearest_scanline_565_565_SRC,
-		       uint16_t, uint16_t, NONE)
-FAST_NEAREST_MAINLOOP (565_565_pad_SRC,
-		       scaled_nearest_scanline_565_565_SRC,
-		       uint16_t, uint16_t, PAD)
-
-static force_inline uint32_t
-fetch_nearest (pixman_repeat_t src_repeat,
-	       pixman_format_code_t format,
-	       uint32_t *src, int x, int src_width)
-{
-    if (repeat (src_repeat, &x, src_width))
-    {
-	if (format == PIXMAN_x8r8g8b8)
-	    return *(src + x) | 0xff000000;
-	else
-	    return *(src + x);
-    }
-    else
-    {
-	return 0;
-    }
-}
-
-static force_inline void
-combine_over (uint32_t s, uint32_t *dst)
-{
-    if (s)
-    {
-	uint8_t ia = 0xff - (s >> 24);
-
-	if (ia)
-	    UN8x4_MUL_UN8_ADD_UN8x4 (*dst, ia, s);
-	else
-	    *dst = s;
-    }
-}
-
-static force_inline void
-combine_src (uint32_t s, uint32_t *dst)
-{
-    *dst = s;
-}
-
-static void
-fast_composite_scaled_nearest (pixman_implementation_t *imp,
-			       pixman_op_t              op,
-			       pixman_image_t *         src_image,
-			       pixman_image_t *         mask_image,
-			       pixman_image_t *         dst_image,
-			       int32_t                  src_x,
-			       int32_t                  src_y,
-			       int32_t                  mask_x,
-			       int32_t                  mask_y,
-			       int32_t                  dest_x,
-			       int32_t                  dest_y,
-			       int32_t                  width,
-			       int32_t                  height)
-{
-    uint32_t       *dst_line;
-    uint32_t       *src_line;
-    int             dst_stride, src_stride;
-    int		    src_width, src_height;
-    pixman_repeat_t src_repeat;
-    pixman_fixed_t unit_x, unit_y;
-    pixman_format_code_t src_format;
-    pixman_vector_t v;
-    pixman_fixed_t vy;
-
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
-    /* pass in 0 instead of src_x and src_y because src_x and src_y need to be
-     * transformed from destination space to source space
-     */
-    PIXMAN_IMAGE_GET_LINE (src_image, 0, 0, uint32_t, src_stride, src_line, 1);
-
-    /* reference point is the center of the pixel */
-    v.vector[0] = pixman_int_to_fixed (src_x) + pixman_fixed_1 / 2;
-    v.vector[1] = pixman_int_to_fixed (src_y) + pixman_fixed_1 / 2;
-    v.vector[2] = pixman_fixed_1;
-
-    if (!pixman_transform_point_3d (src_image->common.transform, &v))
-	return;
-
-    unit_x = src_image->common.transform->matrix[0][0];
-    unit_y = src_image->common.transform->matrix[1][1];
-
-    /* Round down to closest integer, ensuring that 0.5 rounds to 0, not 1 */
-    v.vector[0] -= pixman_fixed_e;
-    v.vector[1] -= pixman_fixed_e;
-
-    src_height = src_image->bits.height;
-    src_width = src_image->bits.width;
-    src_repeat = src_image->common.repeat;
-    src_format = src_image->bits.format;
-
-    vy = v.vector[1];
-    while (height--)
-    {
-        pixman_fixed_t vx = v.vector[0];
-	int y = pixman_fixed_to_int (vy);
-	uint32_t *dst = dst_line;
-
-	dst_line += dst_stride;
-
-        /* adjust the y location by a unit vector in the y direction
-         * this is equivalent to transforming y+1 of the destination point to source space */
-        vy += unit_y;
-
-	if (!repeat (src_repeat, &y, src_height))
-	{
-	    if (op == PIXMAN_OP_SRC)
-		memset (dst, 0, sizeof (*dst) * width);
-	}
-	else
-	{
-	    int w = width;
-
-	    uint32_t *src = src_line + y * src_stride;
-
-	    while (w >= 2)
-	    {
-		uint32_t s1, s2;
-		int x1, x2;
-
-		x1 = pixman_fixed_to_int (vx);
-		vx += unit_x;
-
-		x2 = pixman_fixed_to_int (vx);
-		vx += unit_x;
-
-		w -= 2;
-
-		s1 = fetch_nearest (src_repeat, src_format, src, x1, src_width);
-		s2 = fetch_nearest (src_repeat, src_format, src, x2, src_width);
-
-		if (op == PIXMAN_OP_OVER)
-		{
-		    combine_over (s1, dst++);
-		    combine_over (s2, dst++);
-		}
-		else
-		{
-		    combine_src (s1, dst++);
-		    combine_src (s2, dst++);
-		}
-	    }
-
-	    while (w--)
-	    {
-		uint32_t s;
-		int x;
-
-		x = pixman_fixed_to_int (vx);
-		vx += unit_x;
-
-		s = fetch_nearest (src_repeat, src_format, src, x, src_width);
-
-		if (op == PIXMAN_OP_OVER)
-		    combine_over (s, dst++);
-		else
-		    combine_src (s, dst++);
-	    }
-	}
-    }
-}
-
-static const pixman_fast_path_t c_fast_paths[] =
-{
-    PIXMAN_STD_FAST_PATH (OVER, solid, a8, r5g6b5, fast_composite_over_n_8_0565),
-    PIXMAN_STD_FAST_PATH (OVER, solid, a8, b5g6r5, fast_composite_over_n_8_0565),
-    PIXMAN_STD_FAST_PATH (OVER, solid, a8, r8g8b8, fast_composite_over_n_8_0888),
-    PIXMAN_STD_FAST_PATH (OVER, solid, a8, b8g8r8, fast_composite_over_n_8_0888),
-    PIXMAN_STD_FAST_PATH (OVER, solid, a8, a8r8g8b8, fast_composite_over_n_8_8888),
-    PIXMAN_STD_FAST_PATH (OVER, solid, a8, x8r8g8b8, fast_composite_over_n_8_8888),
-    PIXMAN_STD_FAST_PATH (OVER, solid, a8, a8b8g8r8, fast_composite_over_n_8_8888),
-    PIXMAN_STD_FAST_PATH (OVER, solid, a8, x8b8g8r8, fast_composite_over_n_8_8888),
-    PIXMAN_STD_FAST_PATH (OVER, solid, a1, a8r8g8b8, fast_composite_over_n_1_8888),
-    PIXMAN_STD_FAST_PATH (OVER, solid, a1, x8r8g8b8, fast_composite_over_n_1_8888),
-    PIXMAN_STD_FAST_PATH (OVER, solid, a1, a8b8g8r8, fast_composite_over_n_1_8888),
-    PIXMAN_STD_FAST_PATH (OVER, solid, a1, x8b8g8r8, fast_composite_over_n_1_8888),
-    PIXMAN_STD_FAST_PATH (OVER, solid, a1, r5g6b5,   fast_composite_over_n_1_0565),
-    PIXMAN_STD_FAST_PATH (OVER, solid, a1, b5g6r5,   fast_composite_over_n_1_0565),
-    PIXMAN_STD_FAST_PATH_CA (OVER, solid, a8r8g8b8, a8r8g8b8, fast_composite_over_n_8888_8888_ca),
-    PIXMAN_STD_FAST_PATH_CA (OVER, solid, a8r8g8b8, x8r8g8b8, fast_composite_over_n_8888_8888_ca),
-    PIXMAN_STD_FAST_PATH_CA (OVER, solid, a8r8g8b8, r5g6b5, fast_composite_over_n_8888_0565_ca),
-    PIXMAN_STD_FAST_PATH_CA (OVER, solid, a8b8g8r8, a8b8g8r8, fast_composite_over_n_8888_8888_ca),
-    PIXMAN_STD_FAST_PATH_CA (OVER, solid, a8b8g8r8, x8b8g8r8, fast_composite_over_n_8888_8888_ca),
-    PIXMAN_STD_FAST_PATH_CA (OVER, solid, a8b8g8r8, b5g6r5, fast_composite_over_n_8888_0565_ca),
-    PIXMAN_STD_FAST_PATH (OVER, x8r8g8b8, a8, x8r8g8b8, fast_composite_over_x888_8_8888),
-    PIXMAN_STD_FAST_PATH (OVER, x8r8g8b8, a8, a8r8g8b8, fast_composite_over_x888_8_8888),
-    PIXMAN_STD_FAST_PATH (OVER, x8b8g8r8, a8, x8b8g8r8, fast_composite_over_x888_8_8888),
-    PIXMAN_STD_FAST_PATH (OVER, x8b8g8r8, a8, a8b8g8r8, fast_composite_over_x888_8_8888),
-    PIXMAN_STD_FAST_PATH (OVER, a8r8g8b8, null, a8r8g8b8, fast_composite_over_8888_8888),
-    PIXMAN_STD_FAST_PATH (OVER, a8r8g8b8, null, x8r8g8b8, fast_composite_over_8888_8888),
-    PIXMAN_STD_FAST_PATH (OVER, a8r8g8b8, null, r5g6b5, fast_composite_over_8888_0565),
-    PIXMAN_STD_FAST_PATH (OVER, a8b8g8r8, null, a8b8g8r8, fast_composite_over_8888_8888),
-    PIXMAN_STD_FAST_PATH (OVER, a8b8g8r8, null, x8b8g8r8, fast_composite_over_8888_8888),
-    PIXMAN_STD_FAST_PATH (OVER, a8b8g8r8, null, b5g6r5, fast_composite_over_8888_0565),
-    PIXMAN_STD_FAST_PATH (ADD, a8r8g8b8, null, a8r8g8b8, fast_composite_add_8888_8888),
-    PIXMAN_STD_FAST_PATH (ADD, a8b8g8r8, null, a8b8g8r8, fast_composite_add_8888_8888),
-    PIXMAN_STD_FAST_PATH (ADD, a8, null, a8, fast_composite_add_8_8),
-    PIXMAN_STD_FAST_PATH (ADD, a1, null, a1, fast_composite_add_1000_1000),
-    PIXMAN_STD_FAST_PATH_CA (ADD, solid, a8r8g8b8, a8r8g8b8, fast_composite_add_n_8888_8888_ca),
-    PIXMAN_STD_FAST_PATH (ADD, solid, a8, a8, fast_composite_add_n_8_8),
-    PIXMAN_STD_FAST_PATH (SRC, solid, null, a8r8g8b8, fast_composite_solid_fill),
-    PIXMAN_STD_FAST_PATH (SRC, solid, null, x8r8g8b8, fast_composite_solid_fill),
-    PIXMAN_STD_FAST_PATH (SRC, solid, null, a8b8g8r8, fast_composite_solid_fill),
-    PIXMAN_STD_FAST_PATH (SRC, solid, null, x8b8g8r8, fast_composite_solid_fill),
-    PIXMAN_STD_FAST_PATH (SRC, solid, null, a1, fast_composite_solid_fill),
-    PIXMAN_STD_FAST_PATH (SRC, solid, null, a8, fast_composite_solid_fill),
-    PIXMAN_STD_FAST_PATH (SRC, solid, null, r5g6b5, fast_composite_solid_fill),
-    PIXMAN_STD_FAST_PATH (SRC, x8r8g8b8, null, a8r8g8b8, fast_composite_src_x888_8888),
-    PIXMAN_STD_FAST_PATH (SRC, x8b8g8r8, null, a8b8g8r8, fast_composite_src_x888_8888),
-    PIXMAN_STD_FAST_PATH (SRC, a8r8g8b8, null, x8r8g8b8, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, a8r8g8b8, null, a8r8g8b8, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, x8r8g8b8, null, x8r8g8b8, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, a8b8g8r8, null, x8b8g8r8, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, a8b8g8r8, null, a8b8g8r8, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, x8b8g8r8, null, x8b8g8r8, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, b8g8r8a8, null, b8g8r8x8, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, b8g8r8a8, null, b8g8r8a8, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, b8g8r8x8, null, b8g8r8x8, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, r5g6b5, null, r5g6b5, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, b5g6r5, null, b5g6r5, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, r8g8b8, null, r8g8b8, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, b8g8r8, null, b8g8r8, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, x1r5g5b5, null, x1r5g5b5, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, a1r5g5b5, null, x1r5g5b5, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, a8, null, a8, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, a8r8g8b8, null, r5g6b5, fast_composite_src_x888_0565),
-    PIXMAN_STD_FAST_PATH (SRC, x8r8g8b8, null, r5g6b5, fast_composite_src_x888_0565),
-    PIXMAN_STD_FAST_PATH (SRC, a8b8g8r8, null, b5g6r5, fast_composite_src_x888_0565),
-    PIXMAN_STD_FAST_PATH (SRC, x8b8g8r8, null, b5g6r5, fast_composite_src_x888_0565),
-    PIXMAN_STD_FAST_PATH (IN, a8, null, a8, fast_composite_in_8_8),
-    PIXMAN_STD_FAST_PATH (IN, solid, a8, a8, fast_composite_in_n_8_8),
-
-    SIMPLE_NEAREST_FAST_PATH (SRC, x8r8g8b8, x8r8g8b8, 8888_8888),
-    SIMPLE_NEAREST_FAST_PATH (SRC, a8r8g8b8, x8r8g8b8, 8888_8888),
-    SIMPLE_NEAREST_FAST_PATH (SRC, x8b8g8r8, x8b8g8r8, 8888_8888),
-    SIMPLE_NEAREST_FAST_PATH (SRC, a8b8g8r8, x8b8g8r8, 8888_8888),
-
-    SIMPLE_NEAREST_FAST_PATH (SRC, a8r8g8b8, a8r8g8b8, 8888_8888),
-    SIMPLE_NEAREST_FAST_PATH (SRC, a8b8g8r8, a8b8g8r8, 8888_8888),
-
-    SIMPLE_NEAREST_FAST_PATH (SRC, x8r8g8b8, r5g6b5, 8888_565),
-    SIMPLE_NEAREST_FAST_PATH (SRC, a8r8g8b8, r5g6b5, 8888_565),
-
-    SIMPLE_NEAREST_FAST_PATH (SRC, r5g6b5, r5g6b5, 565_565),
-
-    SIMPLE_NEAREST_FAST_PATH (OVER, a8r8g8b8, x8r8g8b8, 8888_8888),
-    SIMPLE_NEAREST_FAST_PATH (OVER, a8b8g8r8, x8b8g8r8, 8888_8888),
-    SIMPLE_NEAREST_FAST_PATH (OVER, a8r8g8b8, a8r8g8b8, 8888_8888),
-    SIMPLE_NEAREST_FAST_PATH (OVER, a8b8g8r8, a8b8g8r8, 8888_8888),
-
-    SIMPLE_NEAREST_FAST_PATH (OVER, a8r8g8b8, r5g6b5, 8888_565),
-
-#define NEAREST_FAST_PATH(op,s,d)		\
-    {   PIXMAN_OP_ ## op,			\
-	PIXMAN_ ## s, SCALED_NEAREST_FLAGS,	\
-	PIXMAN_null, 0,				\
-	PIXMAN_ ## d, FAST_PATH_STD_DEST_FLAGS,	\
-	fast_composite_scaled_nearest,		\
-    }
-
-    NEAREST_FAST_PATH (SRC, x8r8g8b8, x8r8g8b8),
-    NEAREST_FAST_PATH (SRC, a8r8g8b8, x8r8g8b8),
-    NEAREST_FAST_PATH (SRC, x8b8g8r8, x8b8g8r8),
-    NEAREST_FAST_PATH (SRC, a8b8g8r8, x8b8g8r8),
-
-    NEAREST_FAST_PATH (SRC, x8r8g8b8, a8r8g8b8),
-    NEAREST_FAST_PATH (SRC, a8r8g8b8, a8r8g8b8),
-    NEAREST_FAST_PATH (SRC, x8b8g8r8, a8b8g8r8),
-    NEAREST_FAST_PATH (SRC, a8b8g8r8, a8b8g8r8),
-
-    NEAREST_FAST_PATH (OVER, x8r8g8b8, x8r8g8b8),
-    NEAREST_FAST_PATH (OVER, a8r8g8b8, x8r8g8b8),
-    NEAREST_FAST_PATH (OVER, x8b8g8r8, x8b8g8r8),
-    NEAREST_FAST_PATH (OVER, a8b8g8r8, x8b8g8r8),
-
-    NEAREST_FAST_PATH (OVER, x8r8g8b8, a8r8g8b8),
-    NEAREST_FAST_PATH (OVER, a8r8g8b8, a8r8g8b8),
-    NEAREST_FAST_PATH (OVER, x8b8g8r8, a8b8g8r8),
-    NEAREST_FAST_PATH (OVER, a8b8g8r8, a8b8g8r8),
-
-    {   PIXMAN_OP_NONE	},
-};
-
-#ifdef WORDS_BIGENDIAN
-#define A1_FILL_MASK(n, offs) (((1 << (n)) - 1) << (32 - (offs) - (n)))
-#else
-#define A1_FILL_MASK(n, offs) (((1 << (n)) - 1) << (offs))
-#endif
-
-static force_inline void
-pixman_fill1_line (uint32_t *dst, int offs, int width, int v)
-{
-    if (offs)
-    {
-	int leading_pixels = 32 - offs;
-	if (leading_pixels >= width)
-	{
-	    if (v)
-		*dst |= A1_FILL_MASK (width, offs);
-	    else
-		*dst &= ~A1_FILL_MASK (width, offs);
-	    return;
-	}
-	else
-	{
-	    if (v)
-		*dst++ |= A1_FILL_MASK (leading_pixels, offs);
-	    else
-		*dst++ &= ~A1_FILL_MASK (leading_pixels, offs);
-	    width -= leading_pixels;
-	}
-    }
-    while (width >= 32)
-    {
-	if (v)
-	    *dst++ = 0xFFFFFFFF;
-	else
-	    *dst++ = 0;
-	width -= 32;
-    }
-    if (width > 0)
-    {
-	if (v)
-	    *dst |= A1_FILL_MASK (width, 0);
-	else
-	    *dst &= ~A1_FILL_MASK (width, 0);
-    }
-}
-
-static void
-pixman_fill1 (uint32_t *bits,
-              int       stride,
-              int       x,
-              int       y,
-              int       width,
-              int       height,
-              uint32_t  xor)
-{
-    uint32_t *dst = bits + y * stride + (x >> 5);
-    int offs = x & 31;
-
-    if (xor & 1)
-    {
-	while (height--)
-	{
-	    pixman_fill1_line (dst, offs, width, 1);
-	    dst += stride;
-	}
-    }
-    else
-    {
-	while (height--)
-	{
-	    pixman_fill1_line (dst, offs, width, 0);
-	    dst += stride;
-	}
-    }
-}
-
-static void
-pixman_fill8 (uint32_t *bits,
-              int       stride,
-              int       x,
-              int       y,
-              int       width,
-              int       height,
-              uint32_t xor)
-{
-    int byte_stride = stride * (int) sizeof (uint32_t);
-    uint8_t *dst = (uint8_t *) bits;
-    uint8_t v = xor & 0xff;
-    int i;
-
-    dst = dst + y * byte_stride + x;
-
-    while (height--)
-    {
-	for (i = 0; i < width; ++i)
-	    dst[i] = v;
-
-	dst += byte_stride;
-    }
-}
-
-static void
-pixman_fill16 (uint32_t *bits,
-               int       stride,
-               int       x,
-               int       y,
-               int       width,
-               int       height,
-               uint32_t xor)
-{
-    int short_stride =
-	(stride * (int)sizeof (uint32_t)) / (int)sizeof (uint16_t);
-    uint16_t *dst = (uint16_t *)bits;
-    uint16_t v = xor & 0xffff;
-    int i;
-
-    dst = dst + y * short_stride + x;
-
-    while (height--)
-    {
-	for (i = 0; i < width; ++i)
-	    dst[i] = v;
-
-	dst += short_stride;
-    }
-}
-
-static void
-pixman_fill32 (uint32_t *bits,
-               int       stride,
-               int       x,
-               int       y,
-               int       width,
-               int       height,
-               uint32_t  xor)
-{
-    int i;
-
-    bits = bits + y * stride + x;
-
-    while (height--)
-    {
-	for (i = 0; i < width; ++i)
-	    bits[i] = xor;
-
-	bits += stride;
-    }
-}
-
-static pixman_bool_t
-fast_path_fill (pixman_implementation_t *imp,
-                uint32_t *               bits,
-                int                      stride,
-                int                      bpp,
-                int                      x,
-                int                      y,
-                int                      width,
-                int                      height,
-                uint32_t		 xor)
-{
-    switch (bpp)
-    {
-    case 1:
-	pixman_fill1 (bits, stride, x, y, width, height, xor);
-	break;
-
-    case 8:
-	pixman_fill8 (bits, stride, x, y, width, height, xor);
-	break;
-
-    case 16:
-	pixman_fill16 (bits, stride, x, y, width, height, xor);
-	break;
-
-    case 32:
-	pixman_fill32 (bits, stride, x, y, width, height, xor);
-	break;
-
-    default:
-	return _pixman_implementation_fill (
-	    imp->delegate, bits, stride, bpp, x, y, width, height, xor);
-	break;
-    }
-
-    return TRUE;
-}
-
-pixman_implementation_t *
-_pixman_implementation_create_fast_path (void)
-{
-    pixman_implementation_t *general = _pixman_implementation_create_general ();
-    pixman_implementation_t *imp = _pixman_implementation_create (general, c_fast_paths);
-
-    imp->fill = fast_path_fill;
-
-    return imp;
-}
+/* -*- Mode: c; c-basic-offset: 4; tab-width: 8; indent-tabs-mode: t; -*- */

+/*

+ * Copyright © 2000 SuSE, Inc.

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

+ *

+ * Author:  Keith Packard, SuSE, Inc.

+ */

+

+#ifdef HAVE_CONFIG_H

+#include <config.h>

+#endif

+#include <string.h>

+#include <stdlib.h>

+#include "pixman-private.h"

+#include "pixman-combine32.h"

+#include "pixman-fast-path.h"

+

+static force_inline uint32_t

+fetch_24 (uint8_t *a)

+{

+    if (((unsigned long)a) & 1)

+    {

+#ifdef WORDS_BIGENDIAN

+	return (*a << 16) | (*(uint16_t *)(a + 1));

+#else

+	return *a | (*(uint16_t *)(a + 1) << 8);

+#endif

+    }

+    else

+    {

+#ifdef WORDS_BIGENDIAN

+	return (*(uint16_t *)a << 8) | *(a + 2);

+#else

+	return *(uint16_t *)a | (*(a + 2) << 16);

+#endif

+    }

+}

+

+static force_inline void

+store_24 (uint8_t *a,

+          uint32_t v)

+{

+    if (((unsigned long)a) & 1)

+    {

+#ifdef WORDS_BIGENDIAN

+	*a = (uint8_t) (v >> 16);

+	*(uint16_t *)(a + 1) = (uint16_t) (v);

+#else

+	*a = (uint8_t) (v);

+	*(uint16_t *)(a + 1) = (uint16_t) (v >> 8);

+#endif

+    }

+    else

+    {

+#ifdef WORDS_BIGENDIAN

+	*(uint16_t *)a = (uint16_t)(v >> 8);

+	*(a + 2) = (uint8_t)v;

+#else

+	*(uint16_t *)a = (uint16_t)v;

+	*(a + 2) = (uint8_t)(v >> 16);

+#endif

+    }

+}

+

+static force_inline uint32_t

+over (uint32_t src,

+      uint32_t dest)

+{

+    uint32_t a = ~src >> 24;

+

+    UN8x4_MUL_UN8_ADD_UN8x4 (dest, a, src);

+

+    return dest;

+}

+

+static uint32_t

+in (uint32_t x,

+    uint8_t  y)

+{

+    uint16_t a = y;

+

+    UN8x4_MUL_UN8 (x, a);

+

+    return x;

+}

+

+/*

+ * Naming convention:

+ *

+ *  op_src_mask_dest

+ */

+static void

+fast_composite_over_x888_8_8888 (pixman_implementation_t *imp,

+                                 pixman_op_t              op,

+                                 pixman_image_t *         src_image,

+                                 pixman_image_t *         mask_image,

+                                 pixman_image_t *         dst_image,

+                                 int32_t                  src_x,

+                                 int32_t                  src_y,

+                                 int32_t                  mask_x,

+                                 int32_t                  mask_y,

+                                 int32_t                  dest_x,

+                                 int32_t                  dest_y,

+                                 int32_t                  width,

+                                 int32_t                  height)

+{

+    uint32_t    *src, *src_line;

+    uint32_t    *dst, *dst_line;

+    uint8_t     *mask, *mask_line;

+    int src_stride, mask_stride, dst_stride;

+    uint8_t m;

+    uint32_t s, d;

+    int32_t w;

+

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);

+    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);

+    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);

+

+    while (height--)

+    {

+	src = src_line;

+	src_line += src_stride;

+	dst = dst_line;

+	dst_line += dst_stride;

+	mask = mask_line;

+	mask_line += mask_stride;

+

+	w = width;

+	while (w--)

+	{

+	    m = *mask++;

+	    if (m)

+	    {

+		s = *src | 0xff000000;

+

+		if (m == 0xff)

+		{

+		    *dst = s;

+		}

+		else

+		{

+		    d = in (s, m);

+		    *dst = over (d, *dst);

+		}

+	    }

+	    src++;

+	    dst++;

+	}

+    }

+}

+

+static void

+fast_composite_in_n_8_8 (pixman_implementation_t *imp,

+                         pixman_op_t              op,

+                         pixman_image_t *         src_image,

+                         pixman_image_t *         mask_image,

+                         pixman_image_t *         dest_image,

+                         int32_t                  src_x,

+                         int32_t                  src_y,

+                         int32_t                  mask_x,

+                         int32_t                  mask_y,

+                         int32_t                  dest_x,

+                         int32_t                  dest_y,

+                         int32_t                  width,

+                         int32_t                  height)

+{

+    uint32_t src, srca;

+    uint8_t     *dst_line, *dst;

+    uint8_t     *mask_line, *mask, m;

+    int dst_stride, mask_stride;

+    int32_t w;

+    uint16_t t;

+

+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);

+

+    srca = src >> 24;

+

+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);

+    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);

+

+    if (srca == 0xff)

+    {

+	while (height--)

+	{

+	    dst = dst_line;

+	    dst_line += dst_stride;

+	    mask = mask_line;

+	    mask_line += mask_stride;

+	    w = width;

+

+	    while (w--)

+	    {

+		m = *mask++;

+

+		if (m == 0)

+		    *dst = 0;

+		else if (m != 0xff)

+		    *dst = MUL_UN8 (m, *dst, t);

+

+		dst++;

+	    }

+	}

+    }

+    else

+    {

+	while (height--)

+	{

+	    dst = dst_line;

+	    dst_line += dst_stride;

+	    mask = mask_line;

+	    mask_line += mask_stride;

+	    w = width;

+

+	    while (w--)

+	    {

+		m = *mask++;

+		m = MUL_UN8 (m, srca, t);

+

+		if (m == 0)

+		    *dst = 0;

+		else if (m != 0xff)

+		    *dst = MUL_UN8 (m, *dst, t);

+

+		dst++;

+	    }

+	}

+    }

+}

+

+static void

+fast_composite_in_8_8 (pixman_implementation_t *imp,

+                       pixman_op_t              op,

+                       pixman_image_t *         src_image,

+                       pixman_image_t *         mask_image,

+                       pixman_image_t *         dest_image,

+                       int32_t                  src_x,

+                       int32_t                  src_y,

+                       int32_t                  mask_x,

+                       int32_t                  mask_y,

+                       int32_t                  dest_x,

+                       int32_t                  dest_y,

+                       int32_t                  width,

+                       int32_t                  height)

+{

+    uint8_t     *dst_line, *dst;

+    uint8_t     *src_line, *src;

+    int dst_stride, src_stride;

+    int32_t w;

+    uint8_t s;

+    uint16_t t;

+

+    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint8_t, src_stride, src_line, 1);

+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	src = src_line;

+	src_line += src_stride;

+	w = width;

+

+	while (w--)

+	{

+	    s = *src++;

+

+	    if (s == 0)

+		*dst = 0;

+	    else if (s != 0xff)

+		*dst = MUL_UN8 (s, *dst, t);

+

+	    dst++;

+	}

+    }

+}

+

+static void

+fast_composite_over_n_8_8888 (pixman_implementation_t *imp,

+                              pixman_op_t              op,

+                              pixman_image_t *         src_image,

+                              pixman_image_t *         mask_image,

+                              pixman_image_t *         dst_image,

+                              int32_t                  src_x,

+                              int32_t                  src_y,

+                              int32_t                  mask_x,

+                              int32_t                  mask_y,

+                              int32_t                  dest_x,

+                              int32_t                  dest_y,

+                              int32_t                  width,

+                              int32_t                  height)

+{

+    uint32_t src, srca;

+    uint32_t    *dst_line, *dst, d;

+    uint8_t     *mask_line, *mask, m;

+    int dst_stride, mask_stride;

+    int32_t w;

+

+    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);

+

+    srca = src >> 24;

+    if (src == 0)

+	return;

+

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);

+    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	mask = mask_line;

+	mask_line += mask_stride;

+	w = width;

+

+	while (w--)

+	{

+	    m = *mask++;

+	    if (m == 0xff)

+	    {

+		if (srca == 0xff)

+		    *dst = src;

+		else

+		    *dst = over (src, *dst);

+	    }

+	    else if (m)

+	    {

+		d = in (src, m);

+		*dst = over (d, *dst);

+	    }

+	    dst++;

+	}

+    }

+}

+

+static void

+fast_composite_add_n_8888_8888_ca (pixman_implementation_t *imp,

+				   pixman_op_t              op,

+				   pixman_image_t *         src_image,

+				   pixman_image_t *         mask_image,

+				   pixman_image_t *         dst_image,

+				   int32_t                  src_x,

+				   int32_t                  src_y,

+				   int32_t                  mask_x,

+				   int32_t                  mask_y,

+				   int32_t                  dest_x,

+				   int32_t                  dest_y,

+				   int32_t                  width,

+				   int32_t                  height)

+{

+    uint32_t src, s;

+    uint32_t    *dst_line, *dst, d;

+    uint32_t    *mask_line, *mask, ma;

+    int dst_stride, mask_stride;

+    int32_t w;

+

+    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);

+

+    if (src == 0)

+	return;

+

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);

+    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint32_t, mask_stride, mask_line, 1);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	mask = mask_line;

+	mask_line += mask_stride;

+	w = width;

+

+	while (w--)

+	{

+	    ma = *mask++;

+

+	    if (ma)

+	    {

+		d = *dst;

+		s = src;

+

+		UN8x4_MUL_UN8x4_ADD_UN8x4 (s, ma, d);

+

+		*dst = s;

+	    }

+

+	    dst++;

+	}

+    }

+}

+

+static void

+fast_composite_over_n_8888_8888_ca (pixman_implementation_t *imp,

+                                    pixman_op_t              op,

+                                    pixman_image_t *         src_image,

+                                    pixman_image_t *         mask_image,

+                                    pixman_image_t *         dst_image,

+                                    int32_t                  src_x,

+                                    int32_t                  src_y,

+                                    int32_t                  mask_x,

+                                    int32_t                  mask_y,

+                                    int32_t                  dest_x,

+                                    int32_t                  dest_y,

+                                    int32_t                  width,

+                                    int32_t                  height)

+{

+    uint32_t src, srca, s;

+    uint32_t    *dst_line, *dst, d;

+    uint32_t    *mask_line, *mask, ma;

+    int dst_stride, mask_stride;

+    int32_t w;

+

+    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);

+

+    srca = src >> 24;

+    if (src == 0)

+	return;

+

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);

+    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint32_t, mask_stride, mask_line, 1);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	mask = mask_line;

+	mask_line += mask_stride;

+	w = width;

+

+	while (w--)

+	{

+	    ma = *mask++;

+	    if (ma == 0xffffffff)

+	    {

+		if (srca == 0xff)

+		    *dst = src;

+		else

+		    *dst = over (src, *dst);

+	    }

+	    else if (ma)

+	    {

+		d = *dst;

+		s = src;

+

+		UN8x4_MUL_UN8x4 (s, ma);

+		UN8x4_MUL_UN8 (ma, srca);

+		ma = ~ma;

+		UN8x4_MUL_UN8x4_ADD_UN8x4 (d, ma, s);

+

+		*dst = d;

+	    }

+

+	    dst++;

+	}

+    }

+}

+

+static void

+fast_composite_over_n_8_0888 (pixman_implementation_t *imp,

+                              pixman_op_t              op,

+                              pixman_image_t *         src_image,

+                              pixman_image_t *         mask_image,

+                              pixman_image_t *         dst_image,

+                              int32_t                  src_x,

+                              int32_t                  src_y,

+                              int32_t                  mask_x,

+                              int32_t                  mask_y,

+                              int32_t                  dest_x,

+                              int32_t                  dest_y,

+                              int32_t                  width,

+                              int32_t                  height)

+{

+    uint32_t src, srca;

+    uint8_t     *dst_line, *dst;

+    uint32_t d;

+    uint8_t     *mask_line, *mask, m;

+    int dst_stride, mask_stride;

+    int32_t w;

+

+    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);

+

+    srca = src >> 24;

+    if (src == 0)

+	return;

+

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 3);

+    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	mask = mask_line;

+	mask_line += mask_stride;

+	w = width;

+

+	while (w--)

+	{

+	    m = *mask++;

+	    if (m == 0xff)

+	    {

+		if (srca == 0xff)

+		{

+		    d = src;

+		}

+		else

+		{

+		    d = fetch_24 (dst);

+		    d = over (src, d);

+		}

+		store_24 (dst, d);

+	    }

+	    else if (m)

+	    {

+		d = over (in (src, m), fetch_24 (dst));

+		store_24 (dst, d);

+	    }

+	    dst += 3;

+	}

+    }

+}

+

+static void

+fast_composite_over_n_8_0565 (pixman_implementation_t *imp,

+                              pixman_op_t              op,

+                              pixman_image_t *         src_image,

+                              pixman_image_t *         mask_image,

+                              pixman_image_t *         dst_image,

+                              int32_t                  src_x,

+                              int32_t                  src_y,

+                              int32_t                  mask_x,

+                              int32_t                  mask_y,

+                              int32_t                  dest_x,

+                              int32_t                  dest_y,

+                              int32_t                  width,

+                              int32_t                  height)

+{

+    uint32_t src, srca;

+    uint16_t    *dst_line, *dst;

+    uint32_t d;

+    uint8_t     *mask_line, *mask, m;

+    int dst_stride, mask_stride;

+    int32_t w;

+

+    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);

+

+    srca = src >> 24;

+    if (src == 0)

+	return;

+

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);

+    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	mask = mask_line;

+	mask_line += mask_stride;

+	w = width;

+

+	while (w--)

+	{

+	    m = *mask++;

+	    if (m == 0xff)

+	    {

+		if (srca == 0xff)

+		{

+		    d = src;

+		}

+		else

+		{

+		    d = *dst;

+		    d = over (src, CONVERT_0565_TO_0888 (d));

+		}

+		*dst = CONVERT_8888_TO_0565 (d);

+	    }

+	    else if (m)

+	    {

+		d = *dst;

+		d = over (in (src, m), CONVERT_0565_TO_0888 (d));

+		*dst = CONVERT_8888_TO_0565 (d);

+	    }

+	    dst++;

+	}

+    }

+}

+

+static void

+fast_composite_over_n_8888_0565_ca (pixman_implementation_t *imp,

+                                    pixman_op_t              op,

+                                    pixman_image_t *         src_image,

+                                    pixman_image_t *         mask_image,

+                                    pixman_image_t *         dst_image,

+                                    int32_t                  src_x,

+                                    int32_t                  src_y,

+                                    int32_t                  mask_x,

+                                    int32_t                  mask_y,

+                                    int32_t                  dest_x,

+                                    int32_t                  dest_y,

+                                    int32_t                  width,

+                                    int32_t                  height)

+{

+    uint32_t  src, srca, s;

+    uint16_t  src16;

+    uint16_t *dst_line, *dst;

+    uint32_t  d;

+    uint32_t *mask_line, *mask, ma;

+    int dst_stride, mask_stride;

+    int32_t w;

+

+    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);

+

+    srca = src >> 24;

+    if (src == 0)

+	return;

+

+    src16 = CONVERT_8888_TO_0565 (src);

+

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);

+    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint32_t, mask_stride, mask_line, 1);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	mask = mask_line;

+	mask_line += mask_stride;

+	w = width;

+

+	while (w--)

+	{

+	    ma = *mask++;

+	    if (ma == 0xffffffff)

+	    {

+		if (srca == 0xff)

+		{

+		    *dst = src16;

+		}

+		else

+		{

+		    d = *dst;

+		    d = over (src, CONVERT_0565_TO_0888 (d));

+		    *dst = CONVERT_8888_TO_0565 (d);

+		}

+	    }

+	    else if (ma)

+	    {

+		d = *dst;

+		d = CONVERT_0565_TO_0888 (d);

+

+		s = src;

+

+		UN8x4_MUL_UN8x4 (s, ma);

+		UN8x4_MUL_UN8 (ma, srca);

+		ma = ~ma;

+		UN8x4_MUL_UN8x4_ADD_UN8x4 (d, ma, s);

+

+		*dst = CONVERT_8888_TO_0565 (d);

+	    }

+	    dst++;

+	}

+    }

+}

+

+static void

+fast_composite_over_8888_8888 (pixman_implementation_t *imp,

+                               pixman_op_t              op,

+                               pixman_image_t *         src_image,

+                               pixman_image_t *         mask_image,

+                               pixman_image_t *         dst_image,

+                               int32_t                  src_x,

+                               int32_t                  src_y,

+                               int32_t                  mask_x,

+                               int32_t                  mask_y,

+                               int32_t                  dest_x,

+                               int32_t                  dest_y,

+                               int32_t                  width,

+                               int32_t                  height)

+{

+    uint32_t    *dst_line, *dst;

+    uint32_t    *src_line, *src, s;

+    int dst_stride, src_stride;

+    uint8_t a;

+    int32_t w;

+

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);

+    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	src = src_line;

+	src_line += src_stride;

+	w = width;

+

+	while (w--)

+	{

+	    s = *src++;

+	    a = s >> 24;

+	    if (a == 0xff)

+		*dst = s;

+	    else if (s)

+		*dst = over (s, *dst);

+	    dst++;

+	}

+    }

+}

+

+static void

+fast_composite_src_x888_8888 (pixman_implementation_t *imp,

+			      pixman_op_t              op,

+			      pixman_image_t *         src_image,

+			      pixman_image_t *         mask_image,

+			      pixman_image_t *         dst_image,

+			      int32_t                  src_x,

+			      int32_t                  src_y,

+			      int32_t                  mask_x,

+			      int32_t                  mask_y,

+			      int32_t                  dest_x,

+			      int32_t                  dest_y,

+			      int32_t                  width,

+			      int32_t                  height)

+{

+    uint32_t    *dst_line, *dst;

+    uint32_t    *src_line, *src;

+    int dst_stride, src_stride;

+    int32_t w;

+

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);

+    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	src = src_line;

+	src_line += src_stride;

+	w = width;

+

+	while (w--)

+	    *dst++ = (*src++) | 0xff000000;

+    }

+}

+

+#if 0

+static void

+fast_composite_over_8888_0888 (pixman_implementation_t *imp,

+			       pixman_op_t              op,

+			       pixman_image_t *         src_image,

+			       pixman_image_t *         mask_image,

+			       pixman_image_t *         dst_image,

+			       int32_t                  src_x,

+			       int32_t                  src_y,

+			       int32_t                  mask_x,

+			       int32_t                  mask_y,

+			       int32_t                  dest_x,

+			       int32_t                  dest_y,

+			       int32_t                  width,

+			       int32_t                  height)

+{

+    uint8_t     *dst_line, *dst;

+    uint32_t d;

+    uint32_t    *src_line, *src, s;

+    uint8_t a;

+    int dst_stride, src_stride;

+    int32_t w;

+

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 3);

+    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	src = src_line;

+	src_line += src_stride;

+	w = width;

+

+	while (w--)

+	{

+	    s = *src++;

+	    a = s >> 24;

+	    if (a)

+	    {

+		if (a == 0xff)

+		    d = s;

+		else

+		    d = over (s, fetch_24 (dst));

+

+		store_24 (dst, d);

+	    }

+	    dst += 3;

+	}

+    }

+}

+#endif

+

+static void

+fast_composite_over_8888_0565 (pixman_implementation_t *imp,

+                               pixman_op_t              op,

+                               pixman_image_t *         src_image,

+                               pixman_image_t *         mask_image,

+                               pixman_image_t *         dst_image,

+                               int32_t                  src_x,

+                               int32_t                  src_y,

+                               int32_t                  mask_x,

+                               int32_t                  mask_y,

+                               int32_t                  dest_x,

+                               int32_t                  dest_y,

+                               int32_t                  width,

+                               int32_t                  height)

+{

+    uint16_t    *dst_line, *dst;

+    uint32_t d;

+    uint32_t    *src_line, *src, s;

+    uint8_t a;

+    int dst_stride, src_stride;

+    int32_t w;

+

+    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	src = src_line;

+	src_line += src_stride;

+	w = width;

+

+	while (w--)

+	{

+	    s = *src++;

+	    a = s >> 24;

+	    if (s)

+	    {

+		if (a == 0xff)

+		{

+		    d = s;

+		}

+		else

+		{

+		    d = *dst;

+		    d = over (s, CONVERT_0565_TO_0888 (d));

+		}

+		*dst = CONVERT_8888_TO_0565 (d);

+	    }

+	    dst++;

+	}

+    }

+}

+

+static void

+fast_composite_src_x888_0565 (pixman_implementation_t *imp,

+                              pixman_op_t              op,

+                              pixman_image_t *         src_image,

+                              pixman_image_t *         mask_image,

+                              pixman_image_t *         dst_image,

+                              int32_t                  src_x,

+                              int32_t                  src_y,

+                              int32_t                  mask_x,

+                              int32_t                  mask_y,

+                              int32_t                  dest_x,

+                              int32_t                  dest_y,

+                              int32_t                  width,

+                              int32_t                  height)

+{

+    uint16_t    *dst_line, *dst;

+    uint32_t    *src_line, *src, s;

+    int dst_stride, src_stride;

+    int32_t w;

+

+    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	src = src_line;

+	src_line += src_stride;

+	w = width;

+

+	while (w--)

+	{

+	    s = *src++;

+	    *dst = CONVERT_8888_TO_0565 (s);

+	    dst++;

+	}

+    }

+}

+

+static void

+fast_composite_add_8_8 (pixman_implementation_t *imp,

+			pixman_op_t              op,

+			pixman_image_t *         src_image,

+			pixman_image_t *         mask_image,

+			pixman_image_t *         dst_image,

+			int32_t                  src_x,

+			int32_t                  src_y,

+			int32_t                  mask_x,

+			int32_t                  mask_y,

+			int32_t                  dest_x,

+			int32_t                  dest_y,

+			int32_t                  width,

+			int32_t                  height)

+{

+    uint8_t     *dst_line, *dst;

+    uint8_t     *src_line, *src;

+    int dst_stride, src_stride;

+    int32_t w;

+    uint8_t s, d;

+    uint16_t t;

+

+    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint8_t, src_stride, src_line, 1);

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	src = src_line;

+	src_line += src_stride;

+	w = width;

+

+	while (w--)

+	{

+	    s = *src++;

+	    if (s)

+	    {

+		if (s != 0xff)

+		{

+		    d = *dst;

+		    t = d + s;

+		    s = t | (0 - (t >> 8));

+		}

+		*dst = s;

+	    }

+	    dst++;

+	}

+    }

+}

+

+static void

+fast_composite_add_8888_8888 (pixman_implementation_t *imp,

+                              pixman_op_t              op,

+                              pixman_image_t *         src_image,

+                              pixman_image_t *         mask_image,

+                              pixman_image_t *         dst_image,

+                              int32_t                  src_x,

+                              int32_t                  src_y,

+                              int32_t                  mask_x,

+                              int32_t                  mask_y,

+                              int32_t                  dest_x,

+                              int32_t                  dest_y,

+                              int32_t                  width,

+                              int32_t                  height)

+{

+    uint32_t    *dst_line, *dst;

+    uint32_t    *src_line, *src;

+    int dst_stride, src_stride;

+    int32_t w;

+    uint32_t s, d;

+

+    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	src = src_line;

+	src_line += src_stride;

+	w = width;

+

+	while (w--)

+	{

+	    s = *src++;

+	    if (s)

+	    {

+		if (s != 0xffffffff)

+		{

+		    d = *dst;

+		    if (d)

+			UN8x4_ADD_UN8x4 (s, d);

+		}

+		*dst = s;

+	    }

+	    dst++;

+	}

+    }

+}

+

+static void

+fast_composite_add_n_8_8 (pixman_implementation_t *imp,

+			  pixman_op_t              op,

+			  pixman_image_t *         src_image,

+			  pixman_image_t *         mask_image,

+			  pixman_image_t *         dst_image,

+			  int32_t                  src_x,

+			  int32_t                  src_y,

+			  int32_t                  mask_x,

+			  int32_t                  mask_y,

+			  int32_t                  dest_x,

+			  int32_t                  dest_y,

+			  int32_t                  width,

+			  int32_t                  height)

+{

+    uint8_t     *dst_line, *dst;

+    uint8_t     *mask_line, *mask;

+    int dst_stride, mask_stride;

+    int32_t w;

+    uint32_t src;

+    uint8_t sa;

+

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);

+    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);

+    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);

+    sa = (src >> 24);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	mask = mask_line;

+	mask_line += mask_stride;

+	w = width;

+

+	while (w--)

+	{

+	    uint16_t tmp;

+	    uint16_t a;

+	    uint32_t m, d;

+	    uint32_t r;

+

+	    a = *mask++;

+	    d = *dst;

+

+	    m = MUL_UN8 (sa, a, tmp);

+	    r = ADD_UN8 (m, d, tmp);

+

+	    *dst++ = r;

+	}

+    }

+}

+

+#ifdef WORDS_BIGENDIAN

+#define CREATE_BITMASK(n) (0x80000000 >> (n))

+#define UPDATE_BITMASK(n) ((n) >> 1)

+#else

+#define CREATE_BITMASK(n) (1 << (n))

+#define UPDATE_BITMASK(n) ((n) << 1)

+#endif

+

+#define TEST_BIT(p, n)					\

+    (*((p) + ((n) >> 5)) & CREATE_BITMASK ((n) & 31))

+#define SET_BIT(p, n)							\

+    do { *((p) + ((n) >> 5)) |= CREATE_BITMASK ((n) & 31); } while (0);

+

+static void

+fast_composite_add_1000_1000 (pixman_implementation_t *imp,

+                              pixman_op_t              op,

+                              pixman_image_t *         src_image,

+                              pixman_image_t *         mask_image,

+                              pixman_image_t *         dst_image,

+                              int32_t                  src_x,

+                              int32_t                  src_y,

+                              int32_t                  mask_x,

+                              int32_t                  mask_y,

+                              int32_t                  dest_x,

+                              int32_t                  dest_y,

+                              int32_t                  width,

+                              int32_t                  height)

+{

+    uint32_t     *dst_line, *dst;

+    uint32_t     *src_line, *src;

+    int           dst_stride, src_stride;

+    int32_t       w;

+

+    PIXMAN_IMAGE_GET_LINE (src_image, 0, src_y, uint32_t,

+                           src_stride, src_line, 1);

+    PIXMAN_IMAGE_GET_LINE (dst_image, 0, dest_y, uint32_t,

+                           dst_stride, dst_line, 1);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	src = src_line;

+	src_line += src_stride;

+	w = width;

+

+	while (w--)

+	{

+	    /*

+	     * TODO: improve performance by processing uint32_t data instead

+	     *       of individual bits

+	     */

+	    if (TEST_BIT (src, src_x + w))

+		SET_BIT (dst, dest_x + w);

+	}

+    }

+}

+

+static void

+fast_composite_over_n_1_8888 (pixman_implementation_t *imp,

+                              pixman_op_t              op,

+                              pixman_image_t *         src_image,

+                              pixman_image_t *         mask_image,

+                              pixman_image_t *         dst_image,

+                              int32_t                  src_x,

+                              int32_t                  src_y,

+                              int32_t                  mask_x,

+                              int32_t                  mask_y,

+                              int32_t                  dest_x,

+                              int32_t                  dest_y,

+                              int32_t                  width,

+                              int32_t                  height)

+{

+    uint32_t     src, srca;

+    uint32_t    *dst, *dst_line;

+    uint32_t    *mask, *mask_line;

+    int          mask_stride, dst_stride;

+    uint32_t     bitcache, bitmask;

+    int32_t      w;

+

+    if (width <= 0)

+	return;

+

+    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);

+    srca = src >> 24;

+    if (src == 0)

+	return;

+

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t,

+                           dst_stride, dst_line, 1);

+    PIXMAN_IMAGE_GET_LINE (mask_image, 0, mask_y, uint32_t,

+                           mask_stride, mask_line, 1);

+    mask_line += mask_x >> 5;

+

+    if (srca == 0xff)

+    {

+	while (height--)

+	{

+	    dst = dst_line;

+	    dst_line += dst_stride;

+	    mask = mask_line;

+	    mask_line += mask_stride;

+	    w = width;

+

+	    bitcache = *mask++;

+	    bitmask = CREATE_BITMASK (mask_x & 31);

+

+	    while (w--)

+	    {

+		if (bitmask == 0)

+		{

+		    bitcache = *mask++;

+		    bitmask = CREATE_BITMASK (0);

+		}

+		if (bitcache & bitmask)

+		    *dst = src;

+		bitmask = UPDATE_BITMASK (bitmask);

+		dst++;

+	    }

+	}

+    }

+    else

+    {

+	while (height--)

+	{

+	    dst = dst_line;

+	    dst_line += dst_stride;

+	    mask = mask_line;

+	    mask_line += mask_stride;

+	    w = width;

+

+	    bitcache = *mask++;

+	    bitmask = CREATE_BITMASK (mask_x & 31);

+

+	    while (w--)

+	    {

+		if (bitmask == 0)

+		{

+		    bitcache = *mask++;

+		    bitmask = CREATE_BITMASK (0);

+		}

+		if (bitcache & bitmask)

+		    *dst = over (src, *dst);

+		bitmask = UPDATE_BITMASK (bitmask);

+		dst++;

+	    }

+	}

+    }

+}

+

+static void

+fast_composite_over_n_1_0565 (pixman_implementation_t *imp,

+                              pixman_op_t              op,

+                              pixman_image_t *         src_image,

+                              pixman_image_t *         mask_image,

+                              pixman_image_t *         dst_image,

+                              int32_t                  src_x,

+                              int32_t                  src_y,

+                              int32_t                  mask_x,

+                              int32_t                  mask_y,

+                              int32_t                  dest_x,

+                              int32_t                  dest_y,

+                              int32_t                  width,

+                              int32_t                  height)

+{

+    uint32_t     src, srca;

+    uint16_t    *dst, *dst_line;

+    uint32_t    *mask, *mask_line;

+    int          mask_stride, dst_stride;

+    uint32_t     bitcache, bitmask;

+    int32_t      w;

+    uint32_t     d;

+    uint16_t     src565;

+

+    if (width <= 0)

+	return;

+

+    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);

+    srca = src >> 24;

+    if (src == 0)

+	return;

+

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t,

+                           dst_stride, dst_line, 1);

+    PIXMAN_IMAGE_GET_LINE (mask_image, 0, mask_y, uint32_t,

+                           mask_stride, mask_line, 1);

+    mask_line += mask_x >> 5;

+

+    if (srca == 0xff)

+    {

+	src565 = CONVERT_8888_TO_0565 (src);

+	while (height--)

+	{

+	    dst = dst_line;

+	    dst_line += dst_stride;

+	    mask = mask_line;

+	    mask_line += mask_stride;

+	    w = width;

+

+	    bitcache = *mask++;

+	    bitmask = CREATE_BITMASK (mask_x & 31);

+

+	    while (w--)

+	    {

+		if (bitmask == 0)

+		{

+		    bitcache = *mask++;

+		    bitmask = CREATE_BITMASK (0);

+		}

+		if (bitcache & bitmask)

+		    *dst = src565;

+		bitmask = UPDATE_BITMASK (bitmask);

+		dst++;

+	    }

+	}

+    }

+    else

+    {

+	while (height--)

+	{

+	    dst = dst_line;

+	    dst_line += dst_stride;

+	    mask = mask_line;

+	    mask_line += mask_stride;

+	    w = width;

+

+	    bitcache = *mask++;

+	    bitmask = CREATE_BITMASK (mask_x & 31);

+

+	    while (w--)

+	    {

+		if (bitmask == 0)

+		{

+		    bitcache = *mask++;

+		    bitmask = CREATE_BITMASK (0);

+		}

+		if (bitcache & bitmask)

+		{

+		    d = over (src, CONVERT_0565_TO_0888 (*dst));

+		    *dst = CONVERT_8888_TO_0565 (d);

+		}

+		bitmask = UPDATE_BITMASK (bitmask);

+		dst++;

+	    }

+	}

+    }

+}

+

+/*

+ * Simple bitblt

+ */

+

+static void

+fast_composite_solid_fill (pixman_implementation_t *imp,

+                           pixman_op_t              op,

+                           pixman_image_t *         src_image,

+                           pixman_image_t *         mask_image,

+                           pixman_image_t *         dst_image,

+                           int32_t                  src_x,

+                           int32_t                  src_y,

+                           int32_t                  mask_x,

+                           int32_t                  mask_y,

+                           int32_t                  dest_x,

+                           int32_t                  dest_y,

+                           int32_t                  width,

+                           int32_t                  height)

+{

+    uint32_t src;

+

+    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);

+

+    if (dst_image->bits.format == PIXMAN_a1)

+    {

+	src = src >> 31;

+    }

+    else if (dst_image->bits.format == PIXMAN_a8)

+    {

+	src = src >> 24;

+    }

+    else if (dst_image->bits.format == PIXMAN_r5g6b5 ||

+             dst_image->bits.format == PIXMAN_b5g6r5)

+    {

+	src = CONVERT_8888_TO_0565 (src);

+    }

+

+    pixman_fill (dst_image->bits.bits, dst_image->bits.rowstride,

+                 PIXMAN_FORMAT_BPP (dst_image->bits.format),

+                 dest_x, dest_y,

+                 width, height,

+                 src);

+}

+

+static void

+fast_composite_src_memcpy (pixman_implementation_t *imp,

+			   pixman_op_t              op,

+			   pixman_image_t *         src_image,

+			   pixman_image_t *         mask_image,

+			   pixman_image_t *         dst_image,

+			   int32_t                  src_x,

+			   int32_t                  src_y,

+			   int32_t                  mask_x,

+			   int32_t                  mask_y,

+			   int32_t                  dest_x,

+			   int32_t                  dest_y,

+			   int32_t                  width,

+			   int32_t                  height)

+{

+    int bpp = PIXMAN_FORMAT_BPP (dst_image->bits.format) / 8;

+    uint32_t n_bytes = width * bpp;

+    int dst_stride, src_stride;

+    uint8_t    *dst;

+    uint8_t    *src;

+

+    src_stride = src_image->bits.rowstride * 4;

+    dst_stride = dst_image->bits.rowstride * 4;

+

+    src = (uint8_t *)src_image->bits.bits + src_y * src_stride + src_x * bpp;

+    dst = (uint8_t *)dst_image->bits.bits + dest_y * dst_stride + dest_x * bpp;

+

+    while (height--)

+    {

+	memcpy (dst, src, n_bytes);

+

+	dst += dst_stride;

+	src += src_stride;

+    }

+}

+

+FAST_NEAREST (8888_8888_cover, 8888, 8888, uint32_t, uint32_t, SRC, COVER)

+FAST_NEAREST (8888_8888_none, 8888, 8888, uint32_t, uint32_t, SRC, NONE)

+FAST_NEAREST (8888_8888_pad, 8888, 8888, uint32_t, uint32_t, SRC, PAD)

+FAST_NEAREST (8888_8888_normal, 8888, 8888, uint32_t, uint32_t, SRC, NORMAL)

+FAST_NEAREST (8888_8888_cover, 8888, 8888, uint32_t, uint32_t, OVER, COVER)

+FAST_NEAREST (8888_8888_none, 8888, 8888, uint32_t, uint32_t, OVER, NONE)

+FAST_NEAREST (8888_8888_pad, 8888, 8888, uint32_t, uint32_t, OVER, PAD)

+FAST_NEAREST (8888_8888_normal, 8888, 8888, uint32_t, uint32_t, OVER, NORMAL)

+FAST_NEAREST (8888_565_cover, 8888, 0565, uint32_t, uint16_t, SRC, COVER)

+FAST_NEAREST (8888_565_none, 8888, 0565, uint32_t, uint16_t, SRC, NONE)

+FAST_NEAREST (8888_565_pad, 8888, 0565, uint32_t, uint16_t, SRC, PAD)

+FAST_NEAREST (8888_565_normal, 8888, 0565, uint32_t, uint16_t, SRC, NORMAL)

+FAST_NEAREST (565_565_normal, 0565, 0565, uint16_t, uint16_t, SRC, NORMAL)

+FAST_NEAREST (8888_565_cover, 8888, 0565, uint32_t, uint16_t, OVER, COVER)

+FAST_NEAREST (8888_565_none, 8888, 0565, uint32_t, uint16_t, OVER, NONE)

+FAST_NEAREST (8888_565_pad, 8888, 0565, uint32_t, uint16_t, OVER, PAD)

+FAST_NEAREST (8888_565_normal, 8888, 0565, uint32_t, uint16_t, OVER, NORMAL)

+

+/* Use more unrolling for src_0565_0565 because it is typically CPU bound */

+static force_inline void

+scaled_nearest_scanline_565_565_SRC (uint16_t *      dst,

+				     uint16_t *      src,

+				     int32_t         w,

+				     pixman_fixed_t  vx,

+				     pixman_fixed_t  unit_x,

+				     pixman_fixed_t  max_vx)

+{

+    uint16_t tmp1, tmp2, tmp3, tmp4;

+    while ((w -= 4) >= 0)

+    {

+	tmp1 = src[pixman_fixed_to_int (vx)];

+	vx += unit_x;

+	tmp2 = src[pixman_fixed_to_int (vx)];

+	vx += unit_x;

+	tmp3 = src[pixman_fixed_to_int (vx)];

+	vx += unit_x;

+	tmp4 = src[pixman_fixed_to_int (vx)];

+	vx += unit_x;

+	*dst++ = tmp1;

+	*dst++ = tmp2;

+	*dst++ = tmp3;

+	*dst++ = tmp4;

+    }

+    if (w & 2)

+    {

+	tmp1 = src[pixman_fixed_to_int (vx)];

+	vx += unit_x;

+	tmp2 = src[pixman_fixed_to_int (vx)];

+	vx += unit_x;

+	*dst++ = tmp1;

+	*dst++ = tmp2;

+    }

+    if (w & 1)

+	*dst++ = src[pixman_fixed_to_int (vx)];

+}

+

+FAST_NEAREST_MAINLOOP (565_565_cover_SRC,

+		       scaled_nearest_scanline_565_565_SRC,

+		       uint16_t, uint16_t, COVER)

+FAST_NEAREST_MAINLOOP (565_565_none_SRC,

+		       scaled_nearest_scanline_565_565_SRC,

+		       uint16_t, uint16_t, NONE)

+FAST_NEAREST_MAINLOOP (565_565_pad_SRC,

+		       scaled_nearest_scanline_565_565_SRC,

+		       uint16_t, uint16_t, PAD)

+

+static force_inline uint32_t

+fetch_nearest (pixman_repeat_t src_repeat,

+	       pixman_format_code_t format,

+	       uint32_t *src, int x, int src_width)

+{

+    if (repeat (src_repeat, &x, src_width))

+    {

+	if (format == PIXMAN_x8r8g8b8)

+	    return *(src + x) | 0xff000000;

+	else

+	    return *(src + x);

+    }

+    else

+    {

+	return 0;

+    }

+}

+

+static force_inline void

+combine_over (uint32_t s, uint32_t *dst)

+{

+    if (s)

+    {

+	uint8_t ia = 0xff - (s >> 24);

+

+	if (ia)

+	    UN8x4_MUL_UN8_ADD_UN8x4 (*dst, ia, s);

+	else

+	    *dst = s;

+    }

+}

+

+static force_inline void

+combine_src (uint32_t s, uint32_t *dst)

+{

+    *dst = s;

+}

+

+static void

+fast_composite_scaled_nearest (pixman_implementation_t *imp,

+			       pixman_op_t              op,

+			       pixman_image_t *         src_image,

+			       pixman_image_t *         mask_image,

+			       pixman_image_t *         dst_image,

+			       int32_t                  src_x,

+			       int32_t                  src_y,

+			       int32_t                  mask_x,

+			       int32_t                  mask_y,

+			       int32_t                  dest_x,

+			       int32_t                  dest_y,

+			       int32_t                  width,

+			       int32_t                  height)

+{

+    uint32_t       *dst_line;

+    uint32_t       *src_line;

+    int             dst_stride, src_stride;

+    int		    src_width, src_height;

+    pixman_repeat_t src_repeat;

+    pixman_fixed_t unit_x, unit_y;

+    pixman_format_code_t src_format;

+    pixman_vector_t v;

+    pixman_fixed_t vy;

+

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);

+    /* pass in 0 instead of src_x and src_y because src_x and src_y need to be

+     * transformed from destination space to source space

+     */

+    PIXMAN_IMAGE_GET_LINE (src_image, 0, 0, uint32_t, src_stride, src_line, 1);

+

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

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

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

+    v.vector[2] = pixman_fixed_1;

+

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

+	return;

+

+    unit_x = src_image->common.transform->matrix[0][0];

+    unit_y = src_image->common.transform->matrix[1][1];

+

+    /* Round down to closest integer, ensuring that 0.5 rounds to 0, not 1 */

+    v.vector[0] -= pixman_fixed_e;

+    v.vector[1] -= pixman_fixed_e;

+

+    src_height = src_image->bits.height;

+    src_width = src_image->bits.width;

+    src_repeat = src_image->common.repeat;

+    src_format = src_image->bits.format;

+

+    vy = v.vector[1];

+    while (height--)

+    {

+        pixman_fixed_t vx = v.vector[0];

+	int y = pixman_fixed_to_int (vy);

+	uint32_t *dst = dst_line;

+

+	dst_line += dst_stride;

+

+        /* adjust the y location by a unit vector in the y direction

+         * this is equivalent to transforming y+1 of the destination point to source space */

+        vy += unit_y;

+

+	if (!repeat (src_repeat, &y, src_height))

+	{

+	    if (op == PIXMAN_OP_SRC)

+		memset (dst, 0, sizeof (*dst) * width);

+	}

+	else

+	{

+	    int w = width;

+

+	    uint32_t *src = src_line + y * src_stride;

+

+	    while (w >= 2)

+	    {

+		uint32_t s1, s2;

+		int x1, x2;

+

+		x1 = pixman_fixed_to_int (vx);

+		vx += unit_x;

+

+		x2 = pixman_fixed_to_int (vx);

+		vx += unit_x;

+

+		w -= 2;

+

+		s1 = fetch_nearest (src_repeat, src_format, src, x1, src_width);

+		s2 = fetch_nearest (src_repeat, src_format, src, x2, src_width);

+

+		if (op == PIXMAN_OP_OVER)

+		{

+		    combine_over (s1, dst++);

+		    combine_over (s2, dst++);

+		}

+		else

+		{

+		    combine_src (s1, dst++);

+		    combine_src (s2, dst++);

+		}

+	    }

+

+	    while (w--)

+	    {

+		uint32_t s;

+		int x;

+

+		x = pixman_fixed_to_int (vx);

+		vx += unit_x;

+

+		s = fetch_nearest (src_repeat, src_format, src, x, src_width);

+

+		if (op == PIXMAN_OP_OVER)

+		    combine_over (s, dst++);

+		else

+		    combine_src (s, dst++);

+	    }

+	}

+    }

+}

+

+static const pixman_fast_path_t c_fast_paths[] =

+{

+    PIXMAN_STD_FAST_PATH (OVER, solid, a8, r5g6b5, fast_composite_over_n_8_0565),

+    PIXMAN_STD_FAST_PATH (OVER, solid, a8, b5g6r5, fast_composite_over_n_8_0565),

+    PIXMAN_STD_FAST_PATH (OVER, solid, a8, r8g8b8, fast_composite_over_n_8_0888),

+    PIXMAN_STD_FAST_PATH (OVER, solid, a8, b8g8r8, fast_composite_over_n_8_0888),

+    PIXMAN_STD_FAST_PATH (OVER, solid, a8, a8r8g8b8, fast_composite_over_n_8_8888),

+    PIXMAN_STD_FAST_PATH (OVER, solid, a8, x8r8g8b8, fast_composite_over_n_8_8888),

+    PIXMAN_STD_FAST_PATH (OVER, solid, a8, a8b8g8r8, fast_composite_over_n_8_8888),

+    PIXMAN_STD_FAST_PATH (OVER, solid, a8, x8b8g8r8, fast_composite_over_n_8_8888),

+    PIXMAN_STD_FAST_PATH (OVER, solid, a1, a8r8g8b8, fast_composite_over_n_1_8888),

+    PIXMAN_STD_FAST_PATH (OVER, solid, a1, x8r8g8b8, fast_composite_over_n_1_8888),

+    PIXMAN_STD_FAST_PATH (OVER, solid, a1, a8b8g8r8, fast_composite_over_n_1_8888),

+    PIXMAN_STD_FAST_PATH (OVER, solid, a1, x8b8g8r8, fast_composite_over_n_1_8888),

+    PIXMAN_STD_FAST_PATH (OVER, solid, a1, r5g6b5,   fast_composite_over_n_1_0565),

+    PIXMAN_STD_FAST_PATH (OVER, solid, a1, b5g6r5,   fast_composite_over_n_1_0565),

+    PIXMAN_STD_FAST_PATH_CA (OVER, solid, a8r8g8b8, a8r8g8b8, fast_composite_over_n_8888_8888_ca),

+    PIXMAN_STD_FAST_PATH_CA (OVER, solid, a8r8g8b8, x8r8g8b8, fast_composite_over_n_8888_8888_ca),

+    PIXMAN_STD_FAST_PATH_CA (OVER, solid, a8r8g8b8, r5g6b5, fast_composite_over_n_8888_0565_ca),

+    PIXMAN_STD_FAST_PATH_CA (OVER, solid, a8b8g8r8, a8b8g8r8, fast_composite_over_n_8888_8888_ca),

+    PIXMAN_STD_FAST_PATH_CA (OVER, solid, a8b8g8r8, x8b8g8r8, fast_composite_over_n_8888_8888_ca),

+    PIXMAN_STD_FAST_PATH_CA (OVER, solid, a8b8g8r8, b5g6r5, fast_composite_over_n_8888_0565_ca),

+    PIXMAN_STD_FAST_PATH (OVER, x8r8g8b8, a8, x8r8g8b8, fast_composite_over_x888_8_8888),

+    PIXMAN_STD_FAST_PATH (OVER, x8r8g8b8, a8, a8r8g8b8, fast_composite_over_x888_8_8888),

+    PIXMAN_STD_FAST_PATH (OVER, x8b8g8r8, a8, x8b8g8r8, fast_composite_over_x888_8_8888),

+    PIXMAN_STD_FAST_PATH (OVER, x8b8g8r8, a8, a8b8g8r8, fast_composite_over_x888_8_8888),

+    PIXMAN_STD_FAST_PATH (OVER, a8r8g8b8, null, a8r8g8b8, fast_composite_over_8888_8888),

+    PIXMAN_STD_FAST_PATH (OVER, a8r8g8b8, null, x8r8g8b8, fast_composite_over_8888_8888),

+    PIXMAN_STD_FAST_PATH (OVER, a8r8g8b8, null, r5g6b5, fast_composite_over_8888_0565),

+    PIXMAN_STD_FAST_PATH (OVER, a8b8g8r8, null, a8b8g8r8, fast_composite_over_8888_8888),

+    PIXMAN_STD_FAST_PATH (OVER, a8b8g8r8, null, x8b8g8r8, fast_composite_over_8888_8888),

+    PIXMAN_STD_FAST_PATH (OVER, a8b8g8r8, null, b5g6r5, fast_composite_over_8888_0565),

+    PIXMAN_STD_FAST_PATH (ADD, a8r8g8b8, null, a8r8g8b8, fast_composite_add_8888_8888),

+    PIXMAN_STD_FAST_PATH (ADD, a8b8g8r8, null, a8b8g8r8, fast_composite_add_8888_8888),

+    PIXMAN_STD_FAST_PATH (ADD, a8, null, a8, fast_composite_add_8_8),

+    PIXMAN_STD_FAST_PATH (ADD, a1, null, a1, fast_composite_add_1000_1000),

+    PIXMAN_STD_FAST_PATH_CA (ADD, solid, a8r8g8b8, a8r8g8b8, fast_composite_add_n_8888_8888_ca),

+    PIXMAN_STD_FAST_PATH (ADD, solid, a8, a8, fast_composite_add_n_8_8),

+    PIXMAN_STD_FAST_PATH (SRC, solid, null, a8r8g8b8, fast_composite_solid_fill),

+    PIXMAN_STD_FAST_PATH (SRC, solid, null, x8r8g8b8, fast_composite_solid_fill),

+    PIXMAN_STD_FAST_PATH (SRC, solid, null, a8b8g8r8, fast_composite_solid_fill),

+    PIXMAN_STD_FAST_PATH (SRC, solid, null, x8b8g8r8, fast_composite_solid_fill),

+    PIXMAN_STD_FAST_PATH (SRC, solid, null, a1, fast_composite_solid_fill),

+    PIXMAN_STD_FAST_PATH (SRC, solid, null, a8, fast_composite_solid_fill),

+    PIXMAN_STD_FAST_PATH (SRC, solid, null, r5g6b5, fast_composite_solid_fill),

+    PIXMAN_STD_FAST_PATH (SRC, x8r8g8b8, null, a8r8g8b8, fast_composite_src_x888_8888),

+    PIXMAN_STD_FAST_PATH (SRC, x8b8g8r8, null, a8b8g8r8, fast_composite_src_x888_8888),

+    PIXMAN_STD_FAST_PATH (SRC, a8r8g8b8, null, x8r8g8b8, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, a8r8g8b8, null, a8r8g8b8, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, x8r8g8b8, null, x8r8g8b8, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, a8b8g8r8, null, x8b8g8r8, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, a8b8g8r8, null, a8b8g8r8, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, x8b8g8r8, null, x8b8g8r8, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, b8g8r8a8, null, b8g8r8x8, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, b8g8r8a8, null, b8g8r8a8, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, b8g8r8x8, null, b8g8r8x8, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, r5g6b5, null, r5g6b5, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, b5g6r5, null, b5g6r5, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, r8g8b8, null, r8g8b8, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, b8g8r8, null, b8g8r8, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, x1r5g5b5, null, x1r5g5b5, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, a1r5g5b5, null, x1r5g5b5, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, a8, null, a8, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, a8r8g8b8, null, r5g6b5, fast_composite_src_x888_0565),

+    PIXMAN_STD_FAST_PATH (SRC, x8r8g8b8, null, r5g6b5, fast_composite_src_x888_0565),

+    PIXMAN_STD_FAST_PATH (SRC, a8b8g8r8, null, b5g6r5, fast_composite_src_x888_0565),

+    PIXMAN_STD_FAST_PATH (SRC, x8b8g8r8, null, b5g6r5, fast_composite_src_x888_0565),

+    PIXMAN_STD_FAST_PATH (IN, a8, null, a8, fast_composite_in_8_8),

+    PIXMAN_STD_FAST_PATH (IN, solid, a8, a8, fast_composite_in_n_8_8),

+

+    SIMPLE_NEAREST_FAST_PATH (SRC, x8r8g8b8, x8r8g8b8, 8888_8888),

+    SIMPLE_NEAREST_FAST_PATH (SRC, a8r8g8b8, x8r8g8b8, 8888_8888),

+    SIMPLE_NEAREST_FAST_PATH (SRC, x8b8g8r8, x8b8g8r8, 8888_8888),

+    SIMPLE_NEAREST_FAST_PATH (SRC, a8b8g8r8, x8b8g8r8, 8888_8888),

+

+    SIMPLE_NEAREST_FAST_PATH (SRC, a8r8g8b8, a8r8g8b8, 8888_8888),

+    SIMPLE_NEAREST_FAST_PATH (SRC, a8b8g8r8, a8b8g8r8, 8888_8888),

+

+    SIMPLE_NEAREST_FAST_PATH (SRC, x8r8g8b8, r5g6b5, 8888_565),

+    SIMPLE_NEAREST_FAST_PATH (SRC, a8r8g8b8, r5g6b5, 8888_565),

+

+    SIMPLE_NEAREST_FAST_PATH (SRC, r5g6b5, r5g6b5, 565_565),

+

+    SIMPLE_NEAREST_FAST_PATH (OVER, a8r8g8b8, x8r8g8b8, 8888_8888),

+    SIMPLE_NEAREST_FAST_PATH (OVER, a8b8g8r8, x8b8g8r8, 8888_8888),

+    SIMPLE_NEAREST_FAST_PATH (OVER, a8r8g8b8, a8r8g8b8, 8888_8888),

+    SIMPLE_NEAREST_FAST_PATH (OVER, a8b8g8r8, a8b8g8r8, 8888_8888),

+

+    SIMPLE_NEAREST_FAST_PATH (OVER, a8r8g8b8, r5g6b5, 8888_565),

+

+#define NEAREST_FAST_PATH(op,s,d)		\

+    {   PIXMAN_OP_ ## op,			\

+	PIXMAN_ ## s, SCALED_NEAREST_FLAGS,	\

+	PIXMAN_null, 0,				\

+	PIXMAN_ ## d, FAST_PATH_STD_DEST_FLAGS,	\

+	fast_composite_scaled_nearest,		\

+    }

+

+    NEAREST_FAST_PATH (SRC, x8r8g8b8, x8r8g8b8),

+    NEAREST_FAST_PATH (SRC, a8r8g8b8, x8r8g8b8),

+    NEAREST_FAST_PATH (SRC, x8b8g8r8, x8b8g8r8),

+    NEAREST_FAST_PATH (SRC, a8b8g8r8, x8b8g8r8),

+

+    NEAREST_FAST_PATH (SRC, x8r8g8b8, a8r8g8b8),

+    NEAREST_FAST_PATH (SRC, a8r8g8b8, a8r8g8b8),

+    NEAREST_FAST_PATH (SRC, x8b8g8r8, a8b8g8r8),

+    NEAREST_FAST_PATH (SRC, a8b8g8r8, a8b8g8r8),

+

+    NEAREST_FAST_PATH (OVER, x8r8g8b8, x8r8g8b8),

+    NEAREST_FAST_PATH (OVER, a8r8g8b8, x8r8g8b8),

+    NEAREST_FAST_PATH (OVER, x8b8g8r8, x8b8g8r8),

+    NEAREST_FAST_PATH (OVER, a8b8g8r8, x8b8g8r8),

+

+    NEAREST_FAST_PATH (OVER, x8r8g8b8, a8r8g8b8),

+    NEAREST_FAST_PATH (OVER, a8r8g8b8, a8r8g8b8),

+    NEAREST_FAST_PATH (OVER, x8b8g8r8, a8b8g8r8),

+    NEAREST_FAST_PATH (OVER, a8b8g8r8, a8b8g8r8),

+

+    {   PIXMAN_OP_NONE	},

+};

+

+#ifdef WORDS_BIGENDIAN

+#define A1_FILL_MASK(n, offs) (((1 << (n)) - 1) << (32 - (offs) - (n)))

+#else

+#define A1_FILL_MASK(n, offs) (((1 << (n)) - 1) << (offs))

+#endif

+

+static force_inline void

+pixman_fill1_line (uint32_t *dst, int offs, int width, int v)

+{

+    if (offs)

+    {

+	int leading_pixels = 32 - offs;

+	if (leading_pixels >= width)

+	{

+	    if (v)

+		*dst |= A1_FILL_MASK (width, offs);

+	    else

+		*dst &= ~A1_FILL_MASK (width, offs);

+	    return;

+	}

+	else

+	{

+	    if (v)

+		*dst++ |= A1_FILL_MASK (leading_pixels, offs);

+	    else

+		*dst++ &= ~A1_FILL_MASK (leading_pixels, offs);

+	    width -= leading_pixels;

+	}

+    }

+    while (width >= 32)

+    {

+	if (v)

+	    *dst++ = 0xFFFFFFFF;

+	else

+	    *dst++ = 0;

+	width -= 32;

+    }

+    if (width > 0)

+    {

+	if (v)

+	    *dst |= A1_FILL_MASK (width, 0);

+	else

+	    *dst &= ~A1_FILL_MASK (width, 0);

+    }

+}

+

+static void

+pixman_fill1 (uint32_t *bits,

+              int       stride,

+              int       x,

+              int       y,

+              int       width,

+              int       height,

+              uint32_t  xor)

+{

+    uint32_t *dst = bits + y * stride + (x >> 5);

+    int offs = x & 31;

+

+    if (xor & 1)

+    {

+	while (height--)

+	{

+	    pixman_fill1_line (dst, offs, width, 1);

+	    dst += stride;

+	}

+    }

+    else

+    {

+	while (height--)

+	{

+	    pixman_fill1_line (dst, offs, width, 0);

+	    dst += stride;

+	}

+    }

+}

+

+static void

+pixman_fill8 (uint32_t *bits,

+              int       stride,

+              int       x,

+              int       y,

+              int       width,

+              int       height,

+              uint32_t xor)

+{

+    int byte_stride = stride * (int) sizeof (uint32_t);

+    uint8_t *dst = (uint8_t *) bits;

+    uint8_t v = xor & 0xff;

+    int i;

+

+    dst = dst + y * byte_stride + x;

+

+    while (height--)

+    {

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

+	    dst[i] = v;

+

+	dst += byte_stride;

+    }

+}

+

+static void

+pixman_fill16 (uint32_t *bits,

+               int       stride,

+               int       x,

+               int       y,

+               int       width,

+               int       height,

+               uint32_t xor)

+{

+    int short_stride =

+	(stride * (int)sizeof (uint32_t)) / (int)sizeof (uint16_t);

+    uint16_t *dst = (uint16_t *)bits;

+    uint16_t v = xor & 0xffff;

+    int i;

+

+    dst = dst + y * short_stride + x;

+

+    while (height--)

+    {

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

+	    dst[i] = v;

+

+	dst += short_stride;

+    }

+}

+

+static void

+pixman_fill32 (uint32_t *bits,

+               int       stride,

+               int       x,

+               int       y,

+               int       width,

+               int       height,

+               uint32_t  xor)

+{

+    int i;

+

+    bits = bits + y * stride + x;

+

+    while (height--)

+    {

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

+	    bits[i] = xor;

+

+	bits += stride;

+    }

+}

+

+static pixman_bool_t

+fast_path_fill (pixman_implementation_t *imp,

+                uint32_t *               bits,

+                int                      stride,

+                int                      bpp,

+                int                      x,

+                int                      y,

+                int                      width,

+                int                      height,

+                uint32_t		 xor)

+{

+    switch (bpp)

+    {

+    case 1:

+	pixman_fill1 (bits, stride, x, y, width, height, xor);

+	break;

+

+    case 8:

+	pixman_fill8 (bits, stride, x, y, width, height, xor);

+	break;

+

+    case 16:

+	pixman_fill16 (bits, stride, x, y, width, height, xor);

+	break;

+

+    case 32:

+	pixman_fill32 (bits, stride, x, y, width, height, xor);

+	break;

+

+    default:

+	return _pixman_implementation_fill (

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

+	break;

+    }

+

+    return TRUE;

+}

+

+pixman_implementation_t *

+_pixman_implementation_create_fast_path (void)

+{

+    pixman_implementation_t *general = _pixman_implementation_create_general ();

+    pixman_implementation_t *imp = _pixman_implementation_create (general, c_fast_paths);

+

+    imp->fill = fast_path_fill;

+

+    return imp;

+}

diff --git a/pixman/pixman/pixman-matrix.c b/pixman/pixman/pixman-matrix.c
index f2f67ab41..0b3ae78b3 100644
--- a/pixman/pixman/pixman-matrix.c
+++ b/pixman/pixman/pixman-matrix.c
@@ -1,769 +1,766 @@
-/*
- * Copyright © 2008 Keith Packard
- *
- * 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 the copyright holders not be used in advertising or
- * publicity pertaining to distribution of the software without specific,
- * written prior permission.  The copyright holders make 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.
- */
-
-/*
- * Matrix interfaces
- */
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include <math.h>
-#include <string.h>
-#include "pixman-private.h"
-
-#define F(x)    pixman_int_to_fixed (x)
-
-PIXMAN_EXPORT void
-pixman_transform_init_identity (struct pixman_transform *matrix)
-{
-    int i;
-
-    memset (matrix, '\0', sizeof (struct pixman_transform));
-    for (i = 0; i < 3; i++)
-	matrix->matrix[i][i] = F (1);
-}
-
-typedef pixman_fixed_32_32_t pixman_fixed_34_30_t;
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_transform_point_3d (const struct pixman_transform *transform,
-                           struct pixman_vector *         vector)
-{
-    struct pixman_vector result;
-    pixman_fixed_32_32_t partial;
-    pixman_fixed_48_16_t v;
-    int i, j;
-
-    for (j = 0; j < 3; j++)
-    {
-	v = 0;
-	for (i = 0; i < 3; i++)
-	{
-	    partial = ((pixman_fixed_48_16_t) transform->matrix[j][i] *
-	               (pixman_fixed_48_16_t) vector->vector[i]);
-	    v += partial >> 16;
-	}
-	
-	if (v > pixman_max_fixed_48_16 || v < pixman_min_fixed_48_16)
-	    return FALSE;
-	
-	result.vector[j] = (pixman_fixed_t) v;
-    }
-    
-    *vector = result;
-
-    if (!result.vector[2])
-	return FALSE;
-
-    return TRUE;
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_transform_point (const struct pixman_transform *transform,
-                        struct pixman_vector *         vector)
-{
-    pixman_fixed_32_32_t partial;
-    pixman_fixed_34_30_t v[3];
-    pixman_fixed_48_16_t quo;
-    int i, j;
-
-    for (j = 0; j < 3; j++)
-    {
-	v[j] = 0;
-	
-	for (i = 0; i < 3; i++)
-	{
-	    partial = ((pixman_fixed_32_32_t) transform->matrix[j][i] *
-	               (pixman_fixed_32_32_t) vector->vector[i]);
-	    v[j] += partial >> 2;
-	}
-    }
-    
-    if (!(v[2] >> 16))
-	return FALSE;
-
-    for (j = 0; j < 2; j++)
-    {
-	quo = v[j] / (v[2] >> 16);
-	if (quo > pixman_max_fixed_48_16 || quo < pixman_min_fixed_48_16)
-	    return FALSE;
-	vector->vector[j] = (pixman_fixed_t) quo;
-    }
-    
-    vector->vector[2] = pixman_fixed_1;
-    return TRUE;
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_transform_multiply (struct pixman_transform *      dst,
-                           const struct pixman_transform *l,
-                           const struct pixman_transform *r)
-{
-    struct pixman_transform d;
-    int dx, dy;
-    int o;
-
-    for (dy = 0; dy < 3; dy++)
-    {
-	for (dx = 0; dx < 3; dx++)
-	{
-	    pixman_fixed_48_16_t v;
-	    pixman_fixed_32_32_t partial;
-	    
-	    v = 0;
-	    for (o = 0; o < 3; o++)
-	    {
-		partial =
-		    (pixman_fixed_32_32_t) l->matrix[dy][o] *
-		    (pixman_fixed_32_32_t) r->matrix[o][dx];
-
-		v += partial >> 16;
-	    }
-
-	    if (v > pixman_max_fixed_48_16 || v < pixman_min_fixed_48_16)
-		return FALSE;
-	    
-	    d.matrix[dy][dx] = (pixman_fixed_t) v;
-	}
-    }
-
-    *dst = d;
-    return TRUE;
-}
-
-PIXMAN_EXPORT void
-pixman_transform_init_scale (struct pixman_transform *t,
-                             pixman_fixed_t           sx,
-                             pixman_fixed_t           sy)
-{
-    memset (t, '\0', sizeof (struct pixman_transform));
-
-    t->matrix[0][0] = sx;
-    t->matrix[1][1] = sy;
-    t->matrix[2][2] = F (1);
-}
-
-static pixman_fixed_t
-fixed_inverse (pixman_fixed_t x)
-{
-    return (pixman_fixed_t) ((((pixman_fixed_48_16_t) F (1)) * F (1)) / x);
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_transform_scale (struct pixman_transform *forward,
-                        struct pixman_transform *reverse,
-                        pixman_fixed_t           sx,
-                        pixman_fixed_t           sy)
-{
-    struct pixman_transform t;
-
-    if (sx == 0 || sy == 0)
-	return FALSE;
-
-    if (forward)
-    {
-	pixman_transform_init_scale (&t, sx, sy);
-	if (!pixman_transform_multiply (forward, &t, forward))
-	    return FALSE;
-    }
-    
-    if (reverse)
-    {
-	pixman_transform_init_scale (&t, fixed_inverse (sx),
-	                             fixed_inverse (sy));
-	if (!pixman_transform_multiply (reverse, reverse, &t))
-	    return FALSE;
-    }
-    
-    return TRUE;
-}
-
-PIXMAN_EXPORT void
-pixman_transform_init_rotate (struct pixman_transform *t,
-                              pixman_fixed_t           c,
-                              pixman_fixed_t           s)
-{
-    memset (t, '\0', sizeof (struct pixman_transform));
-
-    t->matrix[0][0] = c;
-    t->matrix[0][1] = -s;
-    t->matrix[1][0] = s;
-    t->matrix[1][1] = c;
-    t->matrix[2][2] = F (1);
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_transform_rotate (struct pixman_transform *forward,
-                         struct pixman_transform *reverse,
-                         pixman_fixed_t           c,
-                         pixman_fixed_t           s)
-{
-    struct pixman_transform t;
-
-    if (forward)
-    {
-	pixman_transform_init_rotate (&t, c, s);
-	if (!pixman_transform_multiply (forward, &t, forward))
-	    return FALSE;
-    }
-
-    if (reverse)
-    {
-	pixman_transform_init_rotate (&t, c, -s);
-	if (!pixman_transform_multiply (reverse, reverse, &t))
-	    return FALSE;
-    }
-    
-    return TRUE;
-}
-
-PIXMAN_EXPORT void
-pixman_transform_init_translate (struct pixman_transform *t,
-                                 pixman_fixed_t           tx,
-                                 pixman_fixed_t           ty)
-{
-    memset (t, '\0', sizeof (struct pixman_transform));
-
-    t->matrix[0][0] = F (1);
-    t->matrix[0][2] = tx;
-    t->matrix[1][1] = F (1);
-    t->matrix[1][2] = ty;
-    t->matrix[2][2] = F (1);
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_transform_translate (struct pixman_transform *forward,
-                            struct pixman_transform *reverse,
-                            pixman_fixed_t           tx,
-                            pixman_fixed_t           ty)
-{
-    struct pixman_transform t;
-
-    if (forward)
-    {
-	pixman_transform_init_translate (&t, tx, ty);
-
-	if (!pixman_transform_multiply (forward, &t, forward))
-	    return FALSE;
-    }
-
-    if (reverse)
-    {
-	pixman_transform_init_translate (&t, -tx, -ty);
-
-	if (!pixman_transform_multiply (reverse, reverse, &t))
-	    return FALSE;
-    }
-    return TRUE;
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_transform_bounds (const struct pixman_transform *matrix,
-                         struct pixman_box16 *          b)
-
-{
-    struct pixman_vector v[4];
-    int i;
-    int x1, y1, x2, y2;
-
-    v[0].vector[0] = F (b->x1);
-    v[0].vector[1] = F (b->y1);
-    v[0].vector[2] = F (1);
-
-    v[1].vector[0] = F (b->x2);
-    v[1].vector[1] = F (b->y1);
-    v[1].vector[2] = F (1);
-
-    v[2].vector[0] = F (b->x2);
-    v[2].vector[1] = F (b->y2);
-    v[2].vector[2] = F (1);
-
-    v[3].vector[0] = F (b->x1);
-    v[3].vector[1] = F (b->y2);
-    v[3].vector[2] = F (1);
-
-    for (i = 0; i < 4; i++)
-    {
-	if (!pixman_transform_point (matrix, &v[i]))
-	    return FALSE;
-
-	x1 = pixman_fixed_to_int (v[i].vector[0]);
-	y1 = pixman_fixed_to_int (v[i].vector[1]);
-	x2 = pixman_fixed_to_int (pixman_fixed_ceil (v[i].vector[0]));
-	y2 = pixman_fixed_to_int (pixman_fixed_ceil (v[i].vector[1]));
-
-	if (i == 0)
-	{
-	    b->x1 = x1;
-	    b->y1 = y1;
-	    b->x2 = x2;
-	    b->y2 = y2;
-	}
-	else
-	{
-	    if (x1 < b->x1) b->x1 = x1;
-	    if (y1 < b->y1) b->y1 = y1;
-	    if (x2 > b->x2) b->x2 = x2;
-	    if (y2 > b->y2) b->y2 = y2;
-	}
-    }
-
-    return TRUE;
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_transform_invert (struct pixman_transform *      dst,
-                         const struct pixman_transform *src)
-{
-    struct pixman_f_transform m, r;
-
-    pixman_f_transform_from_pixman_transform (&m, src);
-
-    if (!pixman_f_transform_invert (&r, &m))
-	return FALSE;
-
-    if (!pixman_transform_from_pixman_f_transform (dst, &r))
-	return FALSE;
-
-    return TRUE;
-}
-
-static pixman_bool_t
-within_epsilon (pixman_fixed_t a,
-                pixman_fixed_t b,
-                pixman_fixed_t epsilon)
-{
-    pixman_fixed_t t = a - b;
-
-    if (t < 0)
-	t = -t;
-
-    return t <= epsilon;
-}
-
-#define EPSILON (pixman_fixed_t) (2)
-
-#define IS_SAME(a, b) (within_epsilon (a, b, EPSILON))
-#define IS_ZERO(a)    (within_epsilon (a, 0, EPSILON))
-#define IS_ONE(a)     (within_epsilon (a, F (1), EPSILON))
-#define IS_UNIT(a)			    \
-    (within_epsilon (a, F (1), EPSILON) ||  \
-     within_epsilon (a, F (-1), EPSILON) || \
-     IS_ZERO (a))
-#define IS_INT(a)    (IS_ZERO (pixman_fixed_frac (a)))
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_transform_is_identity (const struct pixman_transform *t)
-{
-    return (IS_SAME (t->matrix[0][0], t->matrix[1][1]) &&
-	    IS_SAME (t->matrix[0][0], t->matrix[2][2]) &&
-	    !IS_ZERO (t->matrix[0][0]) &&
-	    IS_ZERO (t->matrix[0][1]) &&
-	    IS_ZERO (t->matrix[0][2]) &&
-	    IS_ZERO (t->matrix[1][0]) &&
-	    IS_ZERO (t->matrix[1][2]) &&
-	    IS_ZERO (t->matrix[2][0]) &&
-	    IS_ZERO (t->matrix[2][1]));
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_transform_is_scale (const struct pixman_transform *t)
-{
-    return (!IS_ZERO (t->matrix[0][0]) &&
-            IS_ZERO (t->matrix[0][1]) &&
-            IS_ZERO (t->matrix[0][2]) &&
-
-            IS_ZERO (t->matrix[1][0]) &&
-            !IS_ZERO (t->matrix[1][1]) &&
-            IS_ZERO (t->matrix[1][2]) &&
-
-            IS_ZERO (t->matrix[2][0]) &&
-            IS_ZERO (t->matrix[2][1]) &&
-            !IS_ZERO (t->matrix[2][2]));
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_transform_is_int_translate (const struct pixman_transform *t)
-{
-    return (IS_ONE (t->matrix[0][0]) &&
-            IS_ZERO (t->matrix[0][1]) &&
-            IS_INT (t->matrix[0][2]) &&
-
-            IS_ZERO (t->matrix[1][0]) &&
-            IS_ONE (t->matrix[1][1]) &&
-            IS_INT (t->matrix[1][2]) &&
-
-            IS_ZERO (t->matrix[2][0]) &&
-            IS_ZERO (t->matrix[2][1]) &&
-            IS_ONE (t->matrix[2][2]));
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_transform_is_inverse (const struct pixman_transform *a,
-                             const struct pixman_transform *b)
-{
-    struct pixman_transform t;
-
-    if (!pixman_transform_multiply (&t, a, b))
-	return FALSE;
-
-    return pixman_transform_is_identity (&t);
-}
-
-PIXMAN_EXPORT void
-pixman_f_transform_from_pixman_transform (struct pixman_f_transform *    ft,
-                                          const struct pixman_transform *t)
-{
-    int i, j;
-
-    for (j = 0; j < 3; j++)
-    {
-	for (i = 0; i < 3; i++)
-	    ft->m[j][i] = pixman_fixed_to_double (t->matrix[j][i]);
-    }
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_transform_from_pixman_f_transform (struct pixman_transform *        t,
-                                          const struct pixman_f_transform *ft)
-{
-    int i, j;
-
-    for (j = 0; j < 3; j++)
-    {
-	for (i = 0; i < 3; i++)
-	{
-	    double d = ft->m[j][i];
-	    if (d < -32767.0 || d > 32767.0)
-		return FALSE;
-	    d = d * 65536.0 + 0.5;
-	    t->matrix[j][i] = (pixman_fixed_t) floor (d);
-	}
-    }
-    
-    return TRUE;
-}
-
-static const int a[3] = { 3, 3, 2 };
-static const int b[3] = { 2, 1, 1 };
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_f_transform_invert (struct pixman_f_transform *      dst,
-                           const struct pixman_f_transform *src)
-{
-    double det;
-    int i, j;
-    static int a[3] = { 2, 2, 1 };
-    static int b[3] = { 1, 0, 0 };
-
-    det = 0;
-    for (i = 0; i < 3; i++)
-    {
-	double p;
-	int ai = a[i];
-	int bi = b[i];
-	p = src->m[i][0] * (src->m[ai][2] * src->m[bi][1] -
-	                    src->m[ai][1] * src->m[bi][2]);
-	if (i == 1)
-	    p = -p;
-	det += p;
-    }
-    
-    if (det == 0)
-	return FALSE;
-    
-    det = 1 / det;
-    for (j = 0; j < 3; j++)
-    {
-	for (i = 0; i < 3; i++)
-	{
-	    double p;
-	    int ai = a[i];
-	    int aj = a[j];
-	    int bi = b[i];
-	    int bj = b[j];
-
-	    p = (src->m[ai][aj] * src->m[bi][bj] -
-	         src->m[ai][bj] * src->m[bi][aj]);
-	    
-	    if (((i + j) & 1) != 0)
-		p = -p;
-	    
-	    dst->m[j][i] = det * p;
-	}
-    }
-
-    return TRUE;
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_f_transform_point (const struct pixman_f_transform *t,
-                          struct pixman_f_vector *         v)
-{
-    struct pixman_f_vector result;
-    int i, j;
-    double a;
-
-    for (j = 0; j < 3; j++)
-    {
-	a = 0;
-	for (i = 0; i < 3; i++)
-	    a += t->m[j][i] * v->v[i];
-	result.v[j] = a;
-    }
-    
-    if (!result.v[2])
-	return FALSE;
-
-    for (j = 0; j < 2; j++)
-	v->v[j] = result.v[j] / result.v[2];
-
-    v->v[2] = 1;
-
-    return TRUE;
-}
-
-PIXMAN_EXPORT void
-pixman_f_transform_point_3d (const struct pixman_f_transform *t,
-                             struct pixman_f_vector *         v)
-{
-    struct pixman_f_vector result;
-    int i, j;
-    double a;
-
-    for (j = 0; j < 3; j++)
-    {
-	a = 0;
-	for (i = 0; i < 3; i++)
-	    a += t->m[j][i] * v->v[i];
-	result.v[j] = a;
-    }
-    
-    *v = result;
-}
-
-PIXMAN_EXPORT void
-pixman_f_transform_multiply (struct pixman_f_transform *      dst,
-                             const struct pixman_f_transform *l,
-                             const struct pixman_f_transform *r)
-{
-    struct pixman_f_transform d;
-    int dx, dy;
-    int o;
-
-    for (dy = 0; dy < 3; dy++)
-    {
-	for (dx = 0; dx < 3; dx++)
-	{
-	    double v = 0;
-	    for (o = 0; o < 3; o++)
-		v += l->m[dy][o] * r->m[o][dx];
-	    d.m[dy][dx] = v;
-	}
-    }
-    
-    *dst = d;
-}
-
-PIXMAN_EXPORT void
-pixman_f_transform_init_scale (struct pixman_f_transform *t,
-                               double                     sx,
-                               double                     sy)
-{
-    t->m[0][0] = sx;
-    t->m[0][1] = 0;
-    t->m[0][2] = 0;
-    t->m[1][0] = 0;
-    t->m[1][1] = sy;
-    t->m[1][2] = 0;
-    t->m[2][0] = 0;
-    t->m[2][1] = 0;
-    t->m[2][2] = 1;
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_f_transform_scale (struct pixman_f_transform *forward,
-                          struct pixman_f_transform *reverse,
-                          double                     sx,
-                          double                     sy)
-{
-    struct pixman_f_transform t;
-
-    if (sx == 0 || sy == 0)
-	return FALSE;
-
-    if (forward)
-    {
-	pixman_f_transform_init_scale (&t, sx, sy);
-	pixman_f_transform_multiply (forward, &t, forward);
-    }
-    
-    if (reverse)
-    {
-	pixman_f_transform_init_scale (&t, 1 / sx, 1 / sy);
-	pixman_f_transform_multiply (reverse, reverse, &t);
-    }
-    
-    return TRUE;
-}
-
-PIXMAN_EXPORT void
-pixman_f_transform_init_rotate (struct pixman_f_transform *t,
-                                double                     c,
-                                double                     s)
-{
-    t->m[0][0] = c;
-    t->m[0][1] = -s;
-    t->m[0][2] = 0;
-    t->m[1][0] = s;
-    t->m[1][1] = c;
-    t->m[1][2] = 0;
-    t->m[2][0] = 0;
-    t->m[2][1] = 0;
-    t->m[2][2] = 1;
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_f_transform_rotate (struct pixman_f_transform *forward,
-                           struct pixman_f_transform *reverse,
-                           double                     c,
-                           double                     s)
-{
-    struct pixman_f_transform t;
-
-    if (forward)
-    {
-	pixman_f_transform_init_rotate (&t, c, s);
-	pixman_f_transform_multiply (forward, &t, forward);
-    }
-    
-    if (reverse)
-    {
-	pixman_f_transform_init_rotate (&t, c, -s);
-	pixman_f_transform_multiply (reverse, reverse, &t);
-    }
-
-    return TRUE;
-}
-
-PIXMAN_EXPORT void
-pixman_f_transform_init_translate (struct pixman_f_transform *t,
-                                   double                     tx,
-                                   double                     ty)
-{
-    t->m[0][0] = 1;
-    t->m[0][1] = 0;
-    t->m[0][2] = tx;
-    t->m[1][0] = 0;
-    t->m[1][1] = 1;
-    t->m[1][2] = ty;
-    t->m[2][0] = 0;
-    t->m[2][1] = 0;
-    t->m[2][2] = 1;
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_f_transform_translate (struct pixman_f_transform *forward,
-                              struct pixman_f_transform *reverse,
-                              double                     tx,
-                              double                     ty)
-{
-    struct pixman_f_transform t;
-
-    if (forward)
-    {
-	pixman_f_transform_init_translate (&t, tx, ty);
-	pixman_f_transform_multiply (forward, &t, forward);
-    }
-
-    if (reverse)
-    {
-	pixman_f_transform_init_translate (&t, -tx, -ty);
-	pixman_f_transform_multiply (reverse, reverse, &t);
-    }
-
-    return TRUE;
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_f_transform_bounds (const struct pixman_f_transform *t,
-                           struct pixman_box16 *            b)
-{
-    struct pixman_f_vector v[4];
-    int i;
-    int x1, y1, x2, y2;
-
-    v[0].v[0] = b->x1;
-    v[0].v[1] = b->y1;
-    v[0].v[2] = 1;
-    v[1].v[0] = b->x2;
-    v[1].v[1] = b->y1;
-    v[1].v[2] = 1;
-    v[2].v[0] = b->x2;
-    v[2].v[1] = b->y2;
-    v[2].v[2] = 1;
-    v[3].v[0] = b->x1;
-    v[3].v[1] = b->y2;
-    v[3].v[2] = 1;
-
-    for (i = 0; i < 4; i++)
-    {
-	if (!pixman_f_transform_point (t, &v[i]))
-	    return FALSE;
-
-	x1 = floor (v[i].v[0]);
-	y1 = floor (v[i].v[1]);
-	x2 = ceil (v[i].v[0]);
-	y2 = ceil (v[i].v[1]);
-
-	if (i == 0)
-	{
-	    b->x1 = x1;
-	    b->y1 = y1;
-	    b->x2 = x2;
-	    b->y2 = y2;
-	}
-	else
-	{
-	    if (x1 < b->x1) b->x1 = x1;
-	    if (y1 < b->y1) b->y1 = y1;
-	    if (x2 > b->x2) b->x2 = x2;
-	    if (y2 > b->y2) b->y2 = y2;
-	}
-    }
-
-    return TRUE;
-}
-
-PIXMAN_EXPORT void
-pixman_f_transform_init_identity (struct pixman_f_transform *t)
-{
-    int i, j;
-
-    for (j = 0; j < 3; j++)
-    {
-	for (i = 0; i < 3; i++)
-	    t->m[j][i] = i == j ? 1 : 0;
-    }
-}
+/*

+ * Copyright © 2008 Keith Packard

+ *

+ * 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 the copyright holders not be used in advertising or

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

+ * written prior permission.  The copyright holders make 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.

+ */

+

+/*

+ * Matrix interfaces

+ */

+

+#ifdef HAVE_CONFIG_H

+#include "config.h"

+#endif

+

+#include <math.h>

+#include <string.h>

+#include "pixman-private.h"

+

+#define F(x)    pixman_int_to_fixed (x)

+

+PIXMAN_EXPORT void

+pixman_transform_init_identity (struct pixman_transform *matrix)

+{

+    int i;

+

+    memset (matrix, '\0', sizeof (struct pixman_transform));

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

+	matrix->matrix[i][i] = F (1);

+}

+

+typedef pixman_fixed_32_32_t pixman_fixed_34_30_t;

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_transform_point_3d (const struct pixman_transform *transform,

+                           struct pixman_vector *         vector)

+{

+    struct pixman_vector result;

+    pixman_fixed_32_32_t partial;

+    pixman_fixed_48_16_t v;

+    int i, j;

+

+    for (j = 0; j < 3; j++)

+    {

+	v = 0;

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

+	{

+	    partial = ((pixman_fixed_48_16_t) transform->matrix[j][i] *

+	               (pixman_fixed_48_16_t) vector->vector[i]);

+	    v += partial >> 16;

+	}

+	

+	if (v > pixman_max_fixed_48_16 || v < pixman_min_fixed_48_16)

+	    return FALSE;

+	

+	result.vector[j] = (pixman_fixed_t) v;

+    }

+    

+    *vector = result;

+

+    if (!result.vector[2])

+	return FALSE;

+

+    return TRUE;

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_transform_point (const struct pixman_transform *transform,

+                        struct pixman_vector *         vector)

+{

+    pixman_fixed_32_32_t partial;

+    pixman_fixed_34_30_t v[3];

+    pixman_fixed_48_16_t quo;

+    int i, j;

+

+    for (j = 0; j < 3; j++)

+    {

+	v[j] = 0;

+	

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

+	{

+	    partial = ((pixman_fixed_32_32_t) transform->matrix[j][i] *

+	               (pixman_fixed_32_32_t) vector->vector[i]);

+	    v[j] += partial >> 2;

+	}

+    }

+    

+    if (!(v[2] >> 16))

+	return FALSE;

+

+    for (j = 0; j < 2; j++)

+    {

+	quo = v[j] / (v[2] >> 16);

+	if (quo > pixman_max_fixed_48_16 || quo < pixman_min_fixed_48_16)

+	    return FALSE;

+	vector->vector[j] = (pixman_fixed_t) quo;

+    }

+    

+    vector->vector[2] = pixman_fixed_1;

+    return TRUE;

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_transform_multiply (struct pixman_transform *      dst,

+                           const struct pixman_transform *l,

+                           const struct pixman_transform *r)

+{

+    struct pixman_transform d;

+    int dx, dy;

+    int o;

+

+    for (dy = 0; dy < 3; dy++)

+    {

+	for (dx = 0; dx < 3; dx++)

+	{

+	    pixman_fixed_48_16_t v;

+	    pixman_fixed_32_32_t partial;

+	    

+	    v = 0;

+	    for (o = 0; o < 3; o++)

+	    {

+		partial =

+		    (pixman_fixed_32_32_t) l->matrix[dy][o] *

+		    (pixman_fixed_32_32_t) r->matrix[o][dx];

+

+		v += partial >> 16;

+	    }

+

+	    if (v > pixman_max_fixed_48_16 || v < pixman_min_fixed_48_16)

+		return FALSE;

+	    

+	    d.matrix[dy][dx] = (pixman_fixed_t) v;

+	}

+    }

+

+    *dst = d;

+    return TRUE;

+}

+

+PIXMAN_EXPORT void

+pixman_transform_init_scale (struct pixman_transform *t,

+                             pixman_fixed_t           sx,

+                             pixman_fixed_t           sy)

+{

+    memset (t, '\0', sizeof (struct pixman_transform));

+

+    t->matrix[0][0] = sx;

+    t->matrix[1][1] = sy;

+    t->matrix[2][2] = F (1);

+}

+

+static pixman_fixed_t

+fixed_inverse (pixman_fixed_t x)

+{

+    return (pixman_fixed_t) ((((pixman_fixed_48_16_t) F (1)) * F (1)) / x);

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_transform_scale (struct pixman_transform *forward,

+                        struct pixman_transform *reverse,

+                        pixman_fixed_t           sx,

+                        pixman_fixed_t           sy)

+{

+    struct pixman_transform t;

+

+    if (sx == 0 || sy == 0)

+	return FALSE;

+

+    if (forward)

+    {

+	pixman_transform_init_scale (&t, sx, sy);

+	if (!pixman_transform_multiply (forward, &t, forward))

+	    return FALSE;

+    }

+    

+    if (reverse)

+    {

+	pixman_transform_init_scale (&t, fixed_inverse (sx),

+	                             fixed_inverse (sy));

+	if (!pixman_transform_multiply (reverse, reverse, &t))

+	    return FALSE;

+    }

+    

+    return TRUE;

+}

+

+PIXMAN_EXPORT void

+pixman_transform_init_rotate (struct pixman_transform *t,

+                              pixman_fixed_t           c,

+                              pixman_fixed_t           s)

+{

+    memset (t, '\0', sizeof (struct pixman_transform));

+

+    t->matrix[0][0] = c;

+    t->matrix[0][1] = -s;

+    t->matrix[1][0] = s;

+    t->matrix[1][1] = c;

+    t->matrix[2][2] = F (1);

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_transform_rotate (struct pixman_transform *forward,

+                         struct pixman_transform *reverse,

+                         pixman_fixed_t           c,

+                         pixman_fixed_t           s)

+{

+    struct pixman_transform t;

+

+    if (forward)

+    {

+	pixman_transform_init_rotate (&t, c, s);

+	if (!pixman_transform_multiply (forward, &t, forward))

+	    return FALSE;

+    }

+

+    if (reverse)

+    {

+	pixman_transform_init_rotate (&t, c, -s);

+	if (!pixman_transform_multiply (reverse, reverse, &t))

+	    return FALSE;

+    }

+    

+    return TRUE;

+}

+

+PIXMAN_EXPORT void

+pixman_transform_init_translate (struct pixman_transform *t,

+                                 pixman_fixed_t           tx,

+                                 pixman_fixed_t           ty)

+{

+    memset (t, '\0', sizeof (struct pixman_transform));

+

+    t->matrix[0][0] = F (1);

+    t->matrix[0][2] = tx;

+    t->matrix[1][1] = F (1);

+    t->matrix[1][2] = ty;

+    t->matrix[2][2] = F (1);

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_transform_translate (struct pixman_transform *forward,

+                            struct pixman_transform *reverse,

+                            pixman_fixed_t           tx,

+                            pixman_fixed_t           ty)

+{

+    struct pixman_transform t;

+

+    if (forward)

+    {

+	pixman_transform_init_translate (&t, tx, ty);

+

+	if (!pixman_transform_multiply (forward, &t, forward))

+	    return FALSE;

+    }

+

+    if (reverse)

+    {

+	pixman_transform_init_translate (&t, -tx, -ty);

+

+	if (!pixman_transform_multiply (reverse, reverse, &t))

+	    return FALSE;

+    }

+    return TRUE;

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_transform_bounds (const struct pixman_transform *matrix,

+                         struct pixman_box16 *          b)

+

+{

+    struct pixman_vector v[4];

+    int i;

+    int x1, y1, x2, y2;

+

+    v[0].vector[0] = F (b->x1);

+    v[0].vector[1] = F (b->y1);

+    v[0].vector[2] = F (1);

+

+    v[1].vector[0] = F (b->x2);

+    v[1].vector[1] = F (b->y1);

+    v[1].vector[2] = F (1);

+

+    v[2].vector[0] = F (b->x2);

+    v[2].vector[1] = F (b->y2);

+    v[2].vector[2] = F (1);

+

+    v[3].vector[0] = F (b->x1);

+    v[3].vector[1] = F (b->y2);

+    v[3].vector[2] = F (1);

+

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

+    {

+	if (!pixman_transform_point (matrix, &v[i]))

+	    return FALSE;

+

+	x1 = pixman_fixed_to_int (v[i].vector[0]);

+	y1 = pixman_fixed_to_int (v[i].vector[1]);

+	x2 = pixman_fixed_to_int (pixman_fixed_ceil (v[i].vector[0]));

+	y2 = pixman_fixed_to_int (pixman_fixed_ceil (v[i].vector[1]));

+

+	if (i == 0)

+	{

+	    b->x1 = x1;

+	    b->y1 = y1;

+	    b->x2 = x2;

+	    b->y2 = y2;

+	}

+	else

+	{

+	    if (x1 < b->x1) b->x1 = x1;

+	    if (y1 < b->y1) b->y1 = y1;

+	    if (x2 > b->x2) b->x2 = x2;

+	    if (y2 > b->y2) b->y2 = y2;

+	}

+    }

+

+    return TRUE;

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_transform_invert (struct pixman_transform *      dst,

+                         const struct pixman_transform *src)

+{

+    struct pixman_f_transform m, r;

+

+    pixman_f_transform_from_pixman_transform (&m, src);

+

+    if (!pixman_f_transform_invert (&r, &m))

+	return FALSE;

+

+    if (!pixman_transform_from_pixman_f_transform (dst, &r))

+	return FALSE;

+

+    return TRUE;

+}

+

+static pixman_bool_t

+within_epsilon (pixman_fixed_t a,

+                pixman_fixed_t b,

+                pixman_fixed_t epsilon)

+{

+    pixman_fixed_t t = a - b;

+

+    if (t < 0)

+	t = -t;

+

+    return t <= epsilon;

+}

+

+#define EPSILON (pixman_fixed_t) (2)

+

+#define IS_SAME(a, b) (within_epsilon (a, b, EPSILON))

+#define IS_ZERO(a)    (within_epsilon (a, 0, EPSILON))

+#define IS_ONE(a)     (within_epsilon (a, F (1), EPSILON))

+#define IS_UNIT(a)			    \

+    (within_epsilon (a, F (1), EPSILON) ||  \

+     within_epsilon (a, F (-1), EPSILON) || \

+     IS_ZERO (a))

+#define IS_INT(a)    (IS_ZERO (pixman_fixed_frac (a)))

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_transform_is_identity (const struct pixman_transform *t)

+{

+    return (IS_SAME (t->matrix[0][0], t->matrix[1][1]) &&

+	    IS_SAME (t->matrix[0][0], t->matrix[2][2]) &&

+	    !IS_ZERO (t->matrix[0][0]) &&

+	    IS_ZERO (t->matrix[0][1]) &&

+	    IS_ZERO (t->matrix[0][2]) &&

+	    IS_ZERO (t->matrix[1][0]) &&

+	    IS_ZERO (t->matrix[1][2]) &&

+	    IS_ZERO (t->matrix[2][0]) &&

+	    IS_ZERO (t->matrix[2][1]));

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_transform_is_scale (const struct pixman_transform *t)

+{

+    return (!IS_ZERO (t->matrix[0][0]) &&

+            IS_ZERO (t->matrix[0][1]) &&

+            IS_ZERO (t->matrix[0][2]) &&

+

+            IS_ZERO (t->matrix[1][0]) &&

+            !IS_ZERO (t->matrix[1][1]) &&

+            IS_ZERO (t->matrix[1][2]) &&

+

+            IS_ZERO (t->matrix[2][0]) &&

+            IS_ZERO (t->matrix[2][1]) &&

+            !IS_ZERO (t->matrix[2][2]));

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_transform_is_int_translate (const struct pixman_transform *t)

+{

+    return (IS_ONE (t->matrix[0][0]) &&

+            IS_ZERO (t->matrix[0][1]) &&

+            IS_INT (t->matrix[0][2]) &&

+

+            IS_ZERO (t->matrix[1][0]) &&

+            IS_ONE (t->matrix[1][1]) &&

+            IS_INT (t->matrix[1][2]) &&

+

+            IS_ZERO (t->matrix[2][0]) &&

+            IS_ZERO (t->matrix[2][1]) &&

+            IS_ONE (t->matrix[2][2]));

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_transform_is_inverse (const struct pixman_transform *a,

+                             const struct pixman_transform *b)

+{

+    struct pixman_transform t;

+

+    if (!pixman_transform_multiply (&t, a, b))

+	return FALSE;

+

+    return pixman_transform_is_identity (&t);

+}

+

+PIXMAN_EXPORT void

+pixman_f_transform_from_pixman_transform (struct pixman_f_transform *    ft,

+                                          const struct pixman_transform *t)

+{

+    int i, j;

+

+    for (j = 0; j < 3; j++)

+    {

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

+	    ft->m[j][i] = pixman_fixed_to_double (t->matrix[j][i]);

+    }

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_transform_from_pixman_f_transform (struct pixman_transform *        t,

+                                          const struct pixman_f_transform *ft)

+{

+    int i, j;

+

+    for (j = 0; j < 3; j++)

+    {

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

+	{

+	    double d = ft->m[j][i];

+	    if (d < -32767.0 || d > 32767.0)

+		return FALSE;

+	    d = d * 65536.0 + 0.5;

+	    t->matrix[j][i] = (pixman_fixed_t) floor (d);

+	}

+    }

+    

+    return TRUE;

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_f_transform_invert (struct pixman_f_transform *      dst,

+                           const struct pixman_f_transform *src)

+{

+    double det;

+    int i, j;

+    static int a[3] = { 2, 2, 1 };

+    static int b[3] = { 1, 0, 0 };

+

+    det = 0;

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

+    {

+	double p;

+	int ai = a[i];

+	int bi = b[i];

+	p = src->m[i][0] * (src->m[ai][2] * src->m[bi][1] -

+	                    src->m[ai][1] * src->m[bi][2]);

+	if (i == 1)

+	    p = -p;

+	det += p;

+    }

+    

+    if (det == 0)

+	return FALSE;

+    

+    det = 1 / det;

+    for (j = 0; j < 3; j++)

+    {

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

+	{

+	    double p;

+	    int ai = a[i];

+	    int aj = a[j];

+	    int bi = b[i];

+	    int bj = b[j];

+

+	    p = (src->m[ai][aj] * src->m[bi][bj] -

+	         src->m[ai][bj] * src->m[bi][aj]);

+	    

+	    if (((i + j) & 1) != 0)

+		p = -p;

+	    

+	    dst->m[j][i] = det * p;

+	}

+    }

+

+    return TRUE;

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_f_transform_point (const struct pixman_f_transform *t,

+                          struct pixman_f_vector *         v)

+{

+    struct pixman_f_vector result;

+    int i, j;

+    double a;

+

+    for (j = 0; j < 3; j++)

+    {

+	a = 0;

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

+	    a += t->m[j][i] * v->v[i];

+	result.v[j] = a;

+    }

+    

+    if (!result.v[2])

+	return FALSE;

+

+    for (j = 0; j < 2; j++)

+	v->v[j] = result.v[j] / result.v[2];

+

+    v->v[2] = 1;

+

+    return TRUE;

+}

+

+PIXMAN_EXPORT void

+pixman_f_transform_point_3d (const struct pixman_f_transform *t,

+                             struct pixman_f_vector *         v)

+{

+    struct pixman_f_vector result;

+    int i, j;

+    double a;

+

+    for (j = 0; j < 3; j++)

+    {

+	a = 0;

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

+	    a += t->m[j][i] * v->v[i];

+	result.v[j] = a;

+    }

+    

+    *v = result;

+}

+

+PIXMAN_EXPORT void

+pixman_f_transform_multiply (struct pixman_f_transform *      dst,

+                             const struct pixman_f_transform *l,

+                             const struct pixman_f_transform *r)

+{

+    struct pixman_f_transform d;

+    int dx, dy;

+    int o;

+

+    for (dy = 0; dy < 3; dy++)

+    {

+	for (dx = 0; dx < 3; dx++)

+	{

+	    double v = 0;

+	    for (o = 0; o < 3; o++)

+		v += l->m[dy][o] * r->m[o][dx];

+	    d.m[dy][dx] = v;

+	}

+    }

+    

+    *dst = d;

+}

+

+PIXMAN_EXPORT void

+pixman_f_transform_init_scale (struct pixman_f_transform *t,

+                               double                     sx,

+                               double                     sy)

+{

+    t->m[0][0] = sx;

+    t->m[0][1] = 0;

+    t->m[0][2] = 0;

+    t->m[1][0] = 0;

+    t->m[1][1] = sy;

+    t->m[1][2] = 0;

+    t->m[2][0] = 0;

+    t->m[2][1] = 0;

+    t->m[2][2] = 1;

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_f_transform_scale (struct pixman_f_transform *forward,

+                          struct pixman_f_transform *reverse,

+                          double                     sx,

+                          double                     sy)

+{

+    struct pixman_f_transform t;

+

+    if (sx == 0 || sy == 0)

+	return FALSE;

+

+    if (forward)

+    {

+	pixman_f_transform_init_scale (&t, sx, sy);

+	pixman_f_transform_multiply (forward, &t, forward);

+    }

+    

+    if (reverse)

+    {

+	pixman_f_transform_init_scale (&t, 1 / sx, 1 / sy);

+	pixman_f_transform_multiply (reverse, reverse, &t);

+    }

+    

+    return TRUE;

+}

+

+PIXMAN_EXPORT void

+pixman_f_transform_init_rotate (struct pixman_f_transform *t,

+                                double                     c,

+                                double                     s)

+{

+    t->m[0][0] = c;

+    t->m[0][1] = -s;

+    t->m[0][2] = 0;

+    t->m[1][0] = s;

+    t->m[1][1] = c;

+    t->m[1][2] = 0;

+    t->m[2][0] = 0;

+    t->m[2][1] = 0;

+    t->m[2][2] = 1;

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_f_transform_rotate (struct pixman_f_transform *forward,

+                           struct pixman_f_transform *reverse,

+                           double                     c,

+                           double                     s)

+{

+    struct pixman_f_transform t;

+

+    if (forward)

+    {

+	pixman_f_transform_init_rotate (&t, c, s);

+	pixman_f_transform_multiply (forward, &t, forward);

+    }

+    

+    if (reverse)

+    {

+	pixman_f_transform_init_rotate (&t, c, -s);

+	pixman_f_transform_multiply (reverse, reverse, &t);

+    }

+

+    return TRUE;

+}

+

+PIXMAN_EXPORT void

+pixman_f_transform_init_translate (struct pixman_f_transform *t,

+                                   double                     tx,

+                                   double                     ty)

+{

+    t->m[0][0] = 1;

+    t->m[0][1] = 0;

+    t->m[0][2] = tx;

+    t->m[1][0] = 0;

+    t->m[1][1] = 1;

+    t->m[1][2] = ty;

+    t->m[2][0] = 0;

+    t->m[2][1] = 0;

+    t->m[2][2] = 1;

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_f_transform_translate (struct pixman_f_transform *forward,

+                              struct pixman_f_transform *reverse,

+                              double                     tx,

+                              double                     ty)

+{

+    struct pixman_f_transform t;

+

+    if (forward)

+    {

+	pixman_f_transform_init_translate (&t, tx, ty);

+	pixman_f_transform_multiply (forward, &t, forward);

+    }

+

+    if (reverse)

+    {

+	pixman_f_transform_init_translate (&t, -tx, -ty);

+	pixman_f_transform_multiply (reverse, reverse, &t);

+    }

+

+    return TRUE;

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_f_transform_bounds (const struct pixman_f_transform *t,

+                           struct pixman_box16 *            b)

+{

+    struct pixman_f_vector v[4];

+    int i;

+    int x1, y1, x2, y2;

+

+    v[0].v[0] = b->x1;

+    v[0].v[1] = b->y1;

+    v[0].v[2] = 1;

+    v[1].v[0] = b->x2;

+    v[1].v[1] = b->y1;

+    v[1].v[2] = 1;

+    v[2].v[0] = b->x2;

+    v[2].v[1] = b->y2;

+    v[2].v[2] = 1;

+    v[3].v[0] = b->x1;

+    v[3].v[1] = b->y2;

+    v[3].v[2] = 1;

+

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

+    {

+	if (!pixman_f_transform_point (t, &v[i]))

+	    return FALSE;

+

+	x1 = floor (v[i].v[0]);

+	y1 = floor (v[i].v[1]);

+	x2 = ceil (v[i].v[0]);

+	y2 = ceil (v[i].v[1]);

+

+	if (i == 0)

+	{

+	    b->x1 = x1;

+	    b->y1 = y1;

+	    b->x2 = x2;

+	    b->y2 = y2;

+	}

+	else

+	{

+	    if (x1 < b->x1) b->x1 = x1;

+	    if (y1 < b->y1) b->y1 = y1;

+	    if (x2 > b->x2) b->x2 = x2;

+	    if (y2 > b->y2) b->y2 = y2;

+	}

+    }

+

+    return TRUE;

+}

+

+PIXMAN_EXPORT void

+pixman_f_transform_init_identity (struct pixman_f_transform *t)

+{

+    int i, j;

+

+    for (j = 0; j < 3; j++)

+    {

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

+	    t->m[j][i] = i == j ? 1 : 0;

+    }

+}

diff --git a/pixman/pixman/pixman-trap.c b/pixman/pixman/pixman-trap.c
index 8353992c5..787093a85 100644
--- a/pixman/pixman/pixman-trap.c
+++ b/pixman/pixman/pixman-trap.c
@@ -1,392 +1,386 @@
-/*
- * Copyright © 2004 Keith Packard
- *
- * 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.
- *
- * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL KEITH PACKARD 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 "pixman-private.h"
-
-/*
- * Compute the smallest value greater than or equal to y which is on a
- * grid row.
- */
-
-PIXMAN_EXPORT pixman_fixed_t
-pixman_sample_ceil_y (pixman_fixed_t y, int n)
-{
-    pixman_fixed_t f = pixman_fixed_frac (y);
-    pixman_fixed_t i = pixman_fixed_floor (y);
-
-    f = DIV (f - Y_FRAC_FIRST (n) + (STEP_Y_SMALL (n) - pixman_fixed_e), STEP_Y_SMALL (n)) * STEP_Y_SMALL (n) +
-	Y_FRAC_FIRST (n);
-    
-    if (f > Y_FRAC_LAST (n))
-    {
-	if (pixman_fixed_to_int (i) == 0x7fff)
-	{
-	    f = 0xffff; /* saturate */
-	}
-	else
-	{
-	    f = Y_FRAC_FIRST (n);
-	    i += pixman_fixed_1;
-	}
-    }
-    return (i | f);
-}
-
-/*
- * Compute the largest value strictly less than y which is on a
- * grid row.
- */
-PIXMAN_EXPORT pixman_fixed_t
-pixman_sample_floor_y (pixman_fixed_t y,
-                       int            n)
-{
-    pixman_fixed_t f = pixman_fixed_frac (y);
-    pixman_fixed_t i = pixman_fixed_floor (y);
-
-    f = DIV (f - pixman_fixed_e - Y_FRAC_FIRST (n), STEP_Y_SMALL (n)) * STEP_Y_SMALL (n) +
-	Y_FRAC_FIRST (n);
-
-    if (f < Y_FRAC_FIRST (n))
-    {
-	if (pixman_fixed_to_int (i) == 0x8000)
-	{
-	    f = 0; /* saturate */
-	}
-	else
-	{
-	    f = Y_FRAC_LAST (n);
-	    i -= pixman_fixed_1;
-	}
-    }
-    return (i | f);
-}
-
-/*
- * Step an edge by any amount (including negative values)
- */
-PIXMAN_EXPORT void
-pixman_edge_step (pixman_edge_t *e,
-                  int            n)
-{
-    pixman_fixed_48_16_t ne;
-
-    e->x += n * e->stepx;
-
-    ne = e->e + n * (pixman_fixed_48_16_t) e->dx;
-
-    if (n >= 0)
-    {
-	if (ne > 0)
-	{
-	    int nx = (ne + e->dy - 1) / e->dy;
-	    e->e = ne - nx * (pixman_fixed_48_16_t) e->dy;
-	    e->x += nx * e->signdx;
-	}
-    }
-    else
-    {
-	if (ne <= -e->dy)
-	{
-	    int nx = (-ne) / e->dy;
-	    e->e = ne + nx * (pixman_fixed_48_16_t) e->dy;
-	    e->x -= nx * e->signdx;
-	}
-    }
-}
-
-/*
- * A private routine to initialize the multi-step
- * elements of an edge structure
- */
-static void
-_pixman_edge_multi_init (pixman_edge_t * e,
-                         int             n,
-                         pixman_fixed_t *stepx_p,
-                         pixman_fixed_t *dx_p)
-{
-    pixman_fixed_t stepx;
-    pixman_fixed_48_16_t ne;
-
-    ne = n * (pixman_fixed_48_16_t) e->dx;
-    stepx = n * e->stepx;
-
-    if (ne > 0)
-    {
-	int nx = ne / e->dy;
-	ne -= nx * e->dy;
-	stepx += nx * e->signdx;
-    }
-
-    *dx_p = ne;
-    *stepx_p = stepx;
-}
-
-/*
- * Initialize one edge structure given the line endpoints and a
- * starting y value
- */
-PIXMAN_EXPORT void
-pixman_edge_init (pixman_edge_t *e,
-                  int            n,
-                  pixman_fixed_t y_start,
-                  pixman_fixed_t x_top,
-                  pixman_fixed_t y_top,
-                  pixman_fixed_t x_bot,
-                  pixman_fixed_t y_bot)
-{
-    pixman_fixed_t dx, dy;
-
-    e->x = x_top;
-    e->e = 0;
-    dx = x_bot - x_top;
-    dy = y_bot - y_top;
-    e->dy = dy;
-    e->dx = 0;
-
-    if (dy)
-    {
-	if (dx >= 0)
-	{
-	    e->signdx = 1;
-	    e->stepx = dx / dy;
-	    e->dx = dx % dy;
-	    e->e = -dy;
-	}
-	else
-	{
-	    e->signdx = -1;
-	    e->stepx = -(-dx / dy);
-	    e->dx = -dx % dy;
-	    e->e = 0;
-	}
-
-	_pixman_edge_multi_init (e, STEP_Y_SMALL (n),
-				 &e->stepx_small, &e->dx_small);
-
-	_pixman_edge_multi_init (e, STEP_Y_BIG (n),
-				 &e->stepx_big, &e->dx_big);
-    }
-    pixman_edge_step (e, y_start - y_top);
-}
-
-/*
- * Initialize one edge structure given a line, starting y value
- * and a pixel offset for the line
- */
-PIXMAN_EXPORT void
-pixman_line_fixed_edge_init (pixman_edge_t *            e,
-                             int                        n,
-                             pixman_fixed_t             y,
-                             const pixman_line_fixed_t *line,
-                             int                        x_off,
-                             int                        y_off)
-{
-    pixman_fixed_t x_off_fixed = pixman_int_to_fixed (x_off);
-    pixman_fixed_t y_off_fixed = pixman_int_to_fixed (y_off);
-    const pixman_point_fixed_t *top, *bot;
-
-    if (line->p1.y <= line->p2.y)
-    {
-	top = &line->p1;
-	bot = &line->p2;
-    }
-    else
-    {
-	top = &line->p2;
-	bot = &line->p1;
-    }
-    
-    pixman_edge_init (e, n, y,
-                      top->x + x_off_fixed,
-                      top->y + y_off_fixed,
-                      bot->x + x_off_fixed,
-                      bot->y + y_off_fixed);
-}
-
-PIXMAN_EXPORT void
-pixman_add_traps (pixman_image_t * image,
-                  int16_t          x_off,
-                  int16_t          y_off,
-                  int              ntrap,
-                  pixman_trap_t *  traps)
-{
-    int bpp;
-    int width;
-    int height;
-
-    pixman_fixed_t x_off_fixed;
-    pixman_fixed_t y_off_fixed;
-    pixman_edge_t l, r;
-    pixman_fixed_t t, b;
-
-    _pixman_image_validate (image);
-    
-    width = image->bits.width;
-    height = image->bits.height;
-    bpp = PIXMAN_FORMAT_BPP (image->bits.format);
-
-    x_off_fixed = pixman_int_to_fixed (x_off);
-    y_off_fixed = pixman_int_to_fixed (y_off);
-
-    while (ntrap--)
-    {
-	t = traps->top.y + y_off_fixed;
-	if (t < 0)
-	    t = 0;
-	t = pixman_sample_ceil_y (t, bpp);
-
-	b = traps->bot.y + y_off_fixed;
-	if (pixman_fixed_to_int (b) >= height)
-	    b = pixman_int_to_fixed (height) - 1;
-	b = pixman_sample_floor_y (b, bpp);
-
-	if (b >= t)
-	{
-	    /* initialize edge walkers */
-	    pixman_edge_init (&l, bpp, t,
-	                      traps->top.l + x_off_fixed,
-	                      traps->top.y + y_off_fixed,
-	                      traps->bot.l + x_off_fixed,
-	                      traps->bot.y + y_off_fixed);
-
-	    pixman_edge_init (&r, bpp, t,
-	                      traps->top.r + x_off_fixed,
-	                      traps->top.y + y_off_fixed,
-	                      traps->bot.r + x_off_fixed,
-	                      traps->bot.y + y_off_fixed);
-
-	    pixman_rasterize_edges (image, &l, &r, t, b);
-	}
-
-	traps++;
-    }
-}
-
-#if 0
-static void
-dump_image (pixman_image_t *image,
-            const char *    title)
-{
-    int i, j;
-
-    if (!image->type == BITS)
-	printf ("%s is not a regular image\n", title);
-
-    if (!image->bits.format == PIXMAN_a8)
-	printf ("%s is not an alpha mask\n", title);
-
-    printf ("\n\n\n%s: \n", title);
-
-    for (i = 0; i < image->bits.height; ++i)
-    {
-	uint8_t *line =
-	    (uint8_t *)&(image->bits.bits[i * image->bits.rowstride]);
-
-	for (j = 0; j < image->bits.width; ++j)
-	    printf ("%c", line[j] ? '#' : ' ');
-
-	printf ("\n");
-    }
-}
-#endif
-
-PIXMAN_EXPORT void
-pixman_add_trapezoids (pixman_image_t *          image,
-                       int16_t                   x_off,
-                       int                       y_off,
-                       int                       ntraps,
-                       const pixman_trapezoid_t *traps)
-{
-    int i;
-
-#if 0
-    dump_image (image, "before");
-#endif
-
-    for (i = 0; i < ntraps; ++i)
-    {
-	const pixman_trapezoid_t *trap = &(traps[i]);
-
-	if (!pixman_trapezoid_valid (trap))
-	    continue;
-
-	pixman_rasterize_trapezoid (image, trap, x_off, y_off);
-    }
-
-#if 0
-    dump_image (image, "after");
-#endif
-}
-
-PIXMAN_EXPORT void
-pixman_rasterize_trapezoid (pixman_image_t *          image,
-                            const pixman_trapezoid_t *trap,
-                            int                       x_off,
-                            int                       y_off)
-{
-    int bpp;
-    int width;
-    int height;
-
-    pixman_fixed_t x_off_fixed;
-    pixman_fixed_t y_off_fixed;
-    pixman_edge_t l, r;
-    pixman_fixed_t t, b;
-
-    return_if_fail (image->type == BITS);
-
-    _pixman_image_validate (image);
-    
-    if (!pixman_trapezoid_valid (trap))
-	return;
-
-    width = image->bits.width;
-    height = image->bits.height;
-    bpp = PIXMAN_FORMAT_BPP (image->bits.format);
-
-    x_off_fixed = pixman_int_to_fixed (x_off);
-    y_off_fixed = pixman_int_to_fixed (y_off);
-
-    t = trap->top + y_off_fixed;
-    if (t < 0)
-	t = 0;
-    t = pixman_sample_ceil_y (t, bpp);
-
-    b = trap->bottom + y_off_fixed;
-    if (pixman_fixed_to_int (b) >= height)
-	b = pixman_int_to_fixed (height) - 1;
-    b = pixman_sample_floor_y (b, bpp);
-    
-    if (b >= t)
-    {
-	/* initialize edge walkers */
-	pixman_line_fixed_edge_init (&l, bpp, t, &trap->left, x_off, y_off);
-	pixman_line_fixed_edge_init (&r, bpp, t, &trap->right, x_off, y_off);
-
-	pixman_rasterize_edges (image, &l, &r, t, b);
-    }
-}
+/*

+ * Copyright © 2004 Keith Packard

+ *

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

+ *

+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO

+ * EVENT SHALL KEITH PACKARD 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 "pixman-private.h"

+

+/*

+ * Compute the smallest value greater than or equal to y which is on a

+ * grid row.

+ */

+

+PIXMAN_EXPORT pixman_fixed_t

+pixman_sample_ceil_y (pixman_fixed_t y, int n)

+{

+    pixman_fixed_t f = pixman_fixed_frac (y);

+    pixman_fixed_t i = pixman_fixed_floor (y);

+

+    f = DIV (f - Y_FRAC_FIRST (n) + (STEP_Y_SMALL (n) - pixman_fixed_e), STEP_Y_SMALL (n)) * STEP_Y_SMALL (n) +

+	Y_FRAC_FIRST (n);

+    

+    if (f > Y_FRAC_LAST (n))

+    {

+	if (pixman_fixed_to_int (i) == 0x7fff)

+	{

+	    f = 0xffff; /* saturate */

+	}

+	else

+	{

+	    f = Y_FRAC_FIRST (n);

+	    i += pixman_fixed_1;

+	}

+    }

+    return (i | f);

+}

+

+/*

+ * Compute the largest value strictly less than y which is on a

+ * grid row.

+ */

+PIXMAN_EXPORT pixman_fixed_t

+pixman_sample_floor_y (pixman_fixed_t y,

+                       int            n)

+{

+    pixman_fixed_t f = pixman_fixed_frac (y);

+    pixman_fixed_t i = pixman_fixed_floor (y);

+

+    f = DIV (f - pixman_fixed_e - Y_FRAC_FIRST (n), STEP_Y_SMALL (n)) * STEP_Y_SMALL (n) +

+	Y_FRAC_FIRST (n);

+

+    if (f < Y_FRAC_FIRST (n))

+    {

+	if (pixman_fixed_to_int (i) == 0x8000)

+	{

+	    f = 0; /* saturate */

+	}

+	else

+	{

+	    f = Y_FRAC_LAST (n);

+	    i -= pixman_fixed_1;

+	}

+    }

+    return (i | f);

+}

+

+/*

+ * Step an edge by any amount (including negative values)

+ */

+PIXMAN_EXPORT void

+pixman_edge_step (pixman_edge_t *e,

+                  int            n)

+{

+    pixman_fixed_48_16_t ne;

+

+    e->x += n * e->stepx;

+

+    ne = e->e + n * (pixman_fixed_48_16_t) e->dx;

+

+    if (n >= 0)

+    {

+	if (ne > 0)

+	{

+	    int nx = (ne + e->dy - 1) / e->dy;

+	    e->e = ne - nx * (pixman_fixed_48_16_t) e->dy;

+	    e->x += nx * e->signdx;

+	}

+    }

+    else

+    {

+	if (ne <= -e->dy)

+	{

+	    int nx = (-ne) / e->dy;

+	    e->e = ne + nx * (pixman_fixed_48_16_t) e->dy;

+	    e->x -= nx * e->signdx;

+	}

+    }

+}

+

+/*

+ * A private routine to initialize the multi-step

+ * elements of an edge structure

+ */

+static void

+_pixman_edge_multi_init (pixman_edge_t * e,

+                         int             n,

+                         pixman_fixed_t *stepx_p,

+                         pixman_fixed_t *dx_p)

+{

+    pixman_fixed_t stepx;

+    pixman_fixed_48_16_t ne;

+

+    ne = n * (pixman_fixed_48_16_t) e->dx;

+    stepx = n * e->stepx;

+

+    if (ne > 0)

+    {

+	int nx = ne / e->dy;

+	ne -= nx * e->dy;

+	stepx += nx * e->signdx;

+    }

+

+    *dx_p = ne;

+    *stepx_p = stepx;

+}

+

+/*

+ * Initialize one edge structure given the line endpoints and a

+ * starting y value

+ */

+PIXMAN_EXPORT void

+pixman_edge_init (pixman_edge_t *e,

+                  int            n,

+                  pixman_fixed_t y_start,

+                  pixman_fixed_t x_top,

+                  pixman_fixed_t y_top,

+                  pixman_fixed_t x_bot,

+                  pixman_fixed_t y_bot)

+{

+    pixman_fixed_t dx, dy;

+

+    e->x = x_top;

+    e->e = 0;

+    dx = x_bot - x_top;

+    dy = y_bot - y_top;

+    e->dy = dy;

+    e->dx = 0;

+

+    if (dy)

+    {

+	if (dx >= 0)

+	{

+	    e->signdx = 1;

+	    e->stepx = dx / dy;

+	    e->dx = dx % dy;

+	    e->e = -dy;

+	}

+	else

+	{

+	    e->signdx = -1;

+	    e->stepx = -(-dx / dy);

+	    e->dx = -dx % dy;

+	    e->e = 0;

+	}

+

+	_pixman_edge_multi_init (e, STEP_Y_SMALL (n),

+				 &e->stepx_small, &e->dx_small);

+

+	_pixman_edge_multi_init (e, STEP_Y_BIG (n),

+				 &e->stepx_big, &e->dx_big);

+    }

+    pixman_edge_step (e, y_start - y_top);

+}

+

+/*

+ * Initialize one edge structure given a line, starting y value

+ * and a pixel offset for the line

+ */

+PIXMAN_EXPORT void

+pixman_line_fixed_edge_init (pixman_edge_t *            e,

+                             int                        n,

+                             pixman_fixed_t             y,

+                             const pixman_line_fixed_t *line,

+                             int                        x_off,

+                             int                        y_off)

+{

+    pixman_fixed_t x_off_fixed = pixman_int_to_fixed (x_off);

+    pixman_fixed_t y_off_fixed = pixman_int_to_fixed (y_off);

+    const pixman_point_fixed_t *top, *bot;

+

+    if (line->p1.y <= line->p2.y)

+    {

+	top = &line->p1;

+	bot = &line->p2;

+    }

+    else

+    {

+	top = &line->p2;

+	bot = &line->p1;

+    }

+    

+    pixman_edge_init (e, n, y,

+                      top->x + x_off_fixed,

+                      top->y + y_off_fixed,

+                      bot->x + x_off_fixed,

+                      bot->y + y_off_fixed);

+}

+

+PIXMAN_EXPORT void

+pixman_add_traps (pixman_image_t * image,

+                  int16_t          x_off,

+                  int16_t          y_off,

+                  int              ntrap,

+                  pixman_trap_t *  traps)

+{

+    int bpp;

+    int height;

+

+    pixman_fixed_t x_off_fixed;

+    pixman_fixed_t y_off_fixed;

+    pixman_edge_t l, r;

+    pixman_fixed_t t, b;

+

+    _pixman_image_validate (image);

+    

+    height = image->bits.height;

+    bpp = PIXMAN_FORMAT_BPP (image->bits.format);

+

+    x_off_fixed = pixman_int_to_fixed (x_off);

+    y_off_fixed = pixman_int_to_fixed (y_off);

+

+    while (ntrap--)

+    {

+	t = traps->top.y + y_off_fixed;

+	if (t < 0)

+	    t = 0;

+	t = pixman_sample_ceil_y (t, bpp);

+

+	b = traps->bot.y + y_off_fixed;

+	if (pixman_fixed_to_int (b) >= height)

+	    b = pixman_int_to_fixed (height) - 1;

+	b = pixman_sample_floor_y (b, bpp);

+

+	if (b >= t)

+	{

+	    /* initialize edge walkers */

+	    pixman_edge_init (&l, bpp, t,

+	                      traps->top.l + x_off_fixed,

+	                      traps->top.y + y_off_fixed,

+	                      traps->bot.l + x_off_fixed,

+	                      traps->bot.y + y_off_fixed);

+

+	    pixman_edge_init (&r, bpp, t,

+	                      traps->top.r + x_off_fixed,

+	                      traps->top.y + y_off_fixed,

+	                      traps->bot.r + x_off_fixed,

+	                      traps->bot.y + y_off_fixed);

+

+	    pixman_rasterize_edges (image, &l, &r, t, b);

+	}

+

+	traps++;

+    }

+}

+

+#if 0

+static void

+dump_image (pixman_image_t *image,

+            const char *    title)

+{

+    int i, j;

+

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

+	printf ("%s is not a regular image\n", title);

+

+    if (!image->bits.format == PIXMAN_a8)

+	printf ("%s is not an alpha mask\n", title);

+

+    printf ("\n\n\n%s: \n", title);

+

+    for (i = 0; i < image->bits.height; ++i)

+    {

+	uint8_t *line =

+	    (uint8_t *)&(image->bits.bits[i * image->bits.rowstride]);

+

+	for (j = 0; j < image->bits.width; ++j)

+	    printf ("%c", line[j] ? '#' : ' ');

+

+	printf ("\n");

+    }

+}

+#endif

+

+PIXMAN_EXPORT void

+pixman_add_trapezoids (pixman_image_t *          image,

+                       int16_t                   x_off,

+                       int                       y_off,

+                       int                       ntraps,

+                       const pixman_trapezoid_t *traps)

+{

+    int i;

+

+#if 0

+    dump_image (image, "before");

+#endif

+

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

+    {

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

+

+	if (!pixman_trapezoid_valid (trap))

+	    continue;

+

+	pixman_rasterize_trapezoid (image, trap, x_off, y_off);

+    }

+

+#if 0

+    dump_image (image, "after");

+#endif

+}

+

+PIXMAN_EXPORT void

+pixman_rasterize_trapezoid (pixman_image_t *          image,

+                            const pixman_trapezoid_t *trap,

+                            int                       x_off,

+                            int                       y_off)

+{

+    int bpp;

+    int height;

+

+    pixman_fixed_t y_off_fixed;

+    pixman_edge_t l, r;

+    pixman_fixed_t t, b;

+

+    return_if_fail (image->type == BITS);

+

+    _pixman_image_validate (image);

+    

+    if (!pixman_trapezoid_valid (trap))

+	return;

+

+    height = image->bits.height;

+    bpp = PIXMAN_FORMAT_BPP (image->bits.format);

+

+    y_off_fixed = pixman_int_to_fixed (y_off);

+

+    t = trap->top + y_off_fixed;

+    if (t < 0)

+	t = 0;

+    t = pixman_sample_ceil_y (t, bpp);

+

+    b = trap->bottom + y_off_fixed;

+    if (pixman_fixed_to_int (b) >= height)

+	b = pixman_int_to_fixed (height) - 1;

+    b = pixman_sample_floor_y (b, bpp);

+    

+    if (b >= t)

+    {

+	/* initialize edge walkers */

+	pixman_line_fixed_edge_init (&l, bpp, t, &trap->left, x_off, y_off);

+	pixman_line_fixed_edge_init (&r, bpp, t, &trap->right, x_off, y_off);

+

+	pixman_rasterize_edges (image, &l, &r, t, b);

+    }

+}

diff --git a/pixman/test/affine-test.c b/pixman/test/affine-test.c
index 3e32b5a23..fbb35caa9 100644
--- a/pixman/test/affine-test.c
+++ b/pixman/test/affine-test.c
@@ -40,9 +40,9 @@ test_composite (int      testnum,
     int                w, h;

     pixman_fixed_t     scale_x = 65536, scale_y = 65536;

     pixman_fixed_t     translate_x = 0, translate_y = 0;

-    int                op;

-    int                repeat = 0;

-    int                src_fmt, dst_fmt;

+    pixman_op_t        op;

+    pixman_repeat_t    repeat = PIXMAN_REPEAT_NONE;

+    pixman_format_code_t src_fmt, dst_fmt;

     uint32_t *         srcbuf;

     uint32_t *         dstbuf;

     uint32_t           crc32;

diff --git a/pixman/test/blitters-test.c b/pixman/test/blitters-test.c
index 0ff9a1d48..3b27cd8c1 100644
--- a/pixman/test/blitters-test.c
+++ b/pixman/test/blitters-test.c
@@ -27,7 +27,7 @@ create_random_image (pixman_format_code_t *allowed_formats,
     uint32_t *buf;

     pixman_image_t *img;

 

-    while (allowed_formats[n] != -1)

+    while (allowed_formats[n] != PIXMAN_null)

 	n++;

     fmt = allowed_formats[lcg_rand_n (n)];

 

@@ -78,7 +78,7 @@ free_random_image (uint32_t initcrc,
     uint32_t *data = pixman_image_get_data (img);

     int height = pixman_image_get_height (img);

 

-    if (fmt != -1)

+    if (fmt != PIXMAN_null)

     {

 	/* mask unused 'x' part */

 	if (PIXMAN_FORMAT_BPP (fmt) - PIXMAN_FORMAT_DEPTH (fmt) &&

@@ -218,7 +218,7 @@ static pixman_format_code_t img_fmt_list[] = {
     PIXMAN_a1r1g1b1,

     PIXMAN_a1b1g1r1,

     PIXMAN_a1,

-    -1

+    PIXMAN_null

 };

 

 static pixman_format_code_t mask_fmt_list[] = {

@@ -226,7 +226,7 @@ static pixman_format_code_t mask_fmt_list[] = {
     PIXMAN_a8,

     PIXMAN_a4,

     PIXMAN_a1,

-    -1

+    PIXMAN_null

 };

 

 

@@ -247,7 +247,7 @@ test_composite (int testnum, int verbose)
     int dst_x, dst_y;

     int mask_x, mask_y;

     int w, h;

-    int op;

+    pixman_op_t op;

     pixman_format_code_t src_fmt, dst_fmt, mask_fmt;

     uint32_t *dstbuf, *srcbuf, *maskbuf;

     uint32_t crc32;

@@ -305,7 +305,7 @@ test_composite (int testnum, int verbose)
     dst_y = lcg_rand_n (dst_height);

 

     mask_img = NULL;

-    mask_fmt = -1;

+    mask_fmt = PIXMAN_null;

     mask_x = 0;

     mask_y = 0;

     maskbuf = NULL;

@@ -385,7 +385,7 @@ test_composite (int testnum, int verbose)
 	printf ("---\n");

     }

 

-    free_random_image (0, src_img, -1);

+    free_random_image (0, src_img, PIXMAN_null);

     crc32 = free_random_image (0, dst_img, dst_fmt);

 

     if (mask_img)

@@ -393,7 +393,7 @@ test_composite (int testnum, int verbose)
 	if (srcbuf == maskbuf)

 	    pixman_image_unref(mask_img);

 	else

-	    free_random_image (0, mask_img, -1);

+	    free_random_image (0, mask_img, PIXMAN_null);

     }

 

     FLOAT_REGS_CORRUPTION_DETECTOR_FINISH ();

diff --git a/pixman/test/scaling-crash-test.c b/pixman/test/scaling-crash-test.c
index 0ce1fece9..23ee8c6be 100644
--- a/pixman/test/scaling-crash-test.c
+++ b/pixman/test/scaling-crash-test.c
@@ -95,21 +95,29 @@ run_test (int32_t		dst_width,
     return result;

 }

 

-typedef struct info_t info_t;

-struct info_t

+typedef struct filter_info_t filter_info_t;

+struct filter_info_t

 {

-    int value;

+    pixman_filter_t value;

     char name[28];

 };

 

-static const info_t filters[] =

+static const filter_info_t filters[] =

 {

     { PIXMAN_FILTER_NEAREST, "NEAREST" },

     { PIXMAN_FILTER_BILINEAR, "BILINEAR" },

     { PIXMAN_FILTER_CONVOLUTION, "CONVOLUTION" },

 };

 

-static const info_t repeats[] =

+typedef struct repeat_info_t repeat_info_t;

+struct repeat_info_t

+{

+    pixman_repeat_t value;

+    char name[28];

+};

+

+

+static const repeat_info_t repeats[] =

 {

     { PIXMAN_REPEAT_PAD, "PAD" },

     { PIXMAN_REPEAT_REFLECT, "REFLECT" },

diff --git a/pixman/test/scaling-test.c b/pixman/test/scaling-test.c
index 872805338..7b78017a3 100644
--- a/pixman/test/scaling-test.c
+++ b/pixman/test/scaling-test.c
@@ -40,9 +40,9 @@ test_composite (int      testnum,
     int                w, h;

     pixman_fixed_t     scale_x = 65536, scale_y = 65536;

     pixman_fixed_t     translate_x = 0, translate_y = 0;

-    int                op;

-    int                repeat = 0;

-    int                src_fmt, dst_fmt;

+    pixman_op_t        op;

+    pixman_repeat_t    repeat = PIXMAN_REPEAT_NONE;

+    pixman_format_code_t src_fmt, dst_fmt;

     uint32_t *         srcbuf;

     uint32_t *         dstbuf;

     uint32_t           crc32;