typedef int pixman_bool_t;
typedef enum
{
    PIXMAN_OP_CLEAR = 0x00,
    PIXMAN_OP_SRC = 0x01,
    PIXMAN_OP_DST = 0x02,
    PIXMAN_OP_OVER = 0x03,
    PIXMAN_OP_OVER_REVERSE = 0x04,
    PIXMAN_OP_IN = 0x05,
    PIXMAN_OP_IN_REVERSE = 0x06,
    PIXMAN_OP_OUT = 0x07,
    PIXMAN_OP_OUT_REVERSE = 0x08,
    PIXMAN_OP_ATOP = 0x09,
    PIXMAN_OP_ATOP_REVERSE = 0x0a,
    PIXMAN_OP_XOR = 0x0b,
    PIXMAN_OP_ADD = 0x0c,
    PIXMAN_OP_SATURATE = 0x0d,
    PIXMAN_OP_DISJOINT_CLEAR = 0x10,
    PIXMAN_OP_DISJOINT_SRC = 0x11,
    PIXMAN_OP_DISJOINT_DST = 0x12,
    PIXMAN_OP_DISJOINT_OVER = 0x13,
    PIXMAN_OP_DISJOINT_OVER_REVERSE = 0x14,
    PIXMAN_OP_DISJOINT_IN = 0x15,
    PIXMAN_OP_DISJOINT_IN_REVERSE = 0x16,
    PIXMAN_OP_DISJOINT_OUT = 0x17,
    PIXMAN_OP_DISJOINT_OUT_REVERSE = 0x18,
    PIXMAN_OP_DISJOINT_ATOP = 0x19,
    PIXMAN_OP_DISJOINT_ATOP_REVERSE = 0x1a,
    PIXMAN_OP_DISJOINT_XOR = 0x1b,
    PIXMAN_OP_CONJOINT_CLEAR = 0x20,
    PIXMAN_OP_CONJOINT_SRC = 0x21,
    PIXMAN_OP_CONJOINT_DST = 0x22,
    PIXMAN_OP_CONJOINT_OVER = 0x23,
    PIXMAN_OP_CONJOINT_OVER_REVERSE = 0x24,
    PIXMAN_OP_CONJOINT_IN = 0x25,
    PIXMAN_OP_CONJOINT_IN_REVERSE = 0x26,
    PIXMAN_OP_CONJOINT_OUT = 0x27,
    PIXMAN_OP_CONJOINT_ATOP_REVERSE = 0x2a,
    PIXMAN_OP_CONJOINT_XOR = 0x2b,
    PIXMAN_OP_MULTIPLY = 0x30,
    PIXMAN_OP_SCREEN = 0x31,
    PIXMAN_OP_OVERLAY = 0x32,
    PIXMAN_OP_DARKEN = 0x33,
    PIXMAN_OP_LIGHTEN = 0x34,
    PIXMAN_OP_COLOR_DODGE = 0x35,
    PIXMAN_OP_COLOR_BURN = 0x36,
    PIXMAN_OP_HARD_LIGHT = 0x37,
    PIXMAN_OP_SOFT_LIGHT = 0x38,
    PIXMAN_OP_DIFFERENCE = 0x39,
    PIXMAN_OP_EXCLUSION = 0x3a,
    PIXMAN_N_OPERATORS,
} pixman_op_t;
typedef struct pixman_iter_t pixman_iter_t;
typedef struct pixman_implementation_t pixman_implementation_t;
typedef void (*pixman_combine_float_func_t) (pixman_implementation_t *imp,
        pixman_iter_t *iter);
