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