mathematical 0.1.0 → 0.1.1

data/ext/mathematical/lsmsvgfilterprimitive.h

@@ -0,0 +1,66 @@
+/* Lasem
+ *
+ * Copyright © 2010 Emmanuel Pacaud
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Author:
+ * 	Emmanuel Pacaud <emmanuel@gnome.org>
+ */
+
+#ifndef LSM_SVG_FILTER_PRIMITIVE_H
+#define LSM_SVG_FILTER_PRIMITIVE_H
+
+#include <lsmsvgtypes.h>
+#include <lsmsvgelement.h>
+
+G_BEGIN_DECLS
+
+#define LSM_TYPE_SVG_FILTER_PRIMITIVE             (lsm_svg_filter_primitive_get_type ())
+#define LSM_SVG_FILTER_PRIMITIVE(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), LSM_TYPE_SVG_FILTER_PRIMITIVE, LsmSvgFilterPrimitive))
+#define LSM_SVG_FILTER_PRIMITIVE_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), LSM_TYPE_SVG_FILTER_PRIMITIVE, LsmSvgFilterPrimitiveClass))
+#define LSM_IS_SVG_FILTER_PRIMITIVE(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LSM_TYPE_SVG_FILTER_PRIMITIVE))
+#define LSM_IS_SVG_FILTER_PRIMITIVE_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), LSM_TYPE_SVG_FILTER_PRIMITIVE))
+#define LSM_SVG_FILTER_PRIMITIVE_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS((obj), LSM_TYPE_SVG_FILTER_PRIMITIVE, LsmSvgFilterPrimitiveClass))
+
+typedef struct _LsmSvgFilterPrimitiveClass LsmSvgFilterPrimitiveClass;
+
+struct _LsmSvgFilterPrimitive {
+	LsmSvgElement element;
+
+	LsmSvgLengthAttribute		x;
+	LsmSvgLengthAttribute		y;
+	LsmSvgLengthAttribute		width;
+	LsmSvgLengthAttribute		height;
+
+	LsmAttribute in;
+	LsmAttribute result;
+};
+
+struct _LsmSvgFilterPrimitiveClass {
+	LsmSvgElementClass  element_class;
+
+	void (*apply)		(LsmSvgFilterPrimitive *self, LsmSvgView *view,
+				 const char *input, const char *output, const LsmBox *subregion);
+};
+
+GType 	lsm_svg_filter_primitive_get_type 	(void);
+
+void 	lsm_svg_filter_primitive_apply 		(LsmSvgFilterPrimitive *self, LsmSvgView *view);
+
+G_END_DECLS
+
+#endif

data/ext/mathematical/lsmsvgfilterspecularlighting.c

