svn merge ^/branches/released .

25 files changed, 4706 insertions, 0 deletions

diff --git a/libXrender/.gitignore b/libXrender/.gitignore
new file mode 100644
index 000000000..9ba386edc
--- /dev/null
+++ b/libXrender/.gitignore
@@ -0,0 +1,78 @@
+#
+#		X.Org module default exclusion patterns
+#		The next section if for module specific patterns
+#
+#	Do not edit the following section
+# 	GNU Build System (Autotools)
+aclocal.m4
+autom4te.cache/
+autoscan.log
+ChangeLog
+compile
+config.guess
+config.h
+config.h.in
+config.log
+config-ml.in
+config.py
+config.status
+config.status.lineno
+config.sub
+configure
+configure.scan
+depcomp
+.deps/
+INSTALL
+install-sh
+.libs/
+libtool
+libtool.m4
+ltmain.sh
+lt~obsolete.m4
+ltoptions.m4
+ltsugar.m4
+ltversion.m4
+Makefile
+Makefile.in
+mdate-sh
+missing
+mkinstalldirs
+*.pc
+py-compile
+stamp-h?
+symlink-tree
+texinfo.tex
+ylwrap
+
+#	Do not edit the following section
+# 	Edit Compile Debug Document Distribute
+*~
+*.[0-9]
+*.[0-9]x
+*.bak
+*.bin
+core
+*.dll
+*.exe
+*-ISO*.bdf
+*-JIS*.bdf
+*-KOI8*.bdf
+*.kld
+*.ko
+*.ko.cmd
+*.lai
+*.l[oa]
+*.[oa]
+*.obj
+*.patch
+*.so
+*.pcf.gz
+*.pdb
+*.tar.bz2
+*.tar.gz
+#
+#		Add & Override patterns for libXrender 
+#
+#		Edit the following section as needed
+# For example, !report.pc overrides *.pc. See 'man gitignore'
+# 
diff --git a/libXrender/AUTHORS b/libXrender/AUTHORS
new file mode 100644
index 000000000..5f6c46a80
--- /dev/null
+++ b/libXrender/AUTHORS
@@ -0,0 +1,3 @@
+Keith Packard, of SuSE, XFree86 and Hewlett-Packard
+
+Noah Levitt, autotooling.
diff --git a/libXrender/COPYING b/libXrender/COPYING
new file mode 100644
index 000000000..0d548e5ea
--- /dev/null
+++ b/libXrender/COPYING
@@ -0,0 +1,39 @@
+
+Copyright © 2001,2003 Keith Packard
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation, and that the name of Keith Packard not be used in
+advertising or publicity pertaining to distribution of the software without
+specific, written prior permission.  Keith Packard makes no
+representations about the suitability of this software for any purpose.  It
+is provided "as is" without express or implied warranty.
+
+KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+
+Copyright © 2000 SuSE, 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.
diff --git a/libXrender/Makefile.am b/libXrender/Makefile.am
new file mode 100644
index 000000000..01ef1721e
--- /dev/null
+++ b/libXrender/Makefile.am
@@ -0,0 +1,39 @@
+# 
+#  Copyright © 2003 Keith Packard, Noah Levitt
+# 
+#  Permission to use, copy, modify, distribute, and sell this software and its
+#  documentation for any purpose is hereby granted without fee, provided that
+#  the above copyright notice appear in all copies and that both that
+#  copyright notice and this permission notice appear in supporting
+#  documentation, and that the name of Keith Packard not be used in
+#  advertising or publicity pertaining to distribution of the software without
+#  specific, written prior permission.  Keith Packard makes no
+#  representations about the suitability of this software for any purpose.  It
+#  is provided "as is" without express or implied warranty.
+# 
+#  KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+#  INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+#  EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+#  CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+#  DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+#  TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+#  PERFORMANCE OF THIS SOFTWARE.
+
+SUBDIRS = src
+
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = xrender.pc
+
+dist_doc_DATA = doc/libXrender.txt
+
+MAINTAINERCLEANFILES = ChangeLog INSTALL
+
+.PHONY: ChangeLog INSTALL
+
+INSTALL:
+	$(INSTALL_CMD)
+
+ChangeLog:
+	$(CHANGELOG_CMD)
+
+dist-hook: ChangeLog INSTALL
diff --git a/libXrender/README b/libXrender/README
new file mode 100644
index 000000000..c9d964a0f
--- /dev/null
+++ b/libXrender/README
@@ -0,0 +1,25 @@
+libXrender - library for the Render Extension to the X11 protocol
+
+All questions regarding this software should be directed at the
+Xorg mailing list:
+
+        http://lists.freedesktop.org/mailman/listinfo/xorg
+
+Please submit bug reports to the Xorg bugzilla:
+
+        https://bugs.freedesktop.org/enter_bug.cgi?product=xorg
+
+The master development code repository can be found at:
+
+        git://anongit.freedesktop.org/git/xorg/lib/libXrender
+
+        http://cgit.freedesktop.org/xorg/lib/libXrender
+
+For patch submission instructions, see:
+
+	http://www.x.org/wiki/Development/Documentation/SubmittingPatches
+
+For more information on the git code manager, see:
+
+        http://wiki.x.org/wiki/GitPage
+
diff --git a/libXrender/autogen.sh b/libXrender/autogen.sh
new file mode 100644
index 000000000..904cd6746
--- /dev/null
+++ b/libXrender/autogen.sh
@@ -0,0 +1,12 @@
+#! /bin/sh
+
+srcdir=`dirname $0`
+test -z "$srcdir" && srcdir=.
+
+ORIGDIR=`pwd`
+cd $srcdir
+
+autoreconf -v --install || exit 1
+cd $ORIGDIR || exit $?
+
+$srcdir/configure --enable-maintainer-mode "$@"
diff --git a/libXrender/configure.ac b/libXrender/configure.ac
new file mode 100644
index 000000000..57ae66e37
--- /dev/null
+++ b/libXrender/configure.ac
@@ -0,0 +1,67 @@
+dnl 
+dnl  Copyright © 2003 Keith Packard, Noah Levitt
+dnl 
+dnl  Permission to use, copy, modify, distribute, and sell this software and its
+dnl  documentation for any purpose is hereby granted without fee, provided that
+dnl  the above copyright notice appear in all copies and that both that
+dnl  copyright notice and this permission notice appear in supporting
+dnl  documentation, and that the name of Keith Packard not be used in
+dnl  advertising or publicity pertaining to distribution of the software without
+dnl  specific, written prior permission.  Keith Packard makes no
+dnl  representations about the suitability of this software for any purpose.  It
+dnl  is provided "as is" without express or implied warranty.
+dnl 
+dnl  KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+dnl  INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+dnl  EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+dnl  CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+dnl  DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+dnl  TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+dnl  PERFORMANCE OF THIS SOFTWARE.
+dnl
+dnl Process this file with autoconf to create configure.
+
+AC_PREREQ([2.60])
+
+dnl
+dnl Version should match the current Render version. XRenderQueryVersion
+dnl returns the version from render.h, NOT the version we set here. But we
+dnl try to keep these the same.  Note that the library has an extra
+dnl digit in the version number to track changes which don't affect the
+dnl protocol, so Xrender version l.n.m corresponds to protocol version l.n
+dnl
+AC_INIT(libXrender,
+	0.9.6,
+	[https://bugs.freedesktop.org/enter_bug.cgi?product=xorg],
+	libXrender)
+AM_INIT_AUTOMAKE([foreign dist-bzip2])
+AM_MAINTAINER_MODE
+
+# Require xorg-macros: XORG_DEFAULT_OPTIONS
+m4_ifndef([XORG_MACROS_VERSION],
+          [m4_fatal([must install xorg-macros 1.3 or later before running autoconf/autogen])])
+XORG_MACROS_VERSION(1.3)
+XORG_DEFAULT_OPTIONS
+AM_CONFIG_HEADER(config.h)
+
+# Check for progs
+AC_PROG_CC
+AC_PROG_LIBTOOL
+
+# Check render configuration, strip extra digits from package version to
+# find the required protocol version
+
+if test "$VERSION" = "" ; then
+       VERSION=$PACKAGE_VERSION;
+fi
+RENDER_VERSION=[`echo $VERSION | sed 's/^\([0-9][0-9]*\.[0-9][0-9]*\).*$/\1/'`]
+AC_SUBST(RENDER_VERSION)
+PKG_CHECK_MODULES(RENDER, x11 renderproto >= $RENDER_VERSION)
+AC_SUBST(RENDER_CFLAGS)
+
+XORG_CHECK_MALLOC_ZERO
+
+AC_OUTPUT([Makefile
+	   src/Makefile
+           xrender.pc])
+
diff --git a/libXrender/doc/libXrender.txt b/libXrender/doc/libXrender.txt
new file mode 100644
index 000000000..79af0345a
--- /dev/null
+++ b/libXrender/doc/libXrender.txt
@@ -0,0 +1,600 @@
+                         The Xrender Library
+			    Version 0.7
+			      2002-11-6
+			    Keith Packard
+			  keithp@xfree86.org
+
+1. Introduction
+
+The Xrender library is designed as a lightweight library interface to the
+Render extension.  This document describes how the library maps to the
+protocol without duplicating the semantics described by that document.
+
+2. Data Types
+
+2.1 Primitive Types
+
+For resources represented as CARD32 or XID on the wire, Xrender exposes them
+using an 'unsigned long' type as is the norm for 32-bit data objects in an
+Xlib compatible API.
+
+	typedef unsigned long	Glyph;
+	typedef unsigned long	GlyphSet;
+	typedef unsigned long	Picture;
+	typedef unsigned long	PictFormat;
+
+Glyphs are just CARD32 objects, while GlyphSet, Picture and PictFormat
+values are XIDs.
+
+	typedef int XFixed;
+
+Fixed point numbers buck the Xlib convention by being represented as ints.
+Machines for which 'int' is smaller than 32 bits cannot support the Xrender
+library.
+
+2.2 PictFormat descriptions.
+
+The definition of a PictFormat is exposed by two data structures:
+
+	typedef struct {
+	    short   red;
+	    short   redMask;
+	    short   green;
+	    short   greenMask;
+	    short   blue;
+	    short   blueMask;
+	    short   alpha;
+	    short   alphaMask;
+	} XRenderDirectFormat;
+
+	typedef struct {
+	    PictFormat		id;
+	    int			type;
+	    int			depth;
+	    XRenderDirectFormat	direct;
+	    Colormap		colormap;
+	} XRenderPictFormat;
+
+These serve both as a description of the available formats and as patterns
+against which available formats are matched.
+
+2.3 Picture Attributes
+
+When creating or changing Picture objects, attributes are passed much as
+they are for XCreateWindow/XChangeWindowAttributes.  A structure capable of
+holding all of the attributes has the relevant ones set and a bitmask passed
+as a separate argument which marks the valid entries.
+
+	typedef struct _XRenderPictureAttributes {
+	    Bool		repeat;
+	    Picture		alpha_map;
+	    int			alpha_x_origin;
+	    int			alpha_y_origin;
+	    int			clip_x_origin;
+	    int			clip_y_origin;
+	    Pixmap		clip_mask;
+	    Bool		graphics_exposures;
+	    int			subwindow_mode;
+	    int			poly_edge;
+	    int			poly_mode;
+	    Atom		dither;
+	    Bool		component_alpha;
+	} XRenderPictureAttributes;
+
+2.4 Colors
+
+The core protocol XColor type doesn't include an alpha component, so Xrender
+has a separate type.
+
+	typedef struct {
+	    unsigned short   red;
+	    unsigned short   green;
+	    unsigned short   blue;
+	    unsigned short   alpha;
+	} XRenderColor;
+
+2.5 Glyph Types
+
+Glyphs are stored in the server, so these definitions are passed from the
+client to the library and on to the server as glyphs are rasterized and
+transmitted over the wire.
+
+	typedef struct _XGlyphInfo {
+	    unsigned short  width;
+	    unsigned short  height;
+	    short	    x;
+	    short	    y;
+	    short	    xOff;
+	    short	    yOff;
+	} XGlyphInfo;
+
+2.6 Glyph Rendering types
+
+Glyph rendering can either take a single string of glyph indices or an array
+of one of the following structures.
+
+	typedef struct _XGlyphElt8 {
+	    GlyphSet		    glyphset;
+	    _Xconst char	    *chars;
+	    int			    nchars;
+	    int			    xOff;
+	    int			    yOff;
+	} XGlyphElt8;
+
+	typedef struct _XGlyphElt16 {
+	    GlyphSet		    glyphset;
+	    _Xconst unsigned short  *chars;
+	    int			    nchars;
+	    int			    xOff;
+	    int			    yOff;
+	} XGlyphElt16;
+
+	typedef struct _XGlyphElt32 {
+	    GlyphSet		    glyphset;
+	    _Xconst unsigned int    *chars;
+	    int			    nchars;
+	    int			    xOff;
+	    int			    yOff;
+	} XGlyphElt32;
+
+2.7 Geometric Types
+
+Geometric operations directly expose the available protocol datatypes
+
+	typedef struct _XPointFixed {
+	    XFixed  x, y;
+	} XPointFixed;
+
+	typedef struct _XLineFixed {
+	    XPointFixed	p1, p2;
+	} XLineFixed;
+
+	typedef struct _XTriangle {
+	    XPointFixed	p1, p2, p3;
+	} XTriangle;
+
+	typedef struct _XTrapezoid {
+	    XFixed  top, bottom;
+	    XLineFixed	left, right;
+	} XTrapezoid;
+
+	typedef struct _XTransform {
+	    XFixed  matrix[3][3];
+	} XTransform;
+
+2.8 Transformation Filters
+
+All of the filters are named simultaneously; Xrender provides no convenience
+functions for dealing with them.
+
+	typedef struct _XFilters {
+	    int	    nfilter;
+	    char    **filter;
+	    int	    nalias;
+	    short   *alias;
+	} XFilters;
+
+2.9 Index type PictFormat colors
+
+PictFormats of Index type advertise which colors will be used for drawing
+through this type.
+
+	typedef struct _XIndexValue {
+	    unsigned long    pixel;
+	    unsigned short   red, green, blue, alpha;
+	} XIndexValue;
+
+
+3 Application Startup Functions
+
+3.1 Initialization functions
+
+	Bool XRenderQueryExtension (Display *dpy,
+			            int     *event_basep,
+				    int     *error_basep)
+
+This function returns True if the Render extension is available on dpy.
+event_basep and error_basep will be filled in with the first event and error
+numbers used by the extension (note that Render currently uses no events).
+
+	Status XRenderQueryVersion (Display *dpy,
+				    int     *major_versionp,
+				    int     *minor_versionp)
+
+XRenderQueryVersion returns zero if the Render extension is not present or
+some error occurred while attempting to discover the current Render version
+number.  Otherwise, XRenderQueryVersion returns 1 and stores the version
+number returned by the server in *major_versionp and *minor_versionp, which
+will be less than or equal to the library version numbers RENDER_MAJOR and
+RENDER_MINOR.
+
+	Status XRenderQueryFormats (Display *dpy)
+
+XRenderQueryFormats returns 1 if it successfully fetches the available
+PictFormat information from the X server, 0 otherwise.  Applications needn't
+invoke this function directly (hmm, perhaps it should be removed from the
+external interfaces then).
+
+3.2 Subpixel Order
+
+	int XRenderQuerySubpixelOrder (Display *dpy, int screen)
+
+	Bool XRenderSetSubpixelOrder (Display *dpy, int screen, int subpixel)
+
+Applications interested in the geometry of the elements making up a single
+pixel on the screen should use XRenderQuerySubpixelOrder and not cache the
+return value.  XRenderSetSubpixelOrder is used by the XRandR library to
+update the value stored by Xrender when the subpixel order changes as a
+result of screen reconfiguration.
+
+3.3 PictFormat matching
+
+Xrender provides these APIs to help locate appropriate PictFormats; they are
+intended to work much like the Visual matching APIs in Xlib.  The
+application provides a specification including the necessary PictFormat
+characteristics and Xrender returns a matching XRenderPictFormat structure
+which describes the PictFormat.
+
+	XRenderPictFormat *
+	XRenderFindFormat (Display			*dpy,
+			   unsigned long		mask,
+			   _Xconst XRenderPictFormat	*templ,
+			   int				count)
+
+	#define PictFormatID	    (1 << 0)
+	#define PictFormatType	    (1 << 1)
+	#define PictFormatDepth	    (1 << 2)
+	#define PictFormatRed	    (1 << 3)
+	#define PictFormatRedMask   (1 << 4)
+	#define PictFormatGreen	    (1 << 5)
+	#define PictFormatGreenMask (1 << 6)
+	#define PictFormatBlue	    (1 << 7)
+	#define PictFormatBlueMask  (1 << 8)
+	#define PictFormatAlpha	    (1 << 9)
+	#define PictFormatAlphaMask (1 << 10)
+	#define PictFormatColormap  (1 << 11)
+
+XRenderFindFormat locates a PictFormat matching the characteristics provided
+in the templ.  Only elements whose associated bit in mask are compared.
+
+	XRenderPictFormat *
+	XRenderFindVisualFormat (Display *dpy, _Xconst Visual *visual)
+
+Finds the PictFormat suitable for use with the specified visual.
+
+	XRenderPictFormat *
+	XRenderFindStandardFormat (Display		*dpy,
+				   int			format)
+
+	#define PictStandardARGB32  0
+	#define PictStandardRGB24   1
+	#define PictStandardA8	    2
+	#define PictStandardA4	    3
+	#define PictStandardA1	    4
+	#define PictStandardNUM	    5
+
+As a convenience, this function locates PictFormats that coorespond to
+commonly used formats.
+
+	ARGB32		depth 32, bits 31-24 A, 23-16 R, 15-8 G, 7-0 B
+	RGB24		depth 24, bits 23-16 R, 15-8 G, 7-0 B
+	A8		depth 8, bits 7-0 A
+	A4		depth 4, bits 3-0 A
+	A1		depth 1, bits 0 A
+
+Any server supporting Render must have a PictFormat cooresponding to each of
+these standard formats.
+
+3.4 Index type PictFormat color values
+
+	XIndexValue *
+	XRenderQueryPictIndexValues(Display			*dpy,
+				    _Xconst XRenderPictFormat	*format,
+				    int				*num)
+
+If format refers to an Index type PictFormat, XRenderQueryPictIndexValues
+returns the set of pixel values and their associated colors used when
+drawing to Pictures created with that format.  Otherwise,
+XRenderQueryPictIndexValues generates a BadMatch error.
+
+3.5 Querying available filters
+
+	XFilters *
+	XRenderQueryFilters (Display *dpy, Drawable drawable);
+
+Filters are used with non-identity transformation matrices, this function
+returns a datastructure identifying the available filters on display that
+can be associated with pictures for the screen associated with drawable.
+
+Free this structure with XFree.
+
+4 Picture Functions
+
+	Picture
+	XRenderCreatePicture (Display				*dpy,
+			      Drawable				drawable,
+			      _Xconst XRenderPictFormat		*format,
+			      unsigned long			valuemask,
+			      _Xconst XRenderPictureAttributes	*attributes)
+
+	#define CPRepeat			    (1 << 0)
+	#define CPAlphaMap			    (1 << 1)
+	#define CPAlphaXOrigin			    (1 << 2)
+	#define CPAlphaYOrigin			    (1 << 3)
+	#define CPClipXOrigin			    (1 << 4)
+	#define CPClipYOrigin			    (1 << 5)
+	#define CPClipMask			    (1 << 6)
+	#define CPGraphicsExposure		    (1 << 7)
+	#define CPSubwindowMode			    (1 << 8)
+	#define CPPolyEdge			    (1 << 9)
+	#define CPPolyMode			    (1 << 10)
+	#define CPDither			    (1 << 11)
+	#define CPComponentAlpha		    (1 << 12)
+	#define CPLastBit			    11
+
+Creates a picture for drawable in the specified format.  Any values
+specified in 'attributes' and 'valuemask' are used in place of the default
+values.
+
+	void
+	XRenderChangePicture (Display				*dpy,
+			      Picture				picture,
+			      unsigned long			valuemask,
+			      _Xconst XRenderPictureAttributes  *attributes)
+
+Change values in picture to those specified by valuemask and attributes.
+
+
+	void
+	XRenderSetPictureClipRectangles (Display	    *dpy,
+					 Picture	    picture,
+					 int		    xOrigin,
+					 int		    yOrigin,
+					 _Xconst XRectangle *rects,
+					 int		    n)
+
+Sets the clip mask in picture to the union of rects offset by
+xOrigin/yOrigin.
+
+	void
+	XRenderSetPictureClipRegion (Display	    *dpy,
+				     Picture	    picture,
+				     Region	    r)
+
+Sets the clip mask in picture to r.
+
+	void
+	XRenderSetPictureTransform (Display	    *dpy,
+				    Picture	    picture,
+				    XTransform	    *transform)
+
+Sets the projective transformation matrix of picture to transform.
+
+	void
+	XRenderFreePicture (Display                   *dpy,
+			    Picture                   picture)
+
+Instructs the server to free picture.
+
+5 GlyphSet functions
+
+	GlyphSet
+	XRenderCreateGlyphSet (Display *dpy, _Xconst XRenderPictFormat *format)
+
+Creates a glyphset, every glyph in the set will use PictFormat format.
+
+	GlyphSet
+	XRenderReferenceGlyphSet (Display *dpy, GlyphSet existing)
+
+Creates a new GlyphSet ID which references an existing GlyphSet.  The
+two IDs refer to the same object so that changes using one ID will be
+visible through the other ID.  This is designed to allow multiple clients to
+share the same GlyphSet so that it doesn't get destroyed when the first
+client exits.
+
+	void
+	XRenderFreeGlyphSet (Display *dpy, GlyphSet glyphset)
+
+Frees the glyphset ID.  If no other GlyphSet IDs refer to the underlying
+GlyphSet, it will be destroyed.
+
+	void
+	XRenderAddGlyphs (Display		*dpy,
+			  GlyphSet		glyphset,
+			  _Xconst Glyph		*gids,
+			  _Xconst XGlyphInfo	*glyphs,
+			  int			nglyphs,
+			  _Xconst char		*images,
+			  int			nbyte_images)
+
+Add glyphs to glyphset.  The images are packed together in Z-pixmap format
+according to the depth of the PictFormat used in creating glyphset.
+
+	void
+	XRenderFreeGlyphs (Display	    *dpy,
+			   GlyphSet	    glyphset,
+			   _Xconst Glyph    *gids,
+			   int		    nglyphs)
+
+Free some glyphs from glyphset.
+
+6 Glyph Drawing Routines
+
+Xrender provides two parallel APIs for glyph rendering, a simple API which
+accepts a single string similar to XDrawString and a more complex API which
+accepts an array of XGlyphElt{8,16,32} structures, each of which includes a
+glyphset, string and x/y offsets which parallel the XDrawText API.  Xrender
+also provides glyphs in three sizes, 8 16 and 32 bits.  The simple API is
+just a convenience for the user as both forms generate the same underlying
+Render protocol.
+
+6.1 Simple single-string glyph drawing functions
+
+These are identical except for the format of the glyph ids.
+
+	void
+	XRenderCompositeString8 (Display		    *dpy,
+				 int			    op,
+				 Picture		    src,
+				 Picture		    dst,
+				 _Xconst XRenderPictFormat  *maskFormat,
+				 GlyphSet		    glyphset,
+				 int			    xSrc,
+				 int			    ySrc,
+				 int			    xDst,
+				 int			    yDst,
+				 _Xconst char		    *string,
+				 int			    nchar)
+
+	void
+	XRenderCompositeString16 (Display		    *dpy,
+				  int			    op,
+				  Picture		    src,
+				  Picture		    dst,
+				  _Xconst XRenderPictFormat *maskFormat,
+				  GlyphSet		    glyphset,
+				  int			    xSrc,
+				  int			    ySrc,
+				  int			    xDst,
+				  int			    yDst,
+				  _Xconst unsigned short    *string,
+				  int			    nchar)
+
+	void
+	XRenderCompositeString32 (Display		    *dpy,
+				  int			    op,
+				  Picture		    src,
+				  Picture		    dst,
+				  _Xconst XRenderPictFormat *maskFormat,
+				  GlyphSet		    glyphset,
+				  int			    xSrc,
+				  int			    ySrc,
+				  int			    xDst,
+				  int			    yDst,
+				  _Xconst unsigned int	    *string,
+				  int			    nchar)
+
+6.2 Complete glyph drawing functions
+
+As with the simple functions above, these differ only in the type of the
+underlying glyph id storage type.
+
+	void
+	XRenderCompositeText8 (Display			    *dpy,
+			       int			    op,
+			       Picture			    src,
+			       Picture			    dst,
+			       _Xconst XRenderPictFormat    *maskFormat,
+			       int			    xSrc,
+			       int			    ySrc,
+			       int			    xDst,
+			       int			    yDst,
+			       _Xconst XGlyphElt8	    *elts,
+			       int			    nelt)
+
+	void
+	XRenderCompositeText16 (Display			    *dpy,
+				int			    op,
+				Picture			    src,
+				Picture			    dst,
+				_Xconst XRenderPictFormat   *maskFormat,
+				int			    xSrc,
+				int			    ySrc,
+				int			    xDst,
+				int			    yDst,
+				_Xconst XGlyphElt16	    *elts,
+				int			    nelt)
+
+	void
+	XRenderCompositeText32 (Display			    *dpy,
+				int			    op,
+				Picture			    src,
+				Picture			    dst,
+				_Xconst XRenderPictFormat   *maskFormat,
+				int			    xSrc,
+				int			    ySrc,
+				int			    xDst,
+				int			    yDst,
+				_Xconst XGlyphElt32	    *elts,
+				int			    nelt)
+
+7 Basic Graphics Functions
+
+These are the simplest graphics functions upon which the other functions are
+conceptually built.
+
+7.1 Composite
+
+XRenderComposite exposes the RenderComposite protocol request directly.
+
+	void
+	XRenderComposite (Display   *dpy,
+			  int	    op,
+			  Picture   src,
+			  Picture   mask,
+			  Picture   dst,
+			  int	    src_x,
+			  int	    src_y,
+			  int	    mask_x,
+			  int	    mask_y,
+			  int	    dst_x,
+			  int	    dst_y,
+			  unsigned int	width,
+			  unsigned int	height)
+
+
+7.2 Rectangles
+
+These functions composite rectangles of the specified color, they differ
+only in that XRenderFillRectangles draws more than one at a time.
+
+	void
+	XRenderFillRectangle (Display		    *dpy,
+			      int		    op,
+			      Picture		    dst,
+			      _Xconst XRenderColor  *color,
+			      int		    x,
+			      int		    y,
+			      unsigned int	    width,
+			      unsigned int	    height)
+
+	void
+	XRenderFillRectangles (Display		    *dpy,
+			       int		    op,
+			       Picture		    dst,
+			       _Xconst XRenderColor *color,
+			       _Xconst XRectangle   *rectangles,
+			       int		    n_rects)
+
+8 Geometric Objects
+
+All geometric drawing with Render is performed with sequences of trapezoids
+or triangles; the client is responsible for breaking more complex figures
+into these simple shapes.
+
+8.1 Trapezoids
+
+	void
+	XRenderCompositeTrapezoids (Display		*dpy,
+				    int			op,
+				    Picture		src,
+				    Picture		dst,
+				    _Xconst XRenderPictFormat	*maskFormat,
+				    int			xSrc,
+				    int			ySrc,
+				    _Xconst XTrapezoid	*traps,
+				    int			ntrap)
+
+XRenderCompositeTrapezoids builds RenderTrapezoids requests to composite the
+specified list of trapezoids to dst.  XRenderCompositeTrapezoids will split
+the list of trapezoids to build requests no larger than the maximum request
+size supported by the server.  This can create rendering artifacts as the
+precompositing done by RenderTrapezoids when a maskFormat is specified
+cannot span multiple requests.
+
+8.2 Triangles
+
+Render provides three different ways of encoding triangles on the wire,
+Xrender exposes those with three separate triangle drawing routines.  As
+with trapezoids above, Xrender will split the arguments to fit requests into
+the servers limits, but this may cause rendering artifacts.
diff --git a/libXrender/include/X11/extensions/Xrender.h b/libXrender/include/X11/extensions/Xrender.h
new file mode 100644
index 000000000..5248e99bd
--- /dev/null
+++ b/libXrender/include/X11/extensions/Xrender.h
@@ -0,0 +1,528 @@
+/*
+ *
+ * Copyright © 2000 SuSE, 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.
+ */
+
+#ifndef _XRENDER_H_
+#define _XRENDER_H_
+
+#include <X11/Xlib.h>
+#include <X11/Xfuncproto.h>
+#include <X11/Xosdefs.h>
+#include <X11/Xutil.h>
+
+#include <X11/extensions/render.h>
+
+typedef struct {
+    short   red;
+    short   redMask;
+    short   green;
+    short   greenMask;
+    short   blue;
+    short   blueMask;
+    short   alpha;
+    short   alphaMask;
+} XRenderDirectFormat;
+
+typedef struct {
+    PictFormat		id;
+    int			type;
+    int			depth;
+    XRenderDirectFormat	direct;
+    Colormap		colormap;
+} XRenderPictFormat;
+
+#define PictFormatID	    (1 << 0)
+#define PictFormatType	    (1 << 1)
+#define PictFormatDepth	    (1 << 2)
+#define PictFormatRed	    (1 << 3)
+#define PictFormatRedMask   (1 << 4)
+#define PictFormatGreen	    (1 << 5)
+#define PictFormatGreenMask (1 << 6)
+#define PictFormatBlue	    (1 << 7)
+#define PictFormatBlueMask  (1 << 8)
+#define PictFormatAlpha	    (1 << 9)
+#define PictFormatAlphaMask (1 << 10)
+#define PictFormatColormap  (1 << 11)
+
+typedef struct _XRenderPictureAttributes {
+    int 		repeat;
+    Picture		alpha_map;
+    int			alpha_x_origin;
+    int			alpha_y_origin;
+    int			clip_x_origin;
+    int			clip_y_origin;
+    Pixmap		clip_mask;
+    Bool		graphics_exposures;
+    int			subwindow_mode;
+    int			poly_edge;
+    int			poly_mode;
+    Atom		dither;
+    Bool		component_alpha;
+} XRenderPictureAttributes;
+
+typedef struct {
+    unsigned short   red;
+    unsigned short   green;
+    unsigned short   blue;
+    unsigned short   alpha;
+} XRenderColor;
+
+typedef struct _XGlyphInfo {
+    unsigned short  width;
+    unsigned short  height;
+    short	    x;
+    short	    y;
+    short	    xOff;
+    short	    yOff;
+} XGlyphInfo;
+
+typedef struct _XGlyphElt8 {
+    GlyphSet		    glyphset;
+    _Xconst char	    *chars;
+    int			    nchars;
+    int			    xOff;
+    int			    yOff;
+} XGlyphElt8;
+
+typedef struct _XGlyphElt16 {
+    GlyphSet		    glyphset;
+    _Xconst unsigned short  *chars;
+    int			    nchars;
+    int			    xOff;
+    int			    yOff;
+} XGlyphElt16;
+
+typedef struct _XGlyphElt32 {
+    GlyphSet		    glyphset;
+    _Xconst unsigned int    *chars;
+    int			    nchars;
+    int			    xOff;
+    int			    yOff;
+} XGlyphElt32;
+
+typedef double	XDouble;
+
+typedef struct _XPointDouble {
+    XDouble  x, y;
+} XPointDouble;
+
+#define XDoubleToFixed(f)    ((XFixed) ((f) * 65536))
+#define XFixedToDouble(f)    (((XDouble) (f)) / 65536)
+
+typedef int XFixed;
+
+typedef struct _XPointFixed {
+    XFixed  x, y;
+} XPointFixed;
+
+typedef struct _XLineFixed {
+    XPointFixed	p1, p2;
+} XLineFixed;
+
+typedef struct _XTriangle {
+    XPointFixed	p1, p2, p3;
+} XTriangle;
+
+typedef struct _XCircle {
+    XFixed x;
+    XFixed y;
+    XFixed radius;
+} XCircle;
+
+typedef struct _XTrapezoid {
+    XFixed  top, bottom;
+    XLineFixed	left, right;
+} XTrapezoid;
+
+typedef struct _XTransform {
+    XFixed  matrix[3][3];
+} XTransform;
+
+typedef struct _XFilters {
+    int	    nfilter;
+    char    **filter;
+    int	    nalias;
+    short   *alias;
+} XFilters;
+
+typedef struct _XIndexValue {
+    unsigned long    pixel;
+    unsigned short   red, green, blue, alpha;
+} XIndexValue;
+
+typedef struct _XAnimCursor {
+    Cursor	    cursor;
+    unsigned long   delay;
+} XAnimCursor;
+
+typedef struct _XSpanFix {
+    XFixed	    left, right, y;
+} XSpanFix;
+
+typedef struct _XTrap {
+    XSpanFix	    top, bottom;
+} XTrap;
+
+typedef struct _XLinearGradient {
+    XPointFixed p1;
+    XPointFixed p2;
+} XLinearGradient;
+
+typedef struct _XRadialGradient {
+    XCircle inner;
+    XCircle outer;
+} XRadialGradient;
+
+typedef struct _XConicalGradient {
+    XPointFixed center;
+    XFixed angle; /* in degrees */
+} XConicalGradient;
+
+_XFUNCPROTOBEGIN
+
+Bool XRenderQueryExtension (Display *dpy, int *event_basep, int *error_basep);
+
+Status XRenderQueryVersion (Display *dpy,
+			    int     *major_versionp,
+			    int     *minor_versionp);
+
+Status XRenderQueryFormats (Display *dpy);
+
+int XRenderQuerySubpixelOrder (Display *dpy, int screen);
+
+Bool XRenderSetSubpixelOrder (Display *dpy, int screen, int subpixel);
+
+XRenderPictFormat *
+XRenderFindVisualFormat (Display *dpy, _Xconst Visual *visual);
+
+XRenderPictFormat *
+XRenderFindFormat (Display			*dpy,
+		   unsigned long		mask,
+		   _Xconst XRenderPictFormat	*templ,
+		   int				count);
+    
+#define PictStandardARGB32  0
+#define PictStandardRGB24   1
+#define PictStandardA8	    2
+#define PictStandardA4	    3
+#define PictStandardA1	    4
+#define PictStandardNUM	    5
+
+XRenderPictFormat *
+XRenderFindStandardFormat (Display		*dpy,
+			   int			format);
+
+XIndexValue *
+XRenderQueryPictIndexValues(Display			*dpy,
+			    _Xconst XRenderPictFormat	*format,
+			    int				*num);
+
+Picture
+XRenderCreatePicture (Display				*dpy,
+		      Drawable				drawable,
+		      _Xconst XRenderPictFormat		*format,
+		      unsigned long			valuemask,
+		      _Xconst XRenderPictureAttributes	*attributes);
+
+void
+XRenderChangePicture (Display				*dpy,
+		      Picture				picture,
+		      unsigned long			valuemask,
+		      _Xconst XRenderPictureAttributes  *attributes);
+
+void
+XRenderSetPictureClipRectangles (Display	    *dpy,
+				 Picture	    picture,
+				 int		    xOrigin,
+				 int		    yOrigin,
+				 _Xconst XRectangle *rects,
+				 int		    n);
+
+void
+XRenderSetPictureClipRegion (Display	    *dpy,
+			     Picture	    picture,
+			     Region	    r);
+
+void
+XRenderSetPictureTransform (Display	    *dpy,
+			    Picture	    picture,
+			    XTransform	    *transform);
+
+void
+XRenderFreePicture (Display                   *dpy,
+		    Picture                   picture);
+
+void
+XRenderComposite (Display   *dpy,
+		  int	    op,
+		  Picture   src,
+		  Picture   mask,
+		  Picture   dst,
+		  int	    src_x,
+		  int	    src_y,
+		  int	    mask_x,
+		  int	    mask_y,
+		  int	    dst_x,
+		  int	    dst_y,
+		  unsigned int	width,
+		  unsigned int	height);
+
+GlyphSet
+XRenderCreateGlyphSet (Display *dpy, _Xconst XRenderPictFormat *format);
+
+GlyphSet
+XRenderReferenceGlyphSet (Display *dpy, GlyphSet existing);
+
+void
+XRenderFreeGlyphSet (Display *dpy, GlyphSet glyphset);
+
+void
+XRenderAddGlyphs (Display		*dpy,
+		  GlyphSet		glyphset,
+		  _Xconst Glyph		*gids,
+		  _Xconst XGlyphInfo	*glyphs,
+		  int			nglyphs,
+		  _Xconst char		*images,
+		  int			nbyte_images);
+
+void
+XRenderFreeGlyphs (Display	    *dpy,
+		   GlyphSet	    glyphset,
+		   _Xconst Glyph    *gids,
+		   int		    nglyphs);
+
+void
+XRenderCompositeString8 (Display		    *dpy,
+			 int			    op,
+			 Picture		    src,
+			 Picture		    dst,
+			 _Xconst XRenderPictFormat  *maskFormat,
+			 GlyphSet		    glyphset,
+			 int			    xSrc,
+			 int			    ySrc,
+			 int			    xDst,
+			 int			    yDst,
+			 _Xconst char		    *string,
+			 int			    nchar);
+
+void
+XRenderCompositeString16 (Display		    *dpy,
+			  int			    op,
+			  Picture		    src,
+			  Picture		    dst,
+			  _Xconst XRenderPictFormat *maskFormat,
+			  GlyphSet		    glyphset,
+			  int			    xSrc,
+			  int			    ySrc,
+			  int			    xDst,
+			  int			    yDst,
+			  _Xconst unsigned short    *string,
+			  int			    nchar);
+
+void
+XRenderCompositeString32 (Display		    *dpy,
+			  int			    op,
+			  Picture		    src,
+			  Picture		    dst,
+			  _Xconst XRenderPictFormat *maskFormat,
+			  GlyphSet		    glyphset,
+			  int			    xSrc,
+			  int			    ySrc,
+			  int			    xDst,
+			  int			    yDst,
+			  _Xconst unsigned int	    *string,
+			  int			    nchar);
+
+void
+XRenderCompositeText8 (Display			    *dpy,
+		       int			    op,
+		       Picture			    src,
+		       Picture			    dst,
+		       _Xconst XRenderPictFormat    *maskFormat,
+		       int			    xSrc,
+		       int			    ySrc,
+		       int			    xDst,
+		       int			    yDst,
+		       _Xconst XGlyphElt8	    *elts,
+		       int			    nelt);
+
+void
+XRenderCompositeText16 (Display			    *dpy,
+			int			    op,
+			Picture			    src,
+			Picture			    dst,
+			_Xconst XRenderPictFormat   *maskFormat,
+			int			    xSrc,
+			int			    ySrc,
+			int			    xDst,
+			int			    yDst,
+			_Xconst XGlyphElt16	    *elts,
+			int			    nelt);
+
+void
+XRenderCompositeText32 (Display			    *dpy,
+			int			    op,
+			Picture			    src,
+			Picture			    dst,
+			_Xconst XRenderPictFormat   *maskFormat,
+			int			    xSrc,
+			int			    ySrc,
+			int			    xDst,
+			int			    yDst,
+			_Xconst XGlyphElt32	    *elts,
+			int			    nelt);
+
+void
+XRenderFillRectangle (Display		    *dpy,
+		      int		    op,
+		      Picture		    dst,
+		      _Xconst XRenderColor  *color,
+		      int		    x,
+		      int		    y,
+		      unsigned int	    width,
+		      unsigned int	    height);
+
+void
+XRenderFillRectangles (Display		    *dpy,
+		       int		    op,
+		       Picture		    dst,
+		       _Xconst XRenderColor *color,
+		       _Xconst XRectangle   *rectangles,
+		       int		    n_rects);
+
+void
+XRenderCompositeTrapezoids (Display		*dpy,
+			    int			op,
+			    Picture		src,
+			    Picture		dst,
+			    _Xconst XRenderPictFormat	*maskFormat,
+			    int			xSrc,
+			    int			ySrc,
+			    _Xconst XTrapezoid	*traps,
+			    int			ntrap);
+
+void
+XRenderCompositeTriangles (Display		*dpy,
+			   int			op,
+			   Picture		src,
+			   Picture		dst,
+			    _Xconst XRenderPictFormat	*maskFormat,
+			   int			xSrc,
+			   int			ySrc,
+			   _Xconst XTriangle	*triangles,
+			   int			ntriangle);
+
+void
+XRenderCompositeTriStrip (Display		*dpy,
+			  int			op,
+			  Picture		src,
+			  Picture		dst,
+			    _Xconst XRenderPictFormat	*maskFormat,
+			  int			xSrc,
+			  int			ySrc,
+			  _Xconst XPointFixed	*points,
+			  int			npoint);
+
+void
+XRenderCompositeTriFan (Display			*dpy,
+			int			op,
+			Picture			src,
+			Picture			dst,
+			_Xconst XRenderPictFormat	*maskFormat,
+			int			xSrc,
+			int			ySrc,
+			_Xconst XPointFixed	*points,
+			int			npoint);
+
+void
+XRenderCompositeDoublePoly (Display		    *dpy,
+			    int			    op,
+			    Picture		    src,
+			    Picture		    dst,
+			    _Xconst XRenderPictFormat	*maskFormat,
+			    int			    xSrc,
+			    int			    ySrc,
+			    int			    xDst,
+			    int			    yDst,
+			    _Xconst XPointDouble    *fpoints,
+			    int			    npoints,
+			    int			    winding);
+Status
+XRenderParseColor(Display	*dpy, 
+		  char		*spec,
+		  XRenderColor	*def);
+
+Cursor
+XRenderCreateCursor (Display	    *dpy,
+		     Picture	    source,
+		     unsigned int   x,
+		     unsigned int   y);
+
+XFilters *
+XRenderQueryFilters (Display *dpy, Drawable drawable);
+
+void
+XRenderSetPictureFilter (Display    *dpy,
+			 Picture    picture,
+			 const char *filter,
+			 XFixed	    *params,
+			 int	    nparams);
+
+Cursor
+XRenderCreateAnimCursor (Display	*dpy,
+			 int		ncursor,
+			 XAnimCursor	*cursors);
+
+
+void
+XRenderAddTraps (Display	    *dpy,
+		 Picture	    picture,
+		 int		    xOff,
+		 int		    yOff,
+		 _Xconst XTrap	    *traps,
+		 int		    ntrap);
+
+Picture XRenderCreateSolidFill (Display *dpy,
+                                const XRenderColor *color);
+
+Picture XRenderCreateLinearGradient (Display *dpy,
+                                     const XLinearGradient *gradient,
+                                     const XFixed *stops,
+                                     const XRenderColor *colors,
+                                     int nstops);
+
+Picture XRenderCreateRadialGradient (Display *dpy,
+                                     const XRadialGradient *gradient,
+                                     const XFixed *stops,
+                                     const XRenderColor *colors,
+                                     int nstops);
+
+Picture XRenderCreateConicalGradient (Display *dpy,
+                                      const XConicalGradient *gradient,
+                                      const XFixed *stops,
+                                      const XRenderColor *colors,
+                                      int nstops);
+
+_XFUNCPROTOEND
+
+#endif /* _XRENDER_H_ */
diff --git a/libXrender/src/AddTrap.c b/libXrender/src/AddTrap.c
new file mode 100644
index 000000000..421463def
--- /dev/null
+++ b/libXrender/src/AddTrap.c
@@ -0,0 +1,68 @@
+/*
+ * Copyright © 2004 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xrenderint.h"
+
+#define NLOCAL	256
+
+void
+XRenderAddTraps (Display	    *dpy,
+		 Picture	    picture,
+		 int		    xOff,
+		 int		    yOff,
+		 _Xconst XTrap	    *traps,
+		 int		    ntrap)
+{
+    XRenderExtDisplayInfo   *info = XRenderFindDisplay (dpy);
+    xRenderAddTrapsReq	    *req;
+    int			    n;
+    long    		    len;
+    unsigned long	    max_req = dpy->bigreq_size ? dpy->bigreq_size : dpy->max_request_size;
+
+    RenderSimpleCheckExtension (dpy, info);
+    LockDisplay(dpy);
+    while (ntrap)
+    {
+	GetReq(RenderAddTraps, req);
+	req->reqType = info->codes->major_opcode;
+	req->renderReqType = X_RenderAddTraps;
+	req->picture = picture;
+	req->xOff = xOff;
+	req->yOff = yOff;
+	n = ntrap;
+	len = ((long) n) * (SIZEOF (xTrap) >> 2);
+	if (len > (max_req - req->length)) {
+	    n = (max_req - req->length) / (SIZEOF (xTrap) >> 2);
+	    len = ((long)n) * (SIZEOF (xTrap) >> 2);
+	}
+	SetReqLen (req, len, len);
+	len <<= 2;
+	DataInt32 (dpy, (int *) traps, len);
+	ntrap -= n;
+	traps += n;
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
diff --git a/libXrender/src/Color.c b/libXrender/src/Color.c
new file mode 100644
index 000000000..4f934f038
--- /dev/null
+++ b/libXrender/src/Color.c
@@ -0,0 +1,92 @@
+/*
+ *
+ * Copyright © 2002 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xrenderint.h"
+
+Status
+XRenderParseColor(Display *dpy, char *spec, XRenderColor *def)
+{
+    
+    if (!strncmp (spec, "rgba:", 5))
+    {
+	unsigned short	elements[4];
+	unsigned short	*pShort;
+	int		i, n;
+	char		c;
+	
+	spec += 5;
+	/*
+	 * Attempt to parse the value portion.
+	 */
+	pShort = elements;
+	for (i = 0; i < 4; i++, pShort++, spec++) {
+	    n = 0;
+	    *pShort = 0;
+	    while (*spec != '/' && *spec != '\0') {
+		if (++n > 4) {
+		    return 0;
+		}
+		c = *spec++;
+		*pShort <<= 4;
+		if (c >= '0' && c <= '9')
+		    *pShort |= c - '0';
+		/* assume string in lowercase
+		else if (c >= 'A' && c <= 'F')
+		    *pShort |= c - ('A' - 10);
+		*/
+		else if (c >= 'a' && c <= 'f')
+		    *pShort |= c - ('a' - 10);
+		else return 0;
+	    }
+	    if (n == 0)
+		return 0;
+	    if (n < 4) {
+		*pShort = ((unsigned long)*pShort * 0xFFFF) / ((1 << n*4) - 1);
+	    }
+	}
+	def->red = elements[0];
+	def->green = elements[1];
+	def->blue = elements[2];
+	def->alpha = elements[3];
+    }
+    else
+    {
+	XColor	    coreColor;
+	Colormap    colormap;
+	
+	colormap = DefaultColormap (dpy, DefaultScreen (dpy));
+	if (!XParseColor (dpy, colormap, spec, &coreColor))
+	    return 0;
+	def->red = coreColor.red;
+	def->green = coreColor.green;
+	def->blue = coreColor.blue;
+	def->alpha = 0xffff;
+    }
+    def->red = (def->red * def->alpha) / 65535;
+    def->green = (def->green * def->alpha) / 65535;
+    def->blue = (def->blue * def->alpha) / 65535;
+    return 1;
+}
diff --git a/libXrender/src/Composite.c b/libXrender/src/Composite.c
new file mode 100644
index 000000000..07151ded9
--- /dev/null
+++ b/libXrender/src/Composite.c
@@ -0,0 +1,67 @@
+/*
+ *
+ * Copyright © 2000 SuSE, 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 "Xrenderint.h"
+
+void
+XRenderComposite (Display   *dpy,
+		  int	    op,
+		  Picture   src,
+		  Picture   mask,
+		  Picture   dst,
+		  int	    src_x,
+		  int	    src_y,
+		  int	    mask_x,
+		  int	    mask_y,
+		  int	    dst_x,
+		  int	    dst_y,
+		  unsigned int	width,
+		  unsigned int	height)
+{
+    XRenderExtDisplayInfo         *info = XRenderFindDisplay (dpy);
+    xRenderCompositeReq	    *req;
+
+    RenderSimpleCheckExtension (dpy, info);
+    LockDisplay(dpy);
+    GetReq(RenderComposite, req);
+    req->reqType = info->codes->major_opcode;
+    req->renderReqType = X_RenderComposite;
+    req->op = (CARD8) op;
+    req->src = src;
+    req->mask = mask;
+    req->dst = dst;
+    req->xSrc = src_x;
+    req->ySrc = src_y;
+    req->xMask = mask_x;
+    req->yMask = mask_y;
+    req->xDst = dst_x;
+    req->yDst = dst_y;
+    req->width = width;
+    req->height = height;
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
diff --git a/libXrender/src/Cursor.c b/libXrender/src/Cursor.c
new file mode 100644
index 000000000..2679a9eaa
--- /dev/null
+++ b/libXrender/src/Cursor.c
@@ -0,0 +1,79 @@
+/*
+ *
+ * Copyright © 2002 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xrenderint.h"
+
+Cursor
+XRenderCreateCursor (Display	    *dpy,
+		     Picture	    source,
+		     unsigned int   x,
+		     unsigned int   y)
+{
+    XRenderExtDisplayInfo		*info = XRenderFindDisplay (dpy);
+    Cursor			cid;
+    xRenderCreateCursorReq	*req;
+
+    RenderCheckExtension (dpy, info, 0);
+    LockDisplay(dpy);
+    GetReq(RenderCreateCursor, req);
+    req->reqType = info->codes->major_opcode;
+    req->renderReqType = X_RenderCreateCursor;
+    req->cid = cid = XAllocID (dpy);
+    req->src = source;
+    req->x = x;
+    req->y = y;
+    
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return cid;
+}
+
+Cursor
+XRenderCreateAnimCursor (Display	*dpy,
+			 int		ncursor,
+			 XAnimCursor	*cursors)
+{
+    XRenderExtDisplayInfo		*info = XRenderFindDisplay (dpy);
+    Cursor			cid;
+    xRenderCreateAnimCursorReq	*req;
+    long			len;
+
+    RenderCheckExtension (dpy, info, 0);
+    LockDisplay(dpy);
+    GetReq(RenderCreateAnimCursor, req);
+    req->reqType = info->codes->major_opcode;
+    req->renderReqType = X_RenderCreateAnimCursor;
+    req->cid = cid = XAllocID (dpy);
+    
+    len = (long) ncursor * SIZEOF (xAnimCursorElt) >> 2;
+    SetReqLen (req, len, len);
+    len <<= 2;
+    Data32 (dpy, (long *) cursors, len);
+    
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return cid;
+}
diff --git a/libXrender/src/FillRect.c b/libXrender/src/FillRect.c
new file mode 100644
index 000000000..319c35d57
--- /dev/null
+++ b/libXrender/src/FillRect.c
@@ -0,0 +1,106 @@
+/*
+ *
+ * Copyright © 2000 SuSE, 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 "Xrenderint.h"
+
+/* precompute the maximum size of batching request allowed */
+
+#define size (SIZEOF(xRenderFillRectanglesReq) + FRCTSPERBATCH * SIZEOF(xRectangle))
+
+void
+XRenderFillRectangle (Display	    *dpy,
+		      int	    op,
+		      Picture	    dst,
+		      _Xconst XRenderColor  *color,
+		      int	    x,
+		      int	    y,
+		      unsigned int  width,
+		      unsigned int  height)
+{
+    XRenderExtDisplayInfo		*info = XRenderFindDisplay (dpy);
+    xRectangle			*rect;
+    xRenderFillRectanglesReq	*req;
+#ifdef MUSTCOPY
+    xRectangle			rectdata;
+    long			len = SIZEOF(xRectangle);
+
+    rect = &rectdata;
+#endif /* MUSTCOPY */
+
+    RenderSimpleCheckExtension (dpy, info);
+    LockDisplay(dpy);
+
+    req = (xRenderFillRectanglesReq *) dpy->last_req;
+    /* if same as previous request, with same drawable, batch requests */
+    if (req->reqType == info->codes->major_opcode &&
+	req->renderReqType == X_RenderFillRectangles &&
+	req->op == op &&
+	req->dst == dst &&
+	req->color.red == color->red &&
+	req->color.green == color->green &&
+	req->color.blue == color->blue &&
+	req->color.alpha == color->alpha &&
+	dpy->bufptr + SIZEOF(xRectangle) <= dpy->bufmax &&
+	(char *)dpy->bufptr - (char *)req < size)
+    {
+	req->length += SIZEOF(xRectangle) >> 2;
+#ifndef MUSTCOPY
+	rect = (xRectangle *) dpy->bufptr;
+	dpy->bufptr += SIZEOF(xRectangle);
+#endif /* not MUSTCOPY */
+    }
+    else 
+    {
+	GetReqExtra(RenderFillRectangles, SIZEOF(xRectangle), req);
+	
+	req->reqType = info->codes->major_opcode;
+	req->renderReqType = X_RenderFillRectangles;
+	req->op = op;
+	req->dst = dst;
+	req->color.red = color->red;
+	req->color.green = color->green;
+	req->color.blue = color->blue;
+	req->color.alpha = color->alpha;
+	
+#ifdef MUSTCOPY
+	dpy->bufptr -= SIZEOF(xRectangle);
+#else
+	rect = (xRectangle *) NEXTPTR(req,xRenderFillRectanglesReq);
+#endif /* MUSTCOPY */
+    }
+    rect->x = x;
+    rect->y = y;
+    rect->width = width;
+    rect->height = height;
+
+#ifdef MUSTCOPY
+    Data (dpy, (char *) rect, len);
+#endif /* MUSTCOPY */
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
+
diff --git a/libXrender/src/FillRects.c b/libXrender/src/FillRects.c
new file mode 100644
index 000000000..517eeb0dc
--- /dev/null
+++ b/libXrender/src/FillRects.c
@@ -0,0 +1,79 @@
+/*
+ *
+ * Copyright © 2000 SuSE, 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 "Xrenderint.h"
+
+/* precompute the maximum size of batching request allowed */
+
+#define size (SIZEOF(xRenderFillRectanglesReq) + FRCTSPERBATCH * SIZEOF(xRectangle))
+
+void
+XRenderFillRectangles (Display		    *dpy,
+		       int		    op,
+		       Picture		    dst,
+		       _Xconst XRenderColor *color,
+		       _Xconst XRectangle   *rectangles,
+		       int		    n_rects)
+{
+    XRenderExtDisplayInfo		*info = XRenderFindDisplay (dpy);
+    xRenderFillRectanglesReq	*req;
+    long			len;
+    int				n;
+
+    RenderSimpleCheckExtension (dpy, info);
+    LockDisplay(dpy);
+
+    while (n_rects) 
+    {
+	GetReq(RenderFillRectangles, req);
+	
+	req->reqType = info->codes->major_opcode;
+	req->renderReqType = X_RenderFillRectangles;
+	req->op = op;
+	req->dst = dst;
+	req->color.red = color->red;
+	req->color.green = color->green;
+	req->color.blue = color->blue;
+	req->color.alpha = color->alpha;
+	
+	n = n_rects;
+	len = ((long)n) << 1;
+	if (!dpy->bigreq_size && len > (dpy->max_request_size - req->length)) 
+	{
+	    n = (dpy->max_request_size - req->length) >> 1;
+	    len = ((long)n) << 1;
+	}
+	SetReqLen(req, len, len);
+	len <<= 2; /* watch out for macros... */
+	Data16 (dpy, (short *) rectangles, len);
+	n_rects -= n;
+	rectangles += n;
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
+
diff --git a/libXrender/src/Filter.c b/libXrender/src/Filter.c
new file mode 100644
index 000000000..3ac660a40
--- /dev/null
+++ b/libXrender/src/Filter.c
@@ -0,0 +1,153 @@
+/*
+ *
+ * Copyright © 2002 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xrenderint.h"
+ 
+XFilters *
+XRenderQueryFilters (Display *dpy, Drawable drawable)
+{
+    XRenderExtDisplayInfo		*info = XRenderFindDisplay (dpy);
+    XRenderInfo			*xri;
+    xRenderQueryFiltersReq	*req;
+    xRenderQueryFiltersReply	rep;
+    XFilters			*filters;
+    char			*name;
+    char			len;
+    int				i;
+    long			nbytes, nbytesAlias, nbytesName;
+    
+    if (!RenderHasExtension (info))
+	return NULL;
+
+    if (!XRenderQueryFormats (dpy))
+	return NULL;
+
+    xri = info->info;
+    if (xri->minor_version < 6)
+	return NULL;
+    
+    LockDisplay (dpy);
+    GetReq (RenderQueryFilters, req);
+    req->reqType = info->codes->major_opcode;
+    req->renderReqType = X_RenderQueryFilters;
+    req->drawable = drawable;
+    if (!_XReply (dpy, (xReply *) &rep, 0, xFalse))
+    {
+	UnlockDisplay (dpy);
+	SyncHandle ();
+	return NULL;
+    }
+    /*
+     * Compute total number of bytes for filter names
+     */
+    nbytes = (long)rep.length << 2;
+    nbytesAlias = rep.numAliases * 2;
+    if (rep.numAliases & 1)
+	nbytesAlias += 2;
+    nbytesName = nbytes - nbytesAlias;
+    
+    /*
+     * Allocate one giant block for the whole data structure
+     */
+    filters = Xmalloc (sizeof (XFilters) +
+		       rep.numFilters * sizeof (char *) +
+		       rep.numAliases * sizeof (short) +
+		       nbytesName);
+
+    if (!filters)
+    {
+	_XEatData (dpy, (unsigned long) rep.length << 2);
+	UnlockDisplay (dpy);
+	SyncHandle ();
+	return NULL;
+    }
+
+    /*
+     * Layout:
+     *	XFilters
+     *	numFilters  char * pointers to filter names
+     *	numAliases  short alias values
+     *	nbytesName  char strings
+     */
+    
+    filters->nfilter = rep.numFilters;
+    filters->nalias = rep.numAliases;
+    filters->filter = (char **) (filters + 1);
+    filters->alias = (short *) (filters->filter + rep.numFilters);
+    name = (char *) (filters->alias + rep.numAliases);
+
+    /*
+     * Read the filter aliases
+     */
+    _XRead16Pad (dpy, filters->alias, 2 * rep.numAliases);
+
+    /*
+     * Read the filter names
+     */
+    for (i = 0; i < rep.numFilters; i++)
+    {
+	int	l;
+	_XRead (dpy, &len, 1);
+	l = len & 0xff;
+	filters->filter[i] = name;
+	_XRead (dpy, name, l);
+	name[l] = '\0';
+	name += l + 1;
+    }
+    i = name - (char *) (filters->alias + rep.numAliases);
+
+    if (i & 3)
+	_XEatData (dpy, 4 - (i & 3));
+    
+    UnlockDisplay (dpy);
+    SyncHandle ();
+    return filters;
+}
+
+void
+XRenderSetPictureFilter  (Display   *dpy,
+			  Picture   picture,
+			  const char *filter,
+			  XFixed    *params,
+			  int	    nparams)
+{
+    XRenderExtDisplayInfo		*info = XRenderFindDisplay (dpy);
+    xRenderSetPictureFilterReq	*req;
+    int				nbytes = strlen (filter);
+
+    RenderSimpleCheckExtension (dpy, info);
+    LockDisplay(dpy);
+    GetReq(RenderSetPictureFilter, req);
+    req->reqType = info->codes->major_opcode;
+    req->renderReqType = X_RenderSetPictureFilter;
+    req->picture = picture;
+    req->nbytes = nbytes;
+    req->length += ((nbytes + 3) >> 2) + nparams;
+    Data (dpy, filter, nbytes);
+    Data (dpy, (_Xconst char *)params, nparams << 2);
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
diff --git a/libXrender/src/Glyph.c b/libXrender/src/Glyph.c
new file mode 100644
index 000000000..894bb77f2
--- /dev/null
+++ b/libXrender/src/Glyph.c
@@ -0,0 +1,712 @@
+/*
+ *
+ * Copyright © 2000 SuSE, 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 "Xrenderint.h"
+
+GlyphSet
+XRenderCreateGlyphSet (Display *dpy, _Xconst XRenderPictFormat *format)
+{
+    XRenderExtDisplayInfo		*info = XRenderFindDisplay (dpy);
+    GlyphSet			gsid;
+    xRenderCreateGlyphSetReq	*req;
+
+    RenderCheckExtension (dpy, info, 0);
+    LockDisplay(dpy);
+    GetReq(RenderCreateGlyphSet, req);
+    req->reqType = info->codes->major_opcode;
+    req->renderReqType = X_RenderCreateGlyphSet;
+    req->gsid = gsid = XAllocID(dpy);
+    req->format = format->id;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return gsid;
+}
+
+GlyphSet
+XRenderReferenceGlyphSet (Display *dpy, GlyphSet existing)
+{
+    XRenderExtDisplayInfo             *info = XRenderFindDisplay (dpy);
+    GlyphSet                    gsid;
+    xRenderReferenceGlyphSetReq	*req;
+
+    RenderCheckExtension (dpy, info, 0);
+    LockDisplay(dpy);
+    GetReq(RenderReferenceGlyphSet, req);
+    req->reqType = info->codes->major_opcode;
+    req->renderReqType = X_RenderReferenceGlyphSet;
+    req->gsid = gsid = XAllocID(dpy);
+    req->existing = existing;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return gsid;
+}
+
+void
+XRenderFreeGlyphSet (Display *dpy, GlyphSet glyphset)
+{
+    XRenderExtDisplayInfo         *info = XRenderFindDisplay (dpy);
+    xRenderFreeGlyphSetReq  *req;
+
+    RenderSimpleCheckExtension (dpy, info);
+    LockDisplay(dpy);
+    GetReq(RenderFreeGlyphSet, req);
+    req->reqType = info->codes->major_opcode;
+    req->renderReqType = X_RenderFreeGlyphSet;
+    req->glyphset = glyphset;
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
+
+void
+XRenderAddGlyphs (Display	*dpy,
+		  GlyphSet	glyphset,
+		  _Xconst Glyph		*gids,
+		  _Xconst XGlyphInfo	*glyphs,
+		  int		nglyphs,
+		  _Xconst char		*images,
+		  int		nbyte_images)
+{
+    XRenderExtDisplayInfo         *info = XRenderFindDisplay (dpy);
+    xRenderAddGlyphsReq	    *req;
+    long		    len;
+
+    if (nbyte_images & 3)
+	nbyte_images += 4 - (nbyte_images & 3);
+    RenderSimpleCheckExtension (dpy, info);
+    LockDisplay(dpy);
+    GetReq(RenderAddGlyphs, req);
+    req->reqType = info->codes->major_opcode;
+    req->renderReqType = X_RenderAddGlyphs;
+    req->glyphset = glyphset;
+    req->nglyphs = nglyphs;
+    len = (nglyphs * (SIZEOF (xGlyphInfo) + 4) + nbyte_images) >> 2;
+    SetReqLen(req, len, len);
+    Data32 (dpy, (long *) gids, nglyphs * 4);
+    Data16 (dpy, (short *) glyphs, nglyphs * SIZEOF (xGlyphInfo));
+    Data (dpy, images, nbyte_images);
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
+
+void
+XRenderFreeGlyphs (Display   *dpy,
+		   GlyphSet  glyphset,
+		   _Xconst Glyph     *gids,
+		   int       nglyphs)
+{
+    XRenderExtDisplayInfo         *info = XRenderFindDisplay (dpy);
+    xRenderFreeGlyphsReq    *req;
+    long                    len;
+
+    RenderSimpleCheckExtension (dpy, info);
+    LockDisplay(dpy);
+    GetReq(RenderFreeGlyphs, req);
+    req->reqType = info->codes->major_opcode;
+    req->renderReqType = X_RenderFreeGlyphs;
+    req->glyphset = glyphset;
+    len = nglyphs;
+    SetReqLen(req, len, len);
+    len <<= 2;
+    Data32 (dpy, (long *) gids, len);
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
+	   
+void
+XRenderCompositeString8 (Display	    *dpy,
+			 int		    op,
+			 Picture	    src,
+			 Picture	    dst,
+			 _Xconst XRenderPictFormat  *maskFormat,
+			 GlyphSet	    glyphset,
+			 int		    xSrc,
+			 int		    ySrc,
+			 int		    xDst,
+			 int		    yDst,
+			 _Xconst char	    *string,
+			 int		    nchar)
+{
+    XRenderExtDisplayInfo		*info = XRenderFindDisplay (dpy);
+    xRenderCompositeGlyphs8Req	*req;
+    long			len;
+    xGlyphElt			*elt;
+    int				nbytes;
+
+    if (!nchar)
+	return;
+    
+    RenderSimpleCheckExtension (dpy, info);
+    LockDisplay(dpy);
+
+    GetReq(RenderCompositeGlyphs8, req);
+    req->reqType = info->codes->major_opcode;
+    req->renderReqType = X_RenderCompositeGlyphs8;
+    req->op = op;
+    req->src = src;
+    req->dst = dst;
+    req->maskFormat = maskFormat ? maskFormat->id : None;
+    req->glyphset = glyphset;
+    req->xSrc = xSrc;
+    req->ySrc = ySrc;    
+
+    /*
+     * xGlyphElt must be aligned on a 32-bit boundary; this is
+     * easily done by filling no more than 252 glyphs in each
+     * bucket
+     */
+    
+#define MAX_8 252
+
+    len = SIZEOF(xGlyphElt) * ((nchar + MAX_8-1) / MAX_8) + nchar;
+    
+    req->length += (len + 3)>>2;  /* convert to number of 32-bit words */
+    
+    /* 
+     * If the entire request does not fit into the remaining space in the
+     * buffer, flush the buffer first.
+     */
+
+    if (dpy->bufptr + len > dpy->bufmax)
+    	_XFlush (dpy);
+
+    while(nchar > MAX_8)
+    {
+	nbytes = MAX_8 + SIZEOF(xGlyphElt);
+	BufAlloc (xGlyphElt *, elt, nbytes);
+	elt->len = MAX_8;
+	elt->deltax = xDst;
+	elt->deltay = yDst;
+	xDst = 0;
+	yDst = 0;
+	memcpy ((char *) (elt + 1), string, MAX_8);
+	nchar = nchar - MAX_8;
+	string += MAX_8;
+    }
+	
+    if (nchar)
+    {
+	nbytes = (nchar + SIZEOF(xGlyphElt) + 3) & ~3;
+	BufAlloc (xGlyphElt *, elt, nbytes); 
+	elt->len = nchar;
+	elt->deltax = xDst;
+	elt->deltay = yDst;
+	memcpy ((char *) (elt + 1), string, nchar);
+    }
+#undef MAX_8
+    
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
+void
+XRenderCompositeString16 (Display	    *dpy,
+			  int		    op,
+			  Picture	    src,
+			  Picture	    dst,
+			  _Xconst XRenderPictFormat *maskFormat,
+			  GlyphSet	    glyphset,
+			  int		    xSrc,
+			  int		    ySrc,
+			  int		    xDst,
+			  int		    yDst,
+			  _Xconst unsigned short    *string,
+			  int		    nchar)
+{
+    XRenderExtDisplayInfo		*info = XRenderFindDisplay (dpy);
+    xRenderCompositeGlyphs8Req	*req;
+    long			len;
+    xGlyphElt			*elt;
+    int				nbytes;
+
+    if (!nchar)
+	return;
+    
+    RenderSimpleCheckExtension (dpy, info);
+    LockDisplay(dpy);
+    
+    GetReq(RenderCompositeGlyphs16, req);
+    req->reqType = info->codes->major_opcode;
+    req->renderReqType = X_RenderCompositeGlyphs16;
+    req->op = op;
+    req->src = src;
+    req->dst = dst;
+    req->maskFormat = maskFormat ? maskFormat->id : None;
+    req->glyphset = glyphset;
+    req->xSrc = xSrc;
+    req->ySrc = ySrc;    
+
+#define MAX_16	254
+
+    len = SIZEOF(xGlyphElt) * ((nchar + MAX_16-1) / MAX_16) + nchar * 2;
+    
+    req->length += (len + 3)>>2;  /* convert to number of 32-bit words */
+    
+    /* 
+     * If the entire request does not fit into the remaining space in the
+     * buffer, flush the buffer first.
+     */
+
+    if (dpy->bufptr + len > dpy->bufmax)
+    	_XFlush (dpy);
+
+    while(nchar > MAX_16)
+    {
+	nbytes = MAX_16 * 2 + SIZEOF(xGlyphElt);
+	BufAlloc (xGlyphElt *, elt, nbytes);
+	elt->len = MAX_16;
+	elt->deltax = xDst;
+	elt->deltay = yDst;
+	xDst = 0;
+	yDst = 0;
+	memcpy ((char *) (elt + 1), (char *) string, MAX_16 * 2);
+	nchar = nchar - MAX_16;
+	string += MAX_16;
+    }
+	
+    if (nchar)
+    {
+	nbytes = (nchar * 2 + SIZEOF(xGlyphElt) + 3) & ~3;
+	BufAlloc (xGlyphElt *, elt, nbytes); 
+	elt->len = nchar;
+	elt->deltax = xDst;
+	elt->deltay = yDst;
+	memcpy ((char *) (elt + 1), (char *) string, nchar * 2);
+    }
+#undef MAX_16
+    
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
+
+void
+XRenderCompositeString32 (Display	    *dpy,
+			  int		    op,
+			  Picture	    src,
+			  Picture	    dst,
+			  _Xconst XRenderPictFormat  *maskFormat,
+			  GlyphSet	    glyphset,
+			  int		    xSrc,
+			  int		    ySrc,
+			  int		    xDst,
+			  int		    yDst,
+			  _Xconst unsigned int	    *string,
+			  int		    nchar)
+{
+    XRenderExtDisplayInfo		*info = XRenderFindDisplay (dpy);
+    xRenderCompositeGlyphs8Req	*req;
+    long			len;
+    xGlyphElt			*elt;
+    int				nbytes;
+
+    if (!nchar)
+	return;
+    
+    RenderSimpleCheckExtension (dpy, info);
+    LockDisplay(dpy);
+    
+    GetReq(RenderCompositeGlyphs32, req);
+    req->reqType = info->codes->major_opcode;
+    req->renderReqType = X_RenderCompositeGlyphs32;
+    req->op = op;
+    req->src = src;
+    req->dst = dst;
+    req->maskFormat = maskFormat ? maskFormat->id : None;
+    req->glyphset = glyphset;
+    req->xSrc = xSrc;
+    req->ySrc = ySrc;    
+
+#define MAX_32	254
+
+    len = SIZEOF(xGlyphElt) * ((nchar + MAX_32-1) / MAX_32) + nchar * 4;
+    
+    req->length += (len + 3)>>2;  /* convert to number of 32-bit words */
+    
+    /* 
+     * If the entire request does not fit into the remaining space in the
+     * buffer, flush the buffer first.
+     */
+
+    if (dpy->bufptr + len > dpy->bufmax)
+    	_XFlush (dpy);
+
+    while(nchar > MAX_32)
+    {
+	nbytes = MAX_32 * 4 + SIZEOF(xGlyphElt);
+	BufAlloc (xGlyphElt *, elt, nbytes);
+	elt->len = MAX_32;
+	elt->deltax = xDst;
+	elt->deltay = yDst;
+	xDst = 0;
+	yDst = 0;
+	memcpy ((char *) (elt + 1), (char *) string, MAX_32 * 4);
+	nchar = nchar - MAX_32;
+	string += MAX_32;
+    }
+	
+    if (nchar)
+    {
+	nbytes = nchar * 4 + SIZEOF(xGlyphElt);
+	BufAlloc (xGlyphElt *, elt, nbytes); 
+	elt->len = nchar;
+	elt->deltax = xDst;
+	elt->deltay = yDst;
+	memcpy ((char *) (elt + 1), (char *) string, nchar * 4);
+    }
+#undef MAX_32
+    
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
+
+void
+XRenderCompositeText8 (Display			    *dpy,
+		       int			    op,
+		       Picture			    src,
+		       Picture			    dst,
+		       _Xconst XRenderPictFormat    *maskFormat,
+		       int			    xSrc,
+		       int			    ySrc,
+		       int			    xDst,
+		       int			    yDst,
+		       _Xconst XGlyphElt8	    *elts,
+		       int			    nelt)
+{
+    XRenderExtDisplayInfo		*info = XRenderFindDisplay (dpy);
+    xRenderCompositeGlyphs8Req	*req;
+    GlyphSet			glyphset;
+    long			len;
+    long			elen;
+    xGlyphElt			*elt;
+    int				i;
+    _Xconst char		*chars;
+    int				nchars;
+
+    if (!nelt)
+	return;
+    
+    RenderSimpleCheckExtension (dpy, info);
+    LockDisplay(dpy);
+
+    GetReq(RenderCompositeGlyphs8, req);
+    req->reqType = info->codes->major_opcode;
+    req->renderReqType = X_RenderCompositeGlyphs8;
+    req->op = op;
+    req->src = src;
+    req->dst = dst;
+    req->maskFormat = maskFormat ? maskFormat->id : None;
+    req->glyphset = elts[0].glyphset;
+    req->xSrc = xSrc;
+    req->ySrc = ySrc;    
+
+    /*
+     * Compute the space necessary
+     */
+    len = 0;
+    
+#define MAX_8 252
+
+    glyphset = elts[0].glyphset;
+    for (i = 0; i < nelt; i++)
+    {
+	/*
+	 * Check for glyphset change
+	 */
+	if (elts[i].glyphset != glyphset)
+	{
+	    glyphset = elts[i].glyphset;
+	    len += (SIZEOF (xGlyphElt) + 4) >> 2;
+	}
+	nchars = elts[i].nchars;
+	/*
+	 * xGlyphElt must be aligned on a 32-bit boundary; this is
+	 * easily done by filling no more than 252 glyphs in each
+	 * bucket
+	 */
+	elen = SIZEOF(xGlyphElt) * ((nchars + MAX_8-1) / MAX_8) + nchars;
+	len += (elen + 3) >> 2;
+    }
+    
+    req->length += len;
+
+    /*
+     * Send the glyphs
+     */
+    glyphset = elts[0].glyphset;
+    for (i = 0; i < nelt; i++)
+    {
+	/*
+	 * Switch glyphsets
+	 */
+	if (elts[i].glyphset != glyphset)
+	{
+	    glyphset = elts[i].glyphset;
+	    BufAlloc (xGlyphElt *, elt, SIZEOF (xGlyphElt));
+	    elt->len = 0xff;
+	    elt->deltax = 0;
+	    elt->deltay = 0;
+	    Data32(dpy, &glyphset, 4);
+	}
+	nchars = elts[i].nchars;
+	xDst = elts[i].xOff;
+	yDst = elts[i].yOff;
+	chars = elts[i].chars;
+	while (nchars)
+	{
+	    int this_chars = nchars > MAX_8 ? MAX_8 : nchars;
+
+	    BufAlloc (xGlyphElt *, elt, SIZEOF(xGlyphElt))
+	    elt->len = this_chars;
+	    elt->deltax = xDst;
+	    elt->deltay = yDst;
+	    xDst = 0;
+	    yDst = 0;
+	    Data (dpy, chars, this_chars);
+	    nchars -= this_chars;
+	    chars += this_chars;
+	}
+    }
+#undef MAX_8
+    
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
+
+void
+XRenderCompositeText16 (Display			    *dpy,
+			int			    op,
+			Picture			    src,
+			Picture			    dst,
+			_Xconst XRenderPictFormat   *maskFormat,
+			int			    xSrc,
+			int			    ySrc,
+			int			    xDst,
+			int			    yDst,
+			_Xconst XGlyphElt16	    *elts,
+			int			    nelt)
+{
+    XRenderExtDisplayInfo		*info = XRenderFindDisplay (dpy);
+    xRenderCompositeGlyphs16Req	*req;
+    GlyphSet			glyphset;
+    long			len;
+    long			elen;
+    xGlyphElt			*elt;
+    int				i;
+    _Xconst unsigned short    	*chars;
+    int				nchars;
+
+    if (!nelt)
+	return;
+    
+    RenderSimpleCheckExtension (dpy, info);
+    LockDisplay(dpy);
+
+    GetReq(RenderCompositeGlyphs16, req);
+    req->reqType = info->codes->major_opcode;
+    req->renderReqType = X_RenderCompositeGlyphs16;
+    req->op = op;
+    req->src = src;
+    req->dst = dst;
+    req->maskFormat = maskFormat ? maskFormat->id : None;
+    req->glyphset = elts[0].glyphset;
+    req->xSrc = xSrc;
+    req->ySrc = ySrc;    
+
+    /*
+     * Compute the space necessary
+     */
+    len = 0;
+    
+#define MAX_16	254
+
+    glyphset = elts[0].glyphset;
+    for (i = 0; i < nelt; i++)
+    {
+	/*
+	 * Check for glyphset change
+	 */
+	if (elts[i].glyphset != glyphset)
+	{
+	    glyphset = elts[i].glyphset;
+	    len += (SIZEOF (xGlyphElt) + 4) >> 2;
+	}
+	nchars = elts[i].nchars;
+	/*
+	 * xGlyphElt must be aligned on a 32-bit boundary; this is
+	 * easily done by filling no more than 254 glyphs in each
+	 * bucket
+	 */
+	elen = SIZEOF(xGlyphElt) * ((nchars + MAX_16-1) / MAX_16) + nchars * 2;
+	len += (elen + 3) >> 2;
+    }
+    
+    req->length += len;
+
+    glyphset = elts[0].glyphset;
+    for (i = 0; i < nelt; i++)
+    {
+	/*
+	 * Switch glyphsets
+	 */
+	if (elts[i].glyphset != glyphset)
+	{
+	    glyphset = elts[i].glyphset;
+	    BufAlloc (xGlyphElt *, elt, SIZEOF (xGlyphElt));
+	    elt->len = 0xff;
+	    elt->deltax = 0;
+	    elt->deltay = 0;
+	    Data32(dpy, &glyphset, 4);
+	}
+	nchars = elts[i].nchars;
+	xDst = elts[i].xOff;
+	yDst = elts[i].yOff;
+	chars = elts[i].chars;
+	while (nchars)
+	{
+	    int this_chars = nchars > MAX_16 ? MAX_16 : nchars;
+	    int this_bytes = this_chars * 2;
+    
+	    BufAlloc (xGlyphElt *, elt, SIZEOF(xGlyphElt))
+	    elt->len = this_chars;
+	    elt->deltax = xDst;
+	    elt->deltay = yDst;
+	    xDst = 0;
+	    yDst = 0;
+	    Data16 (dpy, chars, this_bytes);
+	    nchars -= this_chars;
+	    chars += this_chars;
+	}
+    }
+#undef MAX_16
+    
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
+
+void
+XRenderCompositeText32 (Display			    *dpy,
+			int			    op,
+			Picture			    src,
+			Picture			    dst,
+			_Xconst XRenderPictFormat   *maskFormat,
+			int			    xSrc,
+			int			    ySrc,
+			int			    xDst,
+			int			    yDst,
+			_Xconst XGlyphElt32	    *elts,
+			int			    nelt)
+{
+    XRenderExtDisplayInfo		*info = XRenderFindDisplay (dpy);
+    xRenderCompositeGlyphs32Req	*req;
+    GlyphSet			glyphset;
+    long			len;
+    long			elen;
+    xGlyphElt			*elt;
+    int				i;
+    _Xconst unsigned int    	*chars;
+    int				nchars;
+
+    if (!nelt)
+	return;
+    
+    RenderSimpleCheckExtension (dpy, info);
+    LockDisplay(dpy);
+
+    
+    GetReq(RenderCompositeGlyphs32, req);
+    req->reqType = info->codes->major_opcode;
+    req->renderReqType = X_RenderCompositeGlyphs32;
+    req->op = op;
+    req->src = src;
+    req->dst = dst;
+    req->maskFormat = maskFormat ? maskFormat->id : None;
+    req->glyphset = elts[0].glyphset;
+    req->xSrc = xSrc;
+    req->ySrc = ySrc;    
+
+    /*
+     * Compute the space necessary
+     */
+    len = 0;
+
+#define MAX_32	254
+    
+    glyphset = elts[0].glyphset;
+    for (i = 0; i < nelt; i++)
+    {
+	/*
+	 * Check for glyphset change
+	 */
+	if (elts[i].glyphset != glyphset)
+	{
+	    glyphset = elts[i].glyphset;
+	    len += (SIZEOF (xGlyphElt) + 4) >> 2;
+	}
+	nchars = elts[i].nchars;
+	elen = SIZEOF(xGlyphElt) * ((nchars + MAX_32) / MAX_32) + nchars *4;
+	len += (elen + 3) >> 2;
+    }
+    
+    req->length += len;
+
+    glyphset = elts[0].glyphset;
+    for (i = 0; i < nelt; i++)
+    {
+	/*
+	 * Switch glyphsets
+	 */
+	if (elts[i].glyphset != glyphset)
+	{
+	    glyphset = elts[i].glyphset;
+	    BufAlloc (xGlyphElt *, elt, SIZEOF (xGlyphElt));
+	    elt->len = 0xff;
+	    elt->deltax = 0;
+	    elt->deltay = 0;
+	    Data32(dpy, &glyphset, 4);
+	}
+	nchars = elts[i].nchars;
+	xDst = elts[i].xOff;
+	yDst = elts[i].yOff;
+	chars = elts[i].chars;
+	while (nchars)
+	{
+	    int this_chars = nchars > MAX_32 ? MAX_32 : nchars;
+	    int this_bytes = this_chars * 4;
+	    BufAlloc (xGlyphElt *, elt, SIZEOF(xGlyphElt))
+	    elt->len = this_chars;
+	    elt->deltax = xDst;
+	    elt->deltay = yDst;
+	    xDst = 0;
+	    yDst = 0;
+	    DataInt32 (dpy, chars, this_bytes);
+	    nchars -= this_chars;
+	    chars += this_chars;
+	}
+    }
+#undef MAX_32
+    
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
diff --git a/libXrender/src/Makefile.am b/libXrender/src/Makefile.am
new file mode 100644
index 000000000..7474b43a8
--- /dev/null
+++ b/libXrender/src/Makefile.am
@@ -0,0 +1,27 @@
+AM_CFLAGS = $(CWARNFLAGS) $(RENDER_CFLAGS) $(MALLOC_ZERO_CFLAGS)
+AM_CPPFLAGS = -I$(top_srcdir) -I$(top_srcdir)/include/X11/extensions
+
+lib_LTLIBRARIES = libXrender.la
+
+libXrender_la_SOURCES = AddTrap.c \
+                        Color.c \
+                        Composite.c \
+                        Cursor.c \
+                        FillRect.c \
+                        FillRects.c \
+                        Filter.c \
+                        Glyph.c \
+                        Picture.c \
+                        Poly.c \
+                        Trap.c \
+                        Tri.c \
+                        Xrender.c \
+                        Xrenderint.h
+
+libXrender_la_LIBADD = $(RENDER_LIBS)
+
+# -version-number requires libtool >= 1.5
+libXrender_la_LDFLAGS = -version-number 1:3:0 -no-undefined 
+
+libXrenderincludedir = $(includedir)/X11/extensions
+libXrenderinclude_HEADERS = $(top_srcdir)/include/X11/extensions/Xrender.h 
diff --git a/libXrender/src/Picture.c b/libXrender/src/Picture.c
new file mode 100644
index 000000000..509a83580
--- /dev/null
+++ b/libXrender/src/Picture.c
@@ -0,0 +1,372 @@
+/*
+ *
+ * Copyright © 2000 SuSE, 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 "Xrenderint.h"
+#include <X11/Xregion.h>
+
+static void
+_XRenderProcessPictureAttributes (Display		    *dpy,
+				  xRenderChangePictureReq   *req,
+				  unsigned long		    valuemask,
+				  _Xconst XRenderPictureAttributes  *attributes)
+{
+    unsigned long values[32];
+    register unsigned long *value = values;
+    unsigned int nvalues;
+    
+    if (valuemask & CPRepeat)
+	*value++ = attributes->repeat;
+    if (valuemask & CPAlphaMap)
+	*value++ = attributes->alpha_map;
+    if (valuemask & CPAlphaXOrigin)
+	*value++ = attributes->alpha_x_origin;
+    if (valuemask & CPAlphaYOrigin)
+	*value++ = attributes->alpha_y_origin;
+    if (valuemask & CPClipXOrigin)
+	*value++ = attributes->clip_x_origin;
+    if (valuemask & CPClipYOrigin)
+	*value++ = attributes->clip_y_origin;
+    if (valuemask & CPClipMask)
+	*value++ = attributes->clip_mask;
+    if (valuemask & CPGraphicsExposure)
+	*value++ = attributes->graphics_exposures;
+    if (valuemask & CPSubwindowMode)
+	*value++ = attributes->subwindow_mode;
+    if (valuemask & CPPolyEdge)
+	*value++ = attributes->poly_edge;
+    if (valuemask & CPPolyMode)
+	*value++ = attributes->poly_mode;
+    if (valuemask & CPDither)
+	*value++ = attributes->dither;
+    if (valuemask & CPComponentAlpha)
+	*value++ = attributes->component_alpha;
+
+    req->length += (nvalues = value - values);
+
+    nvalues <<= 2;			    /* watch out for macros... */
+    Data32 (dpy, (long *) values, (long)nvalues);
+}
+
+Picture
+XRenderCreatePicture (Display			*dpy,
+		      Drawable			drawable,
+		      _Xconst XRenderPictFormat		*format,
+		      unsigned long		valuemask,
+		      _Xconst XRenderPictureAttributes	*attributes)
+{
+    XRenderExtDisplayInfo	    *info = XRenderFindDisplay (dpy);
+    Picture		    pid;
+    xRenderCreatePictureReq *req;
+
+    RenderCheckExtension (dpy, info, 0);
+    LockDisplay(dpy);
+    GetReq(RenderCreatePicture, req);
+    req->reqType = info->codes->major_opcode;
+    req->renderReqType = X_RenderCreatePicture;
+    req->pid = pid = XAllocID(dpy);
+    req->drawable = drawable;
+    req->format = format->id;
+    if ((req->mask = valuemask))
+	_XRenderProcessPictureAttributes (dpy,
+					  (xRenderChangePictureReq *) req,
+					  valuemask,
+					  attributes);
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return pid;
+}
+
+void
+XRenderChangePicture (Display                   *dpy,
+		      Picture			picture,
+		      unsigned long             valuemask,
+		      _Xconst XRenderPictureAttributes  *attributes)
+{
+    XRenderExtDisplayInfo	    *info = XRenderFindDisplay (dpy);
+    xRenderChangePictureReq *req;
+    
+    RenderSimpleCheckExtension (dpy, info);
+    LockDisplay(dpy);
+    GetReq(RenderChangePicture, req);
+    req->reqType = info->codes->major_opcode;
+    req->renderReqType = X_RenderChangePicture;
+    req->picture = picture;
+    req->mask = valuemask;
+    _XRenderProcessPictureAttributes (dpy,
+				      req,
+				      valuemask,
+				      attributes);
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
+
+static void
+_XRenderSetPictureClipRectangles (Display	    *dpy,
+				  XRenderExtDisplayInfo   *info,
+				  Picture	    picture,
+				  int		    xOrigin,
+				  int		    yOrigin,
+				  _Xconst XRectangle	    *rects,
+				  int		    n)
+{
+    xRenderSetPictureClipRectanglesReq	*req;
+    long				len;
+
+    GetReq (RenderSetPictureClipRectangles, req);
+    req->reqType = info->codes->major_opcode;
+    req->renderReqType = X_RenderSetPictureClipRectangles;
+    req->picture = picture;
+    req->xOrigin = xOrigin;
+    req->yOrigin = yOrigin;
+    len = ((long) n) << 1;
+    SetReqLen (req, len, 1);
+    len <<= 2;
+    Data16 (dpy, (short *) rects, len);
+}
+
+void
+XRenderSetPictureClipRectangles (Display	*dpy,
+				 Picture	picture,
+				 int		xOrigin,
+				 int		yOrigin,
+				 _Xconst XRectangle	*rects,
+				 int		n)
+{
+    XRenderExtDisplayInfo	    *info = XRenderFindDisplay (dpy);
+    
+    RenderSimpleCheckExtension (dpy, info);
+    LockDisplay(dpy);
+    _XRenderSetPictureClipRectangles (dpy, info, picture, 
+				      xOrigin, yOrigin, rects, n);
+    UnlockDisplay (dpy);
+    SyncHandle ();
+}
+
+void
+XRenderSetPictureClipRegion (Display	    *dpy,
+			     Picture	    picture,
+			     Region	    r)
+{
+    XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy);
+    int		    i;
+    XRectangle	    *xr, *pr;
+    BOX		    *pb;
+    unsigned long   total;
+    
+    RenderSimpleCheckExtension (dpy, info);
+    LockDisplay(dpy);
+    total = r->numRects * sizeof (XRectangle);
+    if ((xr = (XRectangle *) _XAllocTemp(dpy, total))) {
+	for (pr = xr, pb = r->rects, i = r->numRects; --i >= 0; pr++, pb++) {
+	    pr->x = pb->x1;
+	    pr->y = pb->y1;
+	    pr->width = pb->x2 - pb->x1;
+	    pr->height = pb->y2 - pb->y1;
+	}
+    }
+    if (xr || !r->numRects)
+	_XRenderSetPictureClipRectangles (dpy, info, picture, 0, 0, 
+					  xr, r->numRects);
+    if (xr)
+	_XFreeTemp(dpy, (char *)xr, total);
+    UnlockDisplay(dpy);
+    SyncHandle();
+}    
+
+void
+XRenderSetPictureTransform (Display	*dpy,
+			    Picture	picture,
+			    XTransform	*transform)
+{
+    XRenderExtDisplayInfo		    *info = XRenderFindDisplay (dpy);
+    xRenderSetPictureTransformReq   *req;
+    
+    RenderSimpleCheckExtension (dpy, info);
+    LockDisplay (dpy);
+    GetReq(RenderSetPictureTransform, req);
+    req->reqType = info->codes->major_opcode;
+    req->renderReqType = X_RenderSetPictureTransform;
+    req->picture = picture;
+    req->transform.matrix11 = transform->matrix[0][0];
+    req->transform.matrix12 = transform->matrix[0][1];
+    req->transform.matrix13 = transform->matrix[0][2];
+    req->transform.matrix21 = transform->matrix[1][0];
+    req->transform.matrix22 = transform->matrix[1][1];
+    req->transform.matrix23 = transform->matrix[1][2];
+    req->transform.matrix31 = transform->matrix[2][0];
+    req->transform.matrix32 = transform->matrix[2][1];
+    req->transform.matrix33 = transform->matrix[2][2];
+    UnlockDisplay(dpy);
+    SyncHandle();
+    
+}
+
+void
+XRenderFreePicture (Display                   *dpy,
+		    Picture                   picture)
+{
+    XRenderExtDisplayInfo         *info = XRenderFindDisplay (dpy);
+    xRenderFreePictureReq   *req;
+
+    RenderSimpleCheckExtension (dpy, info);
+    LockDisplay(dpy);
+    GetReq(RenderFreePicture, req);
+    req->reqType = info->codes->major_opcode;
+    req->renderReqType = X_RenderFreePicture;
+    req->picture = picture;
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
+
+
+Picture XRenderCreateSolidFill(Display *dpy,
+                               const XRenderColor *color)
+{
+    XRenderExtDisplayInfo	    *info = XRenderFindDisplay (dpy);
+    Picture		    pid;
+    xRenderCreateSolidFillReq *req;
+
+    RenderCheckExtension (dpy, info, 0);
+    LockDisplay(dpy);
+    GetReq(RenderCreateSolidFill, req);
+    req->reqType = info->codes->major_opcode;
+    req->renderReqType = X_RenderCreateSolidFill;
+
+    req->pid = pid = XAllocID(dpy);
+    req->color.red = color->red;
+    req->color.green = color->green;
+    req->color.blue = color->blue;
+    req->color.alpha = color->alpha;
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return pid;
+}
+
+
+Picture XRenderCreateLinearGradient(Display *dpy,
+                                    const XLinearGradient *gradient,
+                                    const XFixed *stops,
+                                    const XRenderColor *colors,
+                                    int nStops)
+{
+    XRenderExtDisplayInfo	    *info = XRenderFindDisplay (dpy);
+    Picture		    pid;
+    xRenderCreateLinearGradientReq *req;
+    long			   len;
+
+    RenderCheckExtension (dpy, info, 0);
+    LockDisplay(dpy);
+    GetReq(RenderCreateLinearGradient, req);
+    req->reqType = info->codes->major_opcode;
+    req->renderReqType = X_RenderCreateLinearGradient;
+
+    req->pid = pid = XAllocID(dpy);
+    req->p1.x = gradient->p1.x;
+    req->p1.y = gradient->p1.y;
+    req->p2.x = gradient->p2.x;
+    req->p2.y = gradient->p2.y;
+
+    req->nStops = nStops;
+    len = (long) nStops * 3;
+    SetReqLen (req, len, 6);
+    DataInt32(dpy, stops, nStops * 4);
+    Data16(dpy, colors, nStops * 8);
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return pid;
+}
+
+Picture XRenderCreateRadialGradient(Display *dpy,
+                                    const XRadialGradient *gradient,
+                                    const XFixed *stops,
+                                    const XRenderColor *colors,
+                                    int nStops)
+{
+    XRenderExtDisplayInfo	    *info = XRenderFindDisplay (dpy);
+    Picture		    pid;
+    xRenderCreateRadialGradientReq *req;
+    long			   len;
+
+    RenderCheckExtension (dpy, info, 0);
+    LockDisplay(dpy);
+    GetReq(RenderCreateRadialGradient, req);
+    req->reqType = info->codes->major_opcode;
+    req->renderReqType = X_RenderCreateRadialGradient;
+
+    req->pid = pid = XAllocID(dpy);
+    req->inner.x = gradient->inner.x;
+    req->inner.y = gradient->inner.y;
+    req->outer.x = gradient->outer.x;
+    req->outer.y = gradient->outer.y;
+    req->inner_radius = gradient->inner.radius;
+    req->outer_radius = gradient->outer.radius;
+
+    req->nStops = nStops;
+    len = (long) nStops * 3;
+    SetReqLen (req, len, 6);
+    DataInt32(dpy, stops, nStops * 4);
+    Data16(dpy, colors, nStops * 8);
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return pid;
+}
+
+Picture XRenderCreateConicalGradient(Display *dpy,
+                                     const XConicalGradient *gradient,
+                                     const XFixed *stops,
+                                     const XRenderColor *colors,
+                                     int nStops)
+{
+    XRenderExtDisplayInfo	    *info = XRenderFindDisplay (dpy);
+    Picture		    pid;
+    xRenderCreateConicalGradientReq *req;
+    long			    len;
+
+    RenderCheckExtension (dpy, info, 0);
+    LockDisplay(dpy);
+    GetReq(RenderCreateConicalGradient, req);
+    req->reqType = info->codes->major_opcode;
+    req->renderReqType = X_RenderCreateConicalGradient;
+
+    req->pid = pid = XAllocID(dpy);
+    req->center.x = gradient->center.x;
+    req->center.y = gradient->center.y;
+    req->angle = gradient->angle;
+
+    req->nStops = nStops;
+    len = (long) nStops * 3;
+    SetReqLen (req, len, 6);
+    DataInt32(dpy, stops, nStops * 4);
+    Data16(dpy, colors, nStops * 8);
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return pid;
+}
diff --git a/libXrender/src/Poly.c b/libXrender/src/Poly.c
new file mode 100644
index 000000000..16599b22e
--- /dev/null
+++ b/libXrender/src/Poly.c
@@ -0,0 +1,302 @@
+/*
+ *
+ * Copyright © 2002 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xrenderint.h"
+
+typedef struct _Edge Edge;
+
+struct _Edge {
+    XLineFixed	edge;
+    XFixed	current_x;
+    Bool	clockWise;
+    Edge	*next, *prev;
+};
+
+static int
+CompareEdge (const void *o1, const void *o2)
+{
+    const Edge	*e1 = o1, *e2 = o2;
+
+    return e1->edge.p1.y - e2->edge.p1.y;
+}
+
+static XFixed
+XRenderComputeX (XLineFixed *line, XFixed y)
+{
+    XFixed  dx = line->p2.x - line->p1.x;
+    double  ex = (double) (y - line->p1.y) * (double) dx;
+    XFixed  dy = line->p2.y - line->p1.y;
+
+    return (XFixed) line->p1.x + (XFixed) (ex / dy);
+}
+
+static double
+XRenderComputeInverseSlope (XLineFixed *l)
+{
+    return (XFixedToDouble (l->p2.x - l->p1.x) / 
+	    XFixedToDouble (l->p2.y - l->p1.y));
+}
+
+static double
+XRenderComputeXIntercept (XLineFixed *l, double inverse_slope)
+{
+    return XFixedToDouble (l->p1.x) - inverse_slope * XFixedToDouble (l->p1.y);
+}
+
+static XFixed
+XRenderComputeIntersect (XLineFixed *l1, XLineFixed *l2)
+{
+    /*
+     * x = m1y + b1
+     * x = m2y + b2
+     * m1y + b1 = m2y + b2
+     * y * (m1 - m2) = b2 - b1
+     * y = (b2 - b1) / (m1 - m2)
+     */
+    double  m1 = XRenderComputeInverseSlope (l1);
+    double  b1 = XRenderComputeXIntercept (l1, m1);
+    double  m2 = XRenderComputeInverseSlope (l2);
+    double  b2 = XRenderComputeXIntercept (l2, m2);
+
+    return XDoubleToFixed ((b2 - b1) / (m1 - m2));
+}
+
+static int
+XRenderComputeTrapezoids (Edge		*edges,
+			  int		nedges,
+			  int		winding,
+			  XTrapezoid	*traps)
+{
+    int		ntraps = 0;
+    int		inactive;
+    Edge	*active;
+    Edge	*e, *en, *next;
+    XFixed	y, next_y, intersect;
+    
+    qsort (edges, nedges, sizeof (Edge), CompareEdge);
+    
+    y = edges[0].edge.p1.y;
+    active = NULL;
+    inactive = 0;
+    while (active || inactive < nedges)
+    {
+	/* insert new active edges into list */
+	while (inactive < nedges)
+	{
+	    e = &edges[inactive];
+	    if (e->edge.p1.y > y)
+		break;
+	    /* move this edge into the active list */
+	    inactive++;
+	    e->next = active;
+	    e->prev = NULL;
+	    if (active)
+		active->prev = e;
+	    active = e;
+	}
+	/* compute x coordinates along this group */
+	for (e = active; e; e = e->next)
+	    e->current_x = XRenderComputeX (&e->edge, y);
+	
+	/* sort active list */
+	for (e = active; e; e = next)
+	{
+	    next = e->next;
+	    /*
+	     * Find one later in the list that belongs before the
+	     * current one
+	     */
+	    for (en = next; en; en = en->next)
+	    {
+		if (en->current_x < e->current_x ||
+		    (en->current_x == e->current_x &&
+		     en->edge.p2.x < e->edge.p2.x))
+		{
+		    /*
+		     * insert en before e
+		     *
+		     * extract en
+		     */
+		    en->prev->next = en->next;
+		    if (en->next)
+			en->next->prev = en->prev;
+		    /*
+		     * insert en
+		     */
+		    if (e->prev)
+			e->prev->next = en;
+		    else
+			active = en;
+		    en->prev = e->prev;
+		    e->prev = en;
+		    en->next = e;
+		    /*
+		     * start over at en
+		     */
+		    next = en;
+		    break;
+		}
+	    }
+	}
+#if 0
+	printf ("y: %6.3g:", y / 65536.0);
+	for (e = active; e; e = e->next)
+	{
+	    printf (" %6.3g", e->current_x / 65536.0);
+	}
+	printf ("\n");
+#endif
+	/* find next inflection point */
+	next_y = active->edge.p2.y;
+	for (e = active; e; e = en)
+	{
+	    if (e->edge.p2.y < next_y)
+		next_y = e->edge.p2.y;
+	    en = e->next;
+	    /* check intersect */
+	    if (en && e->edge.p2.x > en->edge.p2.x) 
+	    {
+		intersect = XRenderComputeIntersect (&e->edge, &e->next->edge);
+		/* make sure this point is below the actual intersection */
+		intersect = intersect + 1;
+		if (intersect < next_y)
+		    next_y = intersect;
+	    }
+	}
+	/* check next inactive point */
+	if (inactive < nedges && edges[inactive].edge.p1.y < next_y)
+	    next_y = edges[inactive].edge.p1.y;
+	
+	/* walk the list generating trapezoids */
+	for (e = active; e && (en = e->next); e = en->next)
+	{
+	    traps->top = y;
+	    traps->bottom = next_y;
+	    traps->left = e->edge;
+	    traps->right = en->edge;
+	    traps++;
+	    ntraps++;
+	}
+
+	y = next_y;
+	
+	/* delete inactive edges from list */
+	for (e = active; e; e = next)
+	{
+	    next = e->next;
+	    if (e->edge.p2.y <= y)
+	    {
+		if (e->prev)
+		    e->prev->next = e->next;
+		else
+		    active = e->next;
+		if (e->next)
+		    e->next->prev = e->prev;
+	    }
+	}
+    }
+    return ntraps;
+}
+
+void
+XRenderCompositeDoublePoly (Display		    *dpy,
+			    int			    op,
+			    Picture		    src,
+			    Picture		    dst,
+			    _Xconst XRenderPictFormat	*maskFormat,
+			    int			    xSrc,
+			    int			    ySrc,
+			    int			    xDst,
+			    int			    yDst,
+			    _Xconst XPointDouble    *fpoints,
+			    int			    npoints,
+			    int			    winding)
+{
+    Edge	    *edges;
+    XTrapezoid	    *traps;
+    int		    i, nedges, ntraps;
+    XFixed	    x, y, prevx = 0, prevy = 0, firstx = 0, firsty = 0;
+    XFixed	    top = 0, bottom = 0;	/* GCCism */
+
+    edges = (Edge *) Xmalloc (npoints * sizeof (Edge) +
+			      (npoints * npoints * sizeof (XTrapezoid)));
+    if (!edges)
+	return;
+    traps = (XTrapezoid *) (edges + npoints);
+    nedges = 0;
+    for (i = 0; i <= npoints; i++)
+    {
+	if (i == npoints)
+	{
+	    x = firstx;
+	    y = firsty;
+	}
+	else
+	{
+	    x = XDoubleToFixed (fpoints[i].x);
+	    y = XDoubleToFixed (fpoints[i].y);
+	}
+	if (i)
+	{
+	    if (y < top)
+		top = y;
+	    else if (y > bottom)
+		bottom = y;
+	    if (prevy < y)
+	    {
+		edges[nedges].edge.p1.x = prevx;
+		edges[nedges].edge.p1.y = prevy;
+		edges[nedges].edge.p2.x = x;
+		edges[nedges].edge.p2.y = y;
+		edges[nedges].clockWise = True;
+		nedges++;
+	    }
+	    else if (prevy > y)
+	    {
+		edges[nedges].edge.p1.x = x;
+		edges[nedges].edge.p1.y = y;
+		edges[nedges].edge.p2.x = prevx;
+		edges[nedges].edge.p2.y = prevy;
+		edges[nedges].clockWise = False;
+		nedges++;
+	    }
+	    /* drop horizontal edges */
+	}
+	else
+	{
+	    top = y;
+	    bottom = y;
+	    firstx = x;
+	    firsty = y;
+	}
+	prevx = x;
+	prevy = y;
+    }
+    ntraps = XRenderComputeTrapezoids (edges, nedges, winding, traps);
+    /* XXX adjust xSrc/xDst */
+    XRenderCompositeTrapezoids (dpy, op, src, dst, maskFormat, xSrc, ySrc, traps, ntraps);
+    Xfree (edges);
+}
diff --git a/libXrender/src/Trap.c b/libXrender/src/Trap.c
new file mode 100644
index 000000000..919aaef53
--- /dev/null
+++ b/libXrender/src/Trap.c
@@ -0,0 +1,74 @@
+/*
+ *
+ * Copyright © 2002 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xrenderint.h"
+
+void
+XRenderCompositeTrapezoids (Display		*dpy,
+			    int			op,
+			    Picture		src,
+			    Picture		dst,
+			    _Xconst XRenderPictFormat	*maskFormat,
+			    int			xSrc,
+			    int			ySrc,
+			    _Xconst XTrapezoid	*traps,
+			    int			ntrap)
+{
+    XRenderExtDisplayInfo         *info = XRenderFindDisplay (dpy);
+    xRenderTrapezoidsReq    *req;
+    int			    n;
+    long    		    len;
+    unsigned long	    max_req = dpy->bigreq_size ? dpy->bigreq_size : dpy->max_request_size;
+
+    RenderSimpleCheckExtension (dpy, info);
+    LockDisplay(dpy);
+    while (ntrap)
+    {
+	GetReq(RenderTrapezoids, req);
+	req->reqType = info->codes->major_opcode;
+	req->renderReqType = X_RenderTrapezoids;
+	req->op = (CARD8) op;
+	req->src = src;
+	req->dst = dst;
+	req->maskFormat = maskFormat ? maskFormat->id : 0;
+	req->xSrc = xSrc;
+	req->ySrc = ySrc;
+	n = ntrap;
+	len = ((long) n) * (SIZEOF (xTrapezoid) >> 2);
+	if (len > (max_req - req->length)) {
+	    n = (max_req - req->length) / (SIZEOF (xTrapezoid) >> 2);
+	    len = ((long)n) * (SIZEOF (xTrapezoid) >> 2);
+	}
+	SetReqLen (req, len, len);
+	len <<= 2;
+	DataInt32 (dpy, (int *) traps, len);
+	ntrap -= n;
+	traps += n;
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
+
diff --git a/libXrender/src/Tri.c b/libXrender/src/Tri.c
new file mode 100644
index 000000000..155f2ce14
--- /dev/null
+++ b/libXrender/src/Tri.c
@@ -0,0 +1,169 @@
+/*
+ *
+ * Copyright © 2002 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xrenderint.h"
+
+void
+XRenderCompositeTriangles (Display		*dpy,
+			   int			op,
+			   Picture		src,
+			   Picture		dst,
+			    _Xconst XRenderPictFormat	*maskFormat,
+			   int			xSrc,
+			   int			ySrc,
+			   _Xconst XTriangle	*triangles,
+			   int			ntriangle)
+{
+    XRenderExtDisplayInfo         *info = XRenderFindDisplay (dpy);
+    xRenderTrianglesReq	    *req;
+    int			    n;
+    long    		    len;
+
+    RenderSimpleCheckExtension (dpy, info);
+    LockDisplay(dpy);
+    while (ntriangle)
+    {
+	GetReq(RenderTriangles, req);
+	req->reqType = info->codes->major_opcode;
+	req->renderReqType = X_RenderTriangles;
+	req->op = (CARD8) op;
+	req->src = src;
+	req->dst = dst;
+	req->maskFormat = maskFormat ? maskFormat->id : 0;
+	req->xSrc = xSrc;
+	req->ySrc = ySrc;
+	n = ntriangle;
+	len = ((long) n) * (SIZEOF (xTriangle) >> 2);
+	if (!dpy->bigreq_size && len > (dpy->max_request_size - req->length)) {
+	    n = (dpy->max_request_size - req->length) / (SIZEOF (xTriangle) >> 2);
+	    len = ((long)n) * (SIZEOF (xTriangle) >> 2);
+	}
+	SetReqLen (req, len, len);
+	len <<= 2;
+	DataInt32 (dpy, (int *) triangles, len);
+	ntriangle -= n;
+	triangles += n;
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
+
+void
+XRenderCompositeTriStrip (Display		*dpy,
+			  int			op,
+			  Picture		src,
+			  Picture		dst,
+			  _Xconst XRenderPictFormat	*maskFormat,
+			  int			xSrc,
+			  int			ySrc,
+			  _Xconst XPointFixed	*points,
+			  int			npoint)
+{
+    XRenderExtDisplayInfo         *info = XRenderFindDisplay (dpy);
+    xRenderTriStripReq	    *req;
+    int			    n;
+    long    		    len;
+
+    RenderSimpleCheckExtension (dpy, info);
+    LockDisplay(dpy);
+    while (npoint > 2)
+    {
+	GetReq(RenderTriStrip, req);
+	req->reqType = info->codes->major_opcode;
+	req->renderReqType = X_RenderTriStrip;
+	req->op = (CARD8) op;
+	req->src = src;
+	req->dst = dst;
+	req->maskFormat = maskFormat ? maskFormat->id : 0;
+	req->xSrc = xSrc;
+	req->ySrc = ySrc;
+	n = npoint;
+	len = ((long) n) * (SIZEOF (xPointFixed) >> 2);
+	if (!dpy->bigreq_size && len > (dpy->max_request_size - req->length)) {
+	    n = (dpy->max_request_size - req->length) / (SIZEOF (xPointFixed) >> 2);
+	    len = ((long)n) * (SIZEOF (xPointFixed) >> 2);
+	}
+	SetReqLen (req, len, len);
+	len <<= 2;
+	DataInt32 (dpy, (int *) points, len);
+	npoint -= (n - 2);
+	points += (n - 2);
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
+
+void
+XRenderCompositeTriFan (Display			*dpy,
+			int			op,
+			Picture			src,
+			Picture			dst,
+			_Xconst XRenderPictFormat	*maskFormat,
+			int			xSrc,
+			int			ySrc,
+			_Xconst XPointFixed	*points,
+			int			npoint)
+{
+    XRenderExtDisplayInfo         *info = XRenderFindDisplay (dpy);
+    _Xconst XPointFixed	    *first = points;
+    xPointFixed		    *p;
+    xRenderTriFanReq	    *req;
+    int			    n;
+    long    		    len;
+
+    RenderSimpleCheckExtension (dpy, info);
+    LockDisplay(dpy);
+    points++;
+    npoint--;
+    while (npoint > 1)
+    {
+	GetReqExtra(RenderTriFan, SIZEOF (xPointFixed), req);
+	req->reqType = info->codes->major_opcode;
+	req->renderReqType = X_RenderTriFan;
+	req->op = (CARD8) op;
+	req->src = src;
+	req->dst = dst;
+	req->maskFormat = maskFormat ? maskFormat->id : 0;
+	req->xSrc = xSrc;
+	req->ySrc = ySrc;
+	p = (xPointFixed *) (req + 1);
+	p->x = first->x;
+	p->y = first->y;
+	n = npoint;
+	len = ((long) n) * (SIZEOF (xPointFixed) >> 2);
+	if (!dpy->bigreq_size && len > (dpy->max_request_size - req->length)) {
+	    n = (dpy->max_request_size - req->length) / (SIZEOF (xPointFixed) >> 2);
+	    len = ((long)n) * (SIZEOF (xPointFixed) >> 2);
+	}
+	SetReqLen (req, len, len);
+	len <<= 2;
+	DataInt32 (dpy, (int *) points, len);
+	npoint -= (n - 1);
+	points += (n - 1);
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
diff --git a/libXrender/src/Xrender.c b/libXrender/src/Xrender.c
new file mode 100644
index 000000000..c7630766f
--- /dev/null
+++ b/libXrender/src/Xrender.c
@@ -0,0 +1,889 @@
+/*
+ *
+ * Copyright © 2000 SuSE, 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 "Xrenderint.h"
+
+XRenderExtInfo XRenderExtensionInfo;
+char XRenderExtensionName[] = RENDER_NAME;
+
+static int XRenderCloseDisplay (Display *dpy, XExtCodes *codes);
+
+/*
+ * XRenderExtFindDisplay - look for a display in this extension; keeps a
+ * cache of the most-recently used for efficiency. (Replaces
+ * XextFindDisplay.)
+ */
+static XRenderExtDisplayInfo *
+XRenderExtFindDisplay (XRenderExtInfo *extinfo, 
+                       Display        *dpy)
+{
+    XRenderExtDisplayInfo *dpyinfo;
+
+    /*
+     * see if this was the most recently accessed display
+     */
+    if ((dpyinfo = extinfo->cur) && dpyinfo->display == dpy) 
+        return dpyinfo;
+
+    /*
+     * look for display in list
+     */
+    _XLockMutex(_Xglobal_lock);
+    for (dpyinfo = extinfo->head; dpyinfo; dpyinfo = dpyinfo->next) {
+        if (dpyinfo->display == dpy) {
+            extinfo->cur = dpyinfo;     /* cache most recently used */
+            _XUnlockMutex(_Xglobal_lock);
+            return dpyinfo;
+        }
+    }
+    _XUnlockMutex(_Xglobal_lock);
+
+    return NULL;
+}
+
+/*
+ * If the server is missing support for any of the required depths on
+ * any screen, tell the application that Render is not present.
+ */
+
+#define DEPTH_MASK(d)	(1 << ((d) - 1))
+    
+/*
+ * Render requires support for depth 1, 4, 8, 24 and 32 pixmaps
+ */
+
+#define REQUIRED_DEPTHS	(DEPTH_MASK(1) | \
+			 DEPTH_MASK(4) | \
+			 DEPTH_MASK(8) | \
+			 DEPTH_MASK(24) | \
+			 DEPTH_MASK(32))
+    
+typedef struct _DepthCheckRec {
+    struct _DepthCheckRec *next;
+    Display *dpy;
+    CARD32  missing;
+    unsigned long serial;
+} DepthCheckRec, *DepthCheckPtr;
+
+static DepthCheckPtr	depthChecks;
+
+static int
+XRenderDepthCheckErrorHandler (Display *dpy, XErrorEvent *evt)
+{
+    if (evt->request_code == X_CreatePixmap && evt->error_code == BadValue)
+    {
+	DepthCheckPtr	d;
+	_XLockMutex(_Xglobal_lock);
+	for (d = depthChecks; d; d = d->next)
+	    if (d->dpy == dpy)
+	    {
+		if ((long) (evt->serial - d->serial) >= 0)
+		    d->missing |= DEPTH_MASK(evt->resourceid);
+		break;
+	    }
+	_XUnlockMutex (_Xglobal_lock);
+    }
+    return 0;
+}
+
+static Bool
+XRenderHasDepths (Display *dpy)
+{
+    int	s;
+
+    for (s = 0; s < ScreenCount (dpy); s++)
+    {
+	CARD32		    depths = 0;
+	CARD32		    missing;
+	Screen		    *scr = ScreenOfDisplay (dpy, s);
+	int		    d;
+
+	for (d = 0; d < scr->ndepths; d++)
+	    depths |= DEPTH_MASK(scr->depths[d].depth);
+	missing = ~depths & REQUIRED_DEPTHS;
+	if (missing)
+	{
+	    DepthCheckRec   dc, **dp;
+	    XErrorHandler   previousHandler;
+
+	    /*
+	     * Ok, this is ugly.  It should be sufficient at this
+	     * point to just return False, but Xinerama is broken at
+	     * this point and only advertises depths which have an
+	     * associated visual.  Of course, the other depths still
+	     * work, but the only way to find out is to try them.
+	     */
+	    dc.dpy = dpy;
+	    dc.missing = 0;
+	    dc.serial = XNextRequest (dpy);
+	    _XLockMutex(_Xglobal_lock);
+	    dc.next = depthChecks;
+	    depthChecks = &dc;
+	    _XUnlockMutex (_Xglobal_lock);
+	    /*
+	     * I suspect this is not really thread safe, but Xlib doesn't
+	     * provide a lot of options here
+	     */
+	    previousHandler = XSetErrorHandler (XRenderDepthCheckErrorHandler);
+	    /*
+	     * Try each missing depth and see if pixmap creation succeeds
+	     */
+	    for (d = 1; d <= 32; d++)
+		/* don't check depth 1 == Xcursor recurses... */
+		if ((missing & DEPTH_MASK(d)) && d != 1)
+		{
+		    Pixmap  p;
+		    p = XCreatePixmap (dpy, RootWindow (dpy, s), 1, 1, d);
+		    XFreePixmap (dpy, p);
+		}
+	    XSync (dpy, False);
+	    XSetErrorHandler (previousHandler);
+	    /*
+	     * Unhook from the list of depth check records
+	     */
+	    _XLockMutex(_Xglobal_lock);
+	    for (dp = &depthChecks; *dp; dp = &(*dp)->next)
+	    {
+		if (*dp == &dc)
+		{
+		    *dp = dc.next;
+		    break;
+		}
+	    }
+	    _XUnlockMutex (_Xglobal_lock);
+	    if (dc.missing)
+		return False;
+	}
+    }
+    return True;
+}
+
+/*
+ * XRenderExtAddDisplay - add a display to this extension. (Replaces
+ * XextAddDisplay)
+ */
+static XRenderExtDisplayInfo *
+XRenderExtAddDisplay (XRenderExtInfo *extinfo,
+                      Display        *dpy,
+                      char           *ext_name)
+{
+    XRenderExtDisplayInfo *dpyinfo;
+
+    dpyinfo = (XRenderExtDisplayInfo *) Xmalloc (sizeof (XRenderExtDisplayInfo));
+    if (!dpyinfo) return NULL;
+    dpyinfo->display = dpy;
+    dpyinfo->info = NULL;
+
+    if (XRenderHasDepths (dpy))
+	dpyinfo->codes = XInitExtension (dpy, ext_name);
+    else
+	dpyinfo->codes = NULL;
+
+    /*
+     * if the server has the extension, then we can initialize the 
+     * appropriate function vectors
+     */
+    if (dpyinfo->codes) {
+        XESetCloseDisplay (dpy, dpyinfo->codes->extension, 
+                           XRenderCloseDisplay);
+    } else {
+	/* The server doesn't have this extension.
+	 * Use a private Xlib-internal extension to hang the close_display
+	 * hook on so that the "cache" (extinfo->cur) is properly cleaned.
+	 * (XBUG 7955)
+	 */
+	XExtCodes *codes = XAddExtension(dpy);
+	if (!codes) {
+	    XFree(dpyinfo);
+	    return NULL;
+	}
+        XESetCloseDisplay (dpy, codes->extension, XRenderCloseDisplay);
+    }
+
+    /*
+     * now, chain it onto the list
+     */
+    _XLockMutex(_Xglobal_lock);
+    dpyinfo->next = extinfo->head;
+    extinfo->head = dpyinfo;
+    extinfo->cur = dpyinfo;
+    extinfo->ndisplays++;
+    _XUnlockMutex(_Xglobal_lock);
+    return dpyinfo;
+}
+
+
+/*
+ * XRenderExtRemoveDisplay - remove the indicated display from the
+ * extension object. (Replaces XextRemoveDisplay.)
+ */
+static int 
+XRenderExtRemoveDisplay (XRenderExtInfo *extinfo, Display *dpy)
+{
+    XRenderExtDisplayInfo *dpyinfo, *prev;
+
+    /*
+     * locate this display and its back link so that it can be removed
+     */
+    _XLockMutex(_Xglobal_lock);
+    prev = NULL;
+    for (dpyinfo = extinfo->head; dpyinfo; dpyinfo = dpyinfo->next) {
+	if (dpyinfo->display == dpy) break;
+	prev = dpyinfo;
+    }
+    if (!dpyinfo) {
+	_XUnlockMutex(_Xglobal_lock);
+	return 0;		/* hmm, actually an error */
+    }
+
+    /*
+     * remove the display from the list; handles going to zero
+     */
+    if (prev)
+	prev->next = dpyinfo->next;
+    else
+	extinfo->head = dpyinfo->next;
+
+    extinfo->ndisplays--;
+    if (dpyinfo == extinfo->cur) extinfo->cur = NULL;  /* flush cache */
+    _XUnlockMutex(_Xglobal_lock);
+
+    Xfree ((char *) dpyinfo);
+    return 1;
+}
+
+
+
+XRenderExtDisplayInfo *
+XRenderFindDisplay (Display *dpy)
+{
+    XRenderExtDisplayInfo *dpyinfo;
+
+    dpyinfo = XRenderExtFindDisplay (&XRenderExtensionInfo, dpy);
+    if (!dpyinfo)
+	dpyinfo = XRenderExtAddDisplay (&XRenderExtensionInfo, dpy, 
+                                        XRenderExtensionName);
+    return dpyinfo;
+}
+
+static int
+XRenderCloseDisplay (Display *dpy, XExtCodes *codes)
+{
+    XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy);
+    if (info && info->info) XFree (info->info);
+    
+    return XRenderExtRemoveDisplay (&XRenderExtensionInfo, dpy);
+}
+    
+/****************************************************************************
+ *                                                                          *
+ *			    Render public interfaces                        *
+ *                                                                          *
+ ****************************************************************************/
+
+Bool XRenderQueryExtension (Display *dpy, int *event_basep, int *error_basep)
+{
+    XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy);
+
+    if (RenderHasExtension(info)) {
+	*event_basep = info->codes->first_event;
+	*error_basep = info->codes->first_error;
+	return True;
+    } else {
+	return False;
+    }
+}
+
+
+Status XRenderQueryVersion (Display *dpy,
+			    int	    *major_versionp,
+			    int	    *minor_versionp)
+{
+    XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy);
+    XRenderInfo	    *xri;
+
+    if (!RenderHasExtension (info))
+	return 0;
+
+    if (!XRenderQueryFormats (dpy))
+	return 0;
+    
+    xri = info->info; 
+    *major_versionp = xri->major_version;
+    *minor_versionp = xri->minor_version;
+    return 1;
+}
+
+static XRenderPictFormat *
+_XRenderFindFormat (XRenderInfo *xri, PictFormat format)
+{
+    int	nf;
+    
+    for (nf = 0; nf < xri->nformat; nf++)
+	if (xri->format[nf].id == format)
+	    return &xri->format[nf];
+    return NULL;
+}
+
+static Visual *
+_XRenderFindVisual (Display *dpy, VisualID vid)
+{
+    return _XVIDtoVisual (dpy, vid);
+}
+
+typedef struct _renderVersionState {
+    unsigned long   version_seq;
+    Bool	    error;
+    int		    major_version;
+    int		    minor_version;
+    
+} _XrenderVersionState;
+
+static Bool
+_XRenderVersionHandler (Display	    *dpy,
+			xReply	    *rep,
+			char	    *buf,
+			int	    len,
+			XPointer    data)
+{
+    xRenderQueryVersionReply	replbuf;
+    xRenderQueryVersionReply	*repl;
+    _XrenderVersionState	*state = (_XrenderVersionState *) data;
+
+    if (dpy->last_request_read != state->version_seq)
+	return False;
+    if (rep->generic.type == X_Error)
+    {
+	state->error = True;
+	return False;
+    }
+    repl = (xRenderQueryVersionReply *)
+	_XGetAsyncReply(dpy, (char *)&replbuf, rep, buf, len,
+		     (SIZEOF(xRenderQueryVersionReply) - SIZEOF(xReply)) >> 2,
+			True);
+    state->major_version = repl->majorVersion;
+    state->minor_version = repl->minorVersion;
+    return True;
+}
+
+Status
+XRenderQueryFormats (Display *dpy)
+{
+    XRenderExtDisplayInfo		*info = XRenderFindDisplay (dpy);
+    _XAsyncHandler		async;
+    _XrenderVersionState	async_state;
+    xRenderQueryVersionReq	*vreq;
+    xRenderQueryPictFormatsReply rep;
+    xRenderQueryPictFormatsReq  *req;
+    XRenderInfo			*xri;
+    XRenderPictFormat		*format;
+    XRenderScreen		*screen;
+    XRenderDepth		*depth;
+    XRenderVisual		*visual;
+    xPictFormInfo		*xFormat;
+    xPictScreen			*xScreen;
+    xPictDepth			*xDepth;
+    xPictVisual			*xVisual;
+    CARD32			*xSubpixel;
+    void			*xData;
+    int				nf, ns, nd, nv;
+    int				rlength;
+    int				nbytes;
+    
+    RenderCheckExtension (dpy, info, 0);
+    LockDisplay (dpy);
+    if (info->info)
+    {
+	UnlockDisplay (dpy);
+	return 1;
+    }
+    GetReq (RenderQueryVersion, vreq);
+    vreq->reqType = info->codes->major_opcode;
+    vreq->renderReqType = X_RenderQueryVersion;
+    vreq->majorVersion = RENDER_MAJOR;
+    vreq->minorVersion = RENDER_MINOR;
+    
+    async_state.version_seq = dpy->request;
+    async_state.error = False;
+    async.next = dpy->async_handlers;
+    async.handler = _XRenderVersionHandler;
+    async.data = (XPointer) &async_state;
+    dpy->async_handlers = &async;
+    
+    GetReq (RenderQueryPictFormats, req);
+    req->reqType = info->codes->major_opcode;
+    req->renderReqType = X_RenderQueryPictFormats;
+    
+    if (!_XReply (dpy, (xReply *) &rep, 0, xFalse)) 
+    {
+	DeqAsyncHandler (dpy, &async);
+	UnlockDisplay (dpy);
+	SyncHandle ();
+	return 0;
+    }
+    DeqAsyncHandler (dpy, &async);
+    if (async_state.error)
+    {
+	UnlockDisplay(dpy);
+	SyncHandle();
+	return 0;
+    }
+    /*
+     * Check for the lack of sub-pixel data
+     */
+    if (async_state.major_version == 0 && async_state.minor_version < 6)
+	rep.numSubpixel = 0;
+	
+    xri = (XRenderInfo *) Xmalloc (sizeof (XRenderInfo) +
+				   rep.numFormats * sizeof (XRenderPictFormat) +
+				   rep.numScreens * sizeof (XRenderScreen) +
+				   rep.numDepths * sizeof (XRenderDepth) +
+				   rep.numVisuals * sizeof (XRenderVisual));
+    rlength = (rep.numFormats * sizeof (xPictFormInfo) +
+	       rep.numScreens * sizeof (xPictScreen) +
+	       rep.numDepths * sizeof (xPictDepth) +
+	       rep.numVisuals * sizeof (xPictVisual) +
+	       rep.numSubpixel * 4);
+    xData = (void *) Xmalloc (rlength);
+    nbytes = (int) rep.length << 2;
+    
+    if (!xri || !xData || nbytes < rlength)
+    {
+	if (xri) Xfree (xri);
+	if (xData) Xfree (xData);
+	_XEatData (dpy, nbytes);
+	UnlockDisplay (dpy);
+	SyncHandle ();
+	return 0;
+    }
+    xri->major_version = async_state.major_version;
+    xri->minor_version = async_state.minor_version;
+    xri->format = (XRenderPictFormat *) (xri + 1);
+    xri->nformat = rep.numFormats;
+    xri->screen = (XRenderScreen *) (xri->format + rep.numFormats);
+    xri->nscreen = rep.numScreens;
+    xri->depth = (XRenderDepth *) (xri->screen + rep.numScreens);
+    xri->ndepth = rep.numDepths;
+    xri->visual = (XRenderVisual *) (xri->depth + rep.numDepths);
+    xri->nvisual = rep.numVisuals;
+    _XRead (dpy, (char *) xData, rlength);
+    format = xri->format;
+    xFormat = (xPictFormInfo *) xData;
+    for (nf = 0; nf < rep.numFormats; nf++)
+    {
+	format->id = xFormat->id;
+	format->type = xFormat->type;
+	format->depth = xFormat->depth;
+	format->direct.red = xFormat->direct.red;
+	format->direct.redMask = xFormat->direct.redMask;
+	format->direct.green = xFormat->direct.green;
+	format->direct.greenMask = xFormat->direct.greenMask;
+	format->direct.blue = xFormat->direct.blue;
+	format->direct.blueMask = xFormat->direct.blueMask;
+	format->direct.alpha = xFormat->direct.alpha;
+	format->direct.alphaMask = xFormat->direct.alphaMask;
+	format->colormap = xFormat->colormap;
+	format++;
+	xFormat++;
+    }
+    xScreen = (xPictScreen *) xFormat;
+    screen = xri->screen;
+    depth = xri->depth;
+    visual = xri->visual;
+    for (ns = 0; ns < xri->nscreen; ns++)
+    {
+	screen->depths = depth;
+	screen->ndepths = xScreen->nDepth;
+	screen->fallback = _XRenderFindFormat (xri, xScreen->fallback);
+	screen->subpixel = SubPixelUnknown;
+	xDepth = (xPictDepth *) (xScreen + 1);
+	for (nd = 0; nd < screen->ndepths; nd++)
+	{
+	    depth->depth = xDepth->depth;
+	    depth->nvisuals = xDepth->nPictVisuals;
+	    depth->visuals = visual;
+	    xVisual = (xPictVisual *) (xDepth + 1);
+	    for (nv = 0; nv < depth->nvisuals; nv++)
+	    {
+		visual->visual = _XRenderFindVisual (dpy, xVisual->visual);
+		visual->format = _XRenderFindFormat (xri, xVisual->format);
+		visual++;
+		xVisual++;
+	    }
+	    depth++;
+	    xDepth = (xPictDepth *) xVisual;
+	}
+	screen++;
+	xScreen = (xPictScreen *) xDepth;	    
+    }
+    xSubpixel = (CARD32 *) xScreen;
+    screen = xri->screen;
+    for (ns = 0; ns < rep.numSubpixel; ns++)
+    {
+	screen->subpixel = *xSubpixel;
+	xSubpixel++;
+	screen++;
+    }
+    info->info = xri;
+    /*
+     * Skip any extra data
+     */
+    if (nbytes > rlength)
+	_XEatData (dpy, (unsigned long) (nbytes - rlength));
+    
+    UnlockDisplay (dpy);
+    SyncHandle ();
+    Xfree (xData);
+    return 1;
+}
+
+int
+XRenderQuerySubpixelOrder (Display *dpy, int screen)
+{
+    XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy);
+    XRenderInfo	    *xri;
+
+    if (!RenderHasExtension (info))
+	return SubPixelUnknown;
+
+    if (!XRenderQueryFormats (dpy))
+	return SubPixelUnknown;
+
+    xri = info->info;
+    return xri->screen[screen].subpixel;
+}
+
+Bool
+XRenderSetSubpixelOrder (Display *dpy, int screen, int subpixel)
+{
+    XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy);
+    XRenderInfo	    *xri;
+
+    if (!RenderHasExtension (info))
+	return False;
+
+    if (!XRenderQueryFormats (dpy))
+	return False;
+
+    xri = info->info;
+    xri->screen[screen].subpixel = subpixel;
+    return True;
+}
+
+XRenderPictFormat *
+XRenderFindVisualFormat (Display *dpy, _Xconst Visual *visual)
+{
+    XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy);
+    int		    nv;
+    XRenderInfo	    *xri;
+    XRenderVisual   *xrv;
+
+    RenderCheckExtension (dpy, info, NULL);
+    if (!XRenderQueryFormats (dpy))
+        return NULL;
+    xri = info->info;
+    for (nv = 0, xrv = xri->visual; nv < xri->nvisual; nv++, xrv++)
+	if (xrv->visual == visual)
+	    return xrv->format;
+    return NULL;
+}
+
+XRenderPictFormat *
+XRenderFindFormat (Display		*dpy,
+		   unsigned long	mask,
+		   _Xconst XRenderPictFormat	*template,
+		   int			count)
+{
+    XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy);
+    int		    nf;
+    XRenderInfo     *xri;
+
+    RenderCheckExtension (dpy, info, NULL);
+    if (!XRenderQueryFormats (dpy))
+	return NULL;
+    xri = info->info;
+    for (nf = 0; nf < xri->nformat; nf++)
+    {
+	if (mask & PictFormatID)
+	    if (template->id != xri->format[nf].id)
+		continue;
+	if (mask & PictFormatType)
+	if (template->type != xri->format[nf].type)
+		continue;
+	if (mask & PictFormatDepth)
+	    if (template->depth != xri->format[nf].depth)
+		continue;
+	if (mask & PictFormatRed)
+	    if (template->direct.red != xri->format[nf].direct.red)
+		continue;
+	if (mask & PictFormatRedMask)
+	    if (template->direct.redMask != xri->format[nf].direct.redMask)
+		continue;
+	if (mask & PictFormatGreen)
+	    if (template->direct.green != xri->format[nf].direct.green)
+		continue;
+	if (mask & PictFormatGreenMask)
+	    if (template->direct.greenMask != xri->format[nf].direct.greenMask)
+		continue;
+	if (mask & PictFormatBlue)
+	    if (template->direct.blue != xri->format[nf].direct.blue)
+		continue;
+	if (mask & PictFormatBlueMask)
+	    if (template->direct.blueMask != xri->format[nf].direct.blueMask)
+		continue;
+	if (mask & PictFormatAlpha)
+	    if (template->direct.alpha != xri->format[nf].direct.alpha)
+		continue;
+	if (mask & PictFormatAlphaMask)
+	    if (template->direct.alphaMask != xri->format[nf].direct.alphaMask)
+		continue;
+	if (mask & PictFormatColormap)
+	    if (template->colormap != xri->format[nf].colormap)
+		continue;
+	if (count-- == 0)
+	    return &xri->format[nf];
+    }
+    return NULL;
+}
+
+XRenderPictFormat *
+XRenderFindStandardFormat (Display  *dpy,
+			   int	    format)
+{
+    static struct {
+	XRenderPictFormat   templ;
+	unsigned long	    mask;
+    } standardFormats[PictStandardNUM] = {
+	/* PictStandardARGB32 */
+	{
+	    {
+		0,			    /* id */
+		PictTypeDirect,		    /* type */
+		32,			    /* depth */
+		{			    /* direct */
+		    16,			    /* direct.red */
+		    0xff,		    /* direct.redMask */
+		    8,			    /* direct.green */
+		    0xff,		    /* direct.greenMask */
+		    0,			    /* direct.blue */
+		    0xff,		    /* direct.blueMask */
+		    24,			    /* direct.alpha */
+		    0xff,		    /* direct.alphaMask */
+		},
+		0,			    /* colormap */
+	    },
+	    PictFormatType | 
+	    PictFormatDepth |
+	    PictFormatRed |
+	    PictFormatRedMask |
+	    PictFormatGreen |
+	    PictFormatGreenMask |
+	    PictFormatBlue |
+	    PictFormatBlueMask |
+	    PictFormatAlpha |
+	    PictFormatAlphaMask,
+	},
+	/* PictStandardRGB24 */
+	{
+	    {
+		0,			    /* id */
+		PictTypeDirect,		    /* type */
+		24,			    /* depth */
+		{			    /* direct */
+		    16,			    /* direct.red */
+		    0xff,		    /* direct.redMask */
+		    8,			    /* direct.green */
+		    0xff,		    /* direct.greenMask */
+		    0,			    /* direct.blue */
+		    0xff,		    /* direct.blueMask */
+		    0,			    /* direct.alpha */
+		    0x00,		    /* direct.alphaMask */
+		},
+		0,			    /* colormap */
+	    },
+	    PictFormatType | 
+	    PictFormatDepth |
+	    PictFormatRed |
+	    PictFormatRedMask |
+	    PictFormatGreen |
+	    PictFormatGreenMask |
+	    PictFormatBlue |
+	    PictFormatBlueMask |
+	    PictFormatAlphaMask,
+	},
+	/* PictStandardA8 */
+	{
+	    {
+		0,			    /* id */
+		PictTypeDirect,		    /* type */
+		8,			    /* depth */
+		{			    /* direct */
+		    0,			    /* direct.red */
+		    0x00,		    /* direct.redMask */
+		    0,			    /* direct.green */
+		    0x00,		    /* direct.greenMask */
+		    0,			    /* direct.blue */
+		    0x00,		    /* direct.blueMask */
+		    0,			    /* direct.alpha */
+		    0xff,		    /* direct.alphaMask */
+		},
+		0,			    /* colormap */
+	    },
+	    PictFormatType | 
+	    PictFormatDepth |
+	    PictFormatRedMask |
+	    PictFormatGreenMask |
+	    PictFormatBlueMask |
+	    PictFormatAlpha |
+	    PictFormatAlphaMask,
+	},
+	/* PictStandardA4 */
+	{
+	    {
+		0,			    /* id */
+		PictTypeDirect,		    /* type */
+		4,			    /* depth */
+		{			    /* direct */
+		    0,			    /* direct.red */
+		    0x00,		    /* direct.redMask */
+		    0,			    /* direct.green */
+		    0x00,		    /* direct.greenMask */
+		    0,			    /* direct.blue */
+		    0x00,		    /* direct.blueMask */
+		    0,			    /* direct.alpha */
+		    0x0f,		    /* direct.alphaMask */
+		},
+		0,			    /* colormap */
+	    },
+	    PictFormatType | 
+	    PictFormatDepth |
+	    PictFormatRedMask |
+	    PictFormatGreenMask |
+	    PictFormatBlueMask |
+	    PictFormatAlpha |
+	    PictFormatAlphaMask,
+	},
+	/* PictStandardA1 */
+	{
+	    {
+		0,			    /* id */
+		PictTypeDirect,		    /* type */
+		1,			    /* depth */
+		{			    /* direct */
+		    0,			    /* direct.red */
+		    0x00,		    /* direct.redMask */
+		    0,			    /* direct.green */
+		    0x00,		    /* direct.greenMask */
+		    0,			    /* direct.blue */
+		    0x00,		    /* direct.blueMask */
+		    0,			    /* direct.alpha */
+		    0x01,		    /* direct.alphaMask */
+		},
+		0,			    /* colormap */
+	    },
+	    PictFormatType | 
+	    PictFormatDepth |
+	    PictFormatRedMask |
+	    PictFormatGreenMask |
+	    PictFormatBlueMask |
+	    PictFormatAlpha |
+	    PictFormatAlphaMask,
+	},
+    };
+
+    if (0 <= format && format < PictStandardNUM)
+	return XRenderFindFormat (dpy, 
+				  standardFormats[format].mask,
+				  &standardFormats[format].templ,
+				  0);
+    return NULL;
+}
+
+XIndexValue *
+XRenderQueryPictIndexValues(Display			*dpy,
+			    _Xconst XRenderPictFormat	*format,
+			    int				*num)
+{
+    XRenderExtDisplayInfo			*info = XRenderFindDisplay (dpy);
+    xRenderQueryPictIndexValuesReq	*req;
+    xRenderQueryPictIndexValuesReply	rep;
+    XIndexValue				*values;
+    int					nbytes, nread, rlength, i;
+
+    RenderCheckExtension (dpy, info, NULL);
+
+    LockDisplay (dpy);
+    GetReq (RenderQueryPictIndexValues, req);
+    req->reqType = info->codes->major_opcode;
+    req->renderReqType = X_RenderQueryPictIndexValues;
+    req->format = format->id;
+    if (!_XReply (dpy, (xReply *) &rep, 0, xFalse))
+    {
+	UnlockDisplay (dpy);
+	SyncHandle ();
+	return NULL;
+    }
+
+    /* request data length */
+    nbytes = (long)rep.length << 2;
+    /* bytes of actual data in the request */
+    nread = rep.numIndexValues * SIZEOF (xIndexValue);
+    /* size of array returned to application */
+    rlength = rep.numIndexValues * sizeof (XIndexValue);
+
+    /* allocate returned data */
+    values = (XIndexValue *)Xmalloc (rlength);
+    if (!values)
+    {
+	_XEatData (dpy, nbytes);
+	UnlockDisplay (dpy);
+	SyncHandle ();
+	return NULL;
+    }
+
+    /* read the values one at a time and convert */
+    *num = rep.numIndexValues;
+    for(i = 0; i < rep.numIndexValues; i++)
+    {
+	xIndexValue value;
+	
+	_XRead (dpy, (char *) &value, SIZEOF (xIndexValue));
+	values[i].pixel = value.pixel;
+	values[i].red = value.red;
+	values[i].green = value.green;
+	values[i].blue = value.blue;
+	values[i].alpha = value.alpha;
+    }
+    /* skip any padding */
+    if(nbytes > nread)
+    {
+	_XEatData (dpy, (unsigned long) (nbytes - nread));
+    }
+    UnlockDisplay (dpy);
+    SyncHandle ();
+    return values;
+}
diff --git a/libXrender/src/Xrenderint.h b/libXrender/src/Xrenderint.h
new file mode 100644
index 000000000..49a294b14
--- /dev/null
+++ b/libXrender/src/Xrenderint.h
@@ -0,0 +1,114 @@
+/*
+ *
+ * Copyright © 2000 SuSE, 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.
+ */
+
+#ifndef _XRENDERINT_H_
+#define _XRENDERINT_H_
+
+#include "config.h"
+#define NEED_EVENTS
+#define NEED_REPLIES
+#include <X11/Xlibint.h>
+#include <X11/Xutil.h>
+#include <X11/extensions/renderproto.h>
+#include "Xrender.h"
+
+typedef struct {
+    Visual		*visual;
+    XRenderPictFormat	*format;
+} XRenderVisual;
+
+typedef struct {
+    int			depth;
+    int			nvisuals;
+    XRenderVisual	*visuals;
+} XRenderDepth;
+
+typedef struct {
+    XRenderDepth	*depths;
+    int			ndepths;
+    XRenderPictFormat	*fallback;
+    int			subpixel;
+} XRenderScreen;
+
+typedef struct _XRenderInfo {
+    int			major_version;
+    int			minor_version;
+    XRenderPictFormat	*format;
+    int			nformat;
+    XRenderScreen	*screen;
+    int			nscreen;
+    XRenderDepth	*depth;
+    int			ndepth;
+    XRenderVisual	*visual;
+    int			nvisual;
+    int			*subpixel;
+    int			nsubpixel;
+    char		**filter;
+    int			nfilter;
+    short    		*filter_alias;
+    int			nfilter_alias;
+} XRenderInfo;
+
+/* replaces XRenderExtDisplayInfo */
+typedef struct _XRenderExtDisplayInfo {
+    struct _XRenderExtDisplayInfo *next;    /* keep a linked list */
+    Display                       *display; /* which display this is */
+    XExtCodes                     *codes;   /* the extension protocol codes */
+    XRenderInfo                   *info;    /* extra data for the extension to use */
+} XRenderExtDisplayInfo;
+
+/* replaces XExtensionInfo */
+typedef struct _XRenderExtInfo {
+    XRenderExtDisplayInfo  *head;           /* start of the list */
+    XRenderExtDisplayInfo  *cur;            /* most recently used */
+    int                     ndisplays;      /* number of displays */
+} XRenderExtInfo;
+
+extern XRenderExtInfo XRenderExtensionInfo;
+extern char XRenderExtensionName[];
+
+XRenderExtDisplayInfo *
+XRenderFindDisplay (Display *dpy);
+
+#define RenderHasExtension(i) ((i) && ((i)->codes))
+
+#define RenderCheckExtension(dpy,i,val) \
+  if (!RenderHasExtension(i)) { return val; }
+
+#define RenderSimpleCheckExtension(dpy,i) \
+  if (!RenderHasExtension(i)) { return; }
+
+/*
+ * Xlib uses long for 32-bit values.  Xrender uses int.  This
+ * matters on alpha.  Note that this macro assumes that int is 32 bits
+ * except on WORD64 machines where it is 64 bits.
+ */
+
+#ifdef WORD64
+#define DataInt32(dpy,d,len)	Data32(dpy,(long *) (d),len)
+#else
+#define DataInt32(dpy,d,len)	Data(dpy,(char *) (d),len)
+#endif
+
+#endif /* _XRENDERINT_H_ */
diff --git a/libXrender/xrender.pc.in b/libXrender/xrender.pc.in
new file mode 100644
index 000000000..dd30ce9c2
--- /dev/null
+++ b/libXrender/xrender.pc.in
@@ -0,0 +1,12 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: Xrender
+Description: X Render Library
+Version: @VERSION@
+Requires: xproto renderproto >= @RENDER_VERSION@ x11
+Requires.private: x11
+Cflags: -I${includedir}
+Libs: -L${libdir} -lXrender