svn merge ^/branches/released .

5 files changed, 4086 insertions, 3747 deletions

diff --git a/pixman/pixman/Makefile.win32 b/pixman/pixman/Makefile.win32
index 388bee23a..a61f33f94 100644
--- a/pixman/pixman/Makefile.win32
+++ b/pixman/pixman/Makefile.win32
@@ -1,143 +1,144 @@
-LIBRARY     = pixman-1
-
-CC   = cl
-LINK = link
-
-CFG_VAR = $(CFG)
-ifeq ($(CFG_VAR),)
-CFG_VAR=release
-endif
-
-MMX_VAR = $(MMX)
-ifeq ($(MMX_VAR),)
-MMX_VAR=on
-endif
-
-SSE2_VAR = $(SSE2)
-ifeq ($(SSE2_VAR),)
-SSE2_VAR=on
-endif
-
-CFLAGS     = -MD -nologo -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE -I../pixman/src -I. -DPACKAGE=$(LIBRARY) -DPACKAGE_VERSION="" -DPACKAGE_BUGREPORT=""
-MMX_CFLAGS = -DUSE_MMX -w14710 -w14714
-SSE2_CFLAGS = -DUSE_SSE2
-
-# optimization flags
-ifeq ($(CFG_VAR),debug)
-CFLAGS += -Od -Zi
-else
-CFLAGS += -O2
-endif
-
-SOURCES =				\
-	pixman-image.c			\
-	pixman-access.c			\
-	pixman-access-accessors.c	\
-	pixman-region16.c		\
-	pixman-region32.c		\
-	pixman-combine32.c		\
-	pixman-combine64.c		\
-	pixman-utils.c			\
-	pixman-edge.c			\
-	pixman-edge-accessors.c		\
-	pixman-trap.c			\
-	pixman-timer.c			\
-	pixman-matrix.c			\
-	pixman-gradient-walker.c	\
-	pixman-linear-gradient.c	\
-	pixman-radial-gradient.c	\
-	pixman-bits-image.c		\
-	pixman.c			\
-	pixman-cpu.c			\
-	pixman-fast-path.c		\
-	pixman-implementation.c		\
-	pixman-solid-fill.c		\
-	pixman-general.c		\
-	$(NULL)
-
-# MMX compilation flags
-ifeq ($(MMX_VAR),on)
-CFLAGS += $(MMX_CFLAGS)
-SOURCES += pixman-mmx.c
-endif
-
-# SSE2 compilation flags
-ifeq ($(SSE2_VAR),on)
-CFLAGS += $(SSE2_CFLAGS)
-SOURCES += pixman-sse2.c
-endif
-
-OBJECTS     = $(patsubst %.c, $(CFG_VAR)/%.obj, $(SOURCES))
-
-# targets
-all: inform informMMX informSSE2 $(CFG_VAR)/$(LIBRARY).lib
-	@exit 0
-clean: inform clean_r 
-	@exit 0
-pixman: inform informMMX informSSE2 $(CFG_VAR)/$(LIBRARY).lib 
-	@exit 0
-
-inform:
-ifneq ($(CFG),release)
-ifneq ($(CFG),debug)
-ifneq ($(CFG),)
-	@echo "Invalid specified configuration option : "$(CFG)"."
-	@echo
-	@echo -n "Possible choices for configuration are "
-	@echo "'release' and 'debug'"
-	@echo ""
-	@exit 1
-endif
-	@echo "Using default RELEASE configuration... (use CFG=release or CFG=debug)"
-endif
-endif
-
-informMMX:
-ifneq ($(MMX),off)
-ifneq ($(MMX),on)
-ifneq ($(MMX),)
-	@echo "Invalid specified MMX option : "$(MMX_VAR)"."
-	@echo
-	@echo -n "Possible choices for MMX are 'on' or 'off'"
-	@echo ""
-	@exit 1
-endif
-	@echo "Setting MMX flag to default value 'on'... (use MMX=on or MMX=off)"
-endif
-endif
-
-informSSE2:
-ifneq ($(SSE2),off)
-ifneq ($(SSE2),on)
-ifneq ($(SSE2),)
-	@echo "Invalid specified SSE option : "$(SSE2)"."
-	@echo
-	@echo -n "Possible choices for SSE2 are 'on' or 'off'"
-	@echo ""
-	@exit 1
-endif
-	@echo "Setting SSE2 flag to default value 'on'... (use SSE2=on or SSE2=off)"
-endif
-endif
-
-# pixman compilation and linking
-$(CFG_VAR)/%.obj: %.c
-	@mkdir -p $(CFG_VAR)
-	@$(CC) -c $(CFLAGS) -Fo"$@" $<
-
-$(CFG_VAR)/$(LIBRARY).lib: $(OBJECTS)
-	lib -NOLOGO -OUT:$@ $(OBJECTS) || exit 0
-
-pixman-combine32.c: pixman-combine.c.template pixman-combine32.h make-combine.pl
-	perl ./make-combine.pl 8 < $< > $@ || ($(RM) $@; exit 1)
-pixman-combine32.h: pixman-combine.h.template make-combine.pl
-	perl ./make-combine.pl 8 < $< > $@ || ($(RM) $@; exit 1)
-
-pixman-combine64.c: pixman-combine.c.template pixman-combine64.h make-combine.pl
-	perl ./make-combine.pl 16 < $< > $@ || ($(RM) $@; exit 1)
-pixman-combine64.h: pixman-combine.h.template make-combine.pl
-	perl ./make-combine.pl 16 < $< > $@ || ($(RM) $@; exit 1)
-
-clean_r:
-	@rm -f $(CFG_VAR)/*.obj $(CFG_VAR)/*.lib $(CFG_VAR)/*.pdb $(CFG)/*.ilk || exit 0
-	@rm -f $(CFG)/*.obj $(CFG)/*.lib $(CFG)/*.pdb $(CFG)/*.ilk pixman-combine32.c pixman-combine64.c pixman-combine64.c pixman-combine64.h || exit 0
+LIBRARY     = pixman-1

+

+CC   = cl

+LINK = link

+

+CFG_VAR = $(CFG)

+ifeq ($(CFG_VAR),)

+CFG_VAR=release

+endif

+

+MMX_VAR = $(MMX)

+ifeq ($(MMX_VAR),)

+MMX_VAR=on

+endif

+

+SSE2_VAR = $(SSE2)

+ifeq ($(SSE2_VAR),)

+SSE2_VAR=on

+endif

+

+CFLAGS     = -MD -nologo -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE -I../pixman/src -I. -DPACKAGE=$(LIBRARY) -DPACKAGE_VERSION="" -DPACKAGE_BUGREPORT=""

+MMX_CFLAGS = -DUSE_MMX -w14710 -w14714

+SSE2_CFLAGS = -DUSE_SSE2

+

+# optimization flags

+ifeq ($(CFG_VAR),debug)

+CFLAGS += -Od -Zi

+else

+CFLAGS += -O2

+endif

+

+SOURCES =				\

+	pixman-image.c			\

+	pixman-access.c			\

+	pixman-access-accessors.c	\

+	pixman-region16.c		\

+	pixman-region32.c		\

+	pixman-combine32.c		\

+	pixman-combine64.c		\

+	pixman-utils.c			\

+	pixman-edge.c			\

+	pixman-edge-accessors.c		\

+	pixman-trap.c			\

+	pixman-timer.c			\

+	pixman-matrix.c			\

+	pixman-gradient-walker.c	\

+	pixman-conical-gradient.c	\

+	pixman-linear-gradient.c	\

+	pixman-radial-gradient.c	\

+	pixman-bits-image.c		\

+	pixman.c			\

+	pixman-cpu.c			\

+	pixman-fast-path.c		\

+	pixman-implementation.c		\

+	pixman-solid-fill.c		\

+	pixman-general.c		\

+	$(NULL)

+

+# MMX compilation flags

+ifeq ($(MMX_VAR),on)

+CFLAGS += $(MMX_CFLAGS)

+SOURCES += pixman-mmx.c

+endif

+

+# SSE2 compilation flags

+ifeq ($(SSE2_VAR),on)

+CFLAGS += $(SSE2_CFLAGS)

+SOURCES += pixman-sse2.c

+endif

+

+OBJECTS     = $(patsubst %.c, $(CFG_VAR)/%.obj, $(SOURCES))

+

+# targets

+all: inform informMMX informSSE2 $(CFG_VAR)/$(LIBRARY).lib

+	@exit 0

+clean: inform clean_r 

+	@exit 0

+pixman: inform informMMX informSSE2 $(CFG_VAR)/$(LIBRARY).lib 

+	@exit 0

+

+inform:

+ifneq ($(CFG),release)

+ifneq ($(CFG),debug)

+ifneq ($(CFG),)

+	@echo "Invalid specified configuration option : "$(CFG)"."

+	@echo

+	@echo -n "Possible choices for configuration are "

+	@echo "'release' and 'debug'"

+	@echo ""

+	@exit 1

+endif

+	@echo "Using default RELEASE configuration... (use CFG=release or CFG=debug)"

+endif

+endif

+

+informMMX:

+ifneq ($(MMX),off)

+ifneq ($(MMX),on)

+ifneq ($(MMX),)

+	@echo "Invalid specified MMX option : "$(MMX_VAR)"."

+	@echo

+	@echo -n "Possible choices for MMX are 'on' or 'off'"

+	@echo ""

+	@exit 1

+endif

+	@echo "Setting MMX flag to default value 'on'... (use MMX=on or MMX=off)"

+endif

+endif

+

+informSSE2:

+ifneq ($(SSE2),off)

+ifneq ($(SSE2),on)

+ifneq ($(SSE2),)

+	@echo "Invalid specified SSE option : "$(SSE2)"."

+	@echo

+	@echo -n "Possible choices for SSE2 are 'on' or 'off'"

+	@echo ""

+	@exit 1

+endif

+	@echo "Setting SSE2 flag to default value 'on'... (use SSE2=on or SSE2=off)"

+endif

+endif

+

+# pixman compilation and linking

+$(CFG_VAR)/%.obj: %.c

+	@mkdir -p $(CFG_VAR)

+	@$(CC) -c $(CFLAGS) -Fo"$@" $<

+

+$(CFG_VAR)/$(LIBRARY).lib: $(OBJECTS)

+	lib -NOLOGO -OUT:$@ $(OBJECTS) || exit 0

+

+pixman-combine32.c: pixman-combine.c.template pixman-combine32.h make-combine.pl

+	perl ./make-combine.pl 8 < $< > $@ || ($(RM) $@; exit 1)

+pixman-combine32.h: pixman-combine.h.template make-combine.pl

+	perl ./make-combine.pl 8 < $< > $@ || ($(RM) $@; exit 1)

+

+pixman-combine64.c: pixman-combine.c.template pixman-combine64.h make-combine.pl

+	perl ./make-combine.pl 16 < $< > $@ || ($(RM) $@; exit 1)

+pixman-combine64.h: pixman-combine.h.template make-combine.pl

+	perl ./make-combine.pl 16 < $< > $@ || ($(RM) $@; exit 1)

+

+clean_r:

+	@rm -f $(CFG_VAR)/*.obj $(CFG_VAR)/*.lib $(CFG_VAR)/*.pdb $(CFG)/*.ilk || exit 0

+	@rm -f $(CFG)/*.obj $(CFG)/*.lib $(CFG)/*.pdb $(CFG)/*.ilk pixman-combine32.c pixman-combine64.c pixman-combine64.c pixman-combine64.h || exit 0

diff --git a/pixman/pixman/pixman-fast-path.c b/pixman/pixman/pixman-fast-path.c
index eb0971586..4cb8321aa 100644
--- a/pixman/pixman/pixman-fast-path.c
+++ b/pixman/pixman/pixman-fast-path.c
@@ -1,1935 +1,2227 @@
-/* -*- 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 (pixman_implementation_t *fallback)
-{
-    pixman_implementation_t *imp = _pixman_implementation_create (fallback, 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++);

+	    }

+	}

+    }

+}

+

+#define CACHE_LINE_SIZE 64

+

+#define FAST_SIMPLE_ROTATE(suffix, pix_type)                                  \

+                                                                              \

+static void                                                                   \

+blt_rotated_90_trivial_##suffix (pix_type       *dst,                         \

+				 int             dst_stride,                  \

+				 const pix_type *src,                         \

+				 int             src_stride,                  \

+				 int             w,                           \

+				 int             h)                           \

+{                                                                             \

+    int x, y;                                                                 \

+    for (y = 0; y < h; y++)                                                   \

+    {                                                                         \

+	const pix_type *s = src + (h - y - 1);                                \

+	pix_type *d = dst + dst_stride * y;                                   \

+	for (x = 0; x < w; x++)                                               \

+	{                                                                     \

+	    *d++ = *s;                                                        \

+	    s += src_stride;                                                  \

+	}                                                                     \

+    }                                                                         \

+}                                                                             \

+                                                                              \

+static void                                                                   \

+blt_rotated_270_trivial_##suffix (pix_type       *dst,                        \

+				  int             dst_stride,                 \

+				  const pix_type *src,                        \

+				  int             src_stride,                 \

+				  int             w,                          \

+				  int             h)                          \

+{                                                                             \

+    int x, y;                                                                 \

+    for (y = 0; y < h; y++)                                                   \

+    {                                                                         \

+	const pix_type *s = src + src_stride * (w - 1) + y;                   \

+	pix_type *d = dst + dst_stride * y;                                   \

+	for (x = 0; x < w; x++)                                               \

+	{                                                                     \

+	    *d++ = *s;                                                        \

+	    s -= src_stride;                                                  \

+	}                                                                     \

+    }                                                                         \

+}                                                                             \

+                                                                              \

+static void                                                                   \

+blt_rotated_90_##suffix (pix_type       *dst,                                 \

+			 int             dst_stride,                          \

+			 const pix_type *src,                                 \

+			 int             src_stride,                          \

+			 int             W,                                   \

+			 int             H)                                   \

+{                                                                             \

+    int x;                                                                    \

+    int leading_pixels = 0, trailing_pixels = 0;                              \

+    const int TILE_SIZE = CACHE_LINE_SIZE / sizeof(pix_type);                 \

+                                                                              \

+    /*                                                                        \

+     * split processing into handling destination as TILE_SIZExH cache line   \

+     * aligned vertical stripes (optimistically assuming that destination     \

+     * stride is a multiple of cache line, if not - it will be just a bit     \

+     * slower)                                                                \

+     */                                                                       \

+                                                                              \

+    if ((uintptr_t)dst & (CACHE_LINE_SIZE - 1))                               \

+    {                                                                         \

+	leading_pixels = TILE_SIZE - (((uintptr_t)dst &                       \

+			    (CACHE_LINE_SIZE - 1)) / sizeof(pix_type));       \

+	if (leading_pixels > W)                                               \

+	    leading_pixels = W;                                               \

+                                                                              \

+	/* unaligned leading part NxH (where N < TILE_SIZE) */                \

+	blt_rotated_90_trivial_##suffix (                                     \

+	    dst,                                                              \

+	    dst_stride,                                                       \

+	    src,                                                              \

+	    src_stride,                                                       \

+	    leading_pixels,                                                   \

+	    H);                                                               \

+	                                                                      \

+	dst += leading_pixels;                                                \

+	src += leading_pixels * src_stride;                                   \

+	W -= leading_pixels;                                                  \

+    }                                                                         \

+                                                                              \

+    if ((uintptr_t)(dst + W) & (CACHE_LINE_SIZE - 1))                         \

+    {                                                                         \

+	trailing_pixels = (((uintptr_t)(dst + W) &                            \

+			    (CACHE_LINE_SIZE - 1)) / sizeof(pix_type));       \

+	if (trailing_pixels > W)                                              \

+	    trailing_pixels = W;                                              \

+	W -= trailing_pixels;                                                 \

+    }                                                                         \

+                                                                              \

+    for (x = 0; x < W; x += TILE_SIZE)                                        \

+    {                                                                         \

+	/* aligned middle part TILE_SIZExH */                                 \

+	blt_rotated_90_trivial_##suffix (                                     \

+	    dst + x,                                                          \

+	    dst_stride,                                                       \

+	    src + src_stride * x,                                             \

+	    src_stride,                                                       \

+	    TILE_SIZE,                                                        \

+	    H);                                                               \

+    }                                                                         \

+                                                                              \

+    if (trailing_pixels)                                                      \

