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) ( (t) = (a) * (b) + ONE_HALF, ( ( ( (t)>>G_SHIFT ) + (t) )>>G_SHIFT ) )
  28 #define DIV_UNc(a,b)    (((comp2_t) (a) * MASK) / (b))
  29 #define ADD_UNc(x,y,t) (                                                        \
  30         (t) = x + y,                                                    \
  31         (comp4_t) (comp1_t) ((t) | (0 - ((t) >> G_SHIFT))))
  32
  33 #define DIV_ONE_UNc(x)      (((x) + ONE_HALF + (((x) + ONE_HALF) >> G_SHIFT)) >> G_SHIFT)
  34
  35 /*
  36   The methods below use some tricks to be able to do two color
  37   components at the same time.
  38 */
  39
  40 /*
  41   x_c = (x_c * a) / 255
  42 */
  43 #define UNcx4_MUL_UNc(x, a) do {                                            \
  44         comp4_t t = ((x & RB_MASK) * a) + RB_ONE_HALF;                  \
  45         t = (t + ((t >> COMPONENT_SIZE) & RB_MASK)) >> COMPONENT_SIZE;  \
  46         t &= RB_MASK;                                                   \
  47                                                                         \
  48         x = (((x >> COMPONENT_SIZE) & RB_MASK) * a) + RB_ONE_HALF;      \
  49         x = (x + ((x >> COMPONENT_SIZE) & RB_MASK));                    \
  50         x &= RB_MASK << COMPONENT_SIZE;                                 \
  51         x += t;                                                         \
  52     } while (0)
  53
  54 /*
  55   x_c = (x_c * a) / 255 + y_c
  56 */
  57 #define UNcx4_MUL_UNc_ADD_UNcx4(x, a, y) do {                                      \
  58         /* multiply and divide: trunc((i + 128)*257/65536) */           \
  59         comp4_t t = ((x & RB_MASK) * a) + RB_ONE_HALF;                  \
  60         t = (t + ((t >> COMPONENT_SIZE) & RB_MASK)) >> COMPONENT_SIZE;  \
  61         t &= RB_MASK;                                                   \
  62                                                                         \
  63         /* add */                                                       \
  64         t += y & RB_MASK;                                               \
  65                                                                         \
  66         /* saturate */                                                  \
  67         t |= RB_MASK_PLUS_ONE - ((t >> COMPONENT_SIZE) & RB_MASK);      \
  68         t &= RB_MASK;                                                   \
  69                                                                         \
  70         /* multiply and divide */                                       \
  71         x = (((x >> COMPONENT_SIZE) & RB_MASK) * a) + RB_ONE_HALF;      \
  72         x = (x + ((x >> COMPONENT_SIZE) & RB_MASK)) >> COMPONENT_SIZE;  \
  73         x &= RB_MASK;                                                   \
  74                                                                         \
  75         /* add */                                                       \
  76         x += (y >> COMPONENT_SIZE) & RB_MASK;                           \
  77                                                                         \
  78         /* saturate */                                                  \
  79         x |= RB_MASK_PLUS_ONE - ((x >> COMPONENT_SIZE) & RB_MASK);      \
  80         x &= RB_MASK;                                                   \
  81                                                                         \
  82         /* recombine */                                                 \
  83         x <<= COMPONENT_SIZE;                                           \
  84         x += t;                                                         \
  85     } while (0)
  86
  87 /*
  88   x_c = (x_c * a + y_c * b) / 255
  89 */
  90 #define UNcx4_MUL_UNc_ADD_UNcx4_MUL_UNc(x, a, y, b) do {                                   \
  91         comp4_t t;                                                      \
  92         comp4_t r = (x >> A_SHIFT) * a + (y >> A_SHIFT) * b + ONE_HALF; \
  93         r += (r >> G_SHIFT);                                            \
  94         r >>= G_SHIFT;                                                  \
  95                                                                         \
  96         t = (x & G_MASK) * a + (y & G_MASK) * b;                        \
  97         t += (t >> G_SHIFT) + (ONE_HALF << G_SHIFT);                    \
  98         t >>= R_SHIFT;                                                  \
  99                                                                         \
 100         t |= r << R_SHIFT;                                              \
 101         t |= RB_MASK_PLUS_ONE - ((t >> G_SHIFT) & RB_MASK);             \
 102         t &= RB_MASK;                                                   \
 103         t <<= G_SHIFT;                                                  \
 104                                                                         \
 105         r = ((x >> R_SHIFT) & MASK) * a +                               \
 106             ((y >> R_SHIFT) & MASK) * b + ONE_HALF;                     \
 107         r += (r >> G_SHIFT);                                            \
 108         r >>= G_SHIFT;                                                  \
 109                                                                         \
 110         x = (x & MASK) * a + (y & MASK) * b + ONE_HALF;                 \
 111         x += (x >> G_SHIFT);                                            \
 112         x >>= G_SHIFT;                                                  \
 113         x |= r << R_SHIFT;                                              \
 114         x |= RB_MASK_PLUS_ONE - ((x >> G_SHIFT) & RB_MASK);             \
 115         x &= RB_MASK;                                                   \
 116         x |= t;                                                         \
 117     } while (0)
 118
 119 /*
 120   x_c = (x_c * a_c) / 255
 121 */
 122 #define UNcx4_MUL_UNcx4(x, a) do {                                           \
 123         comp4_t t;                                                      \
 124         comp4_t r = (x & MASK) * (a & MASK);                            \
 125         r |= (x & R_MASK) * ((a >> R_SHIFT) & MASK);                    \
 126         r += RB_ONE_HALF;                                               \
 127         r = (r + ((r >> G_SHIFT) & RB_MASK)) >> G_SHIFT;                \
 128         r &= RB_MASK;                                                   \
 129                                                                         \
 130         x >>= G_SHIFT;                                                  \
 131         t = (x & MASK) * ((a >> G_SHIFT) & MASK);                       \
 132         t |= (x & R_MASK) * (a >> A_SHIFT);                             \
 133         t += RB_ONE_HALF;                                               \
 134         t = t + ((t >> G_SHIFT) & RB_MASK);                             \
 135         x = r | (t & AG_MASK);                                          \
 136     } while (0)
 137
 138 /*
 139   x_c = (x_c * a_c) / 255 + y_c
 140 */
 141 #define UNcx4_MUL_UNcx4_ADD_UNcx4(x, a, y) do {                                     \
 142         comp4_t t;                                                      \
 143         comp4_t r = (x & MASK) * (a & MASK);                            \
 144         r |= (x & R_MASK) * ((a >> R_SHIFT) & MASK);                    \
 145         r += RB_ONE_HALF;                                               \
 146         r = (r + ((r >> G_SHIFT) & RB_MASK)) >> G_SHIFT;                \
 147         r &= RB_MASK;                                                   \
 148         r += y & RB_MASK;                                               \
 149         r |= RB_MASK_PLUS_ONE - ((r >> G_SHIFT) & RB_MASK);             \
 150         r &= RB_MASK;                                                   \
 151                                                                         \
 152         x >>= G_SHIFT;                                                  \
 153         t = (x & MASK) * ((a >> G_SHIFT) & MASK);                       \
 154         t |= (x & R_MASK) * (a >> A_SHIFT);                             \
 155         t += RB_ONE_HALF;                                               \
 156         t = (t + ((t >> G_SHIFT) & RB_MASK)) >> G_SHIFT;                \
 157         t &= RB_MASK;                                                   \
 158         t += (y >> G_SHIFT) & RB_MASK;                                  \
 159         t |= RB_MASK_PLUS_ONE - ((t >> G_SHIFT) & RB_MASK);             \
 160         t &= RB_MASK;                                                   \
 161         x = r | (t << G_SHIFT);                                         \
 162     } while (0)
 163
 164 /*
 165   x_c = (x_c * a_c + y_c * b) / 255
 166 */
 167 #define UNcx4_MUL_UNcx4_ADD_UNcx4_MUL_UNc(x, a, y, b) do {                                  \
 168         comp4_t t;                                                      \
 169         comp4_t r = (x >> A_SHIFT) * (a >> A_SHIFT) +                   \
 170                      (y >> A_SHIFT) * b;                                \
 171         r += (r >> G_SHIFT) + ONE_HALF;                                 \
 172         r >>= G_SHIFT;                                                  \
 173                                                                         \
 174         t = (x & G_MASK) * ((a >> G_SHIFT) & MASK) + (y & G_MASK) * b;  \
 175         t += (t >> G_SHIFT) + (ONE_HALF << G_SHIFT);                    \
 176         t >>= R_SHIFT;                                                  \
 177                                                                         \
 178         t |= r << R_SHIFT;                                              \
 179         t |= RB_MASK_PLUS_ONE - ((t >> G_SHIFT) & RB_MASK);             \
 180         t &= RB_MASK;                                                   \
 181         t <<= G_SHIFT;                                                  \
 182                                                                         \
 183         r = ((x >> R_SHIFT) & MASK) * ((a >> R_SHIFT) & MASK) +         \
 184             ((y >> R_SHIFT) & MASK) * b + ONE_HALF;                     \
 185         r += (r >> G_SHIFT);                                            \
 186         r >>= G_SHIFT;                                                  \
 187                                                                         \
 188         x = (x & MASK) * (a & MASK) + (y & MASK) * b + ONE_HALF;        \
 189         x += (x >> G_SHIFT);                                            \
 190         x >>= G_SHIFT;                                                  \
 191         x |= r << R_SHIFT;                                              \
 192         x |= RB_MASK_PLUS_ONE - ((x >> G_SHIFT) & RB_MASK);             \
 193         x &= RB_MASK;                                                   \
 194         x |= t;                                                         \
 195     } while (0)
 196
 197 /*
 198   x_c = min(x_c + y_c, 255)
 199 */
 200 #define UNcx4_ADD_UNcx4(x, y) do {                                            \
 201         comp4_t t;                                                      \
 202         comp4_t r = (x & RB_MASK) + (y & RB_MASK);                      \
 203         r |= RB_MASK_PLUS_ONE - ((r >> G_SHIFT) & RB_MASK);             \
 204         r &= RB_MASK;                                                   \
 205                                                                         \
 206         t = ((x >> G_SHIFT) & RB_MASK) + ((y >> G_SHIFT) & RB_MASK);    \
 207         t |= RB_MASK_PLUS_ONE - ((t >> G_SHIFT) & RB_MASK);             \
 208         r |= (t & RB_MASK) << G_SHIFT;                                  \
 209         x = r;                                                          \
 210     } while (0)
 211