pixman/pixman-combine.h.template

   1
   2 #define COMPONENT_SIZE
   3 #define MASK
   4 #define ONE_HALF
   5
   6 #define A_SHIFT
   7 #define R_SHIFT
   8 #define G_SHIFT
   9 #define A_MASK
  10 #define R_MASK
  11 #define G_MASK
  12
  13 #define RB_MASK
  14 #define AG_MASK
  15 #define RB_ONE_HALF
  16 #define RB_MASK_PLUS_ONE
  17
  18 #define ALPHA_c(x) ((x) >> A_SHIFT)
  19 #define RED_c(x) (((x) >> R_SHIFT) & MASK)
  20 #define GREEN_c(x) (((x) >> G_SHIFT) & MASK)
  21 #define BLUE_c(x) ((x) & MASK)
  22
  23 /*
  24  * Helper macros.
  25  */
  26
  27 #define MUL_UNc(a, b, t)                                                \
  28     ((t) = (a) * (b) + ONE_HALF, ((((t) >> G_SHIFT ) + (t) ) >> G_SHIFT ))
  29
  30 #define DIV_UNc(a, b)                                                   \
  31     (((comp2_t) (a) * MASK) / (b))
  32
  33 #define ADD_UNc(x, y, t)                                     \
  34     ((t) = x + y,                                            \
  35      (comp4_t) (comp1_t) ((t) | (0 - ((t) >> G_SHIFT))))
  36
  37 #define DIV_ONE_UNc(x)                                                  \
  38     (((x) + ONE_HALF + (((x) + ONE_HALF) >> G_SHIFT)) >> G_SHIFT)
  39
  40 /*
  41  * The methods below use some tricks to be able to do two color
  42  * components at the same time.
  43  */
  44
  45 /*
  46  * x_rb = (x_rb * a) / 255
  47  */
  48 #define UNc_rb_MUL_UNc(x, a, t)                                         \
  49     do                                                                  \
  50     {                                                                   \
  51         t  = ((x) & RB_MASK) * (a);                                     \
  52         t += RB_ONE_HALF;                                               \
  53         x = (t + ((t >> G_SHIFT) & RB_MASK)) >> G_SHIFT;                \
  54         x &= RB_MASK;                                                   \
  55     } while (0)
  56
  57 /*
  58  * x_rb = min (x_rb + y_rb, 255)
  59  */
  60 #define UNc_rb_ADD_UNc_rb(x, y, t)                                      \
  61     do                                                                  \
  62     {                                                                   \
  63         t = ((x) + (y));                                                \
  64         t |= RB_MASK_PLUS_ONE - ((t >> G_SHIFT) & RB_MASK);             \
  65         x = (t & RB_MASK);                                              \
  66     } while (0)
  67
  68 /*
  69  * x_rb = (x_rb * a_rb) / 255
  70  */
  71 #define UNc_rb_MUL_UNc_rb(x, a, t)                                      \
  72     do                                                                  \
  73     {                                                                   \
  74         t  = (x & MASK) * (a & MASK);                                   \
  75         t |= (x & R_MASK) * ((a >> R_SHIFT) & MASK);                    \
  76         t += RB_ONE_HALF;                                               \
  77         t = (t + ((t >> G_SHIFT) & RB_MASK)) >> G_SHIFT;                \
  78         x = t & RB_MASK;                                                \
  79     } while (0)
  80
  81 /*
  82  * x_c = (x_c * a) / 255
  83  */
  84 #define UNcx4_MUL_UNc(x, a)                                             \
  85     do                                                                  \
  86     {                                                                   \
  87         comp4_t r1, r2, t;                                              \
  88                                                                         \
  89         r1 = (x);                                                       \
  90         UNc_rb_MUL_UNc (r1, a, t);                                      \
  91                                                                         \
  92         r2 = (x) >> G_SHIFT;                                            \
  93         UNc_rb_MUL_UNc (r2, a, t);                                      \
  94                                                                         \
  95         x = r1 | (r2 << G_SHIFT);                                       \
  96     } while (0)
  97
  98 /*
  99  * x_c = (x_c * a) / 255 + y_c
 100  */
 101 #define UNcx4_MUL_UNc_ADD_UNcx4(x, a, y)                                \
 102     do                                                                  \
 103     {                                                                   \
 104         comp4_t r1, r2, r3, t;                                          \
 105                                                                         \
 106         r1 = (x);                                                       \
 107         r2 = (y) & RB_MASK;                                             \
 108         UNc_rb_MUL_UNc (r1, a, t);                                      \
 109         UNc_rb_ADD_UNc_rb (r1, r2, t);                                  \
 110                                                                         \
 111         r2 = (x) >> G_SHIFT;                                            \
 112         r3 = ((y) >> G_SHIFT) & RB_MASK;                                \
 113         UNc_rb_MUL_UNc (r2, a, t);                                      \
 114         UNc_rb_ADD_UNc_rb (r2, r3, t);                                  \
 115                                                                         \
 116         x = r1 | (r2 << G_SHIFT);                                       \
 117     } while (0)
 118
 119 /*
 120  * x_c = (x_c * a + y_c * b) / 255
 121  */
 122 #define UNcx4_MUL_UNc_ADD_UNcx4_MUL_UNc(x, a, y, b)                     \
 123     do                                                                  \
 124     {                                                                   \
 125         comp4_t r1, r2, r3, t;                                          \
 126                                                                         \
 127         r1 = x;                                                         \
 128         r2 = y;                                                         \
 129         UNc_rb_MUL_UNc (r1, a, t);                                      \
 130         UNc_rb_MUL_UNc (r2, b, t);                                      \
 131         UNc_rb_ADD_UNc_rb (r1, r2, t);                                  \
 132                                                                         \
 133         r2 = (x >> G_SHIFT);                                            \
 134         r3 = (y >> G_SHIFT);                                            \
 135         UNc_rb_MUL_UNc (r2, a, t);                                      \
 136         UNc_rb_MUL_UNc (r3, b, t);                                      \
 137         UNc_rb_ADD_UNc_rb (r2, r3, t);                                  \
 138                                                                         \
 139         x = r1 | (r2 << G_SHIFT);                                       \
 140     } while (0)
 141
 142 /*
 143  * x_c = (x_c * a_c) / 255
 144  */
 145 #define UNcx4_MUL_UNcx4(x, a)                                           \
 146     do                                                                  \
 147     {                                                                   \
 148         comp4_t r1, r2, r3, t;                                          \
 149                                                                         \
 150         r1 = x;                                                         \
 151         r2 = a;                                                         \
 152         UNc_rb_MUL_UNc_rb (r1, r2, t);                                  \
 153                                                                         \
 154         r2 = x >> G_SHIFT;                                              \
 155         r3 = a >> G_SHIFT;                                              \
 156         UNc_rb_MUL_UNc_rb (r2, r3, t);                                  \
 157                                                                         \
 158         x = r1 | (r2 << G_SHIFT);                                       \
 159     } while (0)
 160
 161 /*
 162  * x_c = (x_c * a_c) / 255 + y_c
 163  */
 164 #define UNcx4_MUL_UNcx4_ADD_UNcx4(x, a, y)                              \
 165     do                                                                  \
 166     {                                                                   \
 167         comp4_t r1, r2, r3, t;                                          \
 168                                                                         \
 169         r1 = x;                                                         \
 170         r2 = a;                                                         \
 171         UNc_rb_MUL_UNc_rb (r1, r2, t);                                  \
 172         r2 = y & RB_MASK;                                               \
 173         UNc_rb_ADD_UNc_rb (r1, r2, t);                                  \
 174                                                                         \
 175         r2 = (x >> G_SHIFT);                                            \
 176         r3 = (a >> G_SHIFT);                                            \
 177         UNc_rb_MUL_UNc_rb (r2, r3, t);                                  \
 178         r3 = (y >> G_SHIFT) & RB_MASK;                                  \
 179         UNc_rb_ADD_UNc_rb (r2, r3, t);                                  \
 180                                                                         \
 181         x = r1 | (r2 << G_SHIFT);                                       \
 182     } while (0)
 183
 184 /*
 185  * x_c = (x_c * a_c + y_c * b) / 255
 186  */
 187 #define UNcx4_MUL_UNcx4_ADD_UNcx4_MUL_UNc(x, a, y, b)                   \
 188     do                                                                  \
 189     {                                                                   \
 190         comp4_t r1, r2, r3, t;                                          \
 191                                                                         \
 192         r1 = x;                                                         \
 193         r2 = a;                                                         \
 194         UNc_rb_MUL_UNc_rb (r1, r2, t);                                  \
 195         r2 = y;                                                         \
 196         UNc_rb_MUL_UNc (r2, b, t);                                      \
 197         UNc_rb_ADD_UNc_rb (r1, r2, t);                                  \
 198                                                                         \
 199         r2 = x >> G_SHIFT;                                              \
 200         r3 = a >> G_SHIFT;                                              \
 201         UNc_rb_MUL_UNc_rb (r2, r3, t);                                  \
 202         r3 = y >> G_SHIFT;                                              \
 203         UNc_rb_MUL_UNc (r3, b, t);                                      \
 204         UNc_rb_ADD_UNc_rb (r2, r3, t);                                  \
 205                                                                         \
 206         x = r1 | (r2 << G_SHIFT);                                       \
 207     } while (0)
 208
 209 /*
 210    x_c = min(x_c + y_c, 255)
 211  */
 212 #define UNcx4_ADD_UNcx4(x, y)                                           \
 213     do                                                                  \
 214     {                                                                   \
 215         comp4_t r1, r2, r3, t;                                          \
 216                                                                         \
 217         r1 = x & RB_MASK;                                               \
 218         r2 = y & RB_MASK;                                               \
 219         UNc_rb_ADD_UNc_rb (r1, r2, t);                                  \
 220                                                                         \
 221         r2 = (x >> G_SHIFT) & RB_MASK;                                  \
 222         r3 = (y >> G_SHIFT) & RB_MASK;                                  \
 223         UNc_rb_ADD_UNc_rb (r2, r3, t);                                  \
 224                                                                         \
 225         x = r1 | (r2 << G_SHIFT);                                       \
 226     } while (0)