pixman components

6 files changed, 293 insertions, 287 deletions

diff --git a/pixman/pixman-combine-float.c b/pixman/pixman-combine-float.c
index fb84d6e..0564f92 100644
--- a/pixman/pixman-combine-float.c
+++ b/pixman/pixman-combine-float.c
@@ -36,11 +36,11 @@
 
 #define IS_ZERO(f) ((f) == 0.0f) /* FIXME? */
 
-typedef float (* combine_channel_t) (float sa, float s, float da, float d);
+typedef pixman_component_t (* combine_channel_t) (pixman_component_t sa, pixman_component_t s, pixman_component_t da, pixman_component_t d);
 
 static force_inline void
 combine_inner (pixman_bool_t component,
-	       float *dest, const float *src, const float *mask, int n_pixels,
+	       pixman_component_t *dest, const pixman_component_t *src, const pixman_component_t *mask, int n_pixels,
 	       combine_channel_t combine_a, combine_channel_t combine_c)
 {
     int i;
@@ -49,15 +49,15 @@ combine_inner (pixman_bool_t component,
     {
 	for (i = 0; i < 4 * n_pixels; i += 4)
 	{
-	    float sa = src[i + 0];
-	    float sr = src[i + 1];
-	    float sg = src[i + 2];
-	    float sb = src[i + 3];
+	    pixman_component_t sa = src[i + 0];
+	    pixman_component_t sr = src[i + 1];
+	    pixman_component_t sg = src[i + 2];
+	    pixman_component_t sb = src[i + 3];
 	    
-	    float da = dest[i + 0];
-	    float dr = dest[i + 1];
-	    float dg = dest[i + 2];
-	    float db = dest[i + 3];					
+	    pixman_component_t da = dest[i + 0];
+	    pixman_component_t dr = dest[i + 1];
+	    pixman_component_t dg = dest[i + 2];
+	    pixman_component_t db = dest[i + 3];					
 	    
 	    dest[i + 0] = combine_a (sa, sa, da, da);
 	    dest[i + 1] = combine_c (sa, sr, da, dr);
@@ -69,9 +69,9 @@ combine_inner (pixman_bool_t component,
     {
 	for (i = 0; i < 4 * n_pixels; i += 4)
 	{
-	    float sa, sr, sg, sb;
-	    float ma, mr, mg, mb;
-	    float da, dr, dg, db;
+	    pixman_component_t sa, sr, sg, sb;
+	    pixman_component_t ma, mr, mg, mb;
+	    pixman_component_t da, dr, dg, db;
 	    
 	    sa = src[i + 0];
 	    sr = src[i + 1];
@@ -125,9 +125,9 @@ combine_inner (pixman_bool_t component,
     static void								\
     combine_ ## name ## _float (pixman_implementation_t *imp,		\
 				pixman_op_t              op,		\
-				float                   *dest,		\
-				const float             *src,		\
-				const float             *mask,		\
+				pixman_component_t                   *dest,		\
+				const pixman_component_t             *src,		\
+				const pixman_component_t             *mask,		\
 				int		         n_pixels)	\
     {									\
 	combine_inner (component, dest, src, mask, n_pixels,		\
@@ -160,8 +160,8 @@ typedef enum
     ONE_MINUS_INV_SA_OVER_DA
 } combine_factor_t;
 
-static force_inline float
-get_factor (combine_factor_t factor, float sa, float da)
+static force_inline pixman_component_t
+get_factor (combine_factor_t factor, pixman_component_t sa, pixman_component_t da)
 {
     switch (factor)
     {
@@ -212,11 +212,11 @@ get_factor (combine_factor_t factor, float sa, float da)
 }
 
 #define MAKE_PD_COMBINERS(name, a, b)					\
-    static float force_inline						\
-    pd_combine_ ## name (float sa, float s, float da, float d)		\
+    static pixman_component_t force_inline						\
+    pd_combine_ ## name (pixman_component_t sa, pixman_component_t s, pixman_component_t da, pixman_component_t d)		\
     {									\
-	const float fa = get_factor (a, sa, da);			\
-	const float fb = get_factor (b, sa, da);			\
+	const pixman_component_t fa = get_factor (a, sa, da);			\
+	const pixman_component_t fb = get_factor (b, sa, da);			\
 									\
 	return MIN (1.0f, s * fa + d * fb);				\
     }									\
@@ -290,36 +290,36 @@ MAKE_PD_COMBINERS (conjoint_xor,		ONE_MINUS_DA_OVER_SA,		ONE_MINUS_SA_OVER_DA)
  */
 
 #define MAKE_SEPARABLE_PDF_COMBINERS(name)				\
-    static force_inline float						\
-    combine_ ## name ## _a (float sa, float s, float da, float d)	\
+    static force_inline pixman_component_t						\
+    combine_ ## name ## _a (pixman_component_t sa, pixman_component_t s, pixman_component_t da, pixman_component_t d)	\
     {									\
 	return da + sa - da * sa;					\
     }									\
     									\
-    static force_inline float						\
-    combine_ ## name ## _c (float sa, float s, float da, float d)	\
+    static force_inline pixman_component_t						\
+    combine_ ## name ## _c (pixman_component_t sa, pixman_component_t s, pixman_component_t da, pixman_component_t d)	\
     {									\
-	float f = (1 - sa) * d + (1 - da) * s;				\
+	pixman_component_t f = (1 - sa) * d + (1 - da) * s;				\
 									\
 	return f + blend_ ## name (sa, s, da, d);			\
     }									\
     									\
     MAKE_COMBINERS (name, combine_ ## name ## _a, combine_ ## name ## _c)
 
-static force_inline float
-blend_multiply (float sa, float s, float da, float d)
+static force_inline pixman_component_t
+blend_multiply (pixman_component_t sa, pixman_component_t s, pixman_component_t da, pixman_component_t d)
 {
     return d * s;
 }
 
-static force_inline float
-blend_screen (float sa, float s, float da, float d)
+static force_inline pixman_component_t
+blend_screen (pixman_component_t sa, pixman_component_t s, pixman_component_t da, pixman_component_t d)
 {
     return d * sa + s * da - s * d;
 }
 
-static force_inline float
-blend_overlay (float sa, float s, float da, float d)
+static force_inline pixman_component_t
+blend_overlay (pixman_component_t sa, pixman_component_t s, pixman_component_t da, pixman_component_t d)
 {
     if (2 * d < da)
 	return 2 * s * d;
@@ -327,8 +327,8 @@ blend_overlay (float sa, float s, float da, float d)
 	return sa * da - 2 * (da - d) * (sa - s);
 }
 
-static force_inline float
-blend_darken (float sa, float s, float da, float d)
+static force_inline pixman_component_t
+blend_darken (pixman_component_t sa, pixman_component_t s, pixman_component_t da, pixman_component_t d)
 {
     s = s * da;
     d = d * sa;
@@ -339,8 +339,8 @@ blend_darken (float sa, float s, float da, float d)
 	return s;
 }
 
-static force_inline float
-blend_lighten (float sa, float s, float da, float d)
+static force_inline pixman_component_t
+blend_lighten (pixman_component_t sa, pixman_component_t s, pixman_component_t da, pixman_component_t d)
 {
     s = s * da;
     d = d * sa;
@@ -351,8 +351,8 @@ blend_lighten (float sa, float s, float da, float d)
 	return d;
 }
 
-static force_inline float
-blend_color_dodge (float sa, float s, float da, float d)
+static force_inline pixman_component_t
+blend_color_dodge (pixman_component_t sa, pixman_component_t s, pixman_component_t da, pixman_component_t d)
 {
     if (d == 0)
       return 0.0f;
@@ -370,14 +370,14 @@ blend_color_dodge (float sa, float s, float da, float d)
     }
     else
     {
-	float r = (d * sa) / (sa - s);
+	pixman_component_t r = (d * sa) / (sa - s);
 
 	return sa * MIN (r, da);
     }
 }
 
-static force_inline float
-blend_color_burn (float sa, float s, float da, float d)
+static force_inline pixman_component_t
+blend_color_burn (pixman_component_t sa, pixman_component_t s, pixman_component_t da, pixman_component_t d)
 {
     if (d >= da)
       return sa * da;
@@ -395,14 +395,14 @@ blend_color_burn (float sa, float s, float da, float d)
     }
     else
     {
-	float r = (da - d) * sa / s;
+	pixman_component_t r = (da - d) * sa / s;
 
 	return sa * (MAX (r, da) - r);
     }
 }
 
-static force_inline float
-blend_hard_light (float sa, float s, float da, float d)
+static force_inline pixman_component_t
+blend_hard_light (pixman_component_t sa, pixman_component_t s, pixman_component_t da, pixman_component_t d)
 {
     if (2 * s < sa)
 	return 2 * s * d;
@@ -410,8 +410,8 @@ blend_hard_light (float sa, float s, float da, float d)
 	return sa * da - 2 * (da - d) * (sa - s);
 }
 
-static force_inline float
-blend_soft_light (float sa, float s, float da, float d)
+static force_inline pixman_component_t
+blend_soft_light (pixman_component_t sa, pixman_component_t s, pixman_component_t da, pixman_component_t d)
 {
     if (2 * s < sa)
     {
@@ -434,11 +434,11 @@ blend_soft_light (float sa, float s, float da, float d)
     }
 }
 
-static force_inline float
-blend_difference (float sa, float s, float da, float d)
+static force_inline pixman_component_t
+blend_difference (pixman_component_t sa, pixman_component_t s, pixman_component_t da, pixman_component_t d)
 {
-    float dsa = d * sa;
-    float sda = s * da;
+    pixman_component_t dsa = d * sa;
+    pixman_component_t sda = s * da;
 
     if (sda < dsa)
 	return dsa - sda;
@@ -446,8 +446,8 @@ blend_difference (float sa, float s, float da, float d)
 	return sda - dsa;
 }
 
-static force_inline float
-blend_exclusion (float sa, float s, float da, float d)
+static force_inline pixman_component_t
+blend_exclusion (pixman_component_t sa, pixman_component_t s, pixman_component_t da, pixman_component_t d)
 {
     return s * da + d * sa - 2 * d * s;
 }
@@ -577,53 +577,53 @@ MAKE_SEPARABLE_PDF_COMBINERS (exclusion)
 
 typedef struct
 {
-    float	r;
-    float	g;
-    float	b;
+    pixman_component_t	r;
+    pixman_component_t	g;
+    pixman_component_t	b;
 } rgb_t;
 
-static force_inline float
-minf (float a, float b)
+static force_inline pixman_component_t
+minf (pixman_component_t a, pixman_component_t b)
 {
     return a < b? a : b;
 }
 
-static force_inline float
-maxf (float a, float b)
+static force_inline pixman_component_t
+maxf (pixman_component_t a, pixman_component_t b)
 {
     return a > b? a : b;
 }
 
-static force_inline float
+static force_inline pixman_component_t
 channel_min (rgb_t *c)
 {
     return minf (minf (c->r, c->g), c->b);
 }
 
-static force_inline float
+static force_inline pixman_component_t
 channel_max (rgb_t *c)
 {
     return maxf (maxf (c->r, c->g), c->b);
 }
 
-static force_inline float
+static force_inline pixman_component_t
 get_lum (rgb_t *c)
 {
     return c->r * 0.3f + c->g * 0.59f + c->b * 0.11f;
 }
 
-static force_inline float
+static force_inline pixman_component_t
 get_sat (rgb_t *c)
 {
     return channel_max (c) - channel_min (c);
 }
 
 static void
-clip_color (rgb_t *color, float a)
+clip_color (rgb_t *color, pixman_component_t a)
 {
-    float l = get_lum (color);
-    float n = channel_min (color);
-    float x = channel_max (color);
+    pixman_component_t l = get_lum (color);
+    pixman_component_t n = channel_min (color);
+    pixman_component_t x = channel_max (color);
 
     if (n < 0.0f)
     {
@@ -640,9 +640,9 @@ clip_color (rgb_t *color, float a)
 }
 
 static void
-set_lum (rgb_t *color, float sa, float l)
+set_lum (rgb_t *color, pixman_component_t sa, pixman_component_t l)
 {
-    float d = l - get_lum (color);
+    pixman_component_t d = l - get_lum (color);
 
     color->r = color->r + d;
     color->g = color->g + d;
@@ -652,9 +652,9 @@ set_lum (rgb_t *color, float sa, float l)
 }
 
 static void
-set_sat (rgb_t *src, float sat)
+set_sat (rgb_t *src, pixman_component_t sat)
 {
-    float *max, *mid, *min;
+    pixman_component_t *max, *mid, *min;
 
     if (src->r > src->g)
     {
@@ -724,8 +724,8 @@ set_sat (rgb_t *src, float sat)
  */
 static force_inline void
 blend_hsl_hue (rgb_t *res,
-	       rgb_t *dest, float da,
-	       rgb_t *src, float sa)
+	       rgb_t *dest, pixman_component_t da,
+	       rgb_t *src, pixman_component_t sa)
 {
     res->r = src->r * da;
     res->g = src->g * da;
@@ -741,8 +741,8 @@ blend_hsl_hue (rgb_t *res,
  */
 static force_inline void
 blend_hsl_saturation (rgb_t *res,
-		      rgb_t *dest, float da,
-		      rgb_t *src, float sa)
+		      rgb_t *dest, pixman_component_t da,
+		      rgb_t *src, pixman_component_t sa)
 {
     res->r = dest->r * sa;
     res->g = dest->g * sa;
@@ -758,8 +758,8 @@ blend_hsl_saturation (rgb_t *res,
  */
 static force_inline void
 blend_hsl_color (rgb_t *res,
-		 rgb_t *dest, float da,
-		 rgb_t *src, float sa)
+		 rgb_t *dest, pixman_component_t da,
+		 rgb_t *src, pixman_component_t sa)
 {
     res->r = src->r * da;
     res->g = src->g * da;
@@ -774,8 +774,8 @@ blend_hsl_color (rgb_t *res,
  */
 static force_inline void
 blend_hsl_luminosity (rgb_t *res,
-		      rgb_t *dest, float da,
-		      rgb_t *src, float sa)
+		      rgb_t *dest, pixman_component_t da,
+		      rgb_t *src, pixman_component_t sa)
 {
     res->r = dest->r * sa;
     res->g = dest->g * sa;
@@ -788,16 +788,16 @@ blend_hsl_luminosity (rgb_t *res,
     static void								\
     combine_ ## name ## _u_float (pixman_implementation_t *imp,		\
 				  pixman_op_t              op,		\
-				  float                   *dest,	\
-				  const float             *src,		\
-				  const float             *mask,	\
+				  pixman_component_t                   *dest,	\
+				  const pixman_component_t             *src,		\
+				  const pixman_component_t             *mask,	\
 				  int		           n_pixels)	\
     {									\
     	int i;								\
 									\
 	for (i = 0; i < 4 * n_pixels; i += 4)				\
 	{								\
-	    float sa, da;						\
+	    pixman_component_t sa, da;						\
 	    rgb_t sc, dc, rc;						\
 									\
 	    sa = src[i + 0];						\
@@ -812,7 +812,7 @@ blend_hsl_luminosity (rgb_t *res,
 									\
 	    if (mask)							\
 	    {								\
-		float ma = mask[i + 0];					\
+		pixman_component_t ma = mask[i + 0];					\
 									\
 		/* Component alpha is not supported for HSL modes */	\
 		sa *= ma;						\
@@ -839,127 +839,127 @@ void
 _pixman_setup_combiner_functions_float (pixman_implementation_t *imp)
 {
     /* Unified alpha */
-    imp->combine_float[PIXMAN_OP_CLEAR] = combine_clear_u_float;
-    imp->combine_float[PIXMAN_OP_SRC] = combine_src_u_float;
-    imp->combine_float[PIXMAN_OP_DST] = combine_dst_u_float;
-    imp->combine_float[PIXMAN_OP_OVER] = combine_over_u_float;
-    imp->combine_float[PIXMAN_OP_OVER_REVERSE] = combine_over_reverse_u_float;
-    imp->combine_float[PIXMAN_OP_IN] = combine_in_u_float;
-    imp->combine_float[PIXMAN_OP_IN_REVERSE] = combine_in_reverse_u_float;
-    imp->combine_float[PIXMAN_OP_OUT] = combine_out_u_float;
-    imp->combine_float[PIXMAN_OP_OUT_REVERSE] = combine_out_reverse_u_float;
-    imp->combine_float[PIXMAN_OP_ATOP] = combine_atop_u_float;
-    imp->combine_float[PIXMAN_OP_ATOP_REVERSE] = combine_atop_reverse_u_float;
-    imp->combine_float[PIXMAN_OP_XOR] = combine_xor_u_float;
-    imp->combine_float[PIXMAN_OP_ADD] = combine_add_u_float;
-    imp->combine_float[PIXMAN_OP_SATURATE] = combine_saturate_u_float;
+    imp->combine[PIXMAN_OP_CLEAR] = combine_clear_u_float;
+    imp->combine[PIXMAN_OP_SRC] = combine_src_u_float;
+    imp->combine[PIXMAN_OP_DST] = combine_dst_u_float;
+    imp->combine[PIXMAN_OP_OVER] = combine_over_u_float;
+    imp->combine[PIXMAN_OP_OVER_REVERSE] = combine_over_reverse_u_float;
+    imp->combine[PIXMAN_OP_IN] = combine_in_u_float;
+    imp->combine[PIXMAN_OP_IN_REVERSE] = combine_in_reverse_u_float;
+    imp->combine[PIXMAN_OP_OUT] = combine_out_u_float;
+    imp->combine[PIXMAN_OP_OUT_REVERSE] = combine_out_reverse_u_float;
+    imp->combine[PIXMAN_OP_ATOP] = combine_atop_u_float;
+    imp->combine[PIXMAN_OP_ATOP_REVERSE] = combine_atop_reverse_u_float;
+    imp->combine[PIXMAN_OP_XOR] = combine_xor_u_float;
+    imp->combine[PIXMAN_OP_ADD] = combine_add_u_float;
+    imp->combine[PIXMAN_OP_SATURATE] = combine_saturate_u_float;
 
     /* Disjoint, unified */
-    imp->combine_float[PIXMAN_OP_DISJOINT_CLEAR] = combine_disjoint_clear_u_float;
-    imp->combine_float[PIXMAN_OP_DISJOINT_SRC] = combine_disjoint_src_u_float;
-    imp->combine_float[PIXMAN_OP_DISJOINT_DST] = combine_disjoint_dst_u_float;
-    imp->combine_float[PIXMAN_OP_DISJOINT_OVER] = combine_disjoint_over_u_float;
-    imp->combine_float[PIXMAN_OP_DISJOINT_OVER_REVERSE] = combine_disjoint_over_reverse_u_float;
-    imp->combine_float[PIXMAN_OP_DISJOINT_IN] = combine_disjoint_in_u_float;
-    imp->combine_float[PIXMAN_OP_DISJOINT_IN_REVERSE] = combine_disjoint_in_reverse_u_float;
-    imp->combine_float[PIXMAN_OP_DISJOINT_OUT] = combine_disjoint_out_u_float;
-    imp->combine_float[PIXMAN_OP_DISJOINT_OUT_REVERSE] = combine_disjoint_out_reverse_u_float;
-    imp->combine_float[PIXMAN_OP_DISJOINT_ATOP] = combine_disjoint_atop_u_float;
-    imp->combine_float[PIXMAN_OP_DISJOINT_ATOP_REVERSE] = combine_disjoint_atop_reverse_u_float;
-    imp->combine_float[PIXMAN_OP_DISJOINT_XOR] = combine_disjoint_xor_u_float;
+    imp->combine[PIXMAN_OP_DISJOINT_CLEAR] = combine_disjoint_clear_u_float;
+    imp->combine[PIXMAN_OP_DISJOINT_SRC] = combine_disjoint_src_u_float;
+    imp->combine[PIXMAN_OP_DISJOINT_DST] = combine_disjoint_dst_u_float;
+    imp->combine[PIXMAN_OP_DISJOINT_OVER] = combine_disjoint_over_u_float;
+    imp->combine[PIXMAN_OP_DISJOINT_OVER_REVERSE] = combine_disjoint_over_reverse_u_float;
+    imp->combine[PIXMAN_OP_DISJOINT_IN] = combine_disjoint_in_u_float;
+    imp->combine[PIXMAN_OP_DISJOINT_IN_REVERSE] = combine_disjoint_in_reverse_u_float;
+    imp->combine[PIXMAN_OP_DISJOINT_OUT] = combine_disjoint_out_u_float;
+    imp->combine[PIXMAN_OP_DISJOINT_OUT_REVERSE] = combine_disjoint_out_reverse_u_float;
+    imp->combine[PIXMAN_OP_DISJOINT_ATOP] = combine_disjoint_atop_u_float;
+    imp->combine[PIXMAN_OP_DISJOINT_ATOP_REVERSE] = combine_disjoint_atop_reverse_u_float;
+    imp->combine[PIXMAN_OP_DISJOINT_XOR] = combine_disjoint_xor_u_float;
 
     /* Conjoint, unified */
-    imp->combine_float[PIXMAN_OP_CONJOINT_CLEAR] = combine_conjoint_clear_u_float;
-    imp->combine_float[PIXMAN_OP_CONJOINT_SRC] = combine_conjoint_src_u_float;
-    imp->combine_float[PIXMAN_OP_CONJOINT_DST] = combine_conjoint_dst_u_float;
-    imp->combine_float[PIXMAN_OP_CONJOINT_OVER] = combine_conjoint_over_u_float;
-    imp->combine_float[PIXMAN_OP_CONJOINT_OVER_REVERSE] = combine_conjoint_over_reverse_u_float;
-    imp->combine_float[PIXMAN_OP_CONJOINT_IN] = combine_conjoint_in_u_float;
-    imp->combine_float[PIXMAN_OP_CONJOINT_IN_REVERSE] = combine_conjoint_in_reverse_u_float;
-    imp->combine_float[PIXMAN_OP_CONJOINT_OUT] = combine_conjoint_out_u_float;
-    imp->combine_float[PIXMAN_OP_CONJOINT_OUT_REVERSE] = combine_conjoint_out_reverse_u_float;
-    imp->combine_float[PIXMAN_OP_CONJOINT_ATOP] = combine_conjoint_atop_u_float;
-    imp->combine_float[PIXMAN_OP_CONJOINT_ATOP_REVERSE] = combine_conjoint_atop_reverse_u_float;
-    imp->combine_float[PIXMAN_OP_CONJOINT_XOR] = combine_conjoint_xor_u_float;
+    imp->combine[PIXMAN_OP_CONJOINT_CLEAR] = combine_conjoint_clear_u_float;
+    imp->combine[PIXMAN_OP_CONJOINT_SRC] = combine_conjoint_src_u_float;
+    imp->combine[PIXMAN_OP_CONJOINT_DST] = combine_conjoint_dst_u_float;
+    imp->combine[PIXMAN_OP_CONJOINT_OVER] = combine_conjoint_over_u_float;
+    imp->combine[PIXMAN_OP_CONJOINT_OVER_REVERSE] = combine_conjoint_over_reverse_u_float;
+    imp->combine[PIXMAN_OP_CONJOINT_IN] = combine_conjoint_in_u_float;
+    imp->combine[PIXMAN_OP_CONJOINT_IN_REVERSE] = combine_conjoint_in_reverse_u_float;
+    imp->combine[PIXMAN_OP_CONJOINT_OUT] = combine_conjoint_out_u_float;
+    imp->combine[PIXMAN_OP_CONJOINT_OUT_REVERSE] = combine_conjoint_out_reverse_u_float;
+    imp->combine[PIXMAN_OP_CONJOINT_ATOP] = combine_conjoint_atop_u_float;
+    imp->combine[PIXMAN_OP_CONJOINT_ATOP_REVERSE] = combine_conjoint_atop_reverse_u_float;
+    imp->combine[PIXMAN_OP_CONJOINT_XOR] = combine_conjoint_xor_u_float;
 
     /* PDF operators, unified */
-    imp->combine_float[PIXMAN_OP_MULTIPLY] = combine_multiply_u_float;
-    imp->combine_float[PIXMAN_OP_SCREEN] = combine_screen_u_float;
-    imp->combine_float[PIXMAN_OP_OVERLAY] = combine_overlay_u_float;
-    imp->combine_float[PIXMAN_OP_DARKEN] = combine_darken_u_float;
-    imp->combine_float[PIXMAN_OP_LIGHTEN] = combine_lighten_u_float;
-    imp->combine_float[PIXMAN_OP_COLOR_DODGE] = combine_color_dodge_u_float;
-    imp->combine_float[PIXMAN_OP_COLOR_BURN] = combine_color_burn_u_float;
-    imp->combine_float[PIXMAN_OP_HARD_LIGHT] = combine_hard_light_u_float;
-    imp->combine_float[PIXMAN_OP_SOFT_LIGHT] = combine_soft_light_u_float;
-    imp->combine_float[PIXMAN_OP_DIFFERENCE] = combine_difference_u_float;
-    imp->combine_float[PIXMAN_OP_EXCLUSION] = combine_exclusion_u_float;
-
-    imp->combine_float[PIXMAN_OP_HSL_HUE] = combine_hsl_hue_u_float;
-    imp->combine_float[PIXMAN_OP_HSL_SATURATION] = combine_hsl_saturation_u_float;
-    imp->combine_float[PIXMAN_OP_HSL_COLOR] = combine_hsl_color_u_float;
-    imp->combine_float[PIXMAN_OP_HSL_LUMINOSITY] = combine_hsl_luminosity_u_float;
+    imp->combine[PIXMAN_OP_MULTIPLY] = combine_multiply_u_float;
+    imp->combine[PIXMAN_OP_SCREEN] = combine_screen_u_float;
+    imp->combine[PIXMAN_OP_OVERLAY] = combine_overlay_u_float;
+    imp->combine[PIXMAN_OP_DARKEN] = combine_darken_u_float;
+    imp->combine[PIXMAN_OP_LIGHTEN] = combine_lighten_u_float;
+    imp->combine[PIXMAN_OP_COLOR_DODGE] = combine_color_dodge_u_float;
+    imp->combine[PIXMAN_OP_COLOR_BURN] = combine_color_burn_u_float;
+    imp->combine[PIXMAN_OP_HARD_LIGHT] = combine_hard_light_u_float;
+    imp->combine[PIXMAN_OP_SOFT_LIGHT] = combine_soft_light_u_float;
+    imp->combine[PIXMAN_OP_DIFFERENCE] = combine_difference_u_float;
+    imp->combine[PIXMAN_OP_EXCLUSION] = combine_exclusion_u_float;
+
+    imp->combine[PIXMAN_OP_HSL_HUE] = combine_hsl_hue_u_float;
+    imp->combine[PIXMAN_OP_HSL_SATURATION] = combine_hsl_saturation_u_float;
+    imp->combine[PIXMAN_OP_HSL_COLOR] = combine_hsl_color_u_float;
+    imp->combine[PIXMAN_OP_HSL_LUMINOSITY] = combine_hsl_luminosity_u_float;
 
     /* Component alpha combiners */
-    imp->combine_float_ca[PIXMAN_OP_CLEAR] = combine_clear_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_SRC] = combine_src_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_DST] = combine_dst_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_OVER] = combine_over_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_OVER_REVERSE] = combine_over_reverse_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_IN] = combine_in_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_IN_REVERSE] = combine_in_reverse_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_OUT] = combine_out_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_OUT_REVERSE] = combine_out_reverse_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_ATOP] = combine_atop_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_ATOP_REVERSE] = combine_atop_reverse_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_XOR] = combine_xor_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_ADD] = combine_add_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_SATURATE] = combine_saturate_ca_float;
+    imp->combine_ca[PIXMAN_OP_CLEAR] = combine_clear_ca_float;
+    imp->combine_ca[PIXMAN_OP_SRC] = combine_src_ca_float;
+    imp->combine_ca[PIXMAN_OP_DST] = combine_dst_ca_float;
+    imp->combine_ca[PIXMAN_OP_OVER] = combine_over_ca_float;
+    imp->combine_ca[PIXMAN_OP_OVER_REVERSE] = combine_over_reverse_ca_float;
+    imp->combine_ca[PIXMAN_OP_IN] = combine_in_ca_float;
+    imp->combine_ca[PIXMAN_OP_IN_REVERSE] = combine_in_reverse_ca_float;
+    imp->combine_ca[PIXMAN_OP_OUT] = combine_out_ca_float;
+    imp->combine_ca[PIXMAN_OP_OUT_REVERSE] = combine_out_reverse_ca_float;
+    imp->combine_ca[PIXMAN_OP_ATOP] = combine_atop_ca_float;
+    imp->combine_ca[PIXMAN_OP_ATOP_REVERSE] = combine_atop_reverse_ca_float;
+    imp->combine_ca[PIXMAN_OP_XOR] = combine_xor_ca_float;
+    imp->combine_ca[PIXMAN_OP_ADD] = combine_add_ca_float;
+    imp->combine_ca[PIXMAN_OP_SATURATE] = combine_saturate_ca_float;
 
     /* Disjoint CA */
-    imp->combine_float_ca[PIXMAN_OP_DISJOINT_CLEAR] = combine_disjoint_clear_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_DISJOINT_SRC] = combine_disjoint_src_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_DISJOINT_DST] = combine_disjoint_dst_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_DISJOINT_OVER] = combine_disjoint_over_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_DISJOINT_OVER_REVERSE] = combine_disjoint_over_reverse_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_DISJOINT_IN] = combine_disjoint_in_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_DISJOINT_IN_REVERSE] = combine_disjoint_in_reverse_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_DISJOINT_OUT] = combine_disjoint_out_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_DISJOINT_OUT_REVERSE] = combine_disjoint_out_reverse_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_DISJOINT_ATOP] = combine_disjoint_atop_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_DISJOINT_ATOP_REVERSE] = combine_disjoint_atop_reverse_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_DISJOINT_XOR] = combine_disjoint_xor_ca_float;
+    imp->combine_ca[PIXMAN_OP_DISJOINT_CLEAR] = combine_disjoint_clear_ca_float;
+    imp->combine_ca[PIXMAN_OP_DISJOINT_SRC] = combine_disjoint_src_ca_float;
+    imp->combine_ca[PIXMAN_OP_DISJOINT_DST] = combine_disjoint_dst_ca_float;
+    imp->combine_ca[PIXMAN_OP_DISJOINT_OVER] = combine_disjoint_over_ca_float;
+    imp->combine_ca[PIXMAN_OP_DISJOINT_OVER_REVERSE] = combine_disjoint_over_reverse_ca_float;
+    imp->combine_ca[PIXMAN_OP_DISJOINT_IN] = combine_disjoint_in_ca_float;
+    imp->combine_ca[PIXMAN_OP_DISJOINT_IN_REVERSE] = combine_disjoint_in_reverse_ca_float;
+    imp->combine_ca[PIXMAN_OP_DISJOINT_OUT] = combine_disjoint_out_ca_float;
+    imp->combine_ca[PIXMAN_OP_DISJOINT_OUT_REVERSE] = combine_disjoint_out_reverse_ca_float;
+    imp->combine_ca[PIXMAN_OP_DISJOINT_ATOP] = combine_disjoint_atop_ca_float;
+    imp->combine_ca[PIXMAN_OP_DISJOINT_ATOP_REVERSE] = combine_disjoint_atop_reverse_ca_float;
+    imp->combine_ca[PIXMAN_OP_DISJOINT_XOR] = combine_disjoint_xor_ca_float;
 
     /* Conjoint CA */
