1 /* 2 * Copyright 2004 Keith Packard 3 * 4 * Permission to use, copy, modify, distribute, and sell this software and its 5 * documentation for any purpose is hereby granted without fee, provided that 6 * the above copyright notice appear in all copies and that both that 7 * copyright notice and this permission notice appear in supporting 8 * documentation, and that the name of Keith Packard not be used in 9 * advertising or publicity pertaining to distribution of the software without 10 * specific, written prior permission. Keith Packard makes no 11 * representations about the suitability of this software for any purpose. It 12 * is provided "as is" without express or implied warranty. 13 * 14 * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 15 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO 16 * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR 17 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, 18 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 19 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 20 * PERFORMANCE OF THIS SOFTWARE. 21 */ 22 23 #ifdef HAVE_CONFIG_H 24 #include <config.h> 25 #endif 26 27 #include <string.h> 28 29 #include "pixman-private.h" 30 #include "pixman-accessor.h" 31 32 /* 33 * Step across a small sample grid gap 34 */ 35 #define RENDER_EDGE_STEP_SMALL(edge) \ 36 { \ 37 edge->x += edge->stepx_small; \ 38 edge->e += edge->dx_small; \ 39 if (edge->e > 0) \ 40 { \ 41 edge->e -= edge->dy; \ 42 edge->x += edge->signdx; \ 43 } \ 44 } 45 46 /* 47 * Step across a large sample grid gap 48 */ 49 #define RENDER_EDGE_STEP_BIG(edge) \ 50 { \ 51 edge->x += edge->stepx_big; \ 52 edge->e += edge->dx_big; \ 53 if (edge->e > 0) \ 54 { \ 55 edge->e -= edge->dy; \ 56 edge->x += edge->signdx; \ 57 } \ 58 } 59 60 #ifdef PIXMAN_FB_ACCESSORS 61 #define PIXMAN_RASTERIZE_EDGES pixman_rasterize_edges_accessors 62 #else 63 #define PIXMAN_RASTERIZE_EDGES pixman_rasterize_edges_no_accessors 64 #endif 65 66 /* 67 * 4 bit alpha 68 */ 69 70 #define N_BITS 4 71 #define RASTERIZE_EDGES rasterize_edges_4 72 73 #ifndef WORDS_BIGENDIAN 74 #define SHIFT_4(o) ((o) << 2) 75 #else 76 #define SHIFT_4(o) ((1 - (o)) << 2) 77 #endif 78 79 #define GET_4(x, o) (((x) >> SHIFT_4 (o)) & 0xf) 80 #define PUT_4(x, o, v) \ 81 (((x) & ~(0xf << SHIFT_4 (o))) | (((v) & 0xf) << SHIFT_4 (o))) 82 83 #define DEFINE_ALPHA(line, x) \ 84 uint8_t *__ap = (uint8_t *) line + ((x) >> 1); \ 85 int __ao = (x) & 1 86 87 #define STEP_ALPHA ((__ap += __ao), (__ao ^= 1)) 88 89 #define ADD_ALPHA(a) \ 90 { \ 91 uint8_t __o = READ (image, __ap); \ 92 uint8_t __a = (a) + GET_4 (__o, __ao); \ 93 WRITE (image, __ap, PUT_4 (__o, __ao, __a | (0 - ((__a) >> 4)))); \ 94 } 95 96 #include "pixman-edge-imp.h" 97 98 #undef ADD_ALPHA 99 #undef STEP_ALPHA 100 #undef DEFINE_ALPHA 101 #undef RASTERIZE_EDGES 102 #undef N_BITS 103 104 105 /* 106 * 1 bit alpha 107 */ 108 109 #define N_BITS 1 110 #define RASTERIZE_EDGES rasterize_edges_1 111 112 #include "pixman-edge-imp.h" 113 114 #undef RASTERIZE_EDGES 115 #undef N_BITS 116 117 /* 118 * 8 bit alpha 119 */ 120 121 static force_inline uint8_t 122 clip255 (int x) 123 { 124 if (x > 255) 125 return 255; 126 127 return x; 128 } 129 130 #define ADD_SATURATE_8(buf, val, length) \ 131 do \ 132 { \ 133 int i__ = (length); \ 134 uint8_t *buf__ = (buf); \ 135 int val__ = (val); \ 136 \ 137 while (i__--) \ 138 { \ 139 WRITE (image, (buf__), clip255 (READ (image, (buf__)) + (val__))); \ 140 (buf__)++; \ 141 } \ 142 } while (0) 143 144 /* 145 * We want to detect the case where we add the same value to a long 146 * span of pixels. The triangles on the end are filled in while we 147 * count how many sub-pixel scanlines contribute to the middle section. 148 * 149 * +--------------------------+ 150 * fill_height =| \ / 151 * +------------------+ 152 * |================| 153 * fill_start fill_end 154 */ 155 static void 156 rasterize_edges_8 (pixman_image_t *image, 157 pixman_edge_t * l, 158 pixman_edge_t * r, 159 pixman_fixed_t t, 160 pixman_fixed_t b) 161 { 162 pixman_fixed_t y = t; 163 uint32_t *line; 164 int fill_start = -1, fill_end = -1; 165 int fill_size = 0; 166 uint32_t *buf = (image)->bits.bits; 167 int stride = (image)->bits.rowstride; 168 int width = (image)->bits.width; 169 170 line = buf + pixman_fixed_to_int (y) * stride; 171 172 for (;;) 173 { 174 uint8_t *ap = (uint8_t *) line; 175 pixman_fixed_t lx, rx; 176 int lxi, rxi; 177 178 /* clip X */ 179 lx = l->x; 180 if (lx < 0) 181 lx = 0; 182 183 rx = r->x; 184 185 if (pixman_fixed_to_int (rx) >= width) 186 { 187 /* Use the last pixel of the scanline, covered 100%. 188 * We can't use the first pixel following the scanline, 189 * because accessing it could result in a buffer overrun. 190 */ 191 rx = pixman_int_to_fixed (width) - 1; 192 } 193 194 /* Skip empty (or backwards) sections */ 195 if (rx > lx) 196 { 197 int lxs, rxs; 198 199 /* Find pixel bounds for span. */ 200 lxi = pixman_fixed_to_int (lx); 201 rxi = pixman_fixed_to_int (rx); 202 203 /* Sample coverage for edge pixels */ 204 lxs = RENDER_SAMPLES_X (lx, 8); 205 rxs = RENDER_SAMPLES_X (rx, 8); 206 207 /* Add coverage across row */ 208 if (lxi == rxi) 209 { 210 WRITE (image, ap + lxi, 211 clip255 (READ (image, ap + lxi) + rxs - lxs)); 212 } 213 else 214 { 215 WRITE (image, ap + lxi, 216 clip255 (READ (image, ap + lxi) + N_X_FRAC (8) - lxs)); 217 218 /* Move forward so that lxi/rxi is the pixel span */ 219 lxi++; 220 221 /* Don't bother trying to optimize the fill unless 222 * the span is longer than 4 pixels. */ 223 if (rxi - lxi > 4) 224 { 225 if (fill_start < 0) 226 { 227 fill_start = lxi; 228 fill_end = rxi; 229 fill_size++; 230 } 231 else 232 { 233 if (lxi >= fill_end || rxi < fill_start) 234 { 235 /* We're beyond what we saved, just fill it */ 236 ADD_SATURATE_8 (ap + fill_start, 237 fill_size * N_X_FRAC (8), 238 fill_end - fill_start); 239 fill_start = lxi; 240 fill_end = rxi; 241 fill_size = 1; 242 } 243 else 244 { 245 /* Update fill_start */ 246 if (lxi > fill_start) 247 { 248 ADD_SATURATE_8 (ap + fill_start, 249 fill_size * N_X_FRAC (8), 250 lxi - fill_start); 251 fill_start = lxi; 252 } 253 else if (lxi < fill_start) 254 { 255 ADD_SATURATE_8 (ap + lxi, N_X_FRAC (8), 256 fill_start - lxi); 257 } 258 259 /* Update fill_end */ 260 if (rxi < fill_end) 261 { 262 ADD_SATURATE_8 (ap + rxi, 263 fill_size * N_X_FRAC (8), 264 fill_end - rxi); 265 fill_end = rxi; 266 } 267 else if (fill_end < rxi) 268 { 269 ADD_SATURATE_8 (ap + fill_end, 270 N_X_FRAC (8), 271 rxi - fill_end); 272 } 273 fill_size++; 274 } 275 } 276 } 277 else 278 { 279 ADD_SATURATE_8 (ap + lxi, N_X_FRAC (8), rxi - lxi); 280 } 281 282 WRITE (image, ap + rxi, clip255 (READ (image, ap + rxi) + rxs)); 283 } 284 } 285 286 if (y == b) 287 { 288 /* We're done, make sure we clean up any remaining fill. */ 289 if (fill_start != fill_end) 290 { 291 if (fill_size == N_Y_FRAC (8)) 292 { 293 MEMSET_WRAPPED (image, ap + fill_start, 294 0xff, fill_end - fill_start); 295 } 296 else 297 { 298 ADD_SATURATE_8 (ap + fill_start, fill_size * N_X_FRAC (8), 299 fill_end - fill_start); 300 } 301 } 302 break; 303 } 304 305 if (pixman_fixed_frac (y) != Y_FRAC_LAST (8)) 306 { 307 RENDER_EDGE_STEP_SMALL (l); 308 RENDER_EDGE_STEP_SMALL (r); 309 y += STEP_Y_SMALL (8); 310 } 311 else 312 { 313 RENDER_EDGE_STEP_BIG (l); 314 RENDER_EDGE_STEP_BIG (r); 315 y += STEP_Y_BIG (8); 316 if (fill_start != fill_end) 317 { 318 if (fill_size == N_Y_FRAC (8)) 319 { 320 MEMSET_WRAPPED (image, ap + fill_start, 321 0xff, fill_end - fill_start); 322 } 323 else 324 { 325 ADD_SATURATE_8 (ap + fill_start, fill_size * N_X_FRAC (8), 326 fill_end - fill_start); 327 } 328 329 fill_start = fill_end = -1; 330 fill_size = 0; 331 } 332 333 line += stride; 334 } 335 } 336 } 337 338 #ifndef PIXMAN_FB_ACCESSORS 339 static 340 #endif 341 void 342 PIXMAN_RASTERIZE_EDGES (pixman_image_t *image, 343 pixman_edge_t * l, 344 pixman_edge_t * r, 345 pixman_fixed_t t, 346 pixman_fixed_t b) 347 { 348 switch (PIXMAN_FORMAT_BPP (image->bits.format)) 349 { 350 case 1: 351 rasterize_edges_1 (image, l, r, t, b); 352 break; 353 354 case 4: 355 rasterize_edges_4 (image, l, r, t, b); 356 break; 357 358 case 8: 359 rasterize_edges_8 (image, l, r, t, b); 360 break; 361 362 default: 363 break; 364 } 365 } 366 367 #ifndef PIXMAN_FB_ACCESSORS 368 369 PIXMAN_EXPORT void 370 pixman_rasterize_edges (pixman_image_t *image, 371 pixman_edge_t * l, 372 pixman_edge_t * r, 373 pixman_fixed_t t, 374 pixman_fixed_t b) 375 { 376 return_if_fail (image->type == BITS); 377 return_if_fail (PIXMAN_FORMAT_TYPE (image->bits.format) == PIXMAN_TYPE_A); 378 379 if (image->bits.read_func || image->bits.write_func) 380 pixman_rasterize_edges_accessors (image, l, r, t, b); 381 else 382 pixman_rasterize_edges_no_accessors (image, l, r, t, b); 383 } 384 385 #endif 386
