Attachment 68094 Details for Bug 55630 – partially reduced testcase

partially reduced testcase

228.i (text/plain), 44.26 KB, created by Siarhei Siamashka on 2012-10-04 21:16:31 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Siarhei Siamashka

Created: 2012-10-04 21:16:31 UTC

Size: 44.26 KB

patch

obsolete

>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;
>}
>

Actions: View

Attachments on bug 55630: 68094 | 68771

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.