struct pixman_implementation_t
{
    pixman_combine_float_func_t combine_float[PIXMAN_N_OPERATORS];
    pixman_combine_float_func_t combine_float_ca[PIXMAN_N_OPERATORS];
};
typedef float (* combine_channel_t) (float sa, float s, float da, float d);
static __inline__ __attribute__ ((__always_inline__)) void
combine_inner (pixman_bool_t component,
        float *dest, const float *src, const float *mask, int n_pixels,
        combine_channel_t combine_a, combine_channel_t combine_c)
{
    int i;
    if (!mask)
    {
 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];
     float da = dest[i + 0];
     float dr = dest[i + 1];
     float dg = dest[i + 2];
     float db = dest[i + 3];
     dest[i + 0] = combine_a (sa, sa, da, da);
     dest[i + 1] = combine_c (sa, sr, da, dr);
     dest[i + 2] = combine_c (sa, sg, da, dg);
     dest[i + 3] = combine_c (sa, sb, da, db);
 }
 for (i = 0; i < 4 * n_pixels; i += 4)
 {
     float sa, sr, sg, sb;
     float ma, mr, mg, mb;
     float da, dr, dg, db;
     sa = src[i + 0];
     sr = src[i + 1];
     sg = src[i + 2];
     {
  ma = mask[i + 0];
     }
     da = dest[i + 0];
     dr = dest[i + 1];
     dg = dest[i + 2];
     db = dest[i + 3];
     dest[i + 0] = combine_a (ma, sa, da, da);
     dest[i + 1] = combine_c (mr, sr, da, dr);
     dest[i + 2] = combine_c (mg, sg, da, dg);
     dest[i + 3] = combine_c (mb, sb, da, db);
 }
    }
}
typedef enum
{
    ZERO,
    ONE,
    SRC_ALPHA,
    DEST_ALPHA,
    INV_SA,
    INV_DA,
    SA_OVER_DA,
    DA_OVER_SA,
    INV_SA_OVER_DA,
    INV_DA_OVER_SA,
    ONE_MINUS_SA_OVER_DA,
    ONE_MINUS_DA_OVER_SA,
    ONE_MINUS_INV_DA_OVER_SA,
    ONE_MINUS_INV_SA_OVER_DA
} combine_factor_t;
static __inline__ __attribute__ ((__always_inline__)) float
get_factor (combine_factor_t factor, float sa, float da)
{
    float f = -1;
    switch (factor)
    {
    case ZERO:
    case INV_DA_OVER_SA:
	if (sa == 0.0f)
	    f = 1.0f;
    case ONE_MINUS_DA_OVER_SA:
    case ONE_MINUS_INV_DA_OVER_SA:
 if (sa == 0.0f)
     f = (((1.0f - (1.0f - da) / sa) < 0)? 0 : (((1.0f - (1.0f - da) / sa) > 1.0) ? 1.0 : (1.0f - (1.0f - da) / sa)));
    }
    return f;
}
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_clear (float sa, float s, float da, float d) { const float fa = get_factor (ZERO, sa, da); const float fb = get_factor (ZERO, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_clear_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_clear, pd_combine_clear); } static void combine_clear_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_clear, pd_combine_clear); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_src (float sa, float s, float da, float d) { const float fa = get_factor (ONE, sa, da); const float fb = get_factor (ZERO, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_src_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_src, pd_combine_src); } static void combine_src_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_src, pd_combine_src); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_dst (float sa, float s, float da, float d) { const float fa = get_factor (ZERO, sa, da); const float fb = get_factor (ONE, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_dst_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_dst, pd_combine_dst); } static void combine_dst_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_dst, pd_combine_dst); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_over (float sa, float s, float da, float d) { const float fa = get_factor (ONE, sa, da); const float fb = get_factor (INV_SA, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_over_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_over, pd_combine_over); } static void combine_over_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_over, pd_combine_over); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_over_reverse (float sa, float s, float da, float d) { const float fa = get_factor (INV_DA, sa, da); const float fb = get_factor (ONE, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_over_reverse_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_over_reverse, pd_combine_over_reverse); } static void combine_over_reverse_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_over_reverse, pd_combine_over_reverse); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_in (float sa, float s, float da, float d) { const float fa = get_factor (DEST_ALPHA, sa, da); const float fb = get_factor (ZERO, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_in_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_in, pd_combine_in); } static void combine_in_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_in, pd_combine_in); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_in_reverse (float sa, float s, float da, float d) { const float fa = get_factor (ZERO, sa, da); const float fb = get_factor (SRC_ALPHA, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_in_reverse_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_in_reverse, pd_combine_in_reverse); } static void combine_in_reverse_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_in_reverse, pd_combine_in_reverse); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_out (float sa, float s, float da, float d) { const float fa = get_factor (INV_DA, sa, da); const float fb = get_factor (ZERO, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_out_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_out, pd_combine_out); } static void combine_out_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_out, pd_combine_out); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_out_reverse (float sa, float s, float da, float d) { const float fa = get_factor (ZERO, sa, da); const float fb = get_factor (INV_SA, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_out_reverse_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_out_reverse, pd_combine_out_reverse); } static void combine_out_reverse_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_out_reverse, pd_combine_out_reverse); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_atop (float sa, float s, float da, float d) { const float fa = get_factor (DEST_ALPHA, sa, da); const float fb = get_factor (INV_SA, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_atop_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_atop, pd_combine_atop); } static void combine_atop_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_atop, pd_combine_atop); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_atop_reverse (float sa, float s, float da, float d) { const float fa = get_factor (INV_DA, sa, da); const float fb = get_factor (SRC_ALPHA, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_atop_reverse_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_atop_reverse, pd_combine_atop_reverse); } static void combine_atop_reverse_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_atop_reverse, pd_combine_atop_reverse); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_xor (float sa, float s, float da, float d) { const float fa = get_factor (INV_DA, sa, da); const float fb = get_factor (INV_SA, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_xor_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_xor, pd_combine_xor); } static void combine_xor_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_xor, pd_combine_xor); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_add (float sa, float s, float da, float d) { const float fa = get_factor (ONE, sa, da); const float fb = get_factor (ONE, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_add_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_add, pd_combine_add); } static void combine_add_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_add, pd_combine_add); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_saturate (float sa, float s, float da, float d) { const float fa = get_factor (INV_DA_OVER_SA, sa, da); const float fb = get_factor (ONE, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_saturate_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_saturate, pd_combine_saturate); } static void combine_saturate_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_saturate, pd_combine_saturate); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_disjoint_clear (float sa, float s, float da, float d) { const float fa = get_factor (ZERO, sa, da); const float fb = get_factor (ZERO, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_disjoint_clear_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_disjoint_clear, pd_combine_disjoint_clear); } static void combine_disjoint_clear_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_disjoint_clear, pd_combine_disjoint_clear); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_disjoint_src (float sa, float s, float da, float d) { const float fa = get_factor (ONE, sa, da); const float fb = get_factor (ZERO, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_disjoint_src_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_disjoint_src, pd_combine_disjoint_src); } static void combine_disjoint_src_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_disjoint_src, pd_combine_disjoint_src); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_disjoint_dst (float sa, float s, float da, float d) { const float fa = get_factor (ZERO, sa, da); const float fb = get_factor (ONE, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_disjoint_dst_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_disjoint_dst, pd_combine_disjoint_dst); } static void combine_disjoint_dst_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_disjoint_dst, pd_combine_disjoint_dst); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_disjoint_over (float sa, float s, float da, float d) { const float fa = get_factor (ONE, sa, da); const float fb = get_factor (INV_SA_OVER_DA, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_disjoint_over_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_disjoint_over, pd_combine_disjoint_over); } static void combine_disjoint_over_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_disjoint_over, pd_combine_disjoint_over); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_disjoint_over_reverse (float sa, float s, float da, float d) { const float fa = get_factor (INV_DA_OVER_SA, sa, da); const float fb = get_factor (ONE, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_disjoint_over_reverse_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_disjoint_over_reverse, pd_combine_disjoint_over_reverse); } static void combine_disjoint_over_reverse_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_disjoint_over_reverse, pd_combine_disjoint_over_reverse); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_disjoint_in (float sa, float s, float da, float d) { const float fa = get_factor (ONE_MINUS_INV_DA_OVER_SA, sa, da); const float fb = get_factor (ZERO, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_disjoint_in_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_disjoint_in, pd_combine_disjoint_in); } static void combine_disjoint_in_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_disjoint_in, pd_combine_disjoint_in); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_disjoint_in_reverse (float sa, float s, float da, float d) { const float fa = get_factor (ZERO, sa, da); const float fb = get_factor (ONE_MINUS_INV_SA_OVER_DA, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_disjoint_in_reverse_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_disjoint_in_reverse, pd_combine_disjoint_in_reverse); } static void combine_disjoint_in_reverse_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_disjoint_in_reverse, pd_combine_disjoint_in_reverse); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_disjoint_out (float sa, float s, float da, float d) { const float fa = get_factor (INV_DA_OVER_SA, sa, da); const float fb = get_factor (ZERO, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_disjoint_out_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_disjoint_out, pd_combine_disjoint_out); } static void combine_disjoint_out_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_disjoint_out, pd_combine_disjoint_out); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_disjoint_out_reverse (float sa, float s, float da, float d) { const float fa = get_factor (ZERO, sa, da); const float fb = get_factor (INV_SA_OVER_DA, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_disjoint_out_reverse_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_disjoint_out_reverse, pd_combine_disjoint_out_reverse); } static void combine_disjoint_out_reverse_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_disjoint_out_reverse, pd_combine_disjoint_out_reverse); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_disjoint_atop (float sa, float s, float da, float d) { const float fa = get_factor (ONE_MINUS_INV_DA_OVER_SA, sa, da); const float fb = get_factor (INV_SA_OVER_DA, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_disjoint_atop_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_disjoint_atop, pd_combine_disjoint_atop); } static void combine_disjoint_atop_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_disjoint_atop, pd_combine_disjoint_atop); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_disjoint_atop_reverse (float sa, float s, float da, float d) { const float fa = get_factor (INV_DA_OVER_SA, sa, da); const float fb = get_factor (ONE_MINUS_INV_SA_OVER_DA, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_disjoint_atop_reverse_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_disjoint_atop_reverse, pd_combine_disjoint_atop_reverse); } static void combine_disjoint_atop_reverse_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_disjoint_atop_reverse, pd_combine_disjoint_atop_reverse); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_disjoint_xor (float sa, float s, float da, float d) { const float fa = get_factor (INV_DA_OVER_SA, sa, da); const float fb = get_factor (INV_SA_OVER_DA, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_disjoint_xor_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_disjoint_xor, pd_combine_disjoint_xor); } static void combine_disjoint_xor_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_disjoint_xor, pd_combine_disjoint_xor); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_conjoint_clear (float sa, float s, float da, float d) { const float fa = get_factor (ZERO, sa, da); const float fb = get_factor (ZERO, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_conjoint_clear_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_conjoint_clear, pd_combine_conjoint_clear); } static void combine_conjoint_clear_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_conjoint_clear, pd_combine_conjoint_clear); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_conjoint_src (float sa, float s, float da, float d) { const float fa = get_factor (ONE, sa, da); const float fb = get_factor (ZERO, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_conjoint_src_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_conjoint_src, pd_combine_conjoint_src); } static void combine_conjoint_src_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_conjoint_src, pd_combine_conjoint_src); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_conjoint_dst (float sa, float s, float da, float d) { const float fa = get_factor (ZERO, sa, da); const float fb = get_factor (ONE, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_conjoint_dst_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_conjoint_dst, pd_combine_conjoint_dst); } static void combine_conjoint_dst_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_conjoint_dst, pd_combine_conjoint_dst); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_conjoint_over (float sa, float s, float da, float d) { const float fa = get_factor (ONE, sa, da); const float fb = get_factor (ONE_MINUS_SA_OVER_DA, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_conjoint_over_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_conjoint_over, pd_combine_conjoint_over); } static void combine_conjoint_over_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_conjoint_over, pd_combine_conjoint_over); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_conjoint_over_reverse (float sa, float s, float da, float d) { const float fa = get_factor (ONE_MINUS_DA_OVER_SA, sa, da); const float fb = get_factor (ONE, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_conjoint_over_reverse_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_conjoint_over_reverse, pd_combine_conjoint_over_reverse); } static void combine_conjoint_over_reverse_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_conjoint_over_reverse, pd_combine_conjoint_over_reverse); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_conjoint_in (float sa, float s, float da, float d) { const float fa = get_factor (DA_OVER_SA, sa, da); const float fb = get_factor (ZERO, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_conjoint_in_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_conjoint_in, pd_combine_conjoint_in); } static void combine_conjoint_in_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_conjoint_in, pd_combine_conjoint_in); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_conjoint_in_reverse (float sa, float s, float da, float d) { const float fa = get_factor (ZERO, sa, da); const float fb = get_factor (SA_OVER_DA, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_conjoint_in_reverse_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_conjoint_in_reverse, pd_combine_conjoint_in_reverse); } static void combine_conjoint_in_reverse_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_conjoint_in_reverse, pd_combine_conjoint_in_reverse); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_conjoint_out (float sa, float s, float da, float d) { const float fa = get_factor (ONE_MINUS_DA_OVER_SA, sa, da); const float fb = get_factor (ZERO, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_conjoint_out_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_conjoint_out, pd_combine_conjoint_out); } static void combine_conjoint_out_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_conjoint_out, pd_combine_conjoint_out); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_conjoint_atop_reverse (float sa, float s, float da, float d) { const float fa = get_factor (ONE_MINUS_DA_OVER_SA, sa, da); const float fb = get_factor (SA_OVER_DA, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_conjoint_atop_reverse_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_conjoint_atop_reverse, pd_combine_conjoint_atop_reverse); } static void combine_conjoint_atop_reverse_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_conjoint_atop_reverse, pd_combine_conjoint_atop_reverse); }
static float __inline__ __attribute__ ((__always_inline__)) pd_combine_conjoint_xor (float sa, float s, float da, float d) { const float fa = get_factor (ONE_MINUS_DA_OVER_SA, sa, da); const float fb = get_factor (ONE_MINUS_SA_OVER_DA, sa, da); return ((1.0f < s * fa + d * fb) ? 1.0f : s * fa + d * fb); } static void combine_conjoint_xor_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, pd_combine_conjoint_xor, pd_combine_conjoint_xor); } static void combine_conjoint_xor_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, pd_combine_conjoint_xor, pd_combine_conjoint_xor); }
float blend_soft_light (float sa, float s, float da, float d)
{
    return 0;
}
static __inline__ __attribute__ ((__always_inline__)) float combine_multiply_a (float sa, float s, float da, float d) { return da + sa - da * sa; }
static __inline__ __attribute__ ((__always_inline__)) float combine_multiply_c (float sa, float s, float da, float d) { float f = (1 - sa) * d + (1 - da) * s; return f + blend_multiply (sa, s, da, d); }
static void combine_multiply_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, combine_multiply_a, combine_multiply_c); } static void combine_multiply_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, combine_multiply_a, combine_multiply_c); }
static __inline__ __attribute__ ((__always_inline__)) float combine_screen_a (float sa, float s, float da, float d) { return da + sa - da * sa; }
static __inline__ __attribute__ ((__always_inline__)) float combine_screen_c (float sa, float s, float da, float d) { float f = (1 - sa) * d + (1 - da) * s; return f + blend_screen (sa, s, da, d); } static void combine_screen_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, combine_screen_a, combine_screen_c); } static void combine_screen_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, combine_screen_a, combine_screen_c); }
static __inline__ __attribute__ ((__always_inline__)) float combine_overlay_a (float sa, float s, float da, float d) { return da + sa - da * sa; }
static __inline__ __attribute__ ((__always_inline__)) float combine_overlay_c (float sa, float s, float da, float d) { float f = (1 - sa) * d + (1 - da) * s; return f + blend_overlay (sa, s, da, d); } static void combine_overlay_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, combine_overlay_a, combine_overlay_c); } static void combine_overlay_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, combine_overlay_a, combine_overlay_c); }
static __inline__ __attribute__ ((__always_inline__)) float combine_darken_a (float sa, float s, float da, float d) { return da + sa - da * sa; }
static __inline__ __attribute__ ((__always_inline__)) float combine_darken_c (float sa, float s, float da, float d) { float f = (1 - sa) * d + (1 - da) * s; return f + blend_darken (sa, s, da, d); } static void combine_darken_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, combine_darken_a, combine_darken_c); } static void combine_darken_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, combine_darken_a, combine_darken_c); }
static __inline__ __attribute__ ((__always_inline__)) float combine_lighten_a (float sa, float s, float da, float d) { return da + sa - da * sa; }
static __inline__ __attribute__ ((__always_inline__)) float combine_lighten_c (float sa, float s, float da, float d) { float f = (1 - sa) * d + (1 - da) * s; return f + blend_lighten (sa, s, da, d); } static void combine_lighten_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, combine_lighten_a, combine_lighten_c); } static void combine_lighten_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, combine_lighten_a, combine_lighten_c); }
static __inline__ __attribute__ ((__always_inline__)) float combine_color_dodge_a (float sa, float s, float da, float d) { return da + sa - da * sa; }
static __inline__ __attribute__ ((__always_inline__)) float combine_color_dodge_c (float sa, float s, float da, float d) { float f = (1 - sa) * d + (1 - da) * s; return f + blend_color_dodge (sa, s, da, d); } static void combine_color_dodge_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, combine_color_dodge_a, combine_color_dodge_c); } static void combine_color_dodge_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, combine_color_dodge_a, combine_color_dodge_c); }
static __inline__ __attribute__ ((__always_inline__)) float combine_color_burn_a (float sa, float s, float da, float d) { return da + sa - da * sa; }
static __inline__ __attribute__ ((__always_inline__)) float combine_color_burn_c (float sa, float s, float da, float d) { float f = (1 - sa) * d + (1 - da) * s; return f + blend_color_burn (sa, s, da, d); } static void combine_color_burn_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, combine_color_burn_a, combine_color_burn_c); } static void combine_color_burn_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, combine_color_burn_a, combine_color_burn_c); }
static __inline__ __attribute__ ((__always_inline__)) float combine_hard_light_a (float sa, float s, float da, float d) { return da + sa - da * sa; }
static __inline__ __attribute__ ((__always_inline__)) float combine_hard_light_c (float sa, float s, float da, float d) { float f = (1 - sa) * d + (1 - da) * s; return f + blend_hard_light (sa, s, da, d); } static void combine_hard_light_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, combine_hard_light_a, combine_hard_light_c); } static void combine_hard_light_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, combine_hard_light_a, combine_hard_light_c); }
static __inline__ __attribute__ ((__always_inline__)) float combine_soft_light_a (float sa, float s, float da, float d) { return da + sa - da * sa; }
static __inline__ __attribute__ ((__always_inline__)) float combine_soft_light_c (float sa, float s, float da, float d) { float f = (1 - sa) * d + (1 - da) * s; return f + blend_soft_light (sa, s, da, d); } static void combine_soft_light_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, combine_soft_light_a, combine_soft_light_c); } static void combine_soft_light_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, combine_soft_light_a, combine_soft_light_c); }
static __inline__ __attribute__ ((__always_inline__)) float combine_difference_a (float sa, float s, float da, float d) { return da + sa - da * sa; }
static __inline__ __attribute__ ((__always_inline__)) float combine_difference_c (float sa, float s, float da, float d) { float f = (1 - sa) * d + (1 - da) * s; return f + blend_difference (sa, s, da, d); } static void combine_difference_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, combine_difference_a, combine_difference_c); } static void combine_difference_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, combine_difference_a, combine_difference_c); }
static __inline__ __attribute__ ((__always_inline__)) float combine_exclusion_a (float sa, float s, float da, float d) { return da + sa - da * sa; }
static __inline__ __attribute__ ((__always_inline__)) float combine_exclusion_c (float sa, float s, float da, float d) { float f = (1 - sa) * d + (1 - da) * s; return f + blend_exclusion (sa, s, da, d); } static void combine_exclusion_ca_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (1, dest, src, mask, n_pixels, combine_exclusion_a, combine_exclusion_c); } static void combine_exclusion_u_float (pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels) { combine_inner (0, dest, src, mask, n_pixels, combine_exclusion_a, combine_exclusion_c); }
void _pixman_setup_combiner_functions_float (pixman_implementation_t *imp)
{
    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_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_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_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_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;
}