@@ -0,0 +1,127 @@
+/* Lasem
+ * 
+ * Copyright © 2012 Emmanuel Pacaud
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Author:
+ * 	Emmanuel Pacaud <emmanuel@gnome.org>
+ */
+
+#include <lsmsvgfilterspecularlighting.h>
+#include <lsmsvgview.h>
+
+static GObjectClass *parent_class;
+
+/* GdomNode implementation */
+
+static const char *
+lsm_svg_filter_specular_lighting_get_node_name (LsmDomNode *node)
+{
+	return "feSpecularLighting";
+}
+
+/* LsmSvgElement implementation */
+
+static void
+lsm_svg_filter_specular_lighting_apply  (LsmSvgFilterPrimitive *self, LsmSvgView *view,
+				     const char *input, const char *output, const LsmBox *subregion)
+{
+/*        lsm_svg_view_apply_specular_lighting (view, output, subregion);*/
+}
+
+/* LsmSvgFilterSpecularLighting implementation */
+
+static const double surface_scale_default = 1.0;
+static const double specular_constant_default = 1.0;
+static const double specular_exponent_default = 1.0;
+static const LsmSvgOneOrTwoDouble kernel_unit_length_default = {1.0, 1.0};
+
+LsmDomNode *
+lsm_svg_filter_specular_lighting_new (void)
+{
+	return g_object_new (LSM_TYPE_SVG_FILTER_SPECULAR_LIGHTING, NULL);
+}
+
+static void
+lsm_svg_filter_specular_lighting_init (LsmSvgFilterSpecularLighting *self)
+{
+	self->surface_scale.value = surface_scale_default;
+	self->specular_constant.value = specular_constant_default;
+	self->specular_exponent.value = specular_exponent_default;
+	self->kernel_unit_length.value = kernel_unit_length_default;
+
+}
+
+static void
+lsm_svg_filter_specular_lighting_finalize (GObject *object)
+{
+	parent_class->finalize (object);
+}
+
+/* LsmSvgFilterSpecularLighting class */
+
+static const LsmAttributeInfos lsm_svg_filter_specular_lighting_attribute_infos[] = {
+	{
+		.name = "sufaceScale",
+		.attribute_offset = offsetof (LsmSvgFilterSpecularLighting, surface_scale),
+		.trait_class = &lsm_double_trait_class,
+		.trait_default = &surface_scale_default
+	},
+	{
+		.name = "specularConstant",
+		.attribute_offset = offsetof (LsmSvgFilterSpecularLighting, specular_constant),
+		.trait_class = &lsm_double_trait_class,
+		.trait_default = &specular_constant_default
+	},
+	{
+		.name = "specularExponent",
+		.attribute_offset = offsetof (LsmSvgFilterSpecularLighting, specular_exponent),
+		.trait_class = &lsm_double_trait_class,
+		.trait_default = &specular_exponent_default
+	},
+	{
+		.name = "kernelUnitLength",
+		.attribute_offset = offsetof (LsmSvgFilterSpecularLighting, kernel_unit_length),
+		.trait_class = &lsm_svg_one_or_two_double_trait_class,
+		.trait_default = &kernel_unit_length_default
+	}
+};
+
+static void
+lsm_svg_filter_specular_lighting_class_init (LsmSvgFilterSpecularLightingClass *klass)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS (klass);
+	LsmDomNodeClass *d_node_class = LSM_DOM_NODE_CLASS (klass);
+	LsmSvgElementClass *s_element_class = LSM_SVG_ELEMENT_CLASS (klass);
+	LsmSvgFilterPrimitiveClass *f_primitive_class = LSM_SVG_FILTER_PRIMITIVE_CLASS (klass);
+
+	parent_class = g_type_class_peek_parent (klass);
+
+	object_class->finalize = lsm_svg_filter_specular_lighting_finalize;
+
+	d_node_class->get_node_name = lsm_svg_filter_specular_lighting_get_node_name;
+
+	s_element_class->attribute_manager = lsm_attribute_manager_duplicate (s_element_class->attribute_manager);
+
+	lsm_attribute_manager_add_attributes (s_element_class->attribute_manager,
+					      G_N_ELEMENTS (lsm_svg_filter_specular_lighting_attribute_infos),
+					      lsm_svg_filter_specular_lighting_attribute_infos);
+
+	f_primitive_class->apply = lsm_svg_filter_specular_lighting_apply;
+}
+
+G_DEFINE_TYPE (LsmSvgFilterSpecularLighting, lsm_svg_filter_specular_lighting, LSM_TYPE_SVG_FILTER_PRIMITIVE)

data/ext/mathematical/lsmsvgfilterspecularlighting.h

@@ -0,0 +1,60 @@
+/* Lasem
+ *
+ * Copyright © 2012 Emmanuel Pacaud
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Author:
+ * 	Emmanuel Pacaud <emmanuel@gnome.org>
+ */
+
+#ifndef LSM_SVG_FILTER_SPECULAR_LIGHTING_H
+#define LSM_SVG_FILTER_SPECULAR_LIGHTING_H
+
+#include <lsmsvgtypes.h>
+#include <lsmsvgfilterprimitive.h>
+
+G_BEGIN_DECLS
+
+#define LSM_TYPE_SVG_FILTER_SPECULAR_LIGHTING             (lsm_svg_filter_specular_lighting_get_type ())
+#define LSM_SVG_FILTER_SPECULAR_LIGHTING(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), LSM_TYPE_SVG_FILTER_SPECULAR_LIGHTING, LsmSvgFilterSpecularLighting))
+#define LSM_SVG_FILTER_SPECULAR_LIGHTING_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), LSM_TYPE_SVG_FILTER_SPECULAR_LIGHTING, LsmSvgFilterSpecularLightingClass))
+#define LSM_IS_SVG_FILTER_SPECULAR_LIGHTING(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LSM_TYPE_SVG_FILTER_SPECULAR_LIGHTING))
+#define LSM_IS_SVG_FILTER_SPECULAR_LIGHTING_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), LSM_TYPE_SVG_FILTER_SPECULAR_LIGHTING))
+#define LSM_SVG_FILTER_SPECULAR_LIGHTING_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS((obj), LSM_TYPE_SVG_FILTER_SPECULAR_LIGHTING, LsmSvgFilterSpecularLightingClass))
+
+typedef struct _LsmSvgFilterSpecularLightingClass LsmSvgFilterSpecularLightingClass;
+
+struct _LsmSvgFilterSpecularLighting {
+	LsmSvgFilterPrimitive base;
+
+	LsmSvgDoubleAttribute surface_scale;
+	LsmSvgDoubleAttribute specular_constant;
+	LsmSvgDoubleAttribute specular_exponent;
+	LsmSvgOneOrTwoDoubleAttribute kernel_unit_length;
+};
+
+struct _LsmSvgFilterSpecularLightingClass {
+	LsmSvgFilterPrimitiveClass  element_class;
+};
+
+GType lsm_svg_filter_specular_lighting_get_type (void);
+
+LsmDomNode * 	lsm_svg_filter_specular_lighting_new 		(void);
+
+G_END_DECLS
+
+#endif