-    imp->combine_float_ca[PIXMAN_OP_CONJOINT_CLEAR] = combine_conjoint_clear_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_CONJOINT_SRC] = combine_conjoint_src_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_CONJOINT_DST] = combine_conjoint_dst_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_CONJOINT_OVER] = combine_conjoint_over_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_CONJOINT_OVER_REVERSE] = combine_conjoint_over_reverse_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_CONJOINT_IN] = combine_conjoint_in_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_CONJOINT_IN_REVERSE] = combine_conjoint_in_reverse_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_CONJOINT_OUT] = combine_conjoint_out_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_CONJOINT_OUT_REVERSE] = combine_conjoint_out_reverse_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_CONJOINT_ATOP] = combine_conjoint_atop_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_CONJOINT_ATOP_REVERSE] = combine_conjoint_atop_reverse_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_CONJOINT_XOR] = combine_conjoint_xor_ca_float;
+    imp->combine_ca[PIXMAN_OP_CONJOINT_CLEAR] = combine_conjoint_clear_ca_float;
+    imp->combine_ca[PIXMAN_OP_CONJOINT_SRC] = combine_conjoint_src_ca_float;
+    imp->combine_ca[PIXMAN_OP_CONJOINT_DST] = combine_conjoint_dst_ca_float;
+    imp->combine_ca[PIXMAN_OP_CONJOINT_OVER] = combine_conjoint_over_ca_float;
+    imp->combine_ca[PIXMAN_OP_CONJOINT_OVER_REVERSE] = combine_conjoint_over_reverse_ca_float;
+    imp->combine_ca[PIXMAN_OP_CONJOINT_IN] = combine_conjoint_in_ca_float;
+    imp->combine_ca[PIXMAN_OP_CONJOINT_IN_REVERSE] = combine_conjoint_in_reverse_ca_float;
+    imp->combine_ca[PIXMAN_OP_CONJOINT_OUT] = combine_conjoint_out_ca_float;
+    imp->combine_ca[PIXMAN_OP_CONJOINT_OUT_REVERSE] = combine_conjoint_out_reverse_ca_float;
+    imp->combine_ca[PIXMAN_OP_CONJOINT_ATOP] = combine_conjoint_atop_ca_float;
+    imp->combine_ca[PIXMAN_OP_CONJOINT_ATOP_REVERSE] = combine_conjoint_atop_reverse_ca_float;
+    imp->combine_ca[PIXMAN_OP_CONJOINT_XOR] = combine_conjoint_xor_ca_float;
 
     /* PDF operators CA */
