The Tor Browser / file comparison
comparison: gfx/cairo/libpixman/src/pixman-combine32.h
gfx/cairo/libpixman/src/pixman-combine32.h
- changeset 0
- 6474c204b198
equal
deleted
inserted
replaced
| -1:000000000000 | 0:01fc1e985974 |
|---|---|
| 1 #define COMPONENT_SIZE 8 | |
| 2 #define MASK 0xff | |
| 3 #define ONE_HALF 0x80 | |
| 4 | |
| 5 #define A_SHIFT 8 * 3 | |
| 6 #define R_SHIFT 8 * 2 | |
| 7 #define G_SHIFT 8 | |
| 8 #define A_MASK 0xff000000 | |
| 9 #define R_MASK 0xff0000 | |
| 10 #define G_MASK 0xff00 | |
| 11 | |
| 12 #define RB_MASK 0xff00ff | |
| 13 #define AG_MASK 0xff00ff00 | |
| 14 #define RB_ONE_HALF 0x800080 | |
| 15 #define RB_MASK_PLUS_ONE 0x10000100 | |
| 16 | |
| 17 #define ALPHA_8(x) ((x) >> A_SHIFT) | |
| 18 #define RED_8(x) (((x) >> R_SHIFT) & MASK) | |
| 19 #define GREEN_8(x) (((x) >> G_SHIFT) & MASK) | |
| 20 #define BLUE_8(x) ((x) & MASK) | |
| 21 | |
| 22 /* | |
| 23 * ARMv6 has UQADD8 instruction, which implements unsigned saturated | |
| 24 * addition for 8-bit values packed in 32-bit registers. It is very useful | |
| 25 * for UN8x4_ADD_UN8x4, UN8_rb_ADD_UN8_rb and ADD_UN8 macros (which would | |
| 26 * otherwise need a lot of arithmetic operations to simulate this operation). | |
| 27 * Since most of the major ARM linux distros are built for ARMv7, we are | |
| 28 * much less dependent on runtime CPU detection and can get practical | |
| 29 * benefits from conditional compilation here for a lot of users. | |
| 30 */ | |
| 31 | |
| 32 #if defined(USE_GCC_INLINE_ASM) && defined(__arm__) && \ | |
| 33 !defined(__aarch64__) && (!defined(__thumb__) || defined(__thumb2__)) | |
| 34 #if defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || \ | |
| 35 defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || \ | |
| 36 defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) || \ | |
| 37 defined(__ARM_ARCH_6M__) || defined(__ARM_ARCH_7__) || \ | |
| 38 defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || \ | |
| 39 defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__) | |
| 40 | |
| 41 static force_inline uint32_t | |
| 42 un8x4_add_un8x4 (uint32_t x, uint32_t y) | |
| 43 { | |
| 44 uint32_t t; | |
| 45 asm ("uqadd8 %0, %1, %2" : "=r" (t) : "%r" (x), "r" (y)); | |
| 46 return t; | |
| 47 } | |
| 48 | |
| 49 #define UN8x4_ADD_UN8x4(x, y) \ | |
| 50 ((x) = un8x4_add_un8x4 ((x), (y))) | |
| 51 | |
| 52 #define UN8_rb_ADD_UN8_rb(x, y, t) \ | |
| 53 ((t) = un8x4_add_un8x4 ((x), (y)), (x) = (t)) | |
| 54 | |
| 55 #define ADD_UN8(x, y, t) \ | |
| 56 ((t) = (x), un8x4_add_un8x4 ((t), (y))) | |
| 57 | |
| 58 #endif | |
| 59 #endif | |
| 60 | |
| 61 /*****************************************************************************/ | |
| 62 | |
| 63 /* | |
| 64 * Helper macros. | |
| 65 */ | |
| 66 | |
| 67 #define MUL_UN8(a, b, t) \ | |
| 68 ((t) = (a) * (uint16_t)(b) + ONE_HALF, ((((t) >> G_SHIFT ) + (t) ) >> G_SHIFT )) | |
| 69 | |
| 70 #define DIV_UN8(a, b) \ | |
| 71 (((uint16_t) (a) * MASK + ((b) / 2)) / (b)) | |
| 72 | |
| 73 #ifndef ADD_UN8 | |
| 74 #define ADD_UN8(x, y, t) \ | |
| 75 ((t) = (x) + (y), \ | |
| 76 (uint32_t) (uint8_t) ((t) | (0 - ((t) >> G_SHIFT)))) | |
| 77 #endif | |
| 78 | |
| 79 #define DIV_ONE_UN8(x) \ | |
| 80 (((x) + ONE_HALF + (((x) + ONE_HALF) >> G_SHIFT)) >> G_SHIFT) | |
| 81 | |
| 82 /* | |
| 83 * The methods below use some tricks to be able to do two color | |
| 84 * components at the same time. | |
| 85 */ | |
| 86 | |
| 87 /* | |
| 88 * x_rb = (x_rb * a) / 255 | |
| 89 */ | |
| 90 #define UN8_rb_MUL_UN8(x, a, t) \ | |
| 91 do \ | |
| 92 { \ | |
| 93 t = ((x) & RB_MASK) * (a); \ | |
| 94 t += RB_ONE_HALF; \ | |
| 95 x = (t + ((t >> G_SHIFT) & RB_MASK)) >> G_SHIFT; \ | |
| 96 x &= RB_MASK; \ | |
| 97 } while (0) | |
| 98 | |
| 99 /* | |
| 100 * x_rb = min (x_rb + y_rb, 255) | |
| 101 */ | |
| 102 #ifndef UN8_rb_ADD_UN8_rb | |
| 103 #define UN8_rb_ADD_UN8_rb(x, y, t) \ | |
| 104 do \ | |
| 105 { \ | |
| 106 t = ((x) + (y)); \ | |
| 107 t |= RB_MASK_PLUS_ONE - ((t >> G_SHIFT) & RB_MASK); \ | |
| 108 x = (t & RB_MASK); \ | |
| 109 } while (0) | |
| 110 #endif | |
| 111 | |
| 112 /* | |
| 113 * x_rb = (x_rb * a_rb) / 255 | |
| 114 */ | |
| 115 #define UN8_rb_MUL_UN8_rb(x, a, t) \ | |
| 116 do \ | |
| 117 { \ | |
| 118 t = (x & MASK) * (a & MASK); \ | |
| 119 t |= (x & R_MASK) * ((a >> R_SHIFT) & MASK); \ | |
| 120 t += RB_ONE_HALF; \ | |
| 121 t = (t + ((t >> G_SHIFT) & RB_MASK)) >> G_SHIFT; \ | |
| 122 x = t & RB_MASK; \ | |
| 123 } while (0) | |
| 124 | |
| 125 /* | |
| 126 * x_c = (x_c * a) / 255 | |
| 127 */ | |
| 128 #define UN8x4_MUL_UN8(x, a) \ | |
| 129 do \ | |
| 130 { \ | |
| 131 uint32_t r1__, r2__, t__; \ | |
| 132 \ | |
| 133 r1__ = (x); \ | |
| 134 UN8_rb_MUL_UN8 (r1__, (a), t__); \ | |
| 135 \ | |
| 136 r2__ = (x) >> G_SHIFT; \ | |
| 137 UN8_rb_MUL_UN8 (r2__, (a), t__); \ | |
| 138 \ | |
| 139 (x) = r1__ | (r2__ << G_SHIFT); \ | |
| 140 } while (0) | |
| 141 | |
| 142 /* | |
| 143 * x_c = (x_c * a) / 255 + y_c | |
| 144 */ | |
| 145 #define UN8x4_MUL_UN8_ADD_UN8x4(x, a, y) \ | |
| 146 do \ | |
| 147 { \ | |
| 148 uint32_t r1__, r2__, r3__, t__; \ | |
| 149 \ | |
| 150 r1__ = (x); \ | |
| 151 r2__ = (y) & RB_MASK; \ | |
| 152 UN8_rb_MUL_UN8 (r1__, (a), t__); \ | |
| 153 UN8_rb_ADD_UN8_rb (r1__, r2__, t__); \ | |
| 154 \ | |
| 155 r2__ = (x) >> G_SHIFT; \ | |
| 156 r3__ = ((y) >> G_SHIFT) & RB_MASK; \ | |
| 157 UN8_rb_MUL_UN8 (r2__, (a), t__); \ | |
| 158 UN8_rb_ADD_UN8_rb (r2__, r3__, t__); \ | |
| 159 \ | |
| 160 (x) = r1__ | (r2__ << G_SHIFT); \ | |
| 161 } while (0) | |
| 162 | |
| 163 /* | |
| 164 * x_c = (x_c * a + y_c * b) / 255 | |
| 165 */ | |
| 166 #define UN8x4_MUL_UN8_ADD_UN8x4_MUL_UN8(x, a, y, b) \ | |
| 167 do \ | |
| 168 { \ | |
| 169 uint32_t r1__, r2__, r3__, t__; \ | |
| 170 \ | |
| 171 r1__ = (x); \ | |
| 172 r2__ = (y); \ | |
| 173 UN8_rb_MUL_UN8 (r1__, (a), t__); \ | |
| 174 UN8_rb_MUL_UN8 (r2__, (b), t__); \ | |
| 175 UN8_rb_ADD_UN8_rb (r1__, r2__, t__); \ | |
| 176 \ | |
| 177 r2__ = ((x) >> G_SHIFT); \ | |
| 178 r3__ = ((y) >> G_SHIFT); \ | |
| 179 UN8_rb_MUL_UN8 (r2__, (a), t__); \ | |
| 180 UN8_rb_MUL_UN8 (r3__, (b), t__); \ | |
| 181 UN8_rb_ADD_UN8_rb (r2__, r3__, t__); \ | |
| 182 \ | |
| 183 (x) = r1__ | (r2__ << G_SHIFT); \ | |
| 184 } while (0) | |
| 185 | |
| 186 /* | |
| 187 * x_c = (x_c * a_c) / 255 | |
| 188 */ | |
| 189 #define UN8x4_MUL_UN8x4(x, a) \ | |
| 190 do \ | |
| 191 { \ | |
| 192 uint32_t r1__, r2__, r3__, t__; \ | |
| 193 \ | |
| 194 r1__ = (x); \ | |
| 195 r2__ = (a); \ | |
| 196 UN8_rb_MUL_UN8_rb (r1__, r2__, t__); \ | |
| 197 \ | |
| 198 r2__ = (x) >> G_SHIFT; \ | |
| 199 r3__ = (a) >> G_SHIFT; \ | |
| 200 UN8_rb_MUL_UN8_rb (r2__, r3__, t__); \ | |
| 201 \ | |
| 202 (x) = r1__ | (r2__ << G_SHIFT); \ | |
| 203 } while (0) | |
| 204 | |
| 205 /* | |
| 206 * x_c = (x_c * a_c) / 255 + y_c | |
| 207 */ | |
| 208 #define UN8x4_MUL_UN8x4_ADD_UN8x4(x, a, y) \ | |
| 209 do \ | |
| 210 { \ | |
| 211 uint32_t r1__, r2__, r3__, t__; \ | |
| 212 \ | |
| 213 r1__ = (x); \ | |
| 214 r2__ = (a); \ | |
| 215 UN8_rb_MUL_UN8_rb (r1__, r2__, t__); \ | |
| 216 r2__ = (y) & RB_MASK; \ | |
| 217 UN8_rb_ADD_UN8_rb (r1__, r2__, t__); \ | |
| 218 \ | |
| 219 r2__ = ((x) >> G_SHIFT); \ | |
| 220 r3__ = ((a) >> G_SHIFT); \ | |
| 221 UN8_rb_MUL_UN8_rb (r2__, r3__, t__); \ | |
| 222 r3__ = ((y) >> G_SHIFT) & RB_MASK; \ | |
| 223 UN8_rb_ADD_UN8_rb (r2__, r3__, t__); \ | |
| 224 \ | |
| 225 (x) = r1__ | (r2__ << G_SHIFT); \ | |
| 226 } while (0) | |
| 227 | |
| 228 /* | |
| 229 * x_c = (x_c * a_c + y_c * b) / 255 | |
| 230 */ | |
| 231 #define UN8x4_MUL_UN8x4_ADD_UN8x4_MUL_UN8(x, a, y, b) \ | |
| 232 do \ | |
| 233 { \ | |
| 234 uint32_t r1__, r2__, r3__, t__; \ | |
| 235 \ | |
| 236 r1__ = (x); \ | |
| 237 r2__ = (a); \ | |
| 238 UN8_rb_MUL_UN8_rb (r1__, r2__, t__); \ | |
| 239 r2__ = (y); \ | |
| 240 UN8_rb_MUL_UN8 (r2__, (b), t__); \ | |
| 241 UN8_rb_ADD_UN8_rb (r1__, r2__, t__); \ | |
| 242 \ | |
| 243 r2__ = (x) >> G_SHIFT; \ | |
| 244 r3__ = (a) >> G_SHIFT; \ | |
| 245 UN8_rb_MUL_UN8_rb (r2__, r3__, t__); \ | |
| 246 r3__ = (y) >> G_SHIFT; \ | |
| 247 UN8_rb_MUL_UN8 (r3__, (b), t__); \ | |
| 248 UN8_rb_ADD_UN8_rb (r2__, r3__, t__); \ | |
| 249 \ | |
| 250 x = r1__ | (r2__ << G_SHIFT); \ | |
| 251 } while (0) | |
| 252 | |
| 253 /* | |
| 254 x_c = min(x_c + y_c, 255) | |
| 255 */ | |
| 256 #ifndef UN8x4_ADD_UN8x4 | |
| 257 #define UN8x4_ADD_UN8x4(x, y) \ | |
| 258 do \ | |
| 259 { \ | |
| 260 uint32_t r1__, r2__, r3__, t__; \ | |
| 261 \ | |
| 262 r1__ = (x) & RB_MASK; \ | |
| 263 r2__ = (y) & RB_MASK; \ | |
| 264 UN8_rb_ADD_UN8_rb (r1__, r2__, t__); \ | |
| 265 \ | |
| 266 r2__ = ((x) >> G_SHIFT) & RB_MASK; \ | |
| 267 r3__ = ((y) >> G_SHIFT) & RB_MASK; \ | |
| 268 UN8_rb_ADD_UN8_rb (r2__, r3__, t__); \ | |
| 269 \ | |
| 270 x = r1__ | (r2__ << G_SHIFT); \ | |
| 271 } while (0) | |
| 272 #endif |