data/ext/mathematical/lsmsvgfiltersurface.c

@@ -0,0 +1,455 @@
+/* Lasem
+ *
+ * Copyright © 2004 Caleb Moore
+ * Copyright © 2012 Emmanuel Pacaud
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Authors:
+ *	Caleb Moore <c.moore@student.unsw.edu.au>
+ * 	Emmanuel Pacaud <emmanuel@gnome.org>
+ */
+
+#include <lsmsvgfiltersurface.h>
+#include <lsmsvgenums.h>
+#include <lsmutils.h>
+#include <math.h>
+#include <string.h>
+
+struct _LsmSvgFilterSurface {
+	char *name;
+	cairo_surface_t *surface;
+	LsmBox subregion;
+
+	gint ref_count;
+};
+
+LsmSvgFilterSurface *
+lsm_svg_filter_surface_new (const char *name, unsigned int width, unsigned int height, const LsmBox *subregion)
+{
+	LsmSvgFilterSurface *filter_surface;
+	cairo_surface_t *surface;
+
+	surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
+
+	filter_surface = lsm_svg_filter_surface_new_with_content (name, surface, subregion);
+
+	cairo_surface_destroy (surface);
+
+	return filter_surface;
+}
+
+LsmSvgFilterSurface *
+lsm_svg_filter_surface_new_with_content (const char *name, cairo_surface_t *surface, const LsmBox *subregion)
+{
+	LsmSvgFilterSurface *filter_surface;
+	LsmBox null_subregion = {0, 0, 0, 0};
+
+	if (surface == NULL ||
+	    cairo_surface_get_type (surface) != CAIRO_SURFACE_TYPE_IMAGE ||
+	    cairo_image_surface_get_format (surface) != CAIRO_FORMAT_ARGB32) {
+		surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 0, 0);
+		subregion = &null_subregion;
+	} else if (subregion == NULL)
+		subregion = &null_subregion;
+
+	cairo_surface_reference (surface);
+
+	filter_surface = g_new (LsmSvgFilterSurface, 1);
+	filter_surface->name = g_strdup (name);
+	filter_surface->subregion = *subregion;
+	filter_surface->surface  = surface;
+	filter_surface->ref_count = 1;
+
+	return filter_surface;
+}
+
+LsmSvgFilterSurface *
+lsm_svg_filter_surface_new_similar (const char *name, LsmSvgFilterSurface *model, const LsmBox *subregion)
+{
+	if (model == NULL)
+		return lsm_svg_filter_surface_new (name, 0, 0, subregion);
+
+	return lsm_svg_filter_surface_new (name,
+				       cairo_image_surface_get_width (model->surface),
+				       cairo_image_surface_get_height (model->surface),
+				       subregion != NULL ? subregion : &model->subregion);
+}
+
+const char *
+lsm_svg_filter_surface_get_name (LsmSvgFilterSurface *surface)
+{
+	g_return_val_if_fail (surface != NULL, NULL);
+
+	return surface->name;
+}
+
+cairo_surface_t *
+lsm_svg_filter_surface_get_cairo_surface (LsmSvgFilterSurface *surface)
+{
+	g_return_val_if_fail (surface != NULL, NULL);
+
+	return surface->surface;
+}
+
+const LsmBox *
+lsm_svg_filter_surface_get_subregion (LsmSvgFilterSurface *surface)
+{
+	static const LsmBox null_subregion = {0, 0, 0, 0};
+
+	if (surface == NULL)
+		return &null_subregion;
+
+	return &surface->subregion;
+}
+
+LsmSvgFilterSurface *
+lsm_svg_filter_surface_ref (LsmSvgFilterSurface *filter_surface)
+{
+	g_return_val_if_fail (filter_surface != NULL, NULL);
+
+	g_atomic_int_inc (&filter_surface->ref_count);
+
+	return filter_surface;
+}
+
+void
+lsm_svg_filter_surface_unref (LsmSvgFilterSurface *filter_surface)
+{
+	g_return_if_fail (filter_surface != NULL);
+	g_return_if_fail (filter_surface->ref_count > 0);
+
+	if (g_atomic_int_dec_and_test (&filter_surface->ref_count)) {
+		cairo_surface_destroy (filter_surface->surface);
+		g_free (filter_surface->name);
+		g_free (filter_surface);
+	}
+}
+
+G_DEFINE_BOXED_TYPE (LsmSvgFilterSurface, lsm_svg_filter_surface, lsm_svg_filter_surface_ref, lsm_svg_filter_surface_unref)
+
+static void
+box_blur (cairo_surface_t *in,
+          cairo_surface_t *output,
+          int kw,
+          int kh,
+          int shiftx,
+          int shifty,
+	  int x0,
+	  int y0,
+	  int x1,
+	  int y1)
+{
+    gint ch;
+    gint x, y;
+    gint offset;
+    gint rowstride;
+    guchar *intermediate;
+    guchar *in_pixels;
+    guchar *output_pixels;
+    gint sum;
+
+    in_pixels = cairo_image_surface_get_data (in);
+    output_pixels = cairo_image_surface_get_data (output);
+
+    rowstride = cairo_image_surface_get_stride (in);
+
+    intermediate = g_new (guchar, MAX (kw, kh));
+
+    if (kw > 1) {
+        offset = shiftx - kw / 2;
+        for (ch = 0; ch < 4; ch++) {
+            for (y = y0; y < y1; y++) {
+                sum = 0;
+                for (x = x0; x < x0 + kw; x++) {
+                    sum += (intermediate[x % kw] = in_pixels[4 * x + y * rowstride + ch]);
+                    if (x + offset >= 0 && x + offset < x1)
+                        output_pixels[4 * (x + offset) + y * rowstride + ch] = sum / kw;
+                }
+                for (x = x0 + kw; x < x1; x++) {
+                    sum -= intermediate[x % kw];
+                    sum += (intermediate[x % kw] = in_pixels[4 * x + y * rowstride + ch]);
+                    if (x + offset >= 0 && x + offset < x1)
+                        output_pixels[4 * (x + offset) + y * rowstride + ch] = sum / kw;
+                }
+                for (x = x1; x < x1 + kw; x++) {
+                    sum -= intermediate[x % kw];
+                    if (x + offset >= 0 && x + offset < x1)
+                        output_pixels[4 * (x + offset) + y * rowstride + ch] = sum / kw;
+                }
+            }
+        }
+        in_pixels = output_pixels;
+    }
+
+    if (kh > 1) {
+        offset = shifty - kh / 2;
+        for (ch = 0; ch < 4; ch++) {
+            for (x = x0; x < x1; x++) {
+                sum = 0;
+
+                for (y = y0; y < y0 + kh; y++) {
+                    sum += (intermediate[y % kh] = in_pixels[4 * x + y * rowstride + ch]);
+                    if (y + offset >= 0 && y + offset < y1)
+                        output_pixels[4 * x + (y + offset) * rowstride + ch] = sum / kh;
+                }
+                for (y = y0 + kh; y < y1; y++) {
+                    sum -= intermediate[y % kh];
+                    sum += (intermediate[y % kh] = in_pixels[4 * x + y * rowstride + ch]);
+                    if (y + offset >= 0 && y + offset < y1)
+                        output_pixels[4 * x + (y + offset) * rowstride + ch] = sum / kh;
+                }
+                for (y = y1; y < y1 + kh; y++) {
+                    sum -= intermediate[y % kh];
+                    if (y + offset >= 0 && y + offset < y1)
+                        output_pixels[4 * x + (y + offset) * rowstride + ch] = sum / kh;
+                }
+            }
+        }
+    }
+    
+    g_free (intermediate);
+}
+
+void
+lsm_svg_filter_surface_fast_blur (LsmSvgFilterSurface *input,
+				  LsmSvgFilterSurface *output,
+				  double sx, double sy)
+{
+	int kx, ky;
+	int width, height;
+
+	g_return_if_fail (input != NULL);
+	g_return_if_fail (output != NULL);
+
+	cairo_surface_flush (input->surface);
+
+	kx = floor (sx * 3 * sqrt (2 * M_PI) / 4 + 0.5);
+	ky = floor (sy * 3 * sqrt (2 * M_PI) / 4 + 0.5);
+
+	width = cairo_image_surface_get_width (input->surface);
+	height = cairo_image_surface_get_height (input->surface);
+
+	if (width != cairo_image_surface_get_width (output->surface) ||
+	    height != cairo_image_surface_get_height (output->surface))
+		return;
+
+	if (kx > 1 || ky > 1) {
+		int x1, y1, x2, y2;
+		cairo_surface_t *blur_surface;
+		gboolean do_clip = FALSE;
+
+		x1 = output->subregion.x - kx;
+		y1 = output->subregion.y - ky;
+		x2 = output->subregion.width + output->subregion.x + kx;
+		y2 = output->subregion.height + output->subregion.y + ky;
+		x1 = CLAMP (x1, 0, width);
+		y1 = CLAMP (y1, 0, height);
+		x2 = CLAMP (x2, x1, width);
+		y2 = CLAMP (y2, y1, height);
+
+
+		if (input->subregion.x < output->subregion.x ||
+		    input->subregion.y < output->subregion.y ||
+		    input->subregion.width > output->subregion.width ||
+		    input->subregion.height > output->subregion.height) {
+			do_clip = TRUE;	
+			blur_surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
+		} else
+			blur_surface = output->surface;
+
+		box_blur (input->surface, blur_surface, kx, ky, 0, 0, x1, y1, x2, y2);
+		box_blur (blur_surface, blur_surface, kx, ky, (kx + 1) % 2, (ky + 1) % 2, x1, y1, x2, y2);
+		box_blur (blur_surface, blur_surface, kx + (kx + 1) % 2, ky + (ky + 1) % 2, 0, 0, x1, y1, x2, y2);
+
+		cairo_surface_mark_dirty (blur_surface);
+
+		if (do_clip) {
+			cairo_t *cairo;
+
+			cairo = cairo_create (output->surface);
+			cairo_rectangle (cairo,
+					 output->subregion.x, output->subregion.y,
+					 output->subregion.width, output->subregion.height);
+			cairo_clip (cairo);
+			cairo_set_source_surface (cairo, blur_surface, 0, 0);
+			cairo_paint (cairo);
+			cairo_destroy (cairo);
+
+			cairo_surface_destroy (blur_surface);
+		}
+	} else {
+		cairo_t *cairo;
+
+		cairo = cairo_create (output->surface);
+		cairo_rectangle (cairo,
+				 output->subregion.x, output->subregion.y,
+				 output->subregion.width, output->subregion.height);
+		cairo_clip (cairo);
+		cairo_set_source_surface (cairo, input->surface, 0, 0);
+		cairo_paint (cairo);
+		cairo_destroy (cairo);
+	}
+}
+
+void
+lsm_svg_filter_surface_flood (LsmSvgFilterSurface *surface,
+			      double red,
+			      double green,
+			      double blue,
+			      double opacity)
+{
+	cairo_t *cairo;
+
+	g_return_if_fail (surface != NULL);
+
+	cairo = cairo_create (surface->surface);
+	cairo_rectangle (cairo, surface->subregion.x, surface->subregion.y, surface->subregion.width, surface->subregion.height);
+	cairo_clip (cairo);
+	cairo_set_source_rgba (cairo, red, green, blue, opacity);
+	cairo_paint (cairo);
+}
+
+void
+lsm_svg_filter_surface_blend (LsmSvgFilterSurface *input_1,
+			      LsmSvgFilterSurface *input_2,
+			      LsmSvgFilterSurface *output,
+			      int blending_mode)
+{
+	cairo_t *cairo;
+	cairo_operator_t op;
+
+	g_return_if_fail (input_1 != NULL);
+	g_return_if_fail (input_2 != NULL);
+	g_return_if_fail (output != NULL);
+
+	switch (blending_mode) {
+		case LSM_SVG_BLENDING_MODE_MULTIPLY:
+			op = CAIRO_OPERATOR_MULTIPLY;
+			break;
+		case LSM_SVG_BLENDING_MODE_SCREEN:
+			op = CAIRO_OPERATOR_SCREEN;
+			break;
+		case LSM_SVG_BLENDING_MODE_DARKEN:
+			op = CAIRO_OPERATOR_DARKEN;
+			break;
+		case LSM_SVG_BLENDING_MODE_LIGHTEN:
+			op = CAIRO_OPERATOR_LIGHTEN;
+			break;
+		case LSM_SVG_BLENDING_MODE_IN:
+			op = CAIRO_OPERATOR_IN;
+			break;
+		case LSM_SVG_BLENDING_MODE_OUT:
+			op = CAIRO_OPERATOR_OUT;
+			break;
+		case LSM_SVG_BLENDING_MODE_ATOP:
+			op = CAIRO_OPERATOR_ATOP;
+			break;
+		case LSM_SVG_BLENDING_MODE_XOR:
+			op = CAIRO_OPERATOR_XOR;
+			break;
+		default:
+			op = CAIRO_OPERATOR_OVER;
+			break;
+	}
+
+	cairo = cairo_create (output->surface);
+	cairo_rectangle (cairo, output->subregion.x, output->subregion.y, output->subregion.width, output->subregion.height);
+	cairo_clip (cairo);
+	cairo_set_source_surface (cairo, input_2->surface, 0, 0);
+	cairo_paint (cairo);
+	cairo_set_source_surface (cairo, input_1->surface, 0, 0);
+	cairo_set_operator (cairo, op);
+	cairo_paint (cairo);
+	cairo_destroy (cairo);
+}
+
+void
+lsm_svg_filter_surface_offset (LsmSvgFilterSurface *input,
+			       LsmSvgFilterSurface *output,
+			       int dx, int dy)
+{
+	cairo_t *cairo;
+
+	g_return_if_fail (input != NULL);
+	g_return_if_fail (output != NULL);
+
+	cairo = cairo_create (output->surface);
+	cairo_rectangle (cairo, output->subregion.x, output->subregion.y, output->subregion.width, output->subregion.height);
+	cairo_clip (cairo);
+	cairo_set_source_surface (cairo, input->surface, dx, dy);
+	cairo_paint (cairo);
+	cairo_destroy (cairo);
+}
+
+void
+lsm_svg_filter_surface_merge (LsmSvgFilterSurface *input,
+			      LsmSvgFilterSurface *output)
+{
+	cairo_t *cairo;
+
+	g_return_if_fail (input != NULL);
+	g_return_if_fail (output != NULL);
+
+	cairo = cairo_create (output->surface);
+	cairo_rectangle (cairo, output->subregion.x, output->subregion.y, output->subregion.width, output->subregion.height);
+	cairo_clip (cairo);
+	cairo_set_source_surface (cairo, input->surface, 0, 0);
+	cairo_paint (cairo);
+	cairo_destroy (cairo);
+}
+
+void
+lsm_svg_filter_surface_tile (LsmSvgFilterSurface *input, LsmSvgFilterSurface *output)
+{
+	cairo_t *cairo;
+	cairo_surface_t *surface;
+	cairo_pattern_t *pattern;
+
+	g_return_if_fail (input != NULL);
+	g_return_if_fail (output != NULL);
+
+	surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, input->subregion.width, input->subregion.height);
+	cairo = cairo_create (surface);
+	cairo_set_source_surface (cairo, input->surface, input->subregion.x, input->subregion.y);
+	cairo_paint (cairo);
+	cairo_destroy (cairo);
+
+	cairo = cairo_create (output->surface);
+	cairo_rectangle (cairo, output->subregion.x, output->subregion.y, output->subregion.width, output->subregion.height);
+	cairo_clip (cairo);
+	cairo_set_source_surface (cairo, surface, 0, 0);
+	pattern = cairo_get_source (cairo);
+	cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT);
+	cairo_paint (cairo);
+	cairo_destroy (cairo);
+	cairo_surface_destroy (surface);
+}
+
+void
+lsm_svg_filter_surface_alpha (LsmSvgFilterSurface *input, LsmSvgFilterSurface *output)
+{
+	cairo_t *cairo;
+
+	g_return_if_fail (input != NULL);
+	g_return_if_fail (output != NULL);
+
+	cairo = cairo_create (output->surface);
+	cairo_set_source_rgb (cairo, 0, 0, 0);
+	cairo_mask_surface (cairo, input->surface, 0, 0);
+
+	cairo_destroy (cairo);
+}