-    imp->combine_float_ca[PIXMAN_OP_MULTIPLY] = combine_multiply_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_SCREEN] = combine_screen_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_OVERLAY] = combine_overlay_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_DARKEN] = combine_darken_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_LIGHTEN] = combine_lighten_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_COLOR_DODGE] = combine_color_dodge_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_COLOR_BURN] = combine_color_burn_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_HARD_LIGHT] = combine_hard_light_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_SOFT_LIGHT] = combine_soft_light_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_DIFFERENCE] = combine_difference_ca_float;
-    imp->combine_float_ca[PIXMAN_OP_EXCLUSION] = combine_exclusion_ca_float;
+    imp->combine_ca[PIXMAN_OP_MULTIPLY] = combine_multiply_ca_float;
+    imp->combine_ca[PIXMAN_OP_SCREEN] = combine_screen_ca_float;
+    imp->combine_ca[PIXMAN_OP_OVERLAY] = combine_overlay_ca_float;
+    imp->combine_ca[PIXMAN_OP_DARKEN] = combine_darken_ca_float;
+    imp->combine_ca[PIXMAN_OP_LIGHTEN] = combine_lighten_ca_float;
+    imp->combine_ca[PIXMAN_OP_COLOR_DODGE] = combine_color_dodge_ca_float;
+    imp->combine_ca[PIXMAN_OP_COLOR_BURN] = combine_color_burn_ca_float;
+    imp->combine_ca[PIXMAN_OP_HARD_LIGHT] = combine_hard_light_ca_float;
+    imp->combine_ca[PIXMAN_OP_SOFT_LIGHT] = combine_soft_light_ca_float;
+    imp->combine_ca[PIXMAN_OP_DIFFERENCE] = combine_difference_ca_float;
+    imp->combine_ca[PIXMAN_OP_EXCLUSION] = combine_exclusion_ca_float;
 
     /* It is not clear that these make sense, so leave them out for now */
