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