+    {                                                                         \

+	/* unaligned trailing part NxH (where N < TILE_SIZE) */               \

+	blt_rotated_90_trivial_##suffix (                                     \

+	    dst + W,                                                          \

+	    dst_stride,                                                       \

+	    src + W * src_stride,                                             \

+	    src_stride,                                                       \

+	    trailing_pixels,                                                  \

+	    H);                                                               \

+    }                                                                         \

+}                                                                             \

+                                                                              \

+static void                                                                   \

+blt_rotated_270_##suffix (pix_type       *dst,                                \

+			  int             dst_stride,                         \

+			  const pix_type *src,                                \

+			  int             src_stride,                         \

+			  int             W,                                  \

+			  int             H)                                  \

+{                                                                             \

+    int x;                                                                    \

+    int leading_pixels = 0, trailing_pixels = 0;                              \

+    const int TILE_SIZE = CACHE_LINE_SIZE / sizeof(pix_type);                 \

+                                                                              \

+    /*                                                                        \

+     * split processing into handling destination as TILE_SIZExH cache line   \

+     * aligned vertical stripes (optimistically assuming that destination     \

+     * stride is a multiple of cache line, if not - it will be just a bit     \

+     * slower)                                                                \

+     */                                                                       \

+                                                                              \

+    if ((uintptr_t)dst & (CACHE_LINE_SIZE - 1))                               \

+    {                                                                         \

+	leading_pixels = TILE_SIZE - (((uintptr_t)dst &                       \

+			    (CACHE_LINE_SIZE - 1)) / sizeof(pix_type));       \

+	if (leading_pixels > W)                                               \

+	    leading_pixels = W;                                               \

+                                                                              \

+	/* unaligned leading part NxH (where N < TILE_SIZE) */                \

+	blt_rotated_270_trivial_##suffix (                                    \

+	    dst,                                                              \

+	    dst_stride,                                                       \

+	    src + src_stride * (W - leading_pixels),                          \

+	    src_stride,                                                       \

+	    leading_pixels,                                                   \

+	    H);                                                               \

+	                                                                      \

+	dst += leading_pixels;                                                \

+	W -= leading_pixels;                                                  \

+    }                                                                         \

+                                                                              \

+    if ((uintptr_t)(dst + W) & (CACHE_LINE_SIZE - 1))                         \

+    {                                                                         \

+	trailing_pixels = (((uintptr_t)(dst + W) &                            \

+			    (CACHE_LINE_SIZE - 1)) / sizeof(pix_type));       \

+	if (trailing_pixels > W)                                              \

+	    trailing_pixels = W;                                              \

+	W -= trailing_pixels;                                                 \

+	src += trailing_pixels * src_stride;                                  \

+    }                                                                         \

+                                                                              \

+    for (x = 0; x < W; x += TILE_SIZE)                                        \

+    {                                                                         \

+	/* aligned middle part TILE_SIZExH */                                 \

+	blt_rotated_270_trivial_##suffix (                                    \

+	    dst + x,                                                          \

+	    dst_stride,                                                       \

+	    src + src_stride * (W - x - TILE_SIZE),                           \

+	    src_stride,                                                       \

+	    TILE_SIZE,                                                        \

+	    H);                                                               \

+    }                                                                         \

+                                                                              \

+    if (trailing_pixels)                                                      \

+    {                                                                         \

+	/* unaligned trailing part NxH (where N < TILE_SIZE) */               \

+	blt_rotated_270_trivial_##suffix (                                    \

+	    dst + W,                                                          \

+	    dst_stride,                                                       \

+	    src - trailing_pixels * src_stride,                               \

+	    src_stride,                                                       \

+	    trailing_pixels,                                                  \

+	    H);                                                               \

+    }                                                                         \

+}                                                                             \

+                                                                              \

+static void                                                                   \

+fast_composite_rotate_90_##suffix (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)           \

+{                                                                             \

+    pix_type       *dst_line;                                                 \

+    pix_type       *src_line;                                                 \

+    int             dst_stride, src_stride;                                   \

+    int             src_x_t, src_y_t;                                         \

+                                                                              \

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, pix_type,               \

+			   dst_stride, dst_line, 1);                          \

+    src_x_t = -src_y + pixman_fixed_to_int (                                  \

+				src_image->common.transform->matrix[0][2] +   \

+				pixman_fixed_1 / 2 - pixman_fixed_e) - height;\

+    src_y_t = src_x + pixman_fixed_to_int (                                   \

+				src_image->common.transform->matrix[1][2] +   \

+				pixman_fixed_1 / 2 - pixman_fixed_e);         \

+    PIXMAN_IMAGE_GET_LINE (src_image, src_x_t, src_y_t, pix_type,             \

+			   src_stride, src_line, 1);                          \

+    blt_rotated_90_##suffix (dst_line, dst_stride, src_line, src_stride,      \

+			     width, height);                                  \

+}                                                                             \

+                                                                              \

+static void                                                                   \

+fast_composite_rotate_270_##suffix (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)          \

+{                                                                             \

+    pix_type       *dst_line;                                                 \

+    pix_type       *src_line;                                                 \

+    int             dst_stride, src_stride;                                   \

+    int             src_x_t, src_y_t;                                         \

+                                                                              \

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, pix_type,               \

+			   dst_stride, dst_line, 1);                          \

+    src_x_t = src_y + pixman_fixed_to_int (                                   \

+				src_image->common.transform->matrix[0][2] +   \

+				pixman_fixed_1 / 2 - pixman_fixed_e);         \

+    src_y_t = -src_x + pixman_fixed_to_int (                                  \

+				src_image->common.transform->matrix[1][2] +   \

+				pixman_fixed_1 / 2 - pixman_fixed_e) - width; \

+    PIXMAN_IMAGE_GET_LINE (src_image, src_x_t, src_y_t, pix_type,             \

+			   src_stride, src_line, 1);                          \

+    blt_rotated_270_##suffix (dst_line, dst_stride, src_line, src_stride,     \

+			      width, height);                                 \

+}

+

+FAST_SIMPLE_ROTATE (8, uint8_t)

+FAST_SIMPLE_ROTATE (565, uint16_t)

+FAST_SIMPLE_ROTATE (8888, uint32_t)

+

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

+

+#define SIMPLE_ROTATE_FLAGS(angle)					  \

+    (FAST_PATH_ROTATE_ ## angle ## _TRANSFORM	|			  \

+     FAST_PATH_NEAREST_FILTER			|			  \

+     FAST_PATH_SAMPLES_COVER_CLIP		|			  \

+     FAST_PATH_STANDARD_FLAGS)

+

+#define SIMPLE_ROTATE_FAST_PATH(op,s,d,suffix)				  \

+    {   PIXMAN_OP_ ## op,						  \

+	PIXMAN_ ## s, SIMPLE_ROTATE_FLAGS (90),				  \

+	PIXMAN_null, 0,							  \

+	PIXMAN_ ## d, FAST_PATH_STD_DEST_FLAGS,				  \

+	fast_composite_rotate_90_##suffix,				  \

+    },									  \

+    {   PIXMAN_OP_ ## op,						  \

+	PIXMAN_ ## s, SIMPLE_ROTATE_FLAGS (270),			  \

+	PIXMAN_null, 0,							  \

+	PIXMAN_ ## d, FAST_PATH_STD_DEST_FLAGS,				  \

+	fast_composite_rotate_270_##suffix,				  \

+    }

+

+    SIMPLE_ROTATE_FAST_PATH (SRC, a8r8g8b8, a8r8g8b8, 8888),

+    SIMPLE_ROTATE_FAST_PATH (SRC, a8r8g8b8, x8r8g8b8, 8888),

+    SIMPLE_ROTATE_FAST_PATH (SRC, x8r8g8b8, x8r8g8b8, 8888),

+    SIMPLE_ROTATE_FAST_PATH (SRC, r5g6b5, r5g6b5, 565),

+    SIMPLE_ROTATE_FAST_PATH (SRC, a8, a8, 8),

+