-    imp->combine_float_ca[PIXMAN_OP_HSL_HUE] = NULL;
-    imp->combine_float_ca[PIXMAN_OP_HSL_SATURATION] = NULL;
-    imp->combine_float_ca[PIXMAN_OP_HSL_COLOR] = NULL;
-    imp->combine_float_ca[PIXMAN_OP_HSL_LUMINOSITY] = NULL;
+    imp->combine_ca[PIXMAN_OP_HSL_HUE] = NULL;
+    imp->combine_ca[PIXMAN_OP_HSL_SATURATION] = NULL;
+    imp->combine_ca[PIXMAN_OP_HSL_COLOR] = NULL;
+    imp->combine_ca[PIXMAN_OP_HSL_LUMINOSITY] = NULL;
 }
diff --git a/pixman/pixman-general.c b/pixman/pixman-general.c
index 0d51d88..1833e1b 100644
--- a/pixman/pixman-general.c
+++ b/pixman/pixman-general.c
@@ -57,11 +57,11 @@ general_composite_rect  (pixman_implementation_t *imp,
                          int32_t                  width,
                          int32_t                  height)
 {
-    float stack_scanline_buffer[SCANLINE_BUFFER_LENGTH * 3];
-    float *scanline_buffer = stack_scanline_buffer;
-    float *src_buffer, *mask_buffer, *dest_buffer;
+    pixman_component_t stack_scanline_buffer[SCANLINE_BUFFER_LENGTH * 3];
+    pixman_component_t *scanline_buffer = stack_scanline_buffer;
+    pixman_component_t *src_buffer, *mask_buffer, *dest_buffer;
     fetch_scanline_t fetch_src = NULL, fetch_mask = NULL, fetch_dest = NULL;
-    pixman_combine_float_func_t compose;
+    pixman_combine_func_t compose;
     store_scanline_t store;
     source_image_class_t src_class, mask_class;
     pixman_bool_t component_alpha;
@@ -78,7 +78,7 @@ general_composite_rect  (pixman_implementation_t *imp,
 
     if (width * 4 > SCANLINE_BUFFER_LENGTH)
     {
-      scanline_buffer = pixman_malloc_abc (width, 3, 4 * sizeof(float));
+      scanline_buffer = pixman_malloc_abc (width, 3, 4 * sizeof(pixman_component_t));
 
 	if (!scanline_buffer)
 	    return;
@@ -128,12 +128,12 @@ general_composite_rect  (pixman_implementation_t *imp,
 	store = _pixman_image_store_scanline_64;
 
     if (fetch_src)
-      fetch_src = _pixman_image_get_scanline_float;
+      fetch_src = _pixman_image_get_scanline;
     if (fetch_mask)
-      fetch_mask = _pixman_image_get_scanline_float;
-    fetch_dest = _pixman_image_get_scanline_float;
+      fetch_mask = _pixman_image_get_scanline;
+    fetch_dest = _pixman_image_get_scanline;
     if (store)
-      store = _pixman_image_store_scanline_float;
+      store = _pixman_image_store_scanline;
 
 #if 0
     /* Skip the store step and composite directly into the
@@ -200,9 +200,9 @@ general_composite_rect  (pixman_implementation_t *imp,
 #endif
 
     if (component_alpha)
-      compose = _pixman_implementation_combine_float_ca;
+      compose = _pixman_implementation_combine_ca;
     else
-      compose = _pixman_implementation_combine_float;
+      compose = _pixman_implementation_combine;
 
     if (!compose)
 	return;
diff --git a/pixman/pixman-image.c b/pixman/pixman-image.c
index 409df0a..58cec13 100644
--- a/pixman/pixman-image.c
+++ b/pixman/pixman-image.c
@@ -134,28 +134,28 @@ _pixman_image_classify (pixman_image_t *image,
 }
 
 void
-_pixman_image_get_scanline_float (pixman_image_t * image,
-				  int              x,
-				  int              y,
-				  int              width,
-				  uint32_t *       buffer,
-				  const uint32_t * mask)
-{
-    uint32_t *tmp = malloc (sizeof(float) * 4 * width);
+_pixman_image_get_scanline (pixman_image_t * image,
+			    int              x,
+			    int              y,
+			    int              width,
+			    uint32_t *       buffer,
+			    const uint32_t * mask)
+{
+    uint32_t *tmp = malloc (sizeof(pixman_component_t) * 4 * width);
     _pixman_image_get_scanline_64 (image, x, y, width, tmp, NULL);
-    pixman_expand_64_to_float ((argb_t *)buffer, (uint64_t *)tmp, width);
+    pixman_expand_64 ((argb_t *)buffer, (uint64_t *)tmp, width);
     free (tmp);
 }
 
 void
-_pixman_image_store_scanline_float (bits_image_t * image,
-				    int              x,
-				    int              y,
-				    int              width,
-				    const float *       buffer)
+_pixman_image_store_scanline (bits_image_t * image,
+			      int              x,
+			      int              y,
+			      int              width,
+			      const uint32_t *       buffer)
 {
     uint64_t *tmp = malloc (sizeof(uint64_t) * 4 * width);
-    pixman_contract_64_from_float (tmp, (argb_t *)buffer, width);
+    pixman_contract_64 (tmp, (argb_t *)buffer, width);
     _pixman_image_store_scanline_64 (image, x, y, width, (uint32_t *) tmp);
     free (tmp);
 }
diff --git a/pixman/pixman-implementation.c b/pixman/pixman-implementation.c
index 8d78cee..925a54d 100644
--- a/pixman/pixman-implementation.c
+++ b/pixman/pixman-implementation.c
@@ -149,25 +149,25 @@ _pixman_implementation_create (pixman_implementation_t *delegate,
 }
 
 void
-_pixman_implementation_combine_float (pixman_implementation_t * imp,
-                                   pixman_op_t               op,
-                                   float *                dest,
-                                   const float *          src,
-                                   const float *          mask,
-                                   int                       width)
+_pixman_implementation_combine (pixman_implementation_t * imp,
+				pixman_op_t               op,
+				pixman_component_t *                dest,
+				const pixman_component_t *          src,
+				const pixman_component_t *          mask,
+				int                       width)
 {
-    (*imp->combine_float[op]) (imp, op, dest, src, mask, width);
+    (*imp->combine[op]) (imp, op, dest, src, mask, width);
 }
 
 void
-_pixman_implementation_combine_float_ca (pixman_implementation_t * imp,
+_pixman_implementation_combine_ca (pixman_implementation_t * imp,
                                    pixman_op_t               op,
-                                   float *                dest,
-                                   const float *          src,
-                                   const float *          mask,
+                                   pixman_component_t *                dest,
+                                   const pixman_component_t *          src,
+                                   const pixman_component_t *          mask,
                                    int                       width)
 {
-    (*imp->combine_float_ca[op]) (imp, op, dest, src, mask, width);
+    (*imp->combine_ca[op]) (imp, op, dest, src, mask, width);
 }
 
 void
diff --git a/pixman/pixman-private.h b/pixman/pixman-private.h
index e1ca402..3b4e5f8 100644
--- a/pixman/pixman-private.h
+++ b/pixman/pixman-private.h
@@ -34,12 +34,14 @@ typedef struct circle circle_t;
 
 typedef struct argb_t argb_t;
 
+typedef float pixman_component_t;
+
 struct argb_t
 {
-    float a;
-    float r;
-    float g;
-    float b;
+    pixman_component_t a;
+    pixman_component_t r;
+    pixman_component_t g;
+    pixman_component_t b;
 };
 
 typedef void (*fetch_scanline_t) (pixman_image_t *image,
@@ -57,9 +59,10 @@ typedef uint64_t (*fetch_pixel_64_t) (bits_image_t *image,
 				      int           x,
 				      int           y);
 
-typedef argb_t (*fetch_pixel_float_t) (bits_image_t *image,
-				       int           x,
-				       int           y);
+typedef void (*fetch_pixel_t) (bits_image_t *image,
+			       int           x,
+			       int           y,
+			       pixman_component_t *buffer);
 
 typedef void (*store_scanline_t) (bits_image_t *  image,
 				  int             x,
@@ -115,7 +118,7 @@ struct image_common
     property_changed_func_t     property_changed;
     fetch_scanline_t            get_scanline_32;
     fetch_scanline_t            get_scanline_64;
-    fetch_scanline_t		get_scanline_float;
+    fetch_scanline_t		get_scanline;
 
     pixman_image_destroy_func_t destroy_func;
     void *                      destroy_data;
@@ -193,9 +196,9 @@ struct bits_image
     fetch_pixel_64_t	       fetch_pixel_64;
     store_scanline_t           store_scanline_64;
 
-    fetch_scanline_t	       fetch_scanline_float;
-    fetch_pixel_float_t	       fetch_pixel_float;
-    store_scanline_t           store_scanline_float;
+    fetch_scanline_t	       fetch_scanline;
+    fetch_pixel_t	       fetch_pixel;
+    store_scanline_t           store_scanline;
 
     /* Used for indirect access to the bits */
     pixman_read_memory_func_t  read_func;
@@ -233,12 +236,12 @@ _pixman_image_classify (pixman_image_t *image,
                         int             height);
 
 void
-_pixman_image_get_scanline_float (pixman_image_t *image,
-				  int             x,
-				  int             y,
-				  int             width,
-				  uint32_t *      buffer,
-				  const uint32_t *mask);
+_pixman_image_get_scanline (pixman_image_t *image,
+			    int             x,
+			    int             y,
+			    int             width,
+			    uint32_t *      buffer,
+			    const uint32_t *mask);
 
 void
 _pixman_image_get_scanline_32 (pixman_image_t *image,
@@ -276,12 +279,15 @@ _pixman_image_store_scanline_64 (bits_image_t *  image,
                                  int             width,
                                  const uint32_t *buffer);
 
+/* Even though the type of buffer is uint32_t *, the function
+ * actually expects a pixman_component_t *buffer.
+ */
 void
-_pixman_image_store_scanline_float (bits_image_t *  image,
-				    int             x,
-				    int             y,
-				    int             width,
-				    const float *buffer);
+_pixman_image_store_scanline (bits_image_t *  image,
+			      int             x,
+			      int             y,
+			      int             width,
+			      const uint32_t *buffer);
 
 
 pixman_image_t *
@@ -398,12 +404,12 @@ typedef void (*pixman_combine_64_func_t) (pixman_implementation_t *imp,
 					  const uint64_t *         mask,
 					  int                      width);
 
-typedef void (*pixman_combine_float_func_t) (pixman_implementation_t *imp,
-					     pixman_op_t	      op,
-					     float *		      dest,
-					     const float *	      src,
-					     const float *	      mask,
-					     int		      n_pixels);
+typedef void (*pixman_combine_func_t) (pixman_implementation_t * imp,
+				       pixman_op_t	         op,
+				       pixman_component_t *      dest,
+				       const pixman_component_t *src,
+				       const pixman_component_t *mask,
+				       int		      n_pixels);
 
 typedef void (*pixman_composite_func_t) (pixman_implementation_t *imp,
 					 pixman_op_t              op,
@@ -470,8 +476,8 @@ struct pixman_implementation_t
     pixman_combine_32_func_t	combine_32_ca[PIXMAN_N_OPERATORS];
     pixman_combine_64_func_t	combine_64[PIXMAN_N_OPERATORS];
     pixman_combine_64_func_t	combine_64_ca[PIXMAN_N_OPERATORS];
-    pixman_combine_float_func_t	combine_float[PIXMAN_N_OPERATORS];
-    pixman_combine_float_func_t	combine_float_ca[PIXMAN_N_OPERATORS];
+    pixman_combine_func_t	combine[PIXMAN_N_OPERATORS];
+    pixman_combine_func_t	combine_ca[PIXMAN_N_OPERATORS];
 };
 
 pixman_implementation_t *
@@ -479,19 +485,19 @@ _pixman_implementation_create (pixman_implementation_t *delegate,
 			       const pixman_fast_path_t *fast_paths);
 
 void
-_pixman_implementation_combine_float (pixman_implementation_t *imp,
-                                   pixman_op_t              op,
-                                   float *               dest,
-                                   const float *         src,
-                                   const float *         mask,
-                                   int                      width);
+_pixman_implementation_combine (pixman_implementation_t * imp,
+				pixman_op_t               op,
+				pixman_component_t *      dest,
+				const pixman_component_t *src,
+				const pixman_component_t *mask,
+				int                       width);
 void
-_pixman_implementation_combine_float_ca (pixman_implementation_t *imp,
-                                   pixman_op_t              op,
-                                   float *               dest,
-                                   const float *         src,
-                                   const float *         mask,
-                                   int                      width);
+_pixman_implementation_combine_ca (pixman_implementation_t * imp,
+                                   pixman_op_t               op,
+                                   pixman_component_t *      dest,
+                                   const pixman_component_t *src,
+                                   const pixman_component_t *mask,
+                                   int                       width);
 void
 _pixman_implementation_combine_32 (pixman_implementation_t *imp,
                                    pixman_op_t              op,
@@ -713,9 +719,9 @@ pixman_expand_to_float (argb_t               *dst,
 			int                   width);
 
 void
-pixman_expand_64_to_float (argb_t               *dst,
-			   const uint64_t       *src,
-			   int                   width);
+pixman_expand_64 (argb_t               *dst,
+		  const uint64_t       *src,
+		  int                   width);
 
 void
 pixman_contract (uint32_t *      dst,
@@ -728,9 +734,9 @@ pixman_contract_from_float (uint32_t     *dst,
 			    int           width);
 
 void
-pixman_contract_64_from_float (uint64_t     *dst,
-			       const argb_t *src,
-			       int           width);
+pixman_contract_64 (uint64_t     *dst,
+		    const argb_t *src,
+		    int           width);
 
 /* Region Helpers */
 pixman_bool_t
diff --git a/pixman/pixman-utils.c b/pixman/pixman-utils.c
index 9e11ab7..fd30c69 100644
--- a/pixman/pixman-utils.c
+++ b/pixman/pixman-utils.c
@@ -120,7 +120,7 @@ pixman_expand (uint64_t *           dst,
 }
 
 static force_inline uint16_t
-float_to_unorm (float f, int n_bits)
+float_to_unorm (pixman_component_t f, int n_bits)
 {
     uint32_t u;
 
@@ -136,12 +136,12 @@ float_to_unorm (float f, int n_bits)
 }
 
 
-static force_inline float
+static force_inline pixman_component_t
 unorm_to_float (uint16_t u, int n_bits)
 {
     uint16_t m = ((1 << n_bits) - 1);
 
-    return (u & m) * (1 / (float)m);
+    return (u & m) * (1 / (pixman_component_t) m);
 }
 
 void
@@ -176,9 +176,9 @@ pixman_expand_to_float (argb_t               *dst,
 }
 
 void
-pixman_expand_64_to_float (argb_t               *dst,
-			   const uint64_t       *src,
-			   int                   width)
+pixman_expand_64 (argb_t               *dst,
+		  const uint64_t       *src,
+		  int                   width)
 {
     const int a_size = 16,
       r_size = 16,
@@ -236,9 +236,9 @@ pixman_contract_from_float (uint32_t     *dst,
 }
 
 void
-pixman_contract_64_from_float (uint64_t     *dst,
-			       const argb_t *src,
-			       int           width)
+pixman_contract_64 (uint64_t     *dst,
+		    const argb_t *src,
+		    int           width)
 {
     int i;