Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdegraphics@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 1841 insertions, 0 deletions

diff --git a/ksvg/impl/libs/art_support/art_misc.c b/ksvg/impl/libs/art_support/art_misc.c
new file mode 100644
index 00000000..69b45306
--- /dev/null
+++ b/ksvg/impl/libs/art_support/art_misc.c
@@ -0,0 +1,1841 @@
+#include <libart_lgpl/art_vpath.h>
+#include <libart_lgpl/art_bpath.h>
+#include <libart_lgpl/art_misc.h>
+#include <libart_lgpl/art_affine.h>
+#include <libart_lgpl/art_svp_render_aa.h>
+
+#include "art_misc.h"
+
+extern double ceil(double x);
+extern double floor(double x);
+
+/**
+ * art_vpath_render_bez: Render a bezier segment into the vpath.
+ * @p_vpath: Where the pointer to the #ArtVpath structure is stored.
+ * @pn_points: Pointer to the number of points in *@p_vpath.
+ * @pn_points_max: Pointer to the number of points allocated.
+ * @x0: X coordinate of starting bezier point.
+ * @y0: Y coordinate of starting bezier point.
+ * @x1: X coordinate of first bezier control point.
+ * @y1: Y coordinate of first bezier control point.
+ * @x2: X coordinate of second bezier control point.
+ * @y2: Y coordinate of second bezier control point.
+ * @x3: X coordinate of ending bezier point.
+ * @y3: Y coordinate of ending bezier point.
+ * @flatness: Flatness control.
+ *
+ * Renders a bezier segment into the vector path, reallocating and
+ * updating *@p_vpath and *@pn_vpath_max as necessary. *@pn_vpath is
+ * incremented by the number of vector points added.
+ *
+ * This step includes (@x0, @y0) but not (@x3, @y3).
+ *
+ * The @flatness argument guides the amount of subdivision. The Adobe
+ * PostScript reference manual defines flatness as the maximum
+ * deviation between the any point on the vpath approximation and the
+ * corresponding point on the "true" curve, and we follow this
+ * definition here. A value of 0.25 should ensure high quality for aa
+ * rendering.
+ **/
+ void
+ksvg_art_vpath_render_bez (ArtVpath **p_vpath, int *pn, int *pn_max,
+		double x0, double y0,
+		double x1, double y1,
+		double x2, double y2,
+		double x3, double y3,
+		double flatness)
+{
+	double x3_0, y3_0;
+	double z3_0_dot;
+	double z1_dot, z2_dot;
+	double z1_perp, z2_perp;
+	double max_perp_sq;
+
+	double x_m, y_m;
+	double xa1, ya1;
+	double xa2, ya2;
+	double xb1, yb1;
+	double xb2, yb2;
+
+	/* It's possible to optimize this routine a fair amount.
+
+	   First, once the _dot conditions are met, they will also be met in
+	   all further subdivisions. So we might recurse to a different
+	   routine that only checks the _perp conditions.
+
+	   Second, the distance _should_ decrease according to fairly
+	   predictable rules (a factor of 4 with each subdivision). So it might
+	   be possible to note that the distance is within a factor of 4 of
+	   acceptable, and subdivide once. But proving this might be hard.
+
+	   Third, at the last subdivision, x_m and y_m can be computed more
+	   expeditiously (as in the routine above).
+
+	   Finally, if we were able to subdivide by, say 2 or 3, this would
+	   allow considerably finer-grain control, i.e. fewer points for the
+	   same flatness tolerance. This would speed things up downstream.
+
+	   In any case, this routine is unlikely to be the bottleneck. It's
+	   just that I have this undying quest for more speed...
+
+*/
+
+	x3_0 = x3 - x0;
+	y3_0 = y3 - y0;
+
+	/* z3_0_dot is dist z0-z3 squared */
+	z3_0_dot = x3_0 * x3_0 + y3_0 * y3_0;
+
+	/* todo: this test is far from satisfactory. */
+	if (z3_0_dot < 0.001)
+		goto nosubdivide;
+
+	/* we can avoid subdivision if:
+
+	   z1 has distance no more than flatness from the z0-z3 line
+
+	   z1 is no more z0'ward than flatness past z0-z3
+
+	   z1 is more z0'ward than z3'ward on the line traversing z0-z3
+
+	   and correspondingly for z2 */
+
+	/* perp is distance from line, multiplied by dist z0-z3 */
+	max_perp_sq = flatness * flatness * z3_0_dot;
+	z1_perp = (y1 - y0) * x3_0 - (x1 - x0) * y3_0;
+	if (z1_perp * z1_perp > max_perp_sq)
+		goto subdivide;
+
+	z2_perp = (y3 - y2) * x3_0 - (x3 - x2) * y3_0;
+	if (z2_perp * z2_perp > max_perp_sq)
+		goto subdivide;
+
+	z1_dot = (x1 - x0) * x3_0 + (y1 - y0) * y3_0;
+	if (z1_dot < 0 && z1_dot * z1_dot > max_perp_sq)
+		goto subdivide;
+
+	z2_dot = (x3 - x2) * x3_0 + (y3 - y2) * y3_0;
+	if (z2_dot < 0 && z2_dot * z2_dot > max_perp_sq)
+		goto subdivide;
+
+	if (z1_dot + z1_dot > z3_0_dot)
+		goto subdivide;
+
+	if (z2_dot + z2_dot > z3_0_dot)
+		goto subdivide;
+
+nosubdivide:
+	/* don't subdivide */
+	art_vpath_add_point (p_vpath, pn, pn_max,
+			ART_LINETO, x3, y3);
+	return;
+
+subdivide:
+
+	xa1 = (x0 + x1) * 0.5;
+	ya1 = (y0 + y1) * 0.5;
+	xa2 = (x0 + 2 * x1 + x2) * 0.25;
+	ya2 = (y0 + 2 * y1 + y2) * 0.25;
+	xb1 = (x1 + 2 * x2 + x3) * 0.25;
+	yb1 = (y1 + 2 * y2 + y3) * 0.25;
+	xb2 = (x2 + x3) * 0.5;
+	yb2 = (y2 + y3) * 0.5;
+	x_m = (xa2 + xb1) * 0.5;
+	y_m = (ya2 + yb1) * 0.5;
+#ifdef VERBOSE
+	printf ("%g,%g %g,%g %g,%g %g,%g\n", xa1, ya1, xa2, ya2,
+			xb1, yb1, xb2, yb2);
+#endif
+	ksvg_art_vpath_render_bez (p_vpath, pn, pn_max,
+			x0, y0, xa1, ya1, xa2, ya2, x_m, y_m, flatness);
+	ksvg_art_vpath_render_bez (p_vpath, pn, pn_max,
+			x_m, y_m, xb1, yb1, xb2, yb2, x3, y3, flatness);
+}
+
+#define RENDER_LEVEL 4
+#define RENDER_SIZE (1 << (RENDER_LEVEL))
+
+/**
+ * ksvg_art_bez_path_to_vec: Create vpath from bezier path.
+ * @bez: Bezier path.
+ * @flatness: Flatness control.
+ *
+ * Creates a vector path closely approximating the bezier path defined by
+ * @bez. The @flatness argument controls the amount of subdivision. In
+ * general, the resulting vpath deviates by at most @flatness pixels
+ * from the "ideal" path described by @bez.
+ *
+ * Return value: Newly allocated vpath.
+ **/
+ ArtVpath *
+ksvg_art_bez_path_to_vec(const ArtBpath *bez, double flatness)
+{
+	ArtVpath *vec;
+	int vec_n, vec_n_max;
+	int bez_index;
+	double x, y;
+
+	vec_n = 0;
+	vec_n_max = RENDER_SIZE;
+	vec = art_new (ArtVpath, vec_n_max);
+
+	/* Initialization is unnecessary because of the precondition that the
+	   bezier path does not begin with LINETO or CURVETO, but is here
+	   to make the code warning-free. */
+	x = 0;
+	y = 0;
+
+	bez_index = 0;
+	do
+	{
+#ifdef VERBOSE
+		printf ("%s %g %g\n",
+				bez[bez_index].code == ART_CURVETO ? "curveto" :
+				bez[bez_index].code == ART_LINETO ? "lineto" :
+				bez[bez_index].code == ART_MOVETO ? "moveto" :
+				bez[bez_index].code == ART_MOVETO_OPEN ? "moveto-open" :
+				"end", bez[bez_index].x3, bez[bez_index].y3);
+#endif
+		/* make sure space for at least one more code */
+		if (vec_n >= vec_n_max)
+			art_expand (vec, ArtVpath, vec_n_max);
+		switch (bez[bez_index].code)
+		{
+			case ART_MOVETO_OPEN:
+			case ART_MOVETO:
+			case ART_LINETO:
+				x = bez[bez_index].x3;
+				y = bez[bez_index].y3;
+				vec[vec_n].code = bez[bez_index].code;
+				vec[vec_n].x = x;
+				vec[vec_n].y = y;
+				vec_n++;
+				break;
+			case ART_END:
+				vec[vec_n].code = ART_END;
+				vec[vec_n].x = 0;
+				vec[vec_n].y = 0;
+				vec_n++;
+				break;
+			case ART_END2:
+				vec[vec_n].code = (ArtPathcode)ART_END2;
+				vec[vec_n].x = bez[bez_index].x3;
+				vec[vec_n].y = bez[bez_index].y3;
+				vec_n++;
+				break;
+			case ART_CURVETO:
+#ifdef VERBOSE
+				printf ("%g,%g %g,%g %g,%g %g,%g\n", x, y,
+						bez[bez_index].x1, bez[bez_index].y1,
+						bez[bez_index].x2, bez[bez_index].y2,
+						bez[bez_index].x3, bez[bez_index].y3);
+#endif
+				ksvg_art_vpath_render_bez (&vec, &vec_n, &vec_n_max,
+						x, y,
+						bez[bez_index].x1, bez[bez_index].y1,
+						bez[bez_index].x2, bez[bez_index].y2,
+						bez[bez_index].x3, bez[bez_index].y3,
+						flatness);
+				x = bez[bez_index].x3;
+				y = bez[bez_index].y3;
+				break;
+		}
+	}
+	while (bez[bez_index++].code != ART_END);
+	return vec;
+}
+
+/* Private functions for the rgb affine image compositors - primarily,
+*    the determination of runs, eliminating the need for source image
+*       bbox calculation in the inner loop. */
+
+/* Determine a "run", such that the inverse affine of all pixels from
+*    (x0, y) inclusive to (x1, y) exclusive fit within the bounds
+*       of the source image.
+*
+*          Initial values of x0, x1, and result values stored in first two
+*             pointer arguments.
+*             */
+
+#define EPSILON 1e-6
+
+ void ksvg_art_rgb_affine_run (int *p_x0, int *p_x1, int y,
+		int src_width, int src_height,
+		const double affine[6])
+{
+	int x0, x1;
+	double z;
+	double x_intercept;
+	int xi;
+
+	x0 = *p_x0;
+	x1 = *p_x1;
+
+	/* do left and right edges */
+	if (affine[0] > EPSILON)
+	{
+		z = affine[2] * (y + 0.5) + affine[4];
+		x_intercept = -z / affine[0];
+		xi = ceil (x_intercept + EPSILON - 0.5);
+		if (xi > x0)
+			x0 = xi;
+		x_intercept = (-z + src_width) / affine[0];
+		xi = ceil (x_intercept - EPSILON - 0.5);
+		if (xi < x1)
+			x1 = xi;
+	}
+	else if (affine[0] < -EPSILON)
+	{
+		z = affine[2] * (y + 0.5) + affine[4];
+		x_intercept = (-z + src_width) / affine[0];
+		xi = ceil (x_intercept + EPSILON - 0.5);
+		if (xi > x0)
+			x0 = xi;
+		x_intercept = -z / affine[0];
+		xi = ceil (x_intercept - EPSILON - 0.5);
+		if (xi < x1)
+			x1 = xi;
+	}
+	else
+	{
+		z = affine[2] * (y + 0.5) + affine[4];
+		if (z < 0 || z >= src_width)
+		{
+			*p_x1 = *p_x0;
+			return;
+		}
+	}
+	/* do top and bottom edges */
+	if (affine[1] > EPSILON)
+	{
+		z = affine[3] * (y + 0.5) + affine[5];
+		x_intercept = -z / affine[1];
+		xi = ceil (x_intercept + EPSILON - 0.5);
+		if (xi > x0)
+			x0 = xi;
+		x_intercept = (-z + src_height) / affine[1];
+		xi = ceil (x_intercept - EPSILON - 0.5);
+		if (xi < x1)
+			x1 = xi;
+	}
+	else if (affine[1] < -EPSILON)
+	{
+		z = affine[3] * (y + 0.5) + affine[5];
+		x_intercept = (-z + src_height) / affine[1];
+		xi = ceil (x_intercept + EPSILON - 0.5);
+		if (xi > x0)
+			x0 = xi;
+		x_intercept = -z / affine[1];
+		xi = ceil (x_intercept - EPSILON - 0.5);
+		if (xi < x1)
+			x1 = xi;
+	}
+	else
+	{
+		z = affine[3] * (y + 0.5) + affine[5];
+		if (z < 0 || z >= src_height)
+		{
+			*p_x1 = *p_x0;
+			return;
+		}
+	}
+
+	*p_x0 = x0;
+	*p_x1 = x1;
+}
+
+/**
+ * ksvg_art_rgb_affine: Affine transform source RGB image and composite.
+ * @dst: Destination image RGB buffer.
+ * @x0: Left coordinate of destination rectangle.
+ * @y0: Top coordinate of destination rectangle.
+ * @x1: Right coordinate of destination rectangle.
+ * @y1: Bottom coordinate of destination rectangle.
+ * @dst_rowstride: Rowstride of @dst buffer.
+ * @src: Source image RGB buffer.
+ * @src_width: Width of source image.
+ * @src_height: Height of source image.
+ * @src_rowstride: Rowstride of @src buffer.
+ * @affine: Affine transform.
+ * @level: Filter level.
+ * @alphagamma: #ArtAlphaGamma for gamma-correcting the compositing.
+ * @alpha: Alpha, range 0..256.
+ *
+ * Affine transform the source image stored in @src, compositing over
+ * the area of destination image @dst specified by the rectangle
+ * (@x0, @y0) - (@x1, @y1). As usual in libart, the left and top edges
+ * of this rectangle are included, and the right and bottom edges are
+ * excluded.
+ *
+ * The @alphagamma parameter specifies that the alpha compositing be done
+ * in a gamma-corrected color space. Since the source image is opaque RGB,
+ * this argument only affects the edges. In the current implementation,
+ * it is ignored.
+ *
+ * The @level parameter specifies the speed/quality tradeoff of the
+ * image interpolation. Currently, only ART_FILTER_NEAREST is
+ * implemented.
+ *
+ * KSVG additions : we have changed this function to support an alpha level as well.
+*                  also we made sure compositing an rgba image over an rgb buffer works.
+**/
+ void ksvg_art_rgb_affine (art_u8 *dst, int x0, int y0, int x1, int y1, int dst_rowstride,
+		const art_u8 *src,
+		int src_width, int src_height, int src_rowstride,
+		const double affine[6],
+		ArtFilterLevel level,
+		ArtAlphaGamma *alphagamma,
+		int alpha)
+{
+	/* Note: this is a slow implementation, and is missing all filter
+	   levels other than NEAREST. It is here for clarity of presentation
+	   and to establish the interface. */
+	int x, y;
+	double inv[6];
+	art_u8 *dst_p, *dst_linestart;
+	const art_u8 *src_p;
+	ArtPoint pt, src_pt;
+	int src_x, src_y;
+	int run_x0, run_x1;
+
+	dst_linestart = dst;
+	art_affine_invert (inv, affine);
+
+	if(alpha == 255)
+		for (y = y0; y < y1; y++)
+		{
+			pt.y = y + 0.5;
+			run_x0 = x0;
+			run_x1 = x1;
+			ksvg_art_rgb_affine_run (&run_x0, &run_x1, y, src_width, src_height,
+					inv);
+			dst_p = dst_linestart + (run_x0 - x0) * 3;
+			for (x = run_x0; x < run_x1; x++)
+			{
+				pt.x = x + 0.5;
+				art_affine_point (&src_pt, &pt, inv);
+				src_x = floor (src_pt.x);
+				src_y = floor (src_pt.y);
+				src_p = src + (src_y * src_rowstride) + src_x * 4;
+				dst_p[0] = dst_p[0] + (((src_p[2] - dst_p[0]) * src_p[3] + 0x80) >> 8);
+				dst_p[1] = dst_p[1] + (((src_p[1] - dst_p[1]) * src_p[3] + 0x80) >> 8);
+				dst_p[2] = dst_p[2] + (((src_p[0] - dst_p[2]) * src_p[3] + 0x80) >> 8);
+				dst_p += 3;
+			}
+			dst_linestart += dst_rowstride;
+		}
+	else
+		for (y = y0; y < y1; y++)
+		{
+			pt.y = y + 0.5;
+			run_x0 = x0;
+			run_x1 = x1;
+			ksvg_art_rgb_affine_run (&run_x0, &run_x1, y, src_width, src_height,
+					inv);
+			dst_p = dst_linestart + (run_x0 - x0) * 3;
+			for (x = run_x0; x < run_x1; x++)
+			{
+				pt.x = x + 0.5;
+				art_affine_point (&src_pt, &pt, inv);
+				src_x = floor (src_pt.x);
+				src_y = floor (src_pt.y);
+				src_p = src + (src_y * src_rowstride) + src_x * 4;
+				dst_p[0] = dst_p[0] + (((src_p[2] - dst_p[0]) * alpha + 0x80) >> 8);
+				dst_p[1] = dst_p[1] + (((src_p[1] - dst_p[1]) * alpha + 0x80) >> 8);
+				dst_p[2] = dst_p[2] + (((src_p[0] - dst_p[2]) * alpha + 0x80) >> 8);
+				dst_p += 3;
+			}
+			dst_linestart += dst_rowstride;
+		}
+}
+
+
+typedef struct _ksvgArtRgbAffineClipAlphaData ksvgArtRgbAffineClipAlphaData;
+
+struct _ksvgArtRgbAffineClipAlphaData
+{
+	int alphatab[256];
+	art_u8 alpha;
+	art_u8 *dst;
+	int dst_rowstride;
+	int x0, x1;
+	double inv[6];
+	const art_u8 *src;
+	int src_width;
+	int src_height;
+	int src_rowstride;
+	const art_u8 *mask;
+	int y0;
+};
+
+static
+void ksvg_art_rgb_affine_clip_run(art_u8 *dst_p, int x0, int x1, int y, const double inv[6],
+	int alpha, const art_u8 *src, int src_rowstride, int src_width, int src_height)
+{
+	const art_u8 *src_p;
+	ArtPoint pt, src_pt;
+	int src_x, src_y;
+	int x;
+
+	if(alpha > 255)
+		alpha = 255;
+
+	pt.y = y;
+
+	for(x = x0; x < x1; x++)
+	{
+		pt.x = x;
+
+		art_affine_point(&src_pt, &pt, inv);
+
+		src_x = (int)(src_pt.x);
+		src_y = (int)(src_pt.y);
+
+		if(src_x >= 0 && src_x < src_width && src_y >= 0 && src_y < src_height)
+		{
+			int s;
+			int d;
+			int tmp;
+			int srcAlpha;
+
+			src_p = src + (src_y * src_rowstride) + src_x * 4;
+
+			srcAlpha = alpha * src_p[3] + 0x80;
+			srcAlpha = (srcAlpha + (srcAlpha >> 8)) >> 8;
+
+			d = *dst_p;
+			s = src_p[2];
+
+			tmp = srcAlpha * (s - d) + 0x80;
+			tmp = (tmp + (tmp >> 8)) >> 8;
+
+			*dst_p++ = d + tmp;
+
+			d = *dst_p;
+			s = src_p[1];
+
+			tmp = srcAlpha * (s - d) + 0x80;
+			tmp = (tmp + (tmp >> 8)) >> 8;
+
+			*dst_p++ = d + tmp;
+
+			d = *dst_p;
+			s = src_p[0];
+
+			tmp = srcAlpha * (s - d) + 0x80;
+			tmp = (tmp + (tmp >> 8)) >> 8;
+
+			*dst_p++ = d + tmp;
+		}
+		else
+			dst_p += 3;
+	}
+}
+
+static void
+ksvg_art_rgb_affine_clip_callback (void *callback_data, int y,
+														int start, ArtSVPRenderAAStep *steps, int n_steps)
+{
+	ksvgArtRgbAffineClipAlphaData *data = (ksvgArtRgbAffineClipAlphaData *)callback_data;
+	art_u8 *linebuf;
+	int run_x0, run_x1;
+	art_u32 running_sum = start;
+	int x0, x1;
+	int k;
+	int *alphatab;
+	int alpha;
+
+	linebuf = data->dst;
+	x0 = data->x0;
+	x1 = data->x1;
+
+	alphatab = data->alphatab;
+
+	if(n_steps > 0)
+	{
+		run_x1 = steps[0].x;
+		if(run_x1 > x0)
+		{
+			alpha = (running_sum >> 16) & 0xff;
+			if(alpha)
+				ksvg_art_rgb_affine_clip_run(linebuf, x0, run_x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+		}
+
+		for(k = 0; k < n_steps - 1; k++)
+		{
+			running_sum += steps[k].delta;
+			run_x0 = run_x1;
+			run_x1 = steps[k + 1].x;
+			if(run_x1 > run_x0)
+			{
+				alpha = (running_sum >> 16) & 0xff;
+				if(alpha)
+					ksvg_art_rgb_affine_clip_run(linebuf + (run_x0 - x0) * 3, run_x0, run_x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+			}
+		}
+		running_sum += steps[k].delta;
+		if(x1 > run_x1)
+		{
+			alpha = (running_sum >> 16) & 0xff;
+			if(alpha)
+				ksvg_art_rgb_affine_clip_run(linebuf + (run_x1 - x0) * 3, run_x1, x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+		}
+	}
+	else
+	{
+		alpha = (running_sum >> 16) & 0xff;
+		if(alpha)
+			ksvg_art_rgb_affine_clip_run(linebuf, x0, x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+	}
+
+	data->dst += data->dst_rowstride;
+}
+
+static
+void ksvg_art_rgb_affine_clip_mask_run(art_u8 *dst_p, const art_u8 *mask, int x0, int x1, int y, const double inv[6],
+	int alpha, const art_u8 *src, int src_rowstride, int src_width, int src_height)
+{
+	const art_u8 *src_p;
+	ArtPoint pt, src_pt;
+	int src_x, src_y;
+	int x;
+
+	if(alpha > 255)
+		alpha = 255;
+
+	pt.y = y;
+
+	for(x = x0; x < x1; x++)
+	{
+		pt.x = x;
+
+		art_affine_point(&src_pt, &pt, inv);
+
+		src_x = (int)(src_pt.x);
+		src_y = (int)(src_pt.y);
+
+		if(src_x >= 0 && src_x < src_width && src_y >= 0 && src_y < src_height)
+		{
+			int s;
+			int d;
+			int tmp;
+			int srcAlpha;
+
+			src_p = src + (src_y * src_rowstride) + src_x * 4;
+
+			srcAlpha = alpha * src_p[3] + 0x80;
+			srcAlpha = (srcAlpha + (srcAlpha >> 8)) >> 8;
+
+			srcAlpha = (srcAlpha * *mask++) + 0x80;
+			srcAlpha = (srcAlpha + (srcAlpha >> 8)) >> 8;
+
+			d = *dst_p;
+			s = src_p[2];
+
+			tmp = srcAlpha * (s - d) + 0x80;
+			tmp = (tmp + (tmp >> 8)) >> 8;
+
+			*dst_p++ = d + tmp;
+
+			d = *dst_p;
+			s = src_p[1];
+
+			tmp = srcAlpha * (s - d) + 0x80;
+			tmp = (tmp + (tmp >> 8)) >> 8;
+
+			*dst_p++ = d + tmp;
+
+			d = *dst_p;
+			s = src_p[0];
+
+			tmp = srcAlpha * (s - d) + 0x80;
+			tmp = (tmp + (tmp >> 8)) >> 8;
+
+			*dst_p++ = d + tmp;
+		}
+		else
+		{
+			dst_p += 3;
+			mask++;
+		}
+	}
+}
+
+static void
+ksvg_art_rgb_affine_clip_mask_callback (void *callback_data, int y,
+														int start, ArtSVPRenderAAStep *steps, int n_steps)
+{
+	ksvgArtRgbAffineClipAlphaData *data = (ksvgArtRgbAffineClipAlphaData *)callback_data;
+	art_u8 *linebuf;
+	int run_x0, run_x1;
+	art_u32 running_sum = start;
+	int x0, x1;
+	int k;
+	int *alphatab;
+	int alpha;
+	const art_u8 *maskbuf;
+
+	linebuf = data->dst;
+	x0 = data->x0;
+	x1 = data->x1;
+
+	alphatab = data->alphatab;
+	maskbuf = data->mask + (y - data->y0) * (x1 - x0);
+
+	if(n_steps > 0)
+	{
+		run_x1 = steps[0].x;
+		if(run_x1 > x0)
+		{
+			alpha = (running_sum >> 16) & 0xff;
+			if(alpha)
+				ksvg_art_rgb_affine_clip_mask_run(linebuf, maskbuf, x0, run_x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+		}
+
+		for(k = 0; k < n_steps - 1; k++)
+		{
+			running_sum += steps[k].delta;
+			run_x0 = run_x1;
+			run_x1 = steps[k + 1].x;
+			if(run_x1 > run_x0)
+			{
+				alpha = (running_sum >> 16) & 0xff;
+				if(alpha)
+					ksvg_art_rgb_affine_clip_mask_run(linebuf + (run_x0 - x0) * 3, maskbuf + (run_x0 - x0), run_x0, run_x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+			}
+		}
+		running_sum += steps[k].delta;
+		if(x1 > run_x1)
+		{
+			alpha = (running_sum >> 16) & 0xff;
+			if(alpha)
+				ksvg_art_rgb_affine_clip_mask_run(linebuf + (run_x1 - x0) * 3, maskbuf + (run_x1 - x0), run_x1, x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+		}
+	}
+	else
+	{
+		alpha = (running_sum >> 16) & 0xff;
+		if(alpha)
+			ksvg_art_rgb_affine_clip_mask_run(linebuf, maskbuf, x0, x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+	}
+
+	data->dst += data->dst_rowstride;
+}
+
+static
+void ksvg_art_rgba_affine_clip_run(art_u8 *dst_p, int x0, int x1, int y, const double inv[6],
+	int alpha, const art_u8 *src, int src_rowstride, int src_width, int src_height)
+{
+	const art_u8 *src_p;
+	ArtPoint pt, src_pt;
+	int src_x, src_y;
+	int x;
+
+	if(alpha > 255)
+		alpha = 255;
+
+	pt.y = y;
+
+	for(x = x0; x < x1; x++)
+	{
+		pt.x = x;
+
+		art_affine_point(&src_pt, &pt, inv);
+
+		src_x = (int)(src_pt.x);
+		src_y = (int)(src_pt.y);
+
+		if(src_x >= 0 && src_x < src_width && src_y >= 0 && src_y < src_height)
+		{
+			int s;
+			int d;
+			int tmp;
+			int srcAlpha;
+
+			src_p = src + (src_y * src_rowstride) + src_x * 4;
+
+			srcAlpha = alpha * src_p[3] + 0x80;
+			srcAlpha = (srcAlpha + (srcAlpha >> 8)) >> 8;
+
+			d = *dst_p;
+			s = src_p[2];
+
+			tmp = srcAlpha * (s - d) + 0x80;
+			tmp = (tmp + (tmp >> 8)) >> 8;
+
+			*dst_p++ = d + tmp;
+
+			d = *dst_p;
+			s = src_p[1];
+
+			tmp = srcAlpha * (s - d) + 0x80;
+			tmp = (tmp + (tmp >> 8)) >> 8;
+
+			*dst_p++ = d + tmp;
+
+			d = *dst_p;
+			s = src_p[0];
+
+			tmp = srcAlpha * (s - d) + 0x80;
+			tmp = (tmp + (tmp >> 8)) >> 8;
+
+			*dst_p++ = d + tmp;
+
+			d = *dst_p;
+
+			tmp = srcAlpha * (255 - d) + 0x80;
+			tmp = (tmp + (tmp >> 8)) >> 8;
+
+			*dst_p++ = d + tmp;
+		}
+		else
+			dst_p += 4;
+	}
+}
+
+static void
+ksvg_art_rgba_affine_clip_callback (void *callback_data, int y,
+														int start, ArtSVPRenderAAStep *steps, int n_steps)
+{
+	ksvgArtRgbAffineClipAlphaData *data = (ksvgArtRgbAffineClipAlphaData *)callback_data;
+	art_u8 *linebuf;
+	int run_x0, run_x1;
+	art_u32 running_sum = start;
+	int x0, x1;
+	int k;
+	int *alphatab;
+	int alpha;
+
+	linebuf = data->dst;
+	x0 = data->x0;
+	x1 = data->x1;
+
+	alphatab = data->alphatab;
+
+	if(n_steps > 0)
+	{
+		run_x1 = steps[0].x;
+		if(run_x1 > x0)
+		{
+			alpha = (running_sum >> 16) & 0xff;
+			if(alpha)
+				ksvg_art_rgba_affine_clip_run(linebuf, x0, run_x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+		}
+
+		for(k = 0; k < n_steps - 1; k++)
+		{
+			running_sum += steps[k].delta;
+			run_x0 = run_x1;
+			run_x1 = steps[k + 1].x;
+			if(run_x1 > run_x0)
+			{
+				alpha = (running_sum >> 16) & 0xff;
+				if(alpha)
+					ksvg_art_rgba_affine_clip_run(linebuf + (run_x0 - x0) * 4, run_x0, run_x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+			}
+		}
+		running_sum += steps[k].delta;
+		if(x1 > run_x1)
+		{
+			alpha = (running_sum >> 16) & 0xff;
+			if(alpha)
+				ksvg_art_rgba_affine_clip_run(linebuf + (run_x1 - x0) * 4, run_x1, x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+		}
+	}
+	else
+	{
+		alpha = (running_sum >> 16) & 0xff;
+		if(alpha)
+			ksvg_art_rgba_affine_clip_run(linebuf, x0, x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+	}
+
+	data->dst += data->dst_rowstride;
+}
+
+static
+void ksvg_art_rgba_affine_clip_mask_run(art_u8 *dst_p, const art_u8 *mask, int x0, int x1, int y, const double inv[6],
+	int alpha, const art_u8 *src, int src_rowstride, int src_width, int src_height)
+{
+	const art_u8 *src_p;
+	ArtPoint pt, src_pt;
+	int src_x, src_y;
+	int x;
+
+	if(alpha > 255)
+		alpha = 255;
+
+	pt.y = y;
+
+	for(x = x0; x < x1; x++)
+	{
+		pt.x = x;
+
+		art_affine_point(&src_pt, &pt, inv);
+
+		src_x = (int)(src_pt.x);
+		src_y = (int)(src_pt.y);
+
+		if(src_x >= 0 && src_x < src_width && src_y >= 0 && src_y < src_height)
+		{
+			int s;
+			int d;
+			int tmp;
+			int srcAlpha;
+
+			src_p = src + (src_y * src_rowstride) + src_x * 4;
+
+			srcAlpha = alpha * src_p[3] + 0x80;
+			srcAlpha = (srcAlpha + (srcAlpha >> 8)) >> 8;
+
+			srcAlpha = (srcAlpha * *mask++) + 0x80;
+			srcAlpha = (srcAlpha + (srcAlpha >> 8)) >> 8;
+
+			d = *dst_p;
+			s = src_p[2];
+
+			tmp = srcAlpha * (s - d) + 0x80;
+			tmp = (tmp + (tmp >> 8)) >> 8;
+
+			*dst_p++ = d + tmp;
+
+			d = *dst_p;
+			s = src_p[1];
+
+			tmp = srcAlpha * (s - d) + 0x80;
+			tmp = (tmp + (tmp >> 8)) >> 8;
+
+			*dst_p++ = d + tmp;
+
+			d = *dst_p;
+			s = src_p[0];
+
+			tmp = srcAlpha * (s - d) + 0x80;
+			tmp = (tmp + (tmp >> 8)) >> 8;
+
+			*dst_p++ = d + tmp;
+
+			d = *dst_p;
+
+			tmp = srcAlpha * (255 - d) + 0x80;
+			tmp = (tmp + (tmp >> 8)) >> 8;
+
+			*dst_p++ = d + tmp;
+		}
+		else
+		{
+			dst_p += 4;
+			mask++;
+		}
+	}
+}
+
+static void
+ksvg_art_rgba_affine_clip_mask_callback (void *callback_data, int y,
+														int start, ArtSVPRenderAAStep *steps, int n_steps)
+{
+	ksvgArtRgbAffineClipAlphaData *data = (ksvgArtRgbAffineClipAlphaData *)callback_data;
+	art_u8 *linebuf;
+	int run_x0, run_x1;
+	art_u32 running_sum = start;
+	int x0, x1;
+	int k;
+	int *alphatab;
+	int alpha;
+	const art_u8 *maskbuf;
+
+	linebuf = data->dst;
+	x0 = data->x0;
+	x1 = data->x1;
+
+	alphatab = data->alphatab;
+	maskbuf = data->mask + (y - data->y0) * (x1 - x0);
+
+	if(n_steps > 0)
+	{
+		run_x1 = steps[0].x;
+		if(run_x1 > x0)
+		{
+			alpha = (running_sum >> 16) & 0xff;
+			if(alpha)
+				ksvg_art_rgba_affine_clip_mask_run(linebuf, maskbuf, x0, run_x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+		}
+
+		for(k = 0; k < n_steps - 1; k++)
+		{
+			running_sum += steps[k].delta;
+			run_x0 = run_x1;
+			run_x1 = steps[k + 1].x;
+			if(run_x1 > run_x0)
+			{
+				alpha = (running_sum >> 16) & 0xff;
+				if(alpha)
+					ksvg_art_rgba_affine_clip_mask_run(linebuf + (run_x0 - x0) * 4, maskbuf + (run_x0 - x0), run_x0, run_x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+			}
+		}
+		running_sum += steps[k].delta;
+		if(x1 > run_x1)
+		{
+			alpha = (running_sum >> 16) & 0xff;
+			if(alpha)
+				ksvg_art_rgba_affine_clip_mask_run(linebuf + (run_x1 - x0) * 4, maskbuf + (run_x1 - x0), run_x1, x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+		}
+	}
+	else
+	{
+		alpha = (running_sum >> 16) & 0xff;
+		if(alpha)
+			ksvg_art_rgba_affine_clip_mask_run(linebuf, maskbuf, x0, x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+	}
+
+	data->dst += data->dst_rowstride;
+}
+
+/**
+ * ksvg_art_rgb_affine_clip: Affine transform source RGB image and composite, with clipping path.
+ * @svp: Clipping path.
+ * @dst: Destination image RGB buffer.
+ * @x0: Left coordinate of destination rectangle.
+ * @y0: Top coordinate of destination rectangle.
+ * @x1: Right coordinate of destination rectangle.
+ * @y1: Bottom coordinate of destination rectangle.
+ * @dst_rowstride: Rowstride of @dst buffer.
+ * @src: Source image RGB buffer.
+ * @src_width: Width of source image.
+ * @src_height: Height of source image.
+ * @src_rowstride: Rowstride of @src buffer.
+ * @affine: Affine transform.
+ * @level: Filter level.
+ * @alphagamma: #ArtAlphaGamma for gamma-correcting the compositing.
+ * @alpha: Alpha, range 0..256.
+ *
+ * Affine transform the source image stored in @src, compositing over
+ * the area of destination image @dst specified by the rectangle
+ * (@x0, @y0) - (@x1, @y1). As usual in libart, the left and top edges
+ * of this rectangle are included, and the right and bottom edges are
+ * excluded.
+ *
+ * The @alphagamma parameter specifies that the alpha compositing be done
+ * in a gamma-corrected color space. Since the source image is opaque RGB,
+ * this argument only affects the edges. In the current implementation,
+ * it is ignored.
+ *
+ * The @level parameter specifies the speed/quality tradeoff of the
+ * image interpolation. Currently, only ART_FILTER_NEAREST is
+ * implemented.
+ *
+ * KSVG additions : we have changed this function to support an alpha level as well.
+*                  also we made sure compositing an rgba image over an rgb buffer works.
+**/
+void ksvg_art_rgb_affine_clip(const ArtSVP *svp, art_u8 *dst, int x0, int y0, int x1, int y1, int dst_rowstride, int dst_channels,
+		const art_u8 *src,
+		int src_width, int src_height, int src_rowstride,
+		const double affine[6],
+		int alpha, const art_u8 *mask)
+{
+	ksvgArtRgbAffineClipAlphaData data;
+	int i;
+	int a, da;
+
+	data.alpha = alpha;
+
+	a = 0x8000;
+	da = (alpha * 66051 + 0x80) >> 8;	/* 66051 equals 2 ^ 32 / (255 * 255) */
+
+	for(i = 0; i < 256; i++)
+	{
+		data.alphatab[i] = a >> 16;
+		a += da;
+	}
+
+	data.dst = dst;
+	data.dst_rowstride = dst_rowstride;
+	data.x0 = x0;
+	data.x1 = x1;
+	data.y0 = y0;
+	data.mask = mask;
+
+	art_affine_invert(data.inv, affine);
+
+	data.src = src;
+	data.src_width = src_width;
+	data.src_height = src_height;
+	data.src_rowstride = src_rowstride;
+
+	if(dst_channels == 3)
+	{
+		if(mask)
+			art_svp_render_aa(svp, x0, y0, x1, y1, ksvg_art_rgb_affine_clip_mask_callback, &data);
+		else
+			art_svp_render_aa(svp, x0, y0, x1, y1, ksvg_art_rgb_affine_clip_callback, &data);
+	}
+	else
+	{
+		if(mask)
+			art_svp_render_aa(svp, x0, y0, x1, y1, ksvg_art_rgba_affine_clip_mask_callback, &data);
+		else
+			art_svp_render_aa(svp, x0, y0, x1, y1, ksvg_art_rgba_affine_clip_callback, &data);
+	}
+}
+
+
+static
+void ksvg_art_rgb_texture_run(art_u8 *dst_p, int x0, int x1, int y, const double inv[6],
+	int alpha, const art_u8 *src, int src_rowstride, int src_width, int src_height)
+{
+	const art_u8 *src_p;
+	ArtPoint pt, src_pt;
+	int src_x, src_y;
+	int x;
+	int srcAlpha;
+
+	if(alpha > 255)
+		alpha = 255;
+
+	/* TODO: optimise and filter? */
+	pt.y = y + 0.5;
+
+	for(x = x0; x < x1; x++)
+	{
+		int s;
+		int d;
+		int tmp;
+		int tmp2;
+
+		pt.x = x + 0.5;
+
+		art_affine_point(&src_pt, &pt, inv);
+
+		src_x = (int)floor(src_pt.x);
+		src_y = (int)floor(src_pt.y);
+
+		if(src_x < 0)
+		{
+			/* Can't assume % behaviour with negative values */
+			src_x += ((src_x / -src_width) + 1) * src_width;
+		}
+
+		if(src_y < 0)
+		{
+			src_y += ((src_y / -src_height) + 1) * src_height;
+		}
+
+		src_x %= src_width;
+		src_y %= src_height;
+
+		src_p = src + (src_y * src_rowstride) + src_x * 4;
+
+		/* Pattern source is in RGBA format, premultiplied.
+		 * alpha represents fill/stroke/group opacity.
+		 *
+		 * Multiply source alpha by 'alpha' then composite over.
+		 * For each channel, d = d + alpha * (s - srcAlpha * d).
+		 */
+		
+		srcAlpha = src_p[3];
+
+		d = *dst_p;
+		s = *src_p++;
+
+		tmp = srcAlpha * d + 0x80;
+		tmp = (tmp + (tmp >> 8)) >> 8;
+
+		tmp2 = alpha * (s - tmp) + 0x80;
+		tmp2 = (tmp2 + (tmp2 >> 8)) >> 8;
+
+		*dst_p++ = d + tmp2;
+
+		d = *dst_p;
+		s = *src_p++;
+
+		tmp = srcAlpha * d + 0x80;
+		tmp = (tmp + (tmp >> 8)) >> 8;
+
+		tmp2 = alpha * (s - tmp) + 0x80;
+		tmp2 = (tmp2 + (tmp2 >> 8)) >> 8;
+
+		*dst_p++ = d + tmp2;
+
+		d = *dst_p;
+		s = *src_p++;
+
+		tmp = srcAlpha * d + 0x80;
+		tmp = (tmp + (tmp >> 8)) >> 8;
+
+		tmp2 = alpha * (s - tmp) + 0x80;
+		tmp2 = (tmp2 + (tmp2 >> 8)) >> 8;
+
+		*dst_p++ = d + tmp2;
+	}
+}
+
+static void
+ksvg_art_rgb_texture_callback (void *callback_data, int y,
+														int start, ArtSVPRenderAAStep *steps, int n_steps)
+{
+	ksvgArtRgbAffineClipAlphaData *data = (ksvgArtRgbAffineClipAlphaData *)callback_data;
+	art_u8 *linebuf;
+	int run_x0, run_x1;
+	art_u32 running_sum = start;
+	int x0, x1;
+	int k;
+	int *alphatab;
+	int alpha;
+
+	linebuf = data->dst;
+	x0 = data->x0;
+	x1 = data->x1;
+
+	alphatab = data->alphatab;
+
+	if(n_steps > 0)
+	{
+		run_x1 = steps[0].x;
+		if(run_x1 > x0)
+		{
+			alpha = (running_sum >> 16) & 0xff;
+			if(alpha)
+				ksvg_art_rgb_texture_run(linebuf, x0, run_x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+		}
+
+		for(k = 0; k < n_steps - 1; k++)
+		{
+			running_sum += steps[k].delta;
+			run_x0 = run_x1;
+			run_x1 = steps[k + 1].x;
+			if(run_x1 > run_x0)
+			{
+				alpha = (running_sum >> 16) & 0xff;
+				if(alpha)
+					ksvg_art_rgb_texture_run(linebuf + (run_x0 - x0) * 3, run_x0, run_x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+			}
+		}
+		running_sum += steps[k].delta;
+		if(x1 > run_x1)
+		{
+			alpha = (running_sum >> 16) & 0xff;
+			if(alpha)
+				ksvg_art_rgb_texture_run(linebuf + (run_x1 - x0) * 3, run_x1, x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+		}
+	}
+	else
+	{
+		alpha = (running_sum >> 16) & 0xff;
+		if(alpha)
+			ksvg_art_rgb_texture_run(linebuf, x0, x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+	}
+
+	data->dst += data->dst_rowstride;
+}
+
+static
+void ksvg_art_rgb_texture_mask_run(art_u8 *dst_p, const art_u8 *mask, int x0, int x1, int y, const double inv[6],
+	int alpha, const art_u8 *src, int src_rowstride, int src_width, int src_height)
+{
+	const art_u8 *src_p;
+	ArtPoint pt, src_pt;
+	int src_x, src_y;
+	int x;
+	int srcAlpha;
+
+	if(alpha > 255)
+		alpha = 255;
+
+	/* TODO: optimise and filter? */
+	pt.y = y + 0.5;
+
+	for(x = x0; x < x1; x++)
+	{
+		int s;
+		int d;
+		int am;
+		int tmp;
+		int tmp2;
+
+		pt.x = x + 0.5;
+
+		art_affine_point(&src_pt, &pt, inv);
+
+		src_x = (int)floor(src_pt.x);
+		src_y = (int)floor(src_pt.y);
+
+		if(src_x < 0)
+		{
+			/* Can't assume % behaviour with negative values */
+			src_x += ((src_x / -src_width) + 1) * src_width;
+		}
+
+		if(src_y < 0)
+		{
+			src_y += ((src_y / -src_height) + 1) * src_height;
+		}
+
+		src_x %= src_width;
+		src_y %= src_height;
+
+		src_p = src + (src_y * src_rowstride) + src_x * 4;
+
+		/* Pattern source is in RGBA format, premultiplied.
+		 * alpha represents fill/stroke/group opacity.
+		 *
+		 * Multiply source alpha by 'alpha' and mask value then composite over.
+		 * For each channel, d = d + alpha * mask * (s - srcAlpha * d).
+		 */
+		
+		am = (alpha * *mask++) + 0x80;
+		am = (am + (am >> 8)) >> 8;
+
+		srcAlpha = src_p[3];
+
+		d = *dst_p;
+		s = *src_p++;
+
+		tmp = srcAlpha * d + 0x80;
+		tmp = (tmp + (tmp >> 8)) >> 8;
+
+		tmp2 = am * (s - tmp) + 0x80;
+		tmp2 = (tmp2 + (tmp2 >> 8)) >> 8;
+
+		*dst_p++ = d + tmp2;
+
+		d = *dst_p;
+		s = *src_p++;
+
+		tmp = srcAlpha * d + 0x80;
+		tmp = (tmp + (tmp >> 8)) >> 8;
+
+		tmp2 = am * (s - tmp) + 0x80;
+		tmp2 = (tmp2 + (tmp2 >> 8)) >> 8;
+
+		*dst_p++ = d + tmp2;
+
+		d = *dst_p;
+		s = *src_p++;
+
+		tmp = srcAlpha * d + 0x80;
+		tmp = (tmp + (tmp >> 8)) >> 8;
+
+		tmp2 = am * (s - tmp) + 0x80;
+		tmp2 = (tmp2 + (tmp2 >> 8)) >> 8;
+
+		*dst_p++ = d + tmp2;
+	}
+}
+
+static void
+ksvg_art_rgb_texture_mask_callback (void *callback_data, int y,
+														int start, ArtSVPRenderAAStep *steps, int n_steps)
+{
+	ksvgArtRgbAffineClipAlphaData *data = (ksvgArtRgbAffineClipAlphaData *)callback_data;
+	art_u8 *linebuf;
+	int run_x0, run_x1;
+	art_u32 running_sum = start;
+	int x0, x1;
+	int k;
+	int *alphatab;
+	int alpha;
+	const art_u8 *maskbuf;
+
+	linebuf = data->dst;
+	x0 = data->x0;
+	x1 = data->x1;
+
+	alphatab = data->alphatab;
+
+	maskbuf = data->mask + (y - data->y0) * (x1 - x0);
+
+	if(n_steps > 0)
+	{
+		run_x1 = steps[0].x;
+		if(run_x1 > x0)
+		{
+			alpha = (running_sum >> 16) & 0xff;
+			if(alpha)
+				ksvg_art_rgb_texture_mask_run(linebuf, maskbuf, x0, run_x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+		}
+
+		for(k = 0; k < n_steps - 1; k++)
+		{
+			running_sum += steps[k].delta;
+			run_x0 = run_x1;
+			run_x1 = steps[k + 1].x;
+			if(run_x1 > run_x0)
+			{
+				alpha = (running_sum >> 16) & 0xff;
+				if(alpha)
+					ksvg_art_rgb_texture_mask_run(linebuf + (run_x0 - x0) * 3, maskbuf + (run_x0 - x0), run_x0, run_x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+			}
+		}
+		running_sum += steps[k].delta;
+		if(x1 > run_x1)
+		{
+			alpha = (running_sum >> 16) & 0xff;
+			if(alpha)
+				ksvg_art_rgb_texture_mask_run(linebuf + (run_x1 - x0) * 3, maskbuf + (run_x1 - x0), run_x1, x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+		}
+	}
+	else
+	{
+		alpha = (running_sum >> 16) & 0xff;
+		if(alpha)
+			ksvg_art_rgb_texture_mask_run(linebuf, maskbuf, x0, x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+	}
+
+	data->dst += data->dst_rowstride;
+}
+
+static
+void ksvg_art_rgba_texture_run(art_u8 *dst_p, int x0, int x1, int y, const double inv[6],
+	int alpha, const art_u8 *src, int src_rowstride, int src_width, int src_height)
+{
+	const art_u8 *src_p;
+	ArtPoint pt, src_pt;
+	int src_x, src_y;
+	int x;
+	int srcAlpha;
+
+	if(alpha > 255)
+		alpha = 255;
+
+	/* TODO: optimise and filter? */
+	pt.y = y + 0.5;
+
+	for(x = x0; x < x1; x++)
+	{
+		int s;
+		int d;
+		int tmp;
+		int tmp2;
+
+		pt.x = x + 0.5;
+
+		art_affine_point(&src_pt, &pt, inv);
+
+		src_x = (int)floor(src_pt.x);
+		src_y = (int)floor(src_pt.y);
+
+		if(src_x < 0)
+		{
+			/* Can't assume % behaviour with negative values */
+			src_x += ((src_x / -src_width) + 1) * src_width;
+		}
+
+		if(src_y < 0)
+		{
+			src_y += ((src_y / -src_height) + 1) * src_height;
+		}
+
+		src_x %= src_width;
+		src_y %= src_height;
+
+		src_p = src + (src_y * src_rowstride) + src_x * 4;
+
+		/* Pattern source is in RGBA format, premultiplied.
+		 * alpha represents fill/stroke/group opacity.
+		 *
+		 * Multiply source alpha by 'alpha' then composite over.
+		 * For each colour channel, d = d + alpha * (s - srcAlpha * d).
+		 */
+		
+		srcAlpha = src_p[3];
+
+		d = *dst_p;
+		s = *src_p++;
+
+		tmp = srcAlpha * d + 0x80;
+		tmp = (tmp + (tmp >> 8)) >> 8;
+
+		tmp2 = alpha * (s - tmp) + 0x80;
+		tmp2 = (tmp2 + (tmp2 >> 8)) >> 8;
+
+		*dst_p++ = d + tmp2;
+
+		d = *dst_p;
+		s = *src_p++;
+
+		tmp = srcAlpha * d + 0x80;
+		tmp = (tmp + (tmp >> 8)) >> 8;
+
+		tmp2 = alpha * (s - tmp) + 0x80;
+		tmp2 = (tmp2 + (tmp2 >> 8)) >> 8;
+
+		*dst_p++ = d + tmp2;
+
+		d = *dst_p;
+		s = *src_p++;
+
+		tmp = srcAlpha * d + 0x80;
+		tmp = (tmp + (tmp >> 8)) >> 8;
+
+		tmp2 = alpha * (s - tmp) + 0x80;
+		tmp2 = (tmp2 + (tmp2 >> 8)) >> 8;
+
+		*dst_p++ = d + tmp2;
+
+		/* dstAlpha = dstAlpha + srcAlpha * alpha * (1 - dstAlpha) */
+		d = *dst_p;
+
+		tmp = srcAlpha * alpha + 0x80;
+		tmp = (tmp + (tmp >> 8)) >> 8;
+
+		tmp2 = tmp * (255 - d) + 0x80;
+		tmp2 = (tmp2 + (tmp2 >> 8)) >> 8;
+
+		*dst_p++ = d + tmp2;
+		src_p++;
+	}
+}
+
+static void
+ksvg_art_rgba_texture_callback (void *callback_data, int y,
+														int start, ArtSVPRenderAAStep *steps, int n_steps)
+{
+	ksvgArtRgbAffineClipAlphaData *data = (ksvgArtRgbAffineClipAlphaData *)callback_data;
+	art_u8 *linebuf;
+	int run_x0, run_x1;
+	art_u32 running_sum = start;
+	int x0, x1;
+	int k;
+	int *alphatab;
+	int alpha;
+
+	linebuf = data->dst;
+	x0 = data->x0;
+	x1 = data->x1;
+
+	alphatab = data->alphatab;
+
+	if(n_steps > 0)
+	{
+		run_x1 = steps[0].x;
+		if(run_x1 > x0)
+		{
+			alpha = (running_sum >> 16) & 0xff;
+			if(alpha)
+				ksvg_art_rgba_texture_run(linebuf, x0, run_x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+		}
+
+		for(k = 0; k < n_steps - 1; k++)
+		{
+			running_sum += steps[k].delta;
+			run_x0 = run_x1;
+			run_x1 = steps[k + 1].x;
+			if(run_x1 > run_x0)
+			{
+				alpha = (running_sum >> 16) & 0xff;
+				if(alpha)
+					ksvg_art_rgba_texture_run(linebuf + (run_x0 - x0) * 4, run_x0, run_x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+			}
+		}
+		running_sum += steps[k].delta;
+		if(x1 > run_x1)
+		{
+			alpha = (running_sum >> 16) & 0xff;
+			if(alpha)
+				ksvg_art_rgba_texture_run(linebuf + (run_x1 - x0) * 4, run_x1, x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+		}
+	}
+	else
+	{
+		alpha = (running_sum >> 16) & 0xff;
+		if(alpha)
+			ksvg_art_rgba_texture_run(linebuf, x0, x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+	}
+
+	data->dst += data->dst_rowstride;
+}
+
+static
+void ksvg_art_rgba_texture_mask_run(art_u8 *dst_p, const art_u8 *mask, int x0, int x1, int y, const double inv[6],
+	int alpha, const art_u8 *src, int src_rowstride, int src_width, int src_height)
+{
+	const art_u8 *src_p;
+	ArtPoint pt, src_pt;
+	int src_x, src_y;
+	int x;
+	int srcAlpha;
+
+	if(alpha > 255)
+		alpha = 255;
+
+	/* TODO: optimise and filter? */
+	pt.y = y + 0.5;
+
+	for(x = x0; x < x1; x++)
+	{
+		int s;
+		int d;
+		int am;
+		int tmp;
+		int tmp2;
+
+		pt.x = x + 0.5;
+
+		art_affine_point(&src_pt, &pt, inv);
+
+		src_x = (int)floor(src_pt.x);
+		src_y = (int)floor(src_pt.y);
+
+		if(src_x < 0)
+		{
+			/* Can't assume % behaviour with negative values */
+			src_x += ((src_x / -src_width) + 1) * src_width;
+		}
+
+		if(src_y < 0)
+		{
+			src_y += ((src_y / -src_height) + 1) * src_height;
+		}
+
+		src_x %= src_width;
+		src_y %= src_height;
+
+		src_p = src + (src_y * src_rowstride) + src_x * 4;
+
+		/* Pattern source is in RGBA format, premultiplied.
+		 * alpha represents fill/stroke/group opacity.
+		 *
+		 * Multiply source alpha by 'alpha' and mask value then composite over.
+		 * For each channel, d = d + alpha * mask * (s - srcAlpha * d).
+		 */
+		
+		am = (alpha * *mask++) + 0x80;
+		am = (am + (am >> 8)) >> 8;
+
+		srcAlpha = src_p[3];
+
+		d = *dst_p;
+		s = *src_p++;
+
+		tmp = srcAlpha * d + 0x80;
+		tmp = (tmp + (tmp >> 8)) >> 8;
+
+		tmp2 = am * (s - tmp) + 0x80;
+		tmp2 = (tmp2 + (tmp2 >> 8)) >> 8;
+
+		*dst_p++ = d + tmp2;
+
+		d = *dst_p;
+		s = *src_p++;
+
+		tmp = srcAlpha * d + 0x80;
+		tmp = (tmp + (tmp >> 8)) >> 8;
+
+		tmp2 = am * (s - tmp) + 0x80;
+		tmp2 = (tmp2 + (tmp2 >> 8)) >> 8;
+
+		*dst_p++ = d + tmp2;
+
+		d = *dst_p;
+		s = *src_p++;
+
+		tmp = srcAlpha * d + 0x80;
+		tmp = (tmp + (tmp >> 8)) >> 8;
+
+		tmp2 = am * (s - tmp) + 0x80;
+		tmp2 = (tmp2 + (tmp2 >> 8)) >> 8;
+
+		*dst_p++ = d + tmp2;
+
+		/* dstAlpha = dstAlpha + srcAlpha * alpha * mask * (1 - dstAlpha) */
+		d = *dst_p;
+
+		tmp = srcAlpha * am + 0x80;
+		tmp = (tmp + (tmp >> 8)) >> 8;
+
+		tmp2 = tmp * (255 - d) + 0x80;
+		tmp2 = (tmp2 + (tmp2 >> 8)) >> 8;
+
+		*dst_p++ = d + tmp2;
+		src_p++;
+	}
+}
+
+static void
+ksvg_art_rgba_texture_mask_callback (void *callback_data, int y,
+														int start, ArtSVPRenderAAStep *steps, int n_steps)
+{
+	ksvgArtRgbAffineClipAlphaData *data = (ksvgArtRgbAffineClipAlphaData *)callback_data;
+	art_u8 *linebuf;
+	int run_x0, run_x1;
+	art_u32 running_sum = start;
+	int x0, x1;
+	int k;
+	int *alphatab;
+	int alpha;
+	const art_u8 *maskbuf;
+
+	linebuf = data->dst;
+	x0 = data->x0;
+	x1 = data->x1;
+
+	alphatab = data->alphatab;
+
+	maskbuf = data->mask + (y - data->y0) * (x1 - x0);
+
+	if(n_steps > 0)
+	{
+		run_x1 = steps[0].x;
+		if(run_x1 > x0)
+		{
+			alpha = (running_sum >> 16) & 0xff;
+			if(alpha)
+				ksvg_art_rgba_texture_mask_run(linebuf, maskbuf, x0, run_x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+		}
+
+		for(k = 0; k < n_steps - 1; k++)
+		{
+			running_sum += steps[k].delta;
+			run_x0 = run_x1;
+			run_x1 = steps[k + 1].x;
+			if(run_x1 > run_x0)
+			{
+				alpha = (running_sum >> 16) & 0xff;
+				if(alpha)
+					ksvg_art_rgba_texture_mask_run(linebuf + (run_x0 - x0) * 4, maskbuf + (run_x0 - x0), run_x0, run_x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+			}
+		}
+		running_sum += steps[k].delta;
+		if(x1 > run_x1)
+		{
+			alpha = (running_sum >> 16) & 0xff;
+			if(alpha)
+				ksvg_art_rgba_texture_mask_run(linebuf + (run_x1 - x0) * 4, maskbuf + (run_x1 - x0), run_x1, x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+		}
+	}
+	else
+	{
+		alpha = (running_sum >> 16) & 0xff;
+		if(alpha)
+			ksvg_art_rgba_texture_mask_run(linebuf, maskbuf, x0, x1, y, data->inv, alphatab[alpha], data->src, data->src_rowstride, data->src_width, data->src_height);
+	}
+
+	data->dst += data->dst_rowstride;
+}
+
+/**
+ * ksvg_art_rgb_texture: Affine transform source RGB image and composite, with clipping path.
+ * @svp: Clipping path.
+ * @dst: Destination image RGB buffer.
+ * @x0: Left coordinate of destination rectangle.
+ * @y0: Top coordinate of destination rectangle.
+ * @x1: Right coordinate of destination rectangle.
+ * @y1: Bottom coordinate of destination rectangle.
+ * @dst_rowstride: Rowstride of @dst buffer.
+ * @src: Source image RGB buffer.
+ * @src_width: Width of source image.
+ * @src_height: Height of source image.
+ * @src_rowstride: Rowstride of @src buffer.
+ * @affine: Affine transform.
+ * @level: Filter level.
+ * @alphagamma: #ArtAlphaGamma for gamma-correcting the compositing.
+ * @alpha: Alpha, range 0..256.
+ *
+ * Affine transform the source image stored in @src, compositing over
+ * the area of destination image @dst specified by the rectangle
+ * (@x0, @y0) - (@x1, @y1). As usual in libart, the left and top edges
+ * of this rectangle are included, and the right and bottom edges are
+ * excluded.
+ *
+ * The @alphagamma parameter specifies that the alpha compositing be done
+ * in a gamma-corrected color space. Since the source image is opaque RGB,
+ * this argument only affects the edges. In the current implementation,
+ * it is ignored.
+ *
+ * The @level parameter specifies the speed/quality tradeoff of the
+ * image interpolation. Currently, only ART_FILTER_NEAREST is
+ * implemented.
+ *
+ * KSVG additions : we have changed this function to support an alpha level as well.
+*                  also we made sure compositing an rgba image over an rgb buffer works.
+**/
+void ksvg_art_rgb_texture(const ArtSVP *svp, art_u8 *dst, int x0, int y0, int x1, int y1, int dst_rowstride,
+		int dst_channels,
+		const art_u8 *src,
+		int src_width, int src_height, int src_rowstride,
+		const double affine[6],
+		ArtFilterLevel level,
+		ArtAlphaGamma *alphaGamma,
+		int alpha,
+		const art_u8 *mask)
+{
+	ksvgArtRgbAffineClipAlphaData data;
+	int i;
+	int a, da;
+
+	data.alpha = alpha;
+
+	a = 0x8000;
+	da = (alpha * 66051 + 0x80) >> 8;	/* 66051 equals 2 ^ 32 / (255 * 255) */
+
+	for(i = 0; i < 256; i++)
+	{
+		data.alphatab[i] = a >> 16;
+		a += da;
+	}
+
+	data.dst = dst;
+	data.dst_rowstride = dst_rowstride;
+	data.x0 = x0;
+	data.x1 = x1;
+	
+	data.inv[0] = affine[0];
+	data.inv[1] = affine[1];
+	data.inv[2] = affine[2];
+	data.inv[3] = affine[3];
+	data.inv[4] = affine[4];
+	data.inv[5] = affine[5];
+
+	data.src = src;
+	data.src_width = src_width;
+	data.src_height = src_height;
+	data.src_rowstride = src_rowstride;
+
+	data.mask = mask;
+	data.y0 = y0;
+
+	if(mask)
+	{
+		if(dst_channels == 3)
+			art_svp_render_aa(svp, x0, y0, x1, y1, ksvg_art_rgb_texture_mask_callback, &data);
+		else
+			art_svp_render_aa(svp, x0, y0, x1, y1, ksvg_art_rgba_texture_mask_callback, &data);
+	}
+	else
+	{
+		if(dst_channels == 3)
+			art_svp_render_aa(svp, x0, y0, x1, y1, ksvg_art_rgb_texture_callback, &data);
+		else
+			art_svp_render_aa(svp, x0, y0, x1, y1, ksvg_art_rgba_texture_callback, &data);
+	}
+}
+
+/**
+ * ksvg_art_svp_move: moves an svp relatively to the current position. 
+ * @svp: SVP to move.
+ * @dx: relative amount to move horizontally.
+ * @dy: relative amount to move vertically.
+ *
+ * Note : this function always moves the svp, not taking into account render buffer
+ * boundaries.
+ **/
+void ksvg_art_svp_move(ArtSVP *svp, int dx, int dy)
+{
+	int i, j;
+	ArtSVPSeg *seg;
+
+	if(dx == 0 && dy == 0) return;
+	for(i = 0;i < svp->n_segs;i++)
+	{
+		seg = &svp->segs[i];
+		for(j = 0;j < seg->n_points;j++)
+		{
+			seg->points[j].x += dx;
+			seg->points[j].y += dy;
+		}
+		seg->bbox.x0 += dx;
+		seg->bbox.y0 += dy;
+		seg->bbox.x1 += dx;
+		seg->bbox.y1 += dy;
+	}
+}
+