+    {   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 (pixman_implementation_t *fallback)

+{

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

+

+    imp->fill = fast_path_fill;

+

+    return imp;

+}

diff --git a/pixman/pixman/pixman-image.c b/pixman/pixman/pixman-image.c
index a72299b3c..beda4b423 100644
--- a/pixman/pixman/pixman-image.c
+++ b/pixman/pixman/pixman-image.c
@@ -1,747 +1,764 @@
-/*
- * 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.
- */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <assert.h>
-
-#include "pixman-private.h"
-#include "pixman-combine32.h"
-
-pixman_bool_t
-_pixman_init_gradient (gradient_t *                  gradient,
-                       const pixman_gradient_stop_t *stops,
-                       int                           n_stops)
-{
-    return_val_if_fail (n_stops > 0, FALSE);
-
-    gradient->stops = pixman_malloc_ab (n_stops, sizeof (pixman_gradient_stop_t));
-    if (!gradient->stops)
-	return FALSE;
-
-    memcpy (gradient->stops, stops, n_stops * sizeof (pixman_gradient_stop_t));
-
-    gradient->n_stops = n_stops;
-
-    return TRUE;
-}
-
-pixman_image_t *
-_pixman_image_allocate (void)
-{
-    pixman_image_t *image = malloc (sizeof (pixman_image_t));
-
-    if (image)
-    {
-	image_common_t *common = &image->common;
-
-	pixman_region32_init (&common->clip_region);
-
-	common->alpha_count = 0;
-	common->have_clip_region = FALSE;
-	common->clip_sources = FALSE;
-	common->transform = NULL;
-	common->repeat = PIXMAN_REPEAT_NONE;
-	common->filter = PIXMAN_FILTER_NEAREST;
-	common->filter_params = NULL;
-	common->n_filter_params = 0;
-	common->alpha_map = NULL;
-	common->component_alpha = FALSE;
-	common->ref_count = 1;
-	common->property_changed = NULL;
-	common->client_clip = FALSE;
-	common->destroy_func = NULL;
-	common->destroy_data = NULL;
-	common->dirty = TRUE;
-    }
-
-    return image;
-}
-
-static void
-image_property_changed (pixman_image_t *image)
-{
-    image->common.dirty = TRUE;
-}
-
-/* Ref Counting */
-PIXMAN_EXPORT pixman_image_t *
-pixman_image_ref (pixman_image_t *image)
-{
-    image->common.ref_count++;
-
-    return image;
-}
-
-/* returns TRUE when the image is freed */
-PIXMAN_EXPORT pixman_bool_t
-pixman_image_unref (pixman_image_t *image)
-{
-    image_common_t *common = (image_common_t *)image;
-
-    common->ref_count--;
-
-    if (common->ref_count == 0)
-    {
-	if (image->common.destroy_func)
-	    image->common.destroy_func (image, image->common.destroy_data);
-
-	pixman_region32_fini (&common->clip_region);
-
-	if (common->transform)
-	    free (common->transform);
-
-	if (common->filter_params)
-	    free (common->filter_params);
-
-	if (common->alpha_map)
-	    pixman_image_unref ((pixman_image_t *)common->alpha_map);
-
-	if (image->type == LINEAR ||
-	    image->type == RADIAL ||
-	    image->type == CONICAL)
-	{
-	    if (image->gradient.stops)
-		free (image->gradient.stops);
-	}
-
-	if (image->type == BITS && image->bits.free_me)
-	    free (image->bits.free_me);
-
-	free (image);
-
-	return TRUE;
-    }
-
-    return FALSE;
-}
-
-PIXMAN_EXPORT void
-pixman_image_set_destroy_function (pixman_image_t *            image,
-                                   pixman_image_destroy_func_t func,
-                                   void *                      data)
-{
-    image->common.destroy_func = func;
-    image->common.destroy_data = data;
-}
-
-PIXMAN_EXPORT void *
-pixman_image_get_destroy_data (pixman_image_t *image)
-{
-  return image->common.destroy_data;
-}
-
-void
-_pixman_image_reset_clip_region (pixman_image_t *image)
-{
-    image->common.have_clip_region = FALSE;
-}
-
-/* Executive Summary: This function is a no-op that only exists
- * for historical reasons.
- *
- * There used to be a bug in the X server where it would rely on
- * out-of-bounds accesses when it was asked to composite with a
- * window as the source. It would create a pixman image pointing
- * to some bogus position in memory, but then set a clip region
- * to the position where the actual bits were.
- *
- * Due to a bug in old versions of pixman, where it would not clip
- * against the image bounds when a clip region was set, this would
- * actually work. So when the pixman bug was fixed, a workaround was
- * added to allow certain out-of-bound accesses. This function disabled
- * those workarounds.
- *
- * Since 0.21.2, pixman doesn't do these workarounds anymore, so now
- * this function is a no-op.
- */
-PIXMAN_EXPORT void
-pixman_disable_out_of_bounds_workaround (void)
-{
-}
-
-static void
-compute_image_info (pixman_image_t *image)
-{
-    pixman_format_code_t code;
-    uint32_t flags = 0;
-
-    /* Transform */
-    if (!image->common.transform)
-    {
-	flags |= (FAST_PATH_ID_TRANSFORM	|
-		  FAST_PATH_X_UNIT_POSITIVE	|
-		  FAST_PATH_Y_UNIT_ZERO		|
-		  FAST_PATH_AFFINE_TRANSFORM);
-    }
-    else
-    {
-	flags |= FAST_PATH_HAS_TRANSFORM;
-
-	if (image->common.transform->matrix[2][0] == 0			&&
-	    image->common.transform->matrix[2][1] == 0			&&
-	    image->common.transform->matrix[2][2] == pixman_fixed_1)
-	{
-	    flags |= FAST_PATH_AFFINE_TRANSFORM;
-
-	    if (image->common.transform->matrix[0][1] == 0 &&
-		image->common.transform->matrix[1][0] == 0)
-	    {
-		flags |= FAST_PATH_SCALE_TRANSFORM;
-	    }
-	}
-
-	if (image->common.transform->matrix[0][0] > 0)
-	    flags |= FAST_PATH_X_UNIT_POSITIVE;
-
-	if (image->common.transform->matrix[1][0] == 0)
-	    flags |= FAST_PATH_Y_UNIT_ZERO;
-    }
-
-    /* Filter */
-    switch (image->common.filter)
-    {
-    case PIXMAN_FILTER_NEAREST:
-    case PIXMAN_FILTER_FAST:
-	flags |= (FAST_PATH_NEAREST_FILTER | FAST_PATH_NO_CONVOLUTION_FILTER);
-	break;
-
-    case PIXMAN_FILTER_BILINEAR:
-    case PIXMAN_FILTER_GOOD:
-    case PIXMAN_FILTER_BEST:
-	flags |= (FAST_PATH_BILINEAR_FILTER | FAST_PATH_NO_CONVOLUTION_FILTER);
-	break;
-
-    case PIXMAN_FILTER_CONVOLUTION:
-	break;
-
-    default:
-	flags |= FAST_PATH_NO_CONVOLUTION_FILTER;
-	break;
-    }
-
-    /* Repeat mode */
-    switch (image->common.repeat)
-    {
-    case PIXMAN_REPEAT_NONE:
-	flags |=
-	    FAST_PATH_NO_REFLECT_REPEAT		|
-	    FAST_PATH_NO_PAD_REPEAT		|
-	    FAST_PATH_NO_NORMAL_REPEAT;
-	break;
-
-    case PIXMAN_REPEAT_REFLECT:
-	flags |=
-	    FAST_PATH_NO_PAD_REPEAT		|
-	    FAST_PATH_NO_NONE_REPEAT		|
-	    FAST_PATH_NO_NORMAL_REPEAT;
-	break;
-
-    case PIXMAN_REPEAT_PAD:
-	flags |=
-	    FAST_PATH_NO_REFLECT_REPEAT		|
-	    FAST_PATH_NO_NONE_REPEAT		|
-	    FAST_PATH_NO_NORMAL_REPEAT;
-	break;
-
-    default:
-	flags |=
-	    FAST_PATH_NO_REFLECT_REPEAT		|
-	    FAST_PATH_NO_PAD_REPEAT		|
-	    FAST_PATH_NO_NONE_REPEAT;
-	break;
-    }
-
-    /* Component alpha */
-    if (image->common.component_alpha)
-	flags |= FAST_PATH_COMPONENT_ALPHA;
-    else
-	flags |= FAST_PATH_UNIFIED_ALPHA;
-
-    flags |= (FAST_PATH_NO_ACCESSORS | FAST_PATH_NARROW_FORMAT);
-
-    /* Type specific checks */
-    switch (image->type)
-    {
-    case SOLID:
-	code = PIXMAN_solid;
-
-	if (image->solid.color.alpha == 0xffff)
-	    flags |= FAST_PATH_IS_OPAQUE;
-	break;
-
-    case BITS:
-	if (image->bits.width == 1	&&
-	    image->bits.height == 1	&&
-	    image->common.repeat != PIXMAN_REPEAT_NONE)
-	{
-	    code = PIXMAN_solid;
-	}
-	else
-	{
-	    code = image->bits.format;
-	}
-
-	if (!PIXMAN_FORMAT_A (image->bits.format)				&&
-	    PIXMAN_FORMAT_TYPE (image->bits.format) != PIXMAN_TYPE_GRAY		&&
-	    PIXMAN_FORMAT_TYPE (image->bits.format) != PIXMAN_TYPE_COLOR)
-	{
-	    flags |= FAST_PATH_SAMPLES_OPAQUE;
-
-	    if (image->common.repeat != PIXMAN_REPEAT_NONE)
-		flags |= FAST_PATH_IS_OPAQUE;
-	}
-
-	if (image->bits.read_func || image->bits.write_func)
-	    flags &= ~FAST_PATH_NO_ACCESSORS;
-
-	if (PIXMAN_FORMAT_IS_WIDE (image->bits.format))
-	    flags &= ~FAST_PATH_NARROW_FORMAT;
-	break;
-
-    case RADIAL:
-	code = PIXMAN_unknown;
-
-	/*
-	 * As explained in pixman-radial-gradient.c, every point of
-	 * the plane has a valid associated radius (and thus will be
-	 * colored) if and only if a is negative (i.e. one of the two
-	 * circles contains the other one).
-	 */
-
-        if (image->radial.a >= 0)
-	    break;
-
-	/* Fall through */
-
-    case CONICAL:
-    case LINEAR:
-	code = PIXMAN_unknown;
-
-	if (image->common.repeat != PIXMAN_REPEAT_NONE)
-	{
-	    int i;
-
-	    flags |= FAST_PATH_IS_OPAQUE;
-	    for (i = 0; i < image->gradient.n_stops; ++i)
-	    {
-		if (image->gradient.stops[i].color.alpha != 0xffff)
-		{
-		    flags &= ~FAST_PATH_IS_OPAQUE;
-		    break;
-		}
-	    }
-	}
-	break;
-
-    default:
-	code = PIXMAN_unknown;
-	break;
-    }
-
-    /* Alpha map */
-    if (!image->common.alpha_map)
-    {
-	flags |= FAST_PATH_NO_ALPHA_MAP;
-    }
-    else
-    {
-	if (PIXMAN_FORMAT_IS_WIDE (image->common.alpha_map->format))
-	    flags &= ~FAST_PATH_NARROW_FORMAT;
-    }
-
-    /* Both alpha maps and convolution filters can introduce
-     * non-opaqueness in otherwise opaque images. Also
-     * an image with component alpha turned on is only opaque
-     * if all channels are opaque, so we simply turn it off
-     * unconditionally for those images.
-     */
-    if (image->common.alpha_map					||
-	image->common.filter == PIXMAN_FILTER_CONVOLUTION	||
-	image->common.component_alpha)
-    {
-	flags &= ~(FAST_PATH_IS_OPAQUE | FAST_PATH_SAMPLES_OPAQUE);
-    }
-
-    image->common.flags = flags;
-    image->common.extended_format_code = code;
-}
-
-void
-_pixman_image_validate (pixman_image_t *image)
-{
-    if (image->common.dirty)
-    {
-	compute_image_info (image);
-
-	/* It is important that property_changed is
-	 * called *after* compute_image_info() because
-	 * property_changed() can make use of the flags
-	 * to set up accessors etc.
-	 */
-	if (image->common.property_changed)
-	    image->common.property_changed (image);
-
-	image->common.dirty = FALSE;
-    }
-
-    if (image->common.alpha_map)
-	_pixman_image_validate ((pixman_image_t *)image->common.alpha_map);
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_image_set_clip_region32 (pixman_image_t *   image,
-                                pixman_region32_t *region)
-{
-    image_common_t *common = (image_common_t *)image;
-    pixman_bool_t result;
-
-    if (region)
-    {
-	if ((result = pixman_region32_copy (&common->clip_region, region)))
-	    image->common.have_clip_region = TRUE;
-    }
-    else
-    {
-	_pixman_image_reset_clip_region (image);
-
-	result = TRUE;
-    }
-
-    image_property_changed (image);
-
-    return result;
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_image_set_clip_region (pixman_image_t *   image,
-                              pixman_region16_t *region)
-{
-    image_common_t *common = (image_common_t *)image;
-    pixman_bool_t result;
-
-    if (region)
-    {
-	if ((result = pixman_region32_copy_from_region16 (&common->clip_region, region)))
-	    image->common.have_clip_region = TRUE;
-    }
-    else
-    {
-	_pixman_image_reset_clip_region (image);
-
-	result = TRUE;
-    }
-
-    image_property_changed (image);
-
-    return result;
-}
-
-PIXMAN_EXPORT void
-pixman_image_set_has_client_clip (pixman_image_t *image,
-                                  pixman_bool_t   client_clip)
-{
-    image->common.client_clip = client_clip;
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_image_set_transform (pixman_image_t *          image,
-                            const pixman_transform_t *transform)
-{
-    static const pixman_transform_t id =
-    {
-	{ { pixman_fixed_1, 0, 0 },
-	  { 0, pixman_fixed_1, 0 },
-	  { 0, 0, pixman_fixed_1 } }
-    };
-
-    image_common_t *common = (image_common_t *)image;
-    pixman_bool_t result;
-
-    if (common->transform == transform)
-	return TRUE;
-
-    if (memcmp (&id, transform, sizeof (pixman_transform_t)) == 0)
-    {
-	free (common->transform);
-	common->transform = NULL;
-	result = TRUE;
-
-	goto out;
-    }
-
-    if (common->transform == NULL)
-	common->transform = malloc (sizeof (pixman_transform_t));
-
-    if (common->transform == NULL)
-    {
-	result = FALSE;
-
-	goto out;
-    }
-
-    memcpy (common->transform, transform, sizeof(pixman_transform_t));
-
-    result = TRUE;
-
-out:
-    image_property_changed (image);
-
-    return result;
-}
-
-PIXMAN_EXPORT void
-pixman_image_set_repeat (pixman_image_t *image,
-                         pixman_repeat_t repeat)
-{
-    image->common.repeat = repeat;
-
-    image_property_changed (image);
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_image_set_filter (pixman_image_t *      image,
-                         pixman_filter_t       filter,
-                         const pixman_fixed_t *params,
-                         int                   n_params)
-{
-    image_common_t *common = (image_common_t *)image;
-    pixman_fixed_t *new_params;
-
-    if (params == common->filter_params && filter == common->filter)
-	return TRUE;
-
-    new_params = NULL;
-    if (params)
-    {
-	new_params = pixman_malloc_ab (n_params, sizeof (pixman_fixed_t));
-	if (!new_params)
-	    return FALSE;
-
-	memcpy (new_params,
-	        params, n_params * sizeof (pixman_fixed_t));
-    }
-
-    common->filter = filter;
-
-    if (common->filter_params)
-	free (common->filter_params);
-
-    common->filter_params = new_params;
-    common->n_filter_params = n_params;
-
-    image_property_changed (image);
-    return TRUE;
-}
-
-PIXMAN_EXPORT void
-pixman_image_set_source_clipping (pixman_image_t *image,
-                                  pixman_bool_t   clip_sources)
-{
-    image->common.clip_sources = clip_sources;
-
-    image_property_changed (image);
-}
-
-/* Unlike all the other property setters, this function does not
- * copy the content of indexed. Doing this copying is simply
- * way, way too expensive.
- */
-PIXMAN_EXPORT void
-pixman_image_set_indexed (pixman_image_t *        image,
-                          const pixman_indexed_t *indexed)
-{
-    bits_image_t *bits = (bits_image_t *)image;
-
-    bits->indexed = indexed;
-
-    image_property_changed (image);
-}
-
-PIXMAN_EXPORT void
-pixman_image_set_alpha_map (pixman_image_t *image,
-                            pixman_image_t *alpha_map,
-                            int16_t         x,
-                            int16_t         y)
-{
-    image_common_t *common = (image_common_t *)image;
-
-    return_if_fail (!alpha_map || alpha_map->type == BITS);
-
-    if (alpha_map && common->alpha_count > 0)
-    {
-	/* If this image is being used as an alpha map itself,
-	 * then you can't give it an alpha map of its own.
-	 */
-	return;
-    }
-
-    if (alpha_map && alpha_map->common.alpha_map)
-    {
-	/* If the image has an alpha map of its own,
-	 * then it can't be used as an alpha map itself
-	 */
-	return;
-    }
-
-    if (common->alpha_map != (bits_image_t *)alpha_map)
-    {
-	if (common->alpha_map)
-	{
-	    common->alpha_map->common.alpha_count--;
-
-	    pixman_image_unref ((pixman_image_t *)common->alpha_map);
-	}
-
-	if (alpha_map)
-	{
-	    common->alpha_map = (bits_image_t *)pixman_image_ref (alpha_map);
-
-	    common->alpha_map->common.alpha_count++;
-	}
-	else
-	{
-	    common->alpha_map = NULL;
-	}
-    }
-
-    common->alpha_origin_x = x;
-    common->alpha_origin_y = y;
-
-    image_property_changed (image);
-}
-
-PIXMAN_EXPORT void
-pixman_image_set_component_alpha   (pixman_image_t *image,
-                                    pixman_bool_t   component_alpha)
-{
-    image->common.component_alpha = component_alpha;
-
-    image_property_changed (image);
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_image_get_component_alpha   (pixman_image_t       *image)
-{
-    return image->common.component_alpha;
-}
-
-PIXMAN_EXPORT void
-pixman_image_set_accessors (pixman_image_t *           image,
-                            pixman_read_memory_func_t  read_func,
-                            pixman_write_memory_func_t write_func)
-{
-    return_if_fail (image != NULL);
-
-    if (image->type == BITS)
-    {
-	image->bits.read_func = read_func;
-	image->bits.write_func = write_func;
-
-	image_property_changed (image);
-    }
-}
-
-PIXMAN_EXPORT uint32_t *
-pixman_image_get_data (pixman_image_t *image)
-{
-    if (image->type == BITS)
-	return image->bits.bits;
-
-    return NULL;
-}
-
-PIXMAN_EXPORT int
-pixman_image_get_width (pixman_image_t *image)
-{
-    if (image->type == BITS)
-	return image->bits.width;
-
-    return 0;
-}
-
-PIXMAN_EXPORT int
-pixman_image_get_height (pixman_image_t *image)
-{
-    if (image->type == BITS)
-	return image->bits.height;
-
-    return 0;
-}
-
-PIXMAN_EXPORT int
-pixman_image_get_stride (pixman_image_t *image)
-{
-    if (image->type == BITS)
-	return image->bits.rowstride * (int) sizeof (uint32_t);
-
-    return 0;
-}
-
-PIXMAN_EXPORT int
-pixman_image_get_depth (pixman_image_t *image)
-{
-    if (image->type == BITS)
-	return PIXMAN_FORMAT_DEPTH (image->bits.format);
-
-    return 0;
-}
-
-PIXMAN_EXPORT pixman_format_code_t
-pixman_image_get_format (pixman_image_t *image)
-{
-    if (image->type == BITS)
-	return image->bits.format;
-
-    return 0;
-}
-
-uint32_t
-_pixman_image_get_solid (pixman_implementation_t *imp,
-			 pixman_image_t *         image,
-                         pixman_format_code_t     format)
-{
-    uint32_t result;
-    pixman_iter_t iter;
-
-    _pixman_implementation_src_iter_init (
-	imp, &iter, image, 0, 0, 1, 1,
-	(uint8_t *)&result, ITER_NARROW);
-
-    result = *iter.get_scanline (&iter, NULL);
-
-    /* If necessary, convert RGB <--> BGR. */
-    if (PIXMAN_FORMAT_TYPE (format) != PIXMAN_TYPE_ARGB)
-    {
-	result = (((result & 0xff000000) >>  0) |
-	          ((result & 0x00ff0000) >> 16) |
-	          ((result & 0x0000ff00) >>  0) |
-	          ((result & 0x000000ff) << 16));
-    }
-
-    return result;
-}
+/*

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

+ */

+

+#ifdef HAVE_CONFIG_H

+#include <config.h>

+#endif

+

+#include <stdlib.h>

+#include <stdio.h>

+#include <string.h>

+#include <assert.h>

+

+#include "pixman-private.h"

+#include "pixman-combine32.h"

+

+pixman_bool_t

+_pixman_init_gradient (gradient_t *                  gradient,

+                       const pixman_gradient_stop_t *stops,

+                       int                           n_stops)

+{

+    return_val_if_fail (n_stops > 0, FALSE);

+

+    gradient->stops = pixman_malloc_ab (n_stops, sizeof (pixman_gradient_stop_t));

+    if (!gradient->stops)

+	return FALSE;

+

+    memcpy (gradient->stops, stops, n_stops * sizeof (pixman_gradient_stop_t));

+

+    gradient->n_stops = n_stops;

+

+    return TRUE;

+}

+

+pixman_image_t *

+_pixman_image_allocate (void)

+{

+    pixman_image_t *image = malloc (sizeof (pixman_image_t));

+

+    if (image)

+    {

+	image_common_t *common = &image->common;

+

+	pixman_region32_init (&common->clip_region);

+

+	common->alpha_count = 0;

+	common->have_clip_region = FALSE;

+	common->clip_sources = FALSE;

+	common->transform = NULL;

+	common->repeat = PIXMAN_REPEAT_NONE;

+	common->filter = PIXMAN_FILTER_NEAREST;

+	common->filter_params = NULL;

+	common->n_filter_params = 0;

+	common->alpha_map = NULL;

+	common->component_alpha = FALSE;

+	common->ref_count = 1;

+	common->property_changed = NULL;

+	common->client_clip = FALSE;

+	common->destroy_func = NULL;

+	common->destroy_data = NULL;

+	common->dirty = TRUE;

+    }

+

+    return image;

+}

+

+static void

+image_property_changed (pixman_image_t *image)

+{

+    image->common.dirty = TRUE;

+}

+

+/* Ref Counting */

+PIXMAN_EXPORT pixman_image_t *

+pixman_image_ref (pixman_image_t *image)

+{

+    image->common.ref_count++;

+

+    return image;

+}

+

+/* returns TRUE when the image is freed */

+PIXMAN_EXPORT pixman_bool_t

+pixman_image_unref (pixman_image_t *image)

+{

+    image_common_t *common = (image_common_t *)image;

+

+    common->ref_count--;

+

+    if (common->ref_count == 0)

+    {

+	if (image->common.destroy_func)

+	    image->common.destroy_func (image, image->common.destroy_data);

+

+	pixman_region32_fini (&common->clip_region);

+

+	if (common->transform)

+	    free (common->transform);

+

+	if (common->filter_params)

+	    free (common->filter_params);

+

+	if (common->alpha_map)

+	    pixman_image_unref ((pixman_image_t *)common->alpha_map);

+

+	if (image->type == LINEAR ||

+	    image->type == RADIAL ||

+	    image->type == CONICAL)

+	{

+	    if (image->gradient.stops)

+		free (image->gradient.stops);

+	}

+

+	if (image->type == BITS && image->bits.free_me)

+	    free (image->bits.free_me);

+

+	free (image);

+

+	return TRUE;

+    }

+

+    return FALSE;

+}

+

+PIXMAN_EXPORT void

+pixman_image_set_destroy_function (pixman_image_t *            image,

+                                   pixman_image_destroy_func_t func,

+                                   void *                      data)

+{

+    image->common.destroy_func = func;

+    image->common.destroy_data = data;

+}

+

+PIXMAN_EXPORT void *

+pixman_image_get_destroy_data (pixman_image_t *image)

+{

+  return image->common.destroy_data;

+}

+

+void

+_pixman_image_reset_clip_region (pixman_image_t *image)

+{

+    image->common.have_clip_region = FALSE;

+}

+

+/* Executive Summary: This function is a no-op that only exists

+ * for historical reasons.

+ *

+ * There used to be a bug in the X server where it would rely on

+ * out-of-bounds accesses when it was asked to composite with a

+ * window as the source. It would create a pixman image pointing

+ * to some bogus position in memory, but then set a clip region

+ * to the position where the actual bits were.

+ *

+ * Due to a bug in old versions of pixman, where it would not clip

+ * against the image bounds when a clip region was set, this would

+ * actually work. So when the pixman bug was fixed, a workaround was

+ * added to allow certain out-of-bound accesses. This function disabled

+ * those workarounds.

+ *

+ * Since 0.21.2, pixman doesn't do these workarounds anymore, so now

+ * this function is a no-op.

+ */

+PIXMAN_EXPORT void

+pixman_disable_out_of_bounds_workaround (void)

+{

+}

+

+static void

+compute_image_info (pixman_image_t *image)

+{

+    pixman_format_code_t code;

+    uint32_t flags = 0;

+

+    /* Transform */

+    if (!image->common.transform)

+    {

+	flags |= (FAST_PATH_ID_TRANSFORM	|

+		  FAST_PATH_X_UNIT_POSITIVE	|

+		  FAST_PATH_Y_UNIT_ZERO		|

+		  FAST_PATH_AFFINE_TRANSFORM);

+    }

+    else

+    {

+	flags |= FAST_PATH_HAS_TRANSFORM;

+

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

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

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

+	{

+	    flags |= FAST_PATH_AFFINE_TRANSFORM;

+

+	    if (image->common.transform->matrix[0][1] == 0 &&

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

+	    {

+		if (image->common.transform->matrix[0][0] == -pixman_fixed_1 &&

+		    image->common.transform->matrix[1][1] == -pixman_fixed_1)

+		{

+		    flags |= FAST_PATH_ROTATE_180_TRANSFORM;

+		}

+		flags |= FAST_PATH_SCALE_TRANSFORM;

+	    }

+	    else if (image->common.transform->matrix[0][0] == 0 &&

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

+	    {

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

+		if (m01 == -image->common.transform->matrix[1][0])

+		{

+			if (m01 == -pixman_fixed_1)

+			    flags |= FAST_PATH_ROTATE_90_TRANSFORM;

+			else if (m01 == pixman_fixed_1)

+			    flags |= FAST_PATH_ROTATE_270_TRANSFORM;

+		}

+	    }

+	}

+

+	if (image->common.transform->matrix[0][0] > 0)

+	    flags |= FAST_PATH_X_UNIT_POSITIVE;

+

+	if (image->common.transform->matrix[1][0] == 0)

+	    flags |= FAST_PATH_Y_UNIT_ZERO;

+    }

+

+    /* Filter */

+    switch (image->common.filter)

+    {

+    case PIXMAN_FILTER_NEAREST:

+    case PIXMAN_FILTER_FAST:

+	flags |= (FAST_PATH_NEAREST_FILTER | FAST_PATH_NO_CONVOLUTION_FILTER);

+	break;

+

+    case PIXMAN_FILTER_BILINEAR:

+    case PIXMAN_FILTER_GOOD:

+    case PIXMAN_FILTER_BEST:

+	flags |= (FAST_PATH_BILINEAR_FILTER | FAST_PATH_NO_CONVOLUTION_FILTER);

+	break;

+

+    case PIXMAN_FILTER_CONVOLUTION:

+	break;

+

+    default:

+	flags |= FAST_PATH_NO_CONVOLUTION_FILTER;

+	break;

+    }

+

+    /* Repeat mode */

+    switch (image->common.repeat)

+    {

+    case PIXMAN_REPEAT_NONE:

+	flags |=

+	    FAST_PATH_NO_REFLECT_REPEAT		|

+	    FAST_PATH_NO_PAD_REPEAT		|

+	    FAST_PATH_NO_NORMAL_REPEAT;

+	break;

+

+    case PIXMAN_REPEAT_REFLECT:

+	flags |=

+	    FAST_PATH_NO_PAD_REPEAT		|

+	    FAST_PATH_NO_NONE_REPEAT		|

+	    FAST_PATH_NO_NORMAL_REPEAT;

+	break;

+

+    case PIXMAN_REPEAT_PAD:

+	flags |=

+	    FAST_PATH_NO_REFLECT_REPEAT		|

+	    FAST_PATH_NO_NONE_REPEAT		|

+	    FAST_PATH_NO_NORMAL_REPEAT;

+	break;

+

+    default:

+	flags |=

+	    FAST_PATH_NO_REFLECT_REPEAT		|

+	    FAST_PATH_NO_PAD_REPEAT		|

+	    FAST_PATH_NO_NONE_REPEAT;

+	break;

+    }

+

+    /* Component alpha */

+    if (image->common.component_alpha)

+	flags |= FAST_PATH_COMPONENT_ALPHA;

+    else

+	flags |= FAST_PATH_UNIFIED_ALPHA;

+

+    flags |= (FAST_PATH_NO_ACCESSORS | FAST_PATH_NARROW_FORMAT);

+

+    /* Type specific checks */

+    switch (image->type)

+    {

+    case SOLID:

+	code = PIXMAN_solid;

+

+	if (image->solid.color.alpha == 0xffff)

+	    flags |= FAST_PATH_IS_OPAQUE;

+	break;

+

+    case BITS:

+	if (image->bits.width == 1	&&

+	    image->bits.height == 1	&&

+	    image->common.repeat != PIXMAN_REPEAT_NONE)

+	{

+	    code = PIXMAN_solid;

+	}

+	else

+	{

+	    code = image->bits.format;

+	}

+

+	if (!PIXMAN_FORMAT_A (image->bits.format)				&&

+	    PIXMAN_FORMAT_TYPE (image->bits.format) != PIXMAN_TYPE_GRAY		&&

+	    PIXMAN_FORMAT_TYPE (image->bits.format) != PIXMAN_TYPE_COLOR)

+	{

+	    flags |= FAST_PATH_SAMPLES_OPAQUE;

+

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

+		flags |= FAST_PATH_IS_OPAQUE;

+	}

+

+	if (image->bits.read_func || image->bits.write_func)

+	    flags &= ~FAST_PATH_NO_ACCESSORS;

+

+	if (PIXMAN_FORMAT_IS_WIDE (image->bits.format))

+	    flags &= ~FAST_PATH_NARROW_FORMAT;

+	break;

+

+    case RADIAL:

+	code = PIXMAN_unknown;

+

+	/*

+	 * As explained in pixman-radial-gradient.c, every point of

+	 * the plane has a valid associated radius (and thus will be

+	 * colored) if and only if a is negative (i.e. one of the two

+	 * circles contains the other one).

+	 */

+

+        if (image->radial.a >= 0)

+	    break;

+

+	/* Fall through */

+

+    case CONICAL:

+    case LINEAR:

+	code = PIXMAN_unknown;

+

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

+	{

+	    int i;

+

+	    flags |= FAST_PATH_IS_OPAQUE;

+	    for (i = 0; i < image->gradient.n_stops; ++i)

+	    {

+		if (image->gradient.stops[i].color.alpha != 0xffff)

+		{

+		    flags &= ~FAST_PATH_IS_OPAQUE;

+		    break;

+		}

+	    }

+	}

+	break;

+

+    default:

+	code = PIXMAN_unknown;

+	break;

+    }

+

+    /* Alpha map */

+    if (!image->common.alpha_map)

+    {

+	flags |= FAST_PATH_NO_ALPHA_MAP;

+    }

+    else

+    {

+	if (PIXMAN_FORMAT_IS_WIDE (image->common.alpha_map->format))

+	    flags &= ~FAST_PATH_NARROW_FORMAT;

+    }

+

+    /* Both alpha maps and convolution filters can introduce

+     * non-opaqueness in otherwise opaque images. Also

+     * an image with component alpha turned on is only opaque

+     * if all channels are opaque, so we simply turn it off

+     * unconditionally for those images.

+     */

+    if (image->common.alpha_map					||

+	image->common.filter == PIXMAN_FILTER_CONVOLUTION	||

+	image->common.component_alpha)

+    {

+	flags &= ~(FAST_PATH_IS_OPAQUE | FAST_PATH_SAMPLES_OPAQUE);

+    }

+

+    image->common.flags = flags;

+    image->common.extended_format_code = code;

+}

+

+void

+_pixman_image_validate (pixman_image_t *image)

+{

+    if (image->common.dirty)

+    {

+	compute_image_info (image);

+

+	/* It is important that property_changed is

+	 * called *after* compute_image_info() because

+	 * property_changed() can make use of the flags

+	 * to set up accessors etc.

+	 */

+	if (image->common.property_changed)

+	    image->common.property_changed (image);

+

+	image->common.dirty = FALSE;

+    }

+

+    if (image->common.alpha_map)

+	_pixman_image_validate ((pixman_image_t *)image->common.alpha_map);

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_image_set_clip_region32 (pixman_image_t *   image,

+                                pixman_region32_t *region)

+{

+    image_common_t *common = (image_common_t *)image;

+    pixman_bool_t result;

+

+    if (region)

+    {

+	if ((result = pixman_region32_copy (&common->clip_region, region)))

+	    image->common.have_clip_region = TRUE;

+    }

+    else

+    {

+	_pixman_image_reset_clip_region (image);

+

+	result = TRUE;

+    }

+

+    image_property_changed (image);

+

+    return result;

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_image_set_clip_region (pixman_image_t *   image,

+                              pixman_region16_t *region)

+{

+    image_common_t *common = (image_common_t *)image;

+    pixman_bool_t result;

+

+    if (region)

+    {

+	if ((result = pixman_region32_copy_from_region16 (&common->clip_region, region)))

+	    image->common.have_clip_region = TRUE;

+    }

+    else

+    {

+	_pixman_image_reset_clip_region (image);

+

+	result = TRUE;

+    }

+

+    image_property_changed (image);

+

+    return result;

+}

+

+PIXMAN_EXPORT void

+pixman_image_set_has_client_clip (pixman_image_t *image,

+                                  pixman_bool_t   client_clip)

+{

+    image->common.client_clip = client_clip;

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_image_set_transform (pixman_image_t *          image,

+                            const pixman_transform_t *transform)

+{

+    static const pixman_transform_t id =

+    {

+	{ { pixman_fixed_1, 0, 0 },

+	  { 0, pixman_fixed_1, 0 },

+	  { 0, 0, pixman_fixed_1 } }

+    };

+

+    image_common_t *common = (image_common_t *)image;

+    pixman_bool_t result;

+

+    if (common->transform == transform)

+	return TRUE;

+

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

+    {

+	free (common->transform);

+	common->transform = NULL;

+	result = TRUE;

+

+	goto out;

+    }

+

+    if (common->transform == NULL)

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

+

+    if (common->transform == NULL)

+    {

+	result = FALSE;

+

+	goto out;

+    }

+

+    memcpy (common->transform, transform, sizeof(pixman_transform_t));

+

+    result = TRUE;

+

+out:

+    image_property_changed (image);

+

+    return result;

+}

+

+PIXMAN_EXPORT void

+pixman_image_set_repeat (pixman_image_t *image,

+                         pixman_repeat_t repeat)

+{

+    image->common.repeat = repeat;

+

+    image_property_changed (image);

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_image_set_filter (pixman_image_t *      image,

+                         pixman_filter_t       filter,

+                         const pixman_fixed_t *params,

+                         int                   n_params)

+{

+    image_common_t *common = (image_common_t *)image;

+    pixman_fixed_t *new_params;

+

+    if (params == common->filter_params && filter == common->filter)

+	return TRUE;

+

+    new_params = NULL;

+    if (params)

+    {

+	new_params = pixman_malloc_ab (n_params, sizeof (pixman_fixed_t));

+	if (!new_params)

+	    return FALSE;

+

+	memcpy (new_params,

+	        params, n_params * sizeof (pixman_fixed_t));

+    }

+

+    common->filter = filter;

+

+    if (common->filter_params)

+	free (common->filter_params);

+

+    common->filter_params = new_params;

+    common->n_filter_params = n_params;

+

+    image_property_changed (image);

+    return TRUE;

+}

+

+PIXMAN_EXPORT void

+pixman_image_set_source_clipping (pixman_image_t *image,

+                                  pixman_bool_t   clip_sources)

+{

+    image->common.clip_sources = clip_sources;

+

+    image_property_changed (image);

+}

+

+/* Unlike all the other property setters, this function does not

+ * copy the content of indexed. Doing this copying is simply

+ * way, way too expensive.

+ */

+PIXMAN_EXPORT void

+pixman_image_set_indexed (pixman_image_t *        image,

+                          const pixman_indexed_t *indexed)

+{

+    bits_image_t *bits = (bits_image_t *)image;

+

+    bits->indexed = indexed;

+

+    image_property_changed (image);

+}

+

+PIXMAN_EXPORT void

+pixman_image_set_alpha_map (pixman_image_t *image,

+                            pixman_image_t *alpha_map,

+                            int16_t         x,

+                            int16_t         y)

+{

+    image_common_t *common = (image_common_t *)image;

+

+    return_if_fail (!alpha_map || alpha_map->type == BITS);

+

+    if (alpha_map && common->alpha_count > 0)

+    {

+	/* If this image is being used as an alpha map itself,

+	 * then you can't give it an alpha map of its own.

+	 */

+	return;

+    }

+

+    if (alpha_map && alpha_map->common.alpha_map)

+    {

+	/* If the image has an alpha map of its own,

+	 * then it can't be used as an alpha map itself

+	 */

+	return;

+    }

+

+    if (common->alpha_map != (bits_image_t *)alpha_map)

+    {

+	if (common->alpha_map)

+	{

+	    common->alpha_map->common.alpha_count--;

+

+	    pixman_image_unref ((pixman_image_t *)common->alpha_map);

+	}

+

+	if (alpha_map)

+	{

+	    common->alpha_map = (bits_image_t *)pixman_image_ref (alpha_map);

+

+	    common->alpha_map->common.alpha_count++;

+	}

+	else

+	{

+	    common->alpha_map = NULL;

+	}

+    }

+

+    common->alpha_origin_x = x;

+    common->alpha_origin_y = y;

+

+    image_property_changed (image);

+}

+

+PIXMAN_EXPORT void

+pixman_image_set_component_alpha   (pixman_image_t *image,

+                                    pixman_bool_t   component_alpha)

+{

+    image->common.component_alpha = component_alpha;

+

+    image_property_changed (image);

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_image_get_component_alpha   (pixman_image_t       *image)

+{

+    return image->common.component_alpha;

+}

+

+PIXMAN_EXPORT void

+pixman_image_set_accessors (pixman_image_t *           image,

+                            pixman_read_memory_func_t  read_func,

+                            pixman_write_memory_func_t write_func)

+{

+    return_if_fail (image != NULL);

+

+    if (image->type == BITS)

+    {

+	image->bits.read_func = read_func;

+	image->bits.write_func = write_func;

+

+	image_property_changed (image);

+    }

+}

+

+PIXMAN_EXPORT uint32_t *

+pixman_image_get_data (pixman_image_t *image)

+{

+    if (image->type == BITS)

+	return image->bits.bits;

+

+    return NULL;

+}

+

+PIXMAN_EXPORT int

+pixman_image_get_width (pixman_image_t *image)

+{

+    if (image->type == BITS)

+	return image->bits.width;

+

+    return 0;

+}

+

+PIXMAN_EXPORT int

+pixman_image_get_height (pixman_image_t *image)

+{

+    if (image->type == BITS)

+	return image->bits.height;

+

+    return 0;

+}

+

+PIXMAN_EXPORT int

+pixman_image_get_stride (pixman_image_t *image)

+{

+    if (image->type == BITS)

+	return image->bits.rowstride * (int) sizeof (uint32_t);

+

+    return 0;

+}

+

+PIXMAN_EXPORT int

+pixman_image_get_depth (pixman_image_t *image)

+{

+    if (image->type == BITS)

+	return PIXMAN_FORMAT_DEPTH (image->bits.format);

+

+    return 0;

+}

+

+PIXMAN_EXPORT pixman_format_code_t

+pixman_image_get_format (pixman_image_t *image)

+{

+    if (image->type == BITS)

+	return image->bits.format;

+

+    return 0;

+}

+

+uint32_t

+_pixman_image_get_solid (pixman_implementation_t *imp,

+			 pixman_image_t *         image,

+                         pixman_format_code_t     format)

+{

+    uint32_t result;

+    pixman_iter_t iter;

+

+    _pixman_implementation_src_iter_init (

+	imp, &iter, image, 0, 0, 1, 1,

+	(uint8_t *)&result, ITER_NARROW);

+

+    result = *iter.get_scanline (&iter, NULL);

+

+    /* If necessary, convert RGB <--> BGR. */

+    if (PIXMAN_FORMAT_TYPE (format) != PIXMAN_TYPE_ARGB)

+    {

+	result = (((result & 0xff000000) >>  0) |

+	          ((result & 0x00ff0000) >> 16) |

+	          ((result & 0x0000ff00) >>  0) |

+	          ((result & 0x000000ff) << 16));

+    }

+

+    return result;

+}

diff --git a/pixman/pixman/pixman-private.h b/pixman/pixman/pixman-private.h
index f5d0ba165..ee7f4d676 100644
--- a/pixman/pixman/pixman-private.h
+++ b/pixman/pixman/pixman-private.h
@@ -1,918 +1,921 @@
-#ifndef PACKAGE
-#  error config.h must be included before pixman-private.h
-#endif
-
-#ifndef PIXMAN_PRIVATE_H
-#define PIXMAN_PRIVATE_H
-
-#define PIXMAN_DISABLE_DEPRECATED
-#define PIXMAN_USE_INTERNAL_API
-
-#include "pixman.h"
-#include <time.h>
-#include <assert.h>
-#include <stdio.h>
-#include <string.h>
-
-#include "pixman-compiler.h"
-
-/*
- * Images
- */
-typedef struct image_common image_common_t;
-typedef struct solid_fill solid_fill_t;
-typedef struct gradient gradient_t;
-typedef struct linear_gradient linear_gradient_t;
-typedef struct horizontal_gradient horizontal_gradient_t;
-typedef struct vertical_gradient vertical_gradient_t;
-typedef struct conical_gradient conical_gradient_t;
-typedef struct radial_gradient radial_gradient_t;
-typedef struct bits_image bits_image_t;
-typedef struct circle circle_t;
-
-typedef void (*fetch_scanline_t) (pixman_image_t *image,
-				  int             x,
-				  int             y,
-				  int             width,
-				  uint32_t       *buffer,
-				  const uint32_t *mask);
-
-typedef uint32_t (*fetch_pixel_32_t) (bits_image_t *image,
-				      int           x,
-				      int           y);
-
-typedef uint64_t (*fetch_pixel_64_t) (bits_image_t *image,
-				      int           x,
-				      int           y);
-
-typedef void (*store_scanline_t) (bits_image_t *  image,
-				  int             x,
-				  int             y,
-				  int             width,
-				  const uint32_t *values);
-
-typedef enum
-{
-    BITS,
-    LINEAR,
-    CONICAL,
-    RADIAL,
-    SOLID
-} image_type_t;
-
-typedef void (*property_changed_func_t) (pixman_image_t *image);
-
-struct image_common
-{
-    image_type_t                type;
-    int32_t                     ref_count;
-    pixman_region32_t           clip_region;
-    int32_t			alpha_count;	    /* How many times this image is being used as an alpha map */
-    pixman_bool_t               have_clip_region;   /* FALSE if there is no clip */
-    pixman_bool_t               client_clip;        /* Whether the source clip was
-						       set by a client */
-    pixman_bool_t               clip_sources;       /* Whether the clip applies when
-						     * the image is used as a source
-						     */
-    pixman_bool_t		dirty;
-    pixman_transform_t *        transform;
-    pixman_repeat_t             repeat;
-    pixman_filter_t             filter;
-    pixman_fixed_t *            filter_params;
-    int                         n_filter_params;
-    bits_image_t *              alpha_map;
-    int                         alpha_origin_x;
-    int                         alpha_origin_y;
-    pixman_bool_t               component_alpha;
-    property_changed_func_t     property_changed;
-
-    pixman_image_destroy_func_t destroy_func;
-    void *                      destroy_data;
-
-    uint32_t			flags;
-    pixman_format_code_t	extended_format_code;
-};
-
-struct solid_fill
-{
-    image_common_t common;
-    pixman_color_t color;
-    
-    uint32_t	   color_32;
-    uint64_t	   color_64;
-};
-
-struct gradient
-{
-    image_common_t	    common;
-    int                     n_stops;
-    pixman_gradient_stop_t *stops;
-};
-
-struct linear_gradient
-{
-    gradient_t           common;
-    pixman_point_fixed_t p1;
-    pixman_point_fixed_t p2;
-};
-
-struct circle
-{
-    pixman_fixed_t x;
-    pixman_fixed_t y;
-    pixman_fixed_t radius;
-};
-
-struct radial_gradient
-{
-    gradient_t common;
-
-    circle_t   c1;
-    circle_t   c2;
-
-    circle_t   delta;
-    double     a;
-    double     inva;
-    double     mindr;
-};
-
-struct conical_gradient
-{
-    gradient_t           common;
-    pixman_point_fixed_t center;
-    double		 angle;
-};
-
-struct bits_image
-{
-    image_common_t             common;
-    pixman_format_code_t       format;
-    const pixman_indexed_t *   indexed;
-    int                        width;
-    int                        height;
-    uint32_t *                 bits;
-    uint32_t *                 free_me;
-    int                        rowstride;  /* in number of uint32_t's */
-
-    fetch_scanline_t           get_scanline_32;
-    fetch_scanline_t           get_scanline_64;
-
-    fetch_scanline_t           fetch_scanline_32;
-    fetch_pixel_32_t	       fetch_pixel_32;
-    store_scanline_t           store_scanline_32;
-
-    fetch_scanline_t           fetch_scanline_64;
-    fetch_pixel_64_t	       fetch_pixel_64;
-    store_scanline_t           store_scanline_64;
-
-    /* Used for indirect access to the bits */
-    pixman_read_memory_func_t  read_func;
-    pixman_write_memory_func_t write_func;
-};
-
-union pixman_image
-{
-    image_type_t       type;
-    image_common_t     common;
-    bits_image_t       bits;
-    gradient_t         gradient;
-    linear_gradient_t  linear;
-    conical_gradient_t conical;
-    radial_gradient_t  radial;
-    solid_fill_t       solid;
-};
-
-typedef struct pixman_iter_t pixman_iter_t;
-typedef uint32_t *(* pixman_iter_get_scanline_t) (pixman_iter_t *iter, const uint32_t *mask);
-typedef void      (* pixman_iter_write_back_t)   (pixman_iter_t *iter);
-
-typedef enum
-{
-    ITER_NARROW =		(1 << 0),
-
-    /* "Localized alpha" is when the alpha channel is used only to compute
-     * the alpha value of the destination. This means that the computation
-     * of the RGB values of the result is independent of the alpha value.
-     *
-     * For example, the OVER operator has localized alpha for the
-     * destination, because the RGB values of the result can be computed
-     * without knowing the destination alpha. Similarly, ADD has localized
-     * alpha for both source and destination because the RGB values of the
-     * result can be computed without knowing the alpha value of source or
-     * destination.
-     *
-     * When he destination is xRGB, this is useful knowledge, because then
-     * we can treat it as if it were ARGB, which means in some cases we can
-     * avoid copying it to a temporary buffer.
-     */
-    ITER_LOCALIZED_ALPHA =	(1 << 1),
-    ITER_IGNORE_ALPHA =		(1 << 2),
-    ITER_IGNORE_RGB =		(1 << 3)
-} iter_flags_t;
-
-struct pixman_iter_t
-{
-    pixman_iter_get_scanline_t	get_scanline;
-    pixman_iter_write_back_t	write_back;
-
-    pixman_image_t *		image;
-    uint32_t *			buffer;
-    int				x, y;
-    int				width;
-
-    uint8_t *			bits;
-    int				stride;
-};
-
-void
-_pixman_bits_image_setup_accessors (bits_image_t *image);
-
-void
-_pixman_bits_image_src_iter_init (pixman_image_t *image,
-				  pixman_iter_t *iter,
-				  int x, int y, int width, int height,
-				  uint8_t *buffer, iter_flags_t flags);
-void
-_pixman_bits_image_dest_iter_init (pixman_image_t *image,
-				   pixman_iter_t *iter,
-				   int x, int y, int width, int height,
-				   uint8_t *buffer, iter_flags_t flags);
-
-void
-_pixman_solid_fill_iter_init (pixman_image_t *image,
-			      pixman_iter_t  *iter,
-			      int x, int y, int width, int height,
-			      uint8_t *buffer, iter_flags_t flags);
-
-void
-_pixman_linear_gradient_iter_init (pixman_image_t *image,
-				   pixman_iter_t  *iter,
-				   int x, int y, int width, int height,
-				   uint8_t *buffer, iter_flags_t flags);
-
-void
-_pixman_radial_gradient_iter_init (pixman_image_t *image,
-				   pixman_iter_t *iter,
-				   int x, int y, int width, int height,
-				   uint8_t *buffer, iter_flags_t flags);
-
-void
-_pixman_conical_gradient_iter_init (pixman_image_t *image,
-				    pixman_iter_t *iter,
-				    int x, int y, int width, int height,
-				    uint8_t *buffer, iter_flags_t flags);
-
-pixman_image_t *
-_pixman_image_allocate (void);
-
-pixman_bool_t
-_pixman_init_gradient (gradient_t *                  gradient,
-                       const pixman_gradient_stop_t *stops,
-                       int                           n_stops);
-void
-_pixman_image_reset_clip_region (pixman_image_t *image);
-
-void
-_pixman_image_validate (pixman_image_t *image);
-
-#define PIXMAN_IMAGE_GET_LINE(image, x, y, type, out_stride, line, mul)	\
-    do									\
-    {									\
-	uint32_t *__bits__;						\
-	int       __stride__;						\
-        								\
-	__bits__ = image->bits.bits;					\
-	__stride__ = image->bits.rowstride;				\
-	(out_stride) =							\
-	    __stride__ * (int) sizeof (uint32_t) / (int) sizeof (type);	\
-	(line) =							\
-	    ((type *) __bits__) + (out_stride) * (y) + (mul) * (x);	\
-    } while (0)
-
-/*
- * Gradient walker
- */
-typedef struct
-{
-    uint32_t                left_ag;
-    uint32_t                left_rb;
-    uint32_t                right_ag;
-    uint32_t                right_rb;
-    int32_t                 left_x;
-    int32_t                 right_x;
-    int32_t                 stepper;
-
-    pixman_gradient_stop_t *stops;
-    int                     num_stops;
-    unsigned int            spread;
-
-    int                     need_reset;
-} pixman_gradient_walker_t;
-
-void
-_pixman_gradient_walker_init (pixman_gradient_walker_t *walker,
-                              gradient_t *              gradient,
-                              unsigned int              spread);
-
-void
-_pixman_gradient_walker_reset (pixman_gradient_walker_t *walker,
-                               pixman_fixed_32_32_t      pos);
-
-uint32_t
-_pixman_gradient_walker_pixel (pixman_gradient_walker_t *walker,
-                               pixman_fixed_32_32_t      x);
-
-/*
- * Edges
- */
-
-#define MAX_ALPHA(n)    ((1 << (n)) - 1)
-#define N_Y_FRAC(n)     ((n) == 1 ? 1 : (1 << ((n) / 2)) - 1)
-#define N_X_FRAC(n)     ((n) == 1 ? 1 : (1 << ((n) / 2)) + 1)
-
-#define STEP_Y_SMALL(n) (pixman_fixed_1 / N_Y_FRAC (n))
-#define STEP_Y_BIG(n)   (pixman_fixed_1 - (N_Y_FRAC (n) - 1) * STEP_Y_SMALL (n))
-
-#define Y_FRAC_FIRST(n) (STEP_Y_BIG (n) / 2)
-#define Y_FRAC_LAST(n)  (Y_FRAC_FIRST (n) + (N_Y_FRAC (n) - 1) * STEP_Y_SMALL (n))
-
-#define STEP_X_SMALL(n) (pixman_fixed_1 / N_X_FRAC (n))
-#define STEP_X_BIG(n)   (pixman_fixed_1 - (N_X_FRAC (n) - 1) * STEP_X_SMALL (n))
-
-#define X_FRAC_FIRST(n) (STEP_X_BIG (n) / 2)
-#define X_FRAC_LAST(n)  (X_FRAC_FIRST (n) + (N_X_FRAC (n) - 1) * STEP_X_SMALL (n))
-
-#define RENDER_SAMPLES_X(x, n)						\
-    ((n) == 1? 0 : (pixman_fixed_frac (x) +				\
-		    X_FRAC_FIRST (n)) / STEP_X_SMALL (n))
-
-void
-pixman_rasterize_edges_accessors (pixman_image_t *image,
-                                  pixman_edge_t * l,
-                                  pixman_edge_t * r,
-                                  pixman_fixed_t  t,
-                                  pixman_fixed_t  b);
-
-/*
- * Implementations
- */
-typedef struct pixman_implementation_t pixman_implementation_t;
-
-typedef void (*pixman_combine_32_func_t) (pixman_implementation_t *imp,
-					  pixman_op_t              op,
-					  uint32_t *               dest,
-					  const uint32_t *         src,
-					  const uint32_t *         mask,
-					  int                      width);
-
-typedef void (*pixman_combine_64_func_t) (pixman_implementation_t *imp,
-					  pixman_op_t              op,
-					  uint64_t *               dest,
-					  const uint64_t *         src,
-					  const uint64_t *         mask,
-					  int                      width);
-
-typedef void (*pixman_composite_func_t) (pixman_implementation_t *imp,
-					 pixman_op_t              op,
-					 pixman_image_t *         src,
-					 pixman_image_t *         mask,
-					 pixman_image_t *         dest,
-					 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);
-typedef pixman_bool_t (*pixman_blt_func_t) (pixman_implementation_t *imp,
-					    uint32_t *               src_bits,
-					    uint32_t *               dst_bits,
-					    int                      src_stride,
-					    int                      dst_stride,
-					    int                      src_bpp,
-					    int                      dst_bpp,
-					    int                      src_x,
-					    int                      src_y,
-					    int                      dst_x,
-					    int                      dst_y,
-					    int                      width,
-					    int                      height);
-typedef pixman_bool_t (*pixman_fill_func_t) (pixman_implementation_t *imp,
-					     uint32_t *               bits,
-					     int                      stride,
-					     int                      bpp,
-					     int                      x,
-					     int                      y,
-					     int                      width,
-					     int                      height,
-					     uint32_t                 xor);
-typedef void (*pixman_iter_init_func_t) (pixman_implementation_t *imp,
-                                         pixman_iter_t           *iter,
-                                         pixman_image_t          *image,
-                                         int                      x,
-                                         int                      y,
-                                         int                      width,
-                                         int                      height,
-                                         uint8_t                 *buffer,
-                                         iter_flags_t             flags);
-
-void _pixman_setup_combiner_functions_32 (pixman_implementation_t *imp);
-void _pixman_setup_combiner_functions_64 (pixman_implementation_t *imp);
-
-typedef struct
-{
-    pixman_op_t             op;
-    pixman_format_code_t    src_format;
-    uint32_t		    src_flags;
-    pixman_format_code_t    mask_format;
-    uint32_t		    mask_flags;
-    pixman_format_code_t    dest_format;
-    uint32_t		    dest_flags;
-    pixman_composite_func_t func;
-} pixman_fast_path_t;
-
-struct pixman_implementation_t
-{
-    pixman_implementation_t *	toplevel;
-    pixman_implementation_t *	delegate;
-    const pixman_fast_path_t *	fast_paths;
-
-    pixman_blt_func_t		blt;
-    pixman_fill_func_t		fill;
-    pixman_iter_init_func_t     src_iter_init;
-    pixman_iter_init_func_t     dest_iter_init;
-
-    pixman_combine_32_func_t	combine_32[PIXMAN_N_OPERATORS];
-    pixman_combine_32_func_t	combine_32_ca[PIXMAN_N_OPERATORS];
-    pixman_combine_64_func_t	combine_64[PIXMAN_N_OPERATORS];
-    pixman_combine_64_func_t	combine_64_ca[PIXMAN_N_OPERATORS];
-};
-
-uint32_t
-_pixman_image_get_solid (pixman_implementation_t *imp,
-			 pixman_image_t *         image,
-                         pixman_format_code_t     format);
-
-pixman_implementation_t *
-_pixman_implementation_create (pixman_implementation_t *delegate,
-			       const pixman_fast_path_t *fast_paths);
-
-void
-_pixman_implementation_combine_32 (pixman_implementation_t *imp,
-                                   pixman_op_t              op,
-                                   uint32_t *               dest,
-                                   const uint32_t *         src,
-                                   const uint32_t *         mask,
-                                   int                      width);
-void
-_pixman_implementation_combine_64 (pixman_implementation_t *imp,
-                                   pixman_op_t              op,
-                                   uint64_t *               dest,
-                                   const uint64_t *         src,
-                                   const uint64_t *         mask,
-                                   int                      width);
-void
-_pixman_implementation_combine_32_ca (pixman_implementation_t *imp,
-                                      pixman_op_t              op,
-                                      uint32_t *               dest,
-                                      const uint32_t *         src,
-                                      const uint32_t *         mask,
-                                      int                      width);
-void
-_pixman_implementation_combine_64_ca (pixman_implementation_t *imp,
-                                      pixman_op_t              op,
-                                      uint64_t *               dest,
-                                      const uint64_t *         src,
-                                      const uint64_t *         mask,
-                                      int                      width);
-
-pixman_bool_t
-_pixman_implementation_blt (pixman_implementation_t *imp,
-                            uint32_t *               src_bits,
-                            uint32_t *               dst_bits,
-                            int                      src_stride,
-                            int                      dst_stride,
-                            int                      src_bpp,
-                            int                      dst_bpp,
-                            int                      src_x,
-                            int                      src_y,
-                            int                      dst_x,
-                            int                      dst_y,
-                            int                      width,
-                            int                      height);
-
-pixman_bool_t
-_pixman_implementation_fill (pixman_implementation_t *imp,
-                             uint32_t *               bits,
-                             int                      stride,
-                             int                      bpp,
-                             int                      x,
-                             int                      y,
-                             int                      width,
-                             int                      height,
-                             uint32_t                 xor);
-
-void
-_pixman_implementation_src_iter_init (pixman_implementation_t       *imp,
-				      pixman_iter_t                 *iter,
-				      pixman_image_t                *image,
-				      int                            x,
-				      int                            y,
-				      int                            width,
-				      int                            height,
-				      uint8_t                       *buffer,
-				      iter_flags_t                   flags);
-
-void
-_pixman_implementation_dest_iter_init (pixman_implementation_t       *imp,
-				       pixman_iter_t                 *iter,
-				       pixman_image_t                *image,
-				       int                            x,
-				       int                            y,
-				       int                            width,
-				       int                            height,
-				       uint8_t                       *buffer,
-				       iter_flags_t                   flags);
-
-/* Specific implementations */
-pixman_implementation_t *
-_pixman_implementation_create_general (void);
-
-pixman_implementation_t *
-_pixman_implementation_create_fast_path (pixman_implementation_t *fallback);
-
-#ifdef USE_MMX
-pixman_implementation_t *
-_pixman_implementation_create_mmx (pixman_implementation_t *fallback);
-#endif
-
-#ifdef USE_SSE2
-pixman_implementation_t *
-_pixman_implementation_create_sse2 (pixman_implementation_t *fallback);
-#endif
-
-#ifdef USE_ARM_SIMD
-pixman_implementation_t *
-_pixman_implementation_create_arm_simd (pixman_implementation_t *fallback);
-#endif
-
-#ifdef USE_ARM_NEON
-pixman_implementation_t *
-_pixman_implementation_create_arm_neon (pixman_implementation_t *fallback);
-#endif
-
-#ifdef USE_VMX
-pixman_implementation_t *
-_pixman_implementation_create_vmx (pixman_implementation_t *fallback);
-#endif
-
-pixman_implementation_t *
-_pixman_choose_implementation (void);
-
-
-
-/*
- * Utilities
- */
-uint32_t *
-_pixman_iter_get_scanline_noop (pixman_iter_t *iter, const uint32_t *mask);
-
-/* These "formats" all have depth 0, so they
- * will never clash with any real ones
- */
-#define PIXMAN_null             PIXMAN_FORMAT (0, 0, 0, 0, 0, 0)
-#define PIXMAN_solid            PIXMAN_FORMAT (0, 1, 0, 0, 0, 0)
-#define PIXMAN_pixbuf		PIXMAN_FORMAT (0, 2, 0, 0, 0, 0)
-#define PIXMAN_rpixbuf		PIXMAN_FORMAT (0, 3, 0, 0, 0, 0)
-#define PIXMAN_unknown		PIXMAN_FORMAT (0, 4, 0, 0, 0, 0)
-#define PIXMAN_any		PIXMAN_FORMAT (0, 5, 0, 0, 0, 0)
-
-#define PIXMAN_OP_any		(PIXMAN_N_OPERATORS + 1)
-
-#define FAST_PATH_ID_TRANSFORM			(1 <<  0)
-#define FAST_PATH_NO_ALPHA_MAP			(1 <<  1)
-#define FAST_PATH_NO_CONVOLUTION_FILTER		(1 <<  2)
-#define FAST_PATH_NO_PAD_REPEAT			(1 <<  3)
-#define FAST_PATH_NO_REFLECT_REPEAT		(1 <<  4)
-#define FAST_PATH_NO_ACCESSORS			(1 <<  5)
-#define FAST_PATH_NARROW_FORMAT			(1 <<  6)
-#define FAST_PATH_COMPONENT_ALPHA		(1 <<  8)
-#define FAST_PATH_SAMPLES_OPAQUE		(1 <<  7)
-#define FAST_PATH_UNIFIED_ALPHA			(1 <<  9)
-#define FAST_PATH_SCALE_TRANSFORM		(1 << 10)
-#define FAST_PATH_NEAREST_FILTER		(1 << 11)
-#define FAST_PATH_HAS_TRANSFORM			(1 << 12)
-#define FAST_PATH_IS_OPAQUE			(1 << 13)
-#define FAST_PATH_NO_NORMAL_REPEAT		(1 << 14)
-#define FAST_PATH_NO_NONE_REPEAT		(1 << 15)
-#define FAST_PATH_SAMPLES_COVER_CLIP		(1 << 16)
-#define FAST_PATH_X_UNIT_POSITIVE		(1 << 17)
-#define FAST_PATH_AFFINE_TRANSFORM		(1 << 18)
-#define FAST_PATH_Y_UNIT_ZERO			(1 << 19)
-#define FAST_PATH_BILINEAR_FILTER		(1 << 20)
-
-#define FAST_PATH_PAD_REPEAT						\
-    (FAST_PATH_NO_NONE_REPEAT		|				\
-     FAST_PATH_NO_NORMAL_REPEAT		|				\
-     FAST_PATH_NO_REFLECT_REPEAT)
-
-#define FAST_PATH_NORMAL_REPEAT						\
-    (FAST_PATH_NO_NONE_REPEAT		|				\
-     FAST_PATH_NO_PAD_REPEAT		|				\
-     FAST_PATH_NO_REFLECT_REPEAT)
-
-#define FAST_PATH_NONE_REPEAT						\
-    (FAST_PATH_NO_NORMAL_REPEAT		|				\
-     FAST_PATH_NO_PAD_REPEAT		|				\
-     FAST_PATH_NO_REFLECT_REPEAT)
-
-#define FAST_PATH_REFLECT_REPEAT					\
-    (FAST_PATH_NO_NONE_REPEAT		|				\
-     FAST_PATH_NO_NORMAL_REPEAT		|				\
-     FAST_PATH_NO_PAD_REPEAT)
-
-#define FAST_PATH_STANDARD_FLAGS					\
-    (FAST_PATH_NO_CONVOLUTION_FILTER	|				\
-     FAST_PATH_NO_ACCESSORS		|				\
-     FAST_PATH_NO_ALPHA_MAP		|				\
-     FAST_PATH_NARROW_FORMAT)
-
-#define FAST_PATH_STD_DEST_FLAGS					\
-    (FAST_PATH_NO_ACCESSORS		|				\
-     FAST_PATH_NO_ALPHA_MAP		|				\
-     FAST_PATH_NARROW_FORMAT)
-
-#define SOURCE_FLAGS(format)						\
-    (FAST_PATH_STANDARD_FLAGS |						\
-     ((PIXMAN_ ## format == PIXMAN_solid) ?				\
-      0 : (FAST_PATH_SAMPLES_COVER_CLIP | FAST_PATH_ID_TRANSFORM)))
-
-#define MASK_FLAGS(format, extra)					\
-    ((PIXMAN_ ## format == PIXMAN_null) ? 0 : (SOURCE_FLAGS (format) | extra))
-
-#define FAST_PATH(op, src, src_flags, mask, mask_flags, dest, dest_flags, func) \
-    PIXMAN_OP_ ## op,							\
-    PIXMAN_ ## src,							\
-    src_flags,							        \
-    PIXMAN_ ## mask,						        \
-    mask_flags,							        \
-    PIXMAN_ ## dest,	                                                \
-    dest_flags,							        \
-    func
-
-#define PIXMAN_STD_FAST_PATH(op, src, mask, dest, func)			\
-    { FAST_PATH (							\
-	    op,								\
-	    src,  SOURCE_FLAGS (src),					\
-	    mask, MASK_FLAGS (mask, FAST_PATH_UNIFIED_ALPHA),		\
-	    dest, FAST_PATH_STD_DEST_FLAGS,				\
-	    func) }
-
-#define PIXMAN_STD_FAST_PATH_CA(op, src, mask, dest, func)		\
-    { FAST_PATH (							\
-	    op,								\
-	    src,  SOURCE_FLAGS (src),					\
-	    mask, MASK_FLAGS (mask, FAST_PATH_COMPONENT_ALPHA),		\
-	    dest, FAST_PATH_STD_DEST_FLAGS,				\
-	    func) }
-
-/* Memory allocation helpers */
-void *
-pixman_malloc_ab (unsigned int n, unsigned int b);
-
-void *
-pixman_malloc_abc (unsigned int a, unsigned int b, unsigned int c);
-
-pixman_bool_t
-pixman_multiply_overflows_int (unsigned int a, unsigned int b);
-
-pixman_bool_t
-pixman_addition_overflows_int (unsigned int a, unsigned int b);
-
-/* Compositing utilities */
-void
-pixman_expand (uint64_t *           dst,
-               const uint32_t *     src,
-               pixman_format_code_t format,
-               int                  width);
-
-void
-pixman_contract (uint32_t *      dst,
-                 const uint64_t *src,
-                 int             width);
-
-
-/* Region Helpers */
-pixman_bool_t
-pixman_region32_copy_from_region16 (pixman_region32_t *dst,
-                                    pixman_region16_t *src);
-
-pixman_bool_t
-pixman_region16_copy_from_region32 (pixman_region16_t *dst,
-                                    pixman_region32_t *src);
-
-
-/* Misc macros */
-
-#ifndef FALSE
-#   define FALSE 0
-#endif
-
-#ifndef TRUE
-#   define TRUE 1
-#endif
-
-#ifndef MIN
-#  define MIN(a, b) ((a < b) ? a : b)
-#endif
-
-#ifndef MAX
-#  define MAX(a, b) ((a > b) ? a : b)
-#endif
-
-/* Integer division that rounds towards -infinity */
-#define DIV(a, b)					   \
-    ((((a) < 0) == ((b) < 0)) ? (a) / (b) :                \
-     ((a) - (b) + 1 - (((b) < 0) << 1)) / (b))
-
-/* Modulus that produces the remainder wrt. DIV */
-#define MOD(a, b) ((a) < 0 ? ((b) - ((-(a) - 1) % (b))) - 1 : (a) % (b))
-
-#define CLIP(v, low, high) ((v) < (low) ? (low) : ((v) > (high) ? (high) : (v)))
-
-/* Conversion between 8888 and 0565 */
-
-#define CONVERT_8888_TO_0565(s)						\
-    ((((s) >> 3) & 0x001f) |						\
-     (((s) >> 5) & 0x07e0) |						\
-     (((s) >> 8) & 0xf800))
-
-#define CONVERT_0565_TO_0888(s)						\
-    (((((s) << 3) & 0xf8) | (((s) >> 2) & 0x7)) |			\
-     ((((s) << 5) & 0xfc00) | (((s) >> 1) & 0x300)) |			\
-     ((((s) << 8) & 0xf80000) | (((s) << 3) & 0x70000)))
-
-#define CONVERT_0565_TO_8888(s) (CONVERT_0565_TO_0888(s) | 0xff000000)
-
-/* Trivial versions that are useful in macros */
-#define CONVERT_8888_TO_8888(s) (s)
-#define CONVERT_0565_TO_0565(s) (s)
-
-#define PIXMAN_FORMAT_IS_WIDE(f)					\
-    (PIXMAN_FORMAT_A (f) > 8 ||						\
-     PIXMAN_FORMAT_R (f) > 8 ||						\
-     PIXMAN_FORMAT_G (f) > 8 ||						\
-     PIXMAN_FORMAT_B (f) > 8)
-
-#ifdef WORDS_BIGENDIAN
-#   define SCREEN_SHIFT_LEFT(x,n)	((x) << (n))
-#   define SCREEN_SHIFT_RIGHT(x,n)	((x) >> (n))
-#else
-#   define SCREEN_SHIFT_LEFT(x,n)	((x) >> (n))
-#   define SCREEN_SHIFT_RIGHT(x,n)	((x) << (n))
-#endif
-
-/*
- * Various debugging code
- */
-
-#undef DEBUG
-
-#define COMPILE_TIME_ASSERT(x)						\
-    do { typedef int compile_time_assertion [(x)?1:-1]; } while (0)
-
-/* Turn on debugging depending on what type of release this is
- */
-#if (((PIXMAN_VERSION_MICRO % 2) == 0) && ((PIXMAN_VERSION_MINOR % 2) == 1))
-
-/* Debugging gets turned on for development releases because these
- * are the things that end up in bleeding edge distributions such
- * as Rawhide etc.
- *
- * For performance reasons we don't turn it on for stable releases or
- * random git checkouts. (Random git checkouts are often used for
- * performance work).
- */
-
-#    define DEBUG
-
-#endif
-
-#ifdef DEBUG
-
-void
-_pixman_log_error (const char *function, const char *message);
-
-#define return_if_fail(expr)                                            \
-    do                                                                  \
-    {                                                                   \
-	if (!(expr))							\
-	{								\
-	    _pixman_log_error (FUNC, "The expression " # expr " was false"); \
-	    return;							\
-	}								\
-    }                                                                   \
-    while (0)
-
-#define return_val_if_fail(expr, retval)                                \
-    do                                                                  \
-    {                                                                   \
-	if (!(expr))                                                    \
-	{								\
-	    _pixman_log_error (FUNC, "The expression " # expr " was false"); \
-	    return (retval);						\
-	}								\
-    }                                                                   \
-    while (0)
-
-#define critical_if_fail(expr)						\
-    do									\
-    {									\
-	if (!(expr))							\
-	    _pixman_log_error (FUNC, "The expression " # expr " was false"); \
-    }									\
-    while (0)
-
-
-#else
-
-#define _pixman_log_error(f,m) do { } while (0)				\
-
-#define return_if_fail(expr)						\
-    do                                                                  \
-    {                                                                   \
-	if (!(expr))							\
-	    return;							\
-    }                                                                   \
-    while (0)
-
-#define return_val_if_fail(expr, retval)                                \
-    do                                                                  \
-    {                                                                   \
-	if (!(expr))							\
-	    return (retval);						\
-    }                                                                   \
-    while (0)
-
-#define critical_if_fail(expr)						\
-    do									\
-    {									\
-    }									\
-    while (0)
-#endif
-
-/*
- * Timers
- */
-
-#ifdef PIXMAN_TIMERS
-
-static inline uint64_t
-oil_profile_stamp_rdtsc (void)
-{
-    uint64_t ts;
-
-    __asm__ __volatile__ ("rdtsc\n" : "=A" (ts));
-    return ts;
-}
-
-#define OIL_STAMP oil_profile_stamp_rdtsc
-
-typedef struct pixman_timer_t pixman_timer_t;
-
-struct pixman_timer_t
-{
-    int             initialized;
-    const char *    name;
-    uint64_t        n_times;
-    uint64_t        total;
-    pixman_timer_t *next;
-};
-
-extern int timer_defined;
-
-void pixman_timer_register (pixman_timer_t *timer);
-
-#define TIMER_BEGIN(tname)                                              \
-    {                                                                   \
-	static pixman_timer_t timer ## tname;                           \
-	uint64_t              begin ## tname;                           \
-        								\
-	if (!timer ## tname.initialized)				\
-	{                                                               \
-	    timer ## tname.initialized = 1;				\
-	    timer ## tname.name = # tname;				\
-	    pixman_timer_register (&timer ## tname);			\
-	}                                                               \
-									\
-	timer ## tname.n_times++;					\
-	begin ## tname = OIL_STAMP ();
-
-#define TIMER_END(tname)                                                \
-    timer ## tname.total += OIL_STAMP () - begin ## tname;		\
-    }
-
-#endif /* PIXMAN_TIMERS */
-
-#endif /* PIXMAN_PRIVATE_H */
+#ifndef PACKAGE

+#  error config.h must be included before pixman-private.h

+#endif

+

+#ifndef PIXMAN_PRIVATE_H

+#define PIXMAN_PRIVATE_H

+

+#define PIXMAN_DISABLE_DEPRECATED

+#define PIXMAN_USE_INTERNAL_API

+

+#include "pixman.h"

+#include <time.h>

+#include <assert.h>

+#include <stdio.h>

+#include <string.h>

+

+#include "pixman-compiler.h"

+

+/*

+ * Images

+ */

+typedef struct image_common image_common_t;

+typedef struct solid_fill solid_fill_t;

+typedef struct gradient gradient_t;

+typedef struct linear_gradient linear_gradient_t;

+typedef struct horizontal_gradient horizontal_gradient_t;

+typedef struct vertical_gradient vertical_gradient_t;

+typedef struct conical_gradient conical_gradient_t;

+typedef struct radial_gradient radial_gradient_t;

+typedef struct bits_image bits_image_t;

+typedef struct circle circle_t;

+

+typedef void (*fetch_scanline_t) (pixman_image_t *image,

+				  int             x,

+				  int             y,

+				  int             width,

+				  uint32_t       *buffer,

+				  const uint32_t *mask);

+

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

+				      int           x,

+				      int           y);

+

+typedef uint64_t (*fetch_pixel_64_t) (bits_image_t *image,

+				      int           x,

+				      int           y);

+

+typedef void (*store_scanline_t) (bits_image_t *  image,

+				  int             x,

+				  int             y,

+				  int             width,

+				  const uint32_t *values);

+

+typedef enum

+{

+    BITS,

+    LINEAR,

+    CONICAL,

+    RADIAL,

+    SOLID

+} image_type_t;

+

+typedef void (*property_changed_func_t) (pixman_image_t *image);

+

+struct image_common

+{

+    image_type_t                type;

+    int32_t                     ref_count;

+    pixman_region32_t           clip_region;

+    int32_t			alpha_count;	    /* How many times this image is being used as an alpha map */

+    pixman_bool_t               have_clip_region;   /* FALSE if there is no clip */

+    pixman_bool_t               client_clip;        /* Whether the source clip was

+						       set by a client */

+    pixman_bool_t               clip_sources;       /* Whether the clip applies when

+						     * the image is used as a source

+						     */

+    pixman_bool_t		dirty;

+    pixman_transform_t *        transform;

+    pixman_repeat_t             repeat;

+    pixman_filter_t             filter;

+    pixman_fixed_t *            filter_params;

+    int                         n_filter_params;

+    bits_image_t *              alpha_map;

+    int                         alpha_origin_x;

+    int                         alpha_origin_y;

+    pixman_bool_t               component_alpha;

+    property_changed_func_t     property_changed;

+

+    pixman_image_destroy_func_t destroy_func;

+    void *                      destroy_data;

+

+    uint32_t			flags;

+    pixman_format_code_t	extended_format_code;

+};

+

+struct solid_fill

+{

+    image_common_t common;

+    pixman_color_t color;

+    

+    uint32_t	   color_32;

+    uint64_t	   color_64;

+};

+

+struct gradient

+{

+    image_common_t	    common;

+    int                     n_stops;

+    pixman_gradient_stop_t *stops;

+};

+

+struct linear_gradient

+{

+    gradient_t           common;

+    pixman_point_fixed_t p1;

+    pixman_point_fixed_t p2;

+};

+

+struct circle

+{

+    pixman_fixed_t x;

+    pixman_fixed_t y;

+    pixman_fixed_t radius;

+};

+

+struct radial_gradient

+{

+    gradient_t common;

+

+    circle_t   c1;

+    circle_t   c2;

+

+    circle_t   delta;

+    double     a;

+    double     inva;

+    double     mindr;

+};

+

+struct conical_gradient

+{

+    gradient_t           common;

+    pixman_point_fixed_t center;

+    double		 angle;

+};

+

+struct bits_image

+{

+    image_common_t             common;

+    pixman_format_code_t       format;

+    const pixman_indexed_t *   indexed;

+    int                        width;

+    int                        height;

+    uint32_t *                 bits;

+    uint32_t *                 free_me;

+    int                        rowstride;  /* in number of uint32_t's */

+

+    fetch_scanline_t           get_scanline_32;

+    fetch_scanline_t           get_scanline_64;

+

+    fetch_scanline_t           fetch_scanline_32;

+    fetch_pixel_32_t	       fetch_pixel_32;

+    store_scanline_t           store_scanline_32;

+

+    fetch_scanline_t           fetch_scanline_64;

+    fetch_pixel_64_t	       fetch_pixel_64;

+    store_scanline_t           store_scanline_64;

+

+    /* Used for indirect access to the bits */

+    pixman_read_memory_func_t  read_func;

+    pixman_write_memory_func_t write_func;

+};

+

+union pixman_image

+{

+    image_type_t       type;

+    image_common_t     common;

+    bits_image_t       bits;

+    gradient_t         gradient;

+    linear_gradient_t  linear;

+    conical_gradient_t conical;

+    radial_gradient_t  radial;

+    solid_fill_t       solid;

+};

+

+typedef struct pixman_iter_t pixman_iter_t;

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

+typedef void      (* pixman_iter_write_back_t)   (pixman_iter_t *iter);

+

+typedef enum

+{

+    ITER_NARROW =		(1 << 0),

+

+    /* "Localized alpha" is when the alpha channel is used only to compute

+     * the alpha value of the destination. This means that the computation

+     * of the RGB values of the result is independent of the alpha value.

+     *

+     * For example, the OVER operator has localized alpha for the

+     * destination, because the RGB values of the result can be computed

+     * without knowing the destination alpha. Similarly, ADD has localized

+     * alpha for both source and destination because the RGB values of the

+     * result can be computed without knowing the alpha value of source or

+     * destination.

+     *

+     * When he destination is xRGB, this is useful knowledge, because then

+     * we can treat it as if it were ARGB, which means in some cases we can

+     * avoid copying it to a temporary buffer.

+     */

+    ITER_LOCALIZED_ALPHA =	(1 << 1),

+    ITER_IGNORE_ALPHA =		(1 << 2),

+    ITER_IGNORE_RGB =		(1 << 3)

+} iter_flags_t;

+

+struct pixman_iter_t

+{

+    pixman_iter_get_scanline_t	get_scanline;

+    pixman_iter_write_back_t	write_back;

+

+    pixman_image_t *		image;

+    uint32_t *			buffer;

+    int				x, y;

+    int				width;

+

+    uint8_t *			bits;

+    int				stride;

+};

+

+void

+_pixman_bits_image_setup_accessors (bits_image_t *image);

+

+void

+_pixman_bits_image_src_iter_init (pixman_image_t *image,

+				  pixman_iter_t *iter,

+				  int x, int y, int width, int height,

+				  uint8_t *buffer, iter_flags_t flags);

+void

+_pixman_bits_image_dest_iter_init (pixman_image_t *image,

+				   pixman_iter_t *iter,

+				   int x, int y, int width, int height,

+				   uint8_t *buffer, iter_flags_t flags);

+

+void

+_pixman_solid_fill_iter_init (pixman_image_t *image,

+			      pixman_iter_t  *iter,

+			      int x, int y, int width, int height,

+			      uint8_t *buffer, iter_flags_t flags);

+

+void

+_pixman_linear_gradient_iter_init (pixman_image_t *image,

+				   pixman_iter_t  *iter,

+				   int x, int y, int width, int height,

+				   uint8_t *buffer, iter_flags_t flags);

+

+void

+_pixman_radial_gradient_iter_init (pixman_image_t *image,

+				   pixman_iter_t *iter,

+				   int x, int y, int width, int height,

+				   uint8_t *buffer, iter_flags_t flags);

+

+void

+_pixman_conical_gradient_iter_init (pixman_image_t *image,

+				    pixman_iter_t *iter,

+				    int x, int y, int width, int height,

+				    uint8_t *buffer, iter_flags_t flags);

+

+pixman_image_t *

+_pixman_image_allocate (void);

+

+pixman_bool_t

+_pixman_init_gradient (gradient_t *                  gradient,

+                       const pixman_gradient_stop_t *stops,

+                       int                           n_stops);

+void

+_pixman_image_reset_clip_region (pixman_image_t *image);

+

+void

+_pixman_image_validate (pixman_image_t *image);

+

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

+    do									\

+    {									\

+	uint32_t *__bits__;						\

+	int       __stride__;						\

+        								\

+	__bits__ = image->bits.bits;					\

+	__stride__ = image->bits.rowstride;				\

+	(out_stride) =							\

+	    __stride__ * (int) sizeof (uint32_t) / (int) sizeof (type);	\

+	(line) =							\

+	    ((type *) __bits__) + (out_stride) * (y) + (mul) * (x);	\

+    } while (0)

+

+/*

+ * Gradient walker

+ */

+typedef struct

+{

+    uint32_t                left_ag;

+    uint32_t                left_rb;

+    uint32_t                right_ag;

+    uint32_t                right_rb;

+    int32_t                 left_x;

+    int32_t                 right_x;

+    int32_t                 stepper;

+

+    pixman_gradient_stop_t *stops;

+    int                     num_stops;

+    unsigned int            spread;

+

+    int                     need_reset;

+} pixman_gradient_walker_t;

+

+void

+_pixman_gradient_walker_init (pixman_gradient_walker_t *walker,

+                              gradient_t *              gradient,

+                              unsigned int              spread);

+

+void

+_pixman_gradient_walker_reset (pixman_gradient_walker_t *walker,

+                               pixman_fixed_32_32_t      pos);

+

+uint32_t

+_pixman_gradient_walker_pixel (pixman_gradient_walker_t *walker,

+                               pixman_fixed_32_32_t      x);

+

+/*

+ * Edges

+ */

+

+#define MAX_ALPHA(n)    ((1 << (n)) - 1)

+#define N_Y_FRAC(n)     ((n) == 1 ? 1 : (1 << ((n) / 2)) - 1)

+#define N_X_FRAC(n)     ((n) == 1 ? 1 : (1 << ((n) / 2)) + 1)

+

+#define STEP_Y_SMALL(n) (pixman_fixed_1 / N_Y_FRAC (n))

+#define STEP_Y_BIG(n)   (pixman_fixed_1 - (N_Y_FRAC (n) - 1) * STEP_Y_SMALL (n))

+

+#define Y_FRAC_FIRST(n) (STEP_Y_BIG (n) / 2)

+#define Y_FRAC_LAST(n)  (Y_FRAC_FIRST (n) + (N_Y_FRAC (n) - 1) * STEP_Y_SMALL (n))

+

+#define STEP_X_SMALL(n) (pixman_fixed_1 / N_X_FRAC (n))

+#define STEP_X_BIG(n)   (pixman_fixed_1 - (N_X_FRAC (n) - 1) * STEP_X_SMALL (n))

+

+#define X_FRAC_FIRST(n) (STEP_X_BIG (n) / 2)

+#define X_FRAC_LAST(n)  (X_FRAC_FIRST (n) + (N_X_FRAC (n) - 1) * STEP_X_SMALL (n))

+

+#define RENDER_SAMPLES_X(x, n)						\

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

+		    X_FRAC_FIRST (n)) / STEP_X_SMALL (n))

+

+void

+pixman_rasterize_edges_accessors (pixman_image_t *image,

+                                  pixman_edge_t * l,

+                                  pixman_edge_t * r,

+                                  pixman_fixed_t  t,

+                                  pixman_fixed_t  b);

+

+/*

+ * Implementations

+ */

+typedef struct pixman_implementation_t pixman_implementation_t;

+

+typedef void (*pixman_combine_32_func_t) (pixman_implementation_t *imp,

+					  pixman_op_t              op,

+					  uint32_t *               dest,

+					  const uint32_t *         src,

+					  const uint32_t *         mask,

+					  int                      width);

+

+typedef void (*pixman_combine_64_func_t) (pixman_implementation_t *imp,

+					  pixman_op_t              op,

+					  uint64_t *               dest,

+					  const uint64_t *         src,

+					  const uint64_t *         mask,

+					  int                      width);

+

+typedef void (*pixman_composite_func_t) (pixman_implementation_t *imp,

+					 pixman_op_t              op,

+					 pixman_image_t *         src,

+					 pixman_image_t *         mask,

+					 pixman_image_t *         dest,

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

+typedef pixman_bool_t (*pixman_blt_func_t) (pixman_implementation_t *imp,

+					    uint32_t *               src_bits,

+					    uint32_t *               dst_bits,

+					    int                      src_stride,

+					    int                      dst_stride,

+					    int                      src_bpp,

+					    int                      dst_bpp,

+					    int                      src_x,

+					    int                      src_y,

+					    int                      dst_x,

+					    int                      dst_y,

+					    int                      width,

+					    int                      height);

+typedef pixman_bool_t (*pixman_fill_func_t) (pixman_implementation_t *imp,

+					     uint32_t *               bits,

+					     int                      stride,

+					     int                      bpp,

+					     int                      x,

+					     int                      y,

+					     int                      width,

+					     int                      height,

+					     uint32_t                 xor);

+typedef void (*pixman_iter_init_func_t) (pixman_implementation_t *imp,

+                                         pixman_iter_t           *iter,

+                                         pixman_image_t          *image,

+                                         int                      x,

+                                         int                      y,

+                                         int                      width,

+                                         int                      height,

+                                         uint8_t                 *buffer,

+                                         iter_flags_t             flags);

+

+void _pixman_setup_combiner_functions_32 (pixman_implementation_t *imp);

+void _pixman_setup_combiner_functions_64 (pixman_implementation_t *imp);

+

+typedef struct

+{

+    pixman_op_t             op;

+    pixman_format_code_t    src_format;

+    uint32_t		    src_flags;

+    pixman_format_code_t    mask_format;

+    uint32_t		    mask_flags;

+    pixman_format_code_t    dest_format;

+    uint32_t		    dest_flags;

+    pixman_composite_func_t func;

+} pixman_fast_path_t;

+

+struct pixman_implementation_t

+{

+    pixman_implementation_t *	toplevel;

+    pixman_implementation_t *	delegate;

+    const pixman_fast_path_t *	fast_paths;

+

+    pixman_blt_func_t		blt;

+    pixman_fill_func_t		fill;

+    pixman_iter_init_func_t     src_iter_init;

+    pixman_iter_init_func_t     dest_iter_init;

+

+    pixman_combine_32_func_t	combine_32[PIXMAN_N_OPERATORS];

+    pixman_combine_32_func_t	combine_32_ca[PIXMAN_N_OPERATORS];

+    pixman_combine_64_func_t	combine_64[PIXMAN_N_OPERATORS];

+    pixman_combine_64_func_t	combine_64_ca[PIXMAN_N_OPERATORS];

+};

+

+uint32_t

+_pixman_image_get_solid (pixman_implementation_t *imp,

+			 pixman_image_t *         image,

+                         pixman_format_code_t     format);

+

+pixman_implementation_t *

+_pixman_implementation_create (pixman_implementation_t *delegate,

+			       const pixman_fast_path_t *fast_paths);

+

+void

+_pixman_implementation_combine_32 (pixman_implementation_t *imp,

+                                   pixman_op_t              op,

+                                   uint32_t *               dest,

+                                   const uint32_t *         src,

+                                   const uint32_t *         mask,

+                                   int                      width);

+void

+_pixman_implementation_combine_64 (pixman_implementation_t *imp,

+                                   pixman_op_t              op,

+                                   uint64_t *               dest,

+                                   const uint64_t *         src,

+                                   const uint64_t *         mask,

+                                   int                      width);

+void

+_pixman_implementation_combine_32_ca (pixman_implementation_t *imp,

+                                      pixman_op_t              op,

+                                      uint32_t *               dest,

+                                      const uint32_t *         src,

+                                      const uint32_t *         mask,

+                                      int                      width);

+void

+_pixman_implementation_combine_64_ca (pixman_implementation_t *imp,

+                                      pixman_op_t              op,

+                                      uint64_t *               dest,

+                                      const uint64_t *         src,

+                                      const uint64_t *         mask,

+                                      int                      width);

+

+pixman_bool_t

+_pixman_implementation_blt (pixman_implementation_t *imp,

+                            uint32_t *               src_bits,

+                            uint32_t *               dst_bits,

+                            int                      src_stride,

+                            int                      dst_stride,

+                            int                      src_bpp,

+                            int                      dst_bpp,

+                            int                      src_x,

+                            int                      src_y,

+                            int                      dst_x,

+                            int                      dst_y,

+                            int                      width,

+                            int                      height);

+

+pixman_bool_t

+_pixman_implementation_fill (pixman_implementation_t *imp,

+                             uint32_t *               bits,

+                             int                      stride,

+                             int                      bpp,

+                             int                      x,

+                             int                      y,

+                             int                      width,

+                             int                      height,

+                             uint32_t                 xor);

+

+void

+_pixman_implementation_src_iter_init (pixman_implementation_t       *imp,

+				      pixman_iter_t                 *iter,

+				      pixman_image_t                *image,

+				      int                            x,

+				      int                            y,

+				      int                            width,

+				      int                            height,

+				      uint8_t                       *buffer,

+				      iter_flags_t                   flags);

+

+void

+_pixman_implementation_dest_iter_init (pixman_implementation_t       *imp,

+				       pixman_iter_t                 *iter,

+				       pixman_image_t                *image,

+				       int                            x,

+				       int                            y,

+				       int                            width,

+				       int                            height,

+				       uint8_t                       *buffer,

+				       iter_flags_t                   flags);

+

+/* Specific implementations */

+pixman_implementation_t *

+_pixman_implementation_create_general (void);

+

+pixman_implementation_t *

+_pixman_implementation_create_fast_path (pixman_implementation_t *fallback);

+

+#ifdef USE_MMX

+pixman_implementation_t *

+_pixman_implementation_create_mmx (pixman_implementation_t *fallback);

+#endif

+

+#ifdef USE_SSE2

+pixman_implementation_t *

+_pixman_implementation_create_sse2 (pixman_implementation_t *fallback);

+#endif

+

+#ifdef USE_ARM_SIMD

+pixman_implementation_t *

+_pixman_implementation_create_arm_simd (pixman_implementation_t *fallback);

+#endif

+

+#ifdef USE_ARM_NEON

+pixman_implementation_t *

+_pixman_implementation_create_arm_neon (pixman_implementation_t *fallback);

+#endif

+

+#ifdef USE_VMX

+pixman_implementation_t *

+_pixman_implementation_create_vmx (pixman_implementation_t *fallback);

+#endif

+

+pixman_implementation_t *

+_pixman_choose_implementation (void);

+

+

+

+/*

+ * Utilities

+ */

+uint32_t *

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

+

+/* These "formats" all have depth 0, so they

+ * will never clash with any real ones

+ */

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

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

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

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

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

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

+

+#define PIXMAN_OP_any		(PIXMAN_N_OPERATORS + 1)

+

+#define FAST_PATH_ID_TRANSFORM			(1 <<  0)

+#define FAST_PATH_NO_ALPHA_MAP			(1 <<  1)

+#define FAST_PATH_NO_CONVOLUTION_FILTER		(1 <<  2)

+#define FAST_PATH_NO_PAD_REPEAT			(1 <<  3)

+#define FAST_PATH_NO_REFLECT_REPEAT		(1 <<  4)

+#define FAST_PATH_NO_ACCESSORS			(1 <<  5)

+#define FAST_PATH_NARROW_FORMAT			(1 <<  6)

+#define FAST_PATH_COMPONENT_ALPHA		(1 <<  8)

+#define FAST_PATH_SAMPLES_OPAQUE		(1 <<  7)

+#define FAST_PATH_UNIFIED_ALPHA			(1 <<  9)

+#define FAST_PATH_SCALE_TRANSFORM		(1 << 10)

+#define FAST_PATH_NEAREST_FILTER		(1 << 11)

+#define FAST_PATH_HAS_TRANSFORM			(1 << 12)

+#define FAST_PATH_IS_OPAQUE			(1 << 13)

+#define FAST_PATH_NO_NORMAL_REPEAT		(1 << 14)

+#define FAST_PATH_NO_NONE_REPEAT		(1 << 15)

+#define FAST_PATH_SAMPLES_COVER_CLIP		(1 << 16)

+#define FAST_PATH_X_UNIT_POSITIVE		(1 << 17)

+#define FAST_PATH_AFFINE_TRANSFORM		(1 << 18)

+#define FAST_PATH_Y_UNIT_ZERO			(1 << 19)

+#define FAST_PATH_BILINEAR_FILTER		(1 << 20)

+#define FAST_PATH_ROTATE_90_TRANSFORM		(1 << 21)

+#define FAST_PATH_ROTATE_180_TRANSFORM		(1 << 22)

+#define FAST_PATH_ROTATE_270_TRANSFORM		(1 << 23)

+

+#define FAST_PATH_PAD_REPEAT						\

+    (FAST_PATH_NO_NONE_REPEAT		|				\

+     FAST_PATH_NO_NORMAL_REPEAT		|				\

+     FAST_PATH_NO_REFLECT_REPEAT)

+

+#define FAST_PATH_NORMAL_REPEAT						\

+    (FAST_PATH_NO_NONE_REPEAT		|				\

+     FAST_PATH_NO_PAD_REPEAT		|				\

+     FAST_PATH_NO_REFLECT_REPEAT)

+

+#define FAST_PATH_NONE_REPEAT						\

+    (FAST_PATH_NO_NORMAL_REPEAT		|				\

+     FAST_PATH_NO_PAD_REPEAT		|				\

+     FAST_PATH_NO_REFLECT_REPEAT)

+

+#define FAST_PATH_REFLECT_REPEAT					\

+    (FAST_PATH_NO_NONE_REPEAT		|				\

+     FAST_PATH_NO_NORMAL_REPEAT		|				\

+     FAST_PATH_NO_PAD_REPEAT)

+

+#define FAST_PATH_STANDARD_FLAGS					\

+    (FAST_PATH_NO_CONVOLUTION_FILTER	|				\

+     FAST_PATH_NO_ACCESSORS		|				\

+     FAST_PATH_NO_ALPHA_MAP		|				\

+     FAST_PATH_NARROW_FORMAT)

+

+#define FAST_PATH_STD_DEST_FLAGS					\

+    (FAST_PATH_NO_ACCESSORS		|				\

+     FAST_PATH_NO_ALPHA_MAP		|				\

+     FAST_PATH_NARROW_FORMAT)

+

+#define SOURCE_FLAGS(format)						\

+    (FAST_PATH_STANDARD_FLAGS |						\

+     ((PIXMAN_ ## format == PIXMAN_solid) ?				\

+      0 : (FAST_PATH_SAMPLES_COVER_CLIP | FAST_PATH_ID_TRANSFORM)))

+

+#define MASK_FLAGS(format, extra)					\

+    ((PIXMAN_ ## format == PIXMAN_null) ? 0 : (SOURCE_FLAGS (format) | extra))

+

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

+    PIXMAN_OP_ ## op,							\

+    PIXMAN_ ## src,							\

+    src_flags,							        \

+    PIXMAN_ ## mask,						        \

+    mask_flags,							        \

+    PIXMAN_ ## dest,	                                                \

+    dest_flags,							        \

+    func

+

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

+    { FAST_PATH (							\

+	    op,								\

+	    src,  SOURCE_FLAGS (src),					\

+	    mask, MASK_FLAGS (mask, FAST_PATH_UNIFIED_ALPHA),		\

+	    dest, FAST_PATH_STD_DEST_FLAGS,				\

+	    func) }

+

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

+    { FAST_PATH (							\

+	    op,								\

+	    src,  SOURCE_FLAGS (src),					\

+	    mask, MASK_FLAGS (mask, FAST_PATH_COMPONENT_ALPHA),		\

+	    dest, FAST_PATH_STD_DEST_FLAGS,				\

+	    func) }

+

+/* Memory allocation helpers */

+void *

+pixman_malloc_ab (unsigned int n, unsigned int b);

+

+void *

+pixman_malloc_abc (unsigned int a, unsigned int b, unsigned int c);

+

+pixman_bool_t

+pixman_multiply_overflows_int (unsigned int a, unsigned int b);

+

+pixman_bool_t

+pixman_addition_overflows_int (unsigned int a, unsigned int b);

+

+/* Compositing utilities */

+void

+pixman_expand (uint64_t *           dst,

+               const uint32_t *     src,

+               pixman_format_code_t format,

+               int                  width);

+

+void

+pixman_contract (uint32_t *      dst,

+                 const uint64_t *src,

+                 int             width);

+

+

+/* Region Helpers */

+pixman_bool_t

+pixman_region32_copy_from_region16 (pixman_region32_t *dst,

+                                    pixman_region16_t *src);

+

+pixman_bool_t

+pixman_region16_copy_from_region32 (pixman_region16_t *dst,

+                                    pixman_region32_t *src);

+

+

+/* Misc macros */

+

+#ifndef FALSE

+#   define FALSE 0

+#endif

+

+#ifndef TRUE

+#   define TRUE 1

+#endif

+

+#ifndef MIN

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

+#endif

+

+#ifndef MAX

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

+#endif

+

+/* Integer division that rounds towards -infinity */

+#define DIV(a, b)					   \

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

+     ((a) - (b) + 1 - (((b) < 0) << 1)) / (b))

+

+/* Modulus that produces the remainder wrt. DIV */

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

+

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

+

+/* Conversion between 8888 and 0565 */

+

+#define CONVERT_8888_TO_0565(s)						\

+    ((((s) >> 3) & 0x001f) |						\

+     (((s) >> 5) & 0x07e0) |						\

+     (((s) >> 8) & 0xf800))

+

+#define CONVERT_0565_TO_0888(s)						\

+    (((((s) << 3) & 0xf8) | (((s) >> 2) & 0x7)) |			\

+     ((((s) << 5) & 0xfc00) | (((s) >> 1) & 0x300)) |			\

+     ((((s) << 8) & 0xf80000) | (((s) << 3) & 0x70000)))

+

+#define CONVERT_0565_TO_8888(s) (CONVERT_0565_TO_0888(s) | 0xff000000)

+

+/* Trivial versions that are useful in macros */

+#define CONVERT_8888_TO_8888(s) (s)

+#define CONVERT_0565_TO_0565(s) (s)

+

+#define PIXMAN_FORMAT_IS_WIDE(f)					\

+    (PIXMAN_FORMAT_A (f) > 8 ||						\

+     PIXMAN_FORMAT_R (f) > 8 ||						\

+     PIXMAN_FORMAT_G (f) > 8 ||						\

+     PIXMAN_FORMAT_B (f) > 8)

+

+#ifdef WORDS_BIGENDIAN

+#   define SCREEN_SHIFT_LEFT(x,n)	((x) << (n))

+#   define SCREEN_SHIFT_RIGHT(x,n)	((x) >> (n))

+#else

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

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

+#endif

+

+/*

+ * Various debugging code

+ */

+

+#undef DEBUG

+

+#define COMPILE_TIME_ASSERT(x)						\

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

+

+/* Turn on debugging depending on what type of release this is

+ */

+#if (((PIXMAN_VERSION_MICRO % 2) == 0) && ((PIXMAN_VERSION_MINOR % 2) == 1))

+

+/* Debugging gets turned on for development releases because these

+ * are the things that end up in bleeding edge distributions such

+ * as Rawhide etc.

+ *

+ * For performance reasons we don't turn it on for stable releases or

+ * random git checkouts. (Random git checkouts are often used for

+ * performance work).

+ */

+

+#    define DEBUG

+

+#endif

+

+#ifdef DEBUG

+

+void

+_pixman_log_error (const char *function, const char *message);

+

+#define return_if_fail(expr)                                            \

+    do                                                                  \

+    {                                                                   \

+	if (!(expr))							\

+	{								\

+	    _pixman_log_error (FUNC, "The expression " # expr " was false"); \

+	    return;							\

+	}								\

+    }                                                                   \

+    while (0)

+

+#define return_val_if_fail(expr, retval)                                \

+    do                                                                  \

+    {                                                                   \

+	if (!(expr))                                                    \

+	{								\

+	    _pixman_log_error (FUNC, "The expression " # expr " was false"); \

+	    return (retval);						\

+	}								\

+    }                                                                   \

+    while (0)

+

+#define critical_if_fail(expr)						\

+    do									\

+    {									\

+	if (!(expr))							\

+	    _pixman_log_error (FUNC, "The expression " # expr " was false"); \

+    }									\

+    while (0)

+

+

+#else

+

+#define _pixman_log_error(f,m) do { } while (0)				\

+

+#define return_if_fail(expr)						\

+    do                                                                  \

+    {                                                                   \

+	if (!(expr))							\

+	    return;							\

+    }                                                                   \

+    while (0)

+

+#define return_val_if_fail(expr, retval)                                \

+    do                                                                  \

+    {                                                                   \

+	if (!(expr))							\

+	    return (retval);						\

+    }                                                                   \

+    while (0)

+

+#define critical_if_fail(expr)						\

+    do									\

+    {									\

+    }									\

+    while (0)

+#endif

+

+/*

+ * Timers

+ */

+

+#ifdef PIXMAN_TIMERS

+

+static inline uint64_t

+oil_profile_stamp_rdtsc (void)

+{

+    uint64_t ts;

+

+    __asm__ __volatile__ ("rdtsc\n" : "=A" (ts));

+    return ts;

+}

+

+#define OIL_STAMP oil_profile_stamp_rdtsc

+

+typedef struct pixman_timer_t pixman_timer_t;

+

+struct pixman_timer_t

+{

+    int             initialized;

+    const char *    name;

+    uint64_t        n_times;

+    uint64_t        total;

+    pixman_timer_t *next;

+};

+

+extern int timer_defined;

+

+void pixman_timer_register (pixman_timer_t *timer);

+

+#define TIMER_BEGIN(tname)                                              \

+    {                                                                   \

+	static pixman_timer_t timer ## tname;                           \

+	uint64_t              begin ## tname;                           \

+        								\

+	if (!timer ## tname.initialized)				\

+	{                                                               \

+	    timer ## tname.initialized = 1;				\

+	    timer ## tname.name = # tname;				\

+	    pixman_timer_register (&timer ## tname);			\

+	}                                                               \

+									\

+	timer ## tname.n_times++;					\

+	begin ## tname = OIL_STAMP ();

+

+#define TIMER_END(tname)                                                \

+    timer ## tname.total += OIL_STAMP () - begin ## tname;		\

+    }

+

+#endif /* PIXMAN_TIMERS */

+

+#endif /* PIXMAN_PRIVATE_H */

diff --git a/pixman/test/affine-test.c b/pixman/test/affine-test.c
index fbb35caa9..3c224d220 100644
--- a/pixman/test/affine-test.c
+++ b/pixman/test/affine-test.c
@@ -112,10 +112,36 @@ test_composite (int      testnum,
 

     if (lcg_rand_n (4) > 0)

     {

-	int c = lcg_rand_N (2 * 65536) - 65536;

-	int s = lcg_rand_N (2 * 65536) - 65536;

-	

+	int c, s, tx = 0, ty = 0;

+	switch (lcg_rand_n (4))

+	{

+	case 0:

+	    /* 90 degrees */

+	    c = 0;

+	    s = pixman_fixed_1;

+	    tx = pixman_int_to_fixed (MAX_SRC_HEIGHT);

+	    break;

+	case 1:

+	    /* 180 degrees */

+	    c = -pixman_fixed_1;

+	    s = 0;

+	    tx = pixman_int_to_fixed (MAX_SRC_WIDTH);

+	    ty = pixman_int_to_fixed (MAX_SRC_HEIGHT);

+	    break;

+	case 2:

+	    /* 270 degrees */

+	    c = 0;

+	    s = -pixman_fixed_1;

+	    ty = pixman_int_to_fixed (MAX_SRC_WIDTH);

+	    break;

+	default:

+	    /* arbitrary rotation */

+	    c = lcg_rand_N (2 * 65536) - 65536;

+	    s = lcg_rand_N (2 * 65536) - 65536;

+	    break;

+	}

 	pixman_transform_rotate (&transform, NULL, c, s);

+	pixman_transform_translate (&transform, NULL, tx, ty);

     }

 

     pixman_image_set_transform (src_img, &transform);

@@ -256,6 +282,6 @@ main (int argc, const char *argv[])
 {

     pixman_disable_out_of_bounds_workaround ();

 

-    return fuzzer_test_main ("affine", 8000000, 0x46EC3C6A,

+    return fuzzer_test_main ("affine", 8000000, 0x4B5D1852,

 			     test_composite, argc, argv);

 }