Go to most recent revision | Details | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 4680 | right-hear | 1 | #include "fitz.h" |
| 2 | |||
| 3 | typedef unsigned char byte; |
||
| 4 | |||
| 5 | /* These C implementations use SWAR (SIMD-within-a-register) techniques. */ |
||
| 6 | |||
| 7 | #if 0 /* TODO: move into porterduff.c functions */ |
||
| 8 | |||
| 9 | #define MASK 0xFF00FF00; |
||
| 10 | |||
| 11 | static void |
||
| 12 | path_w4i1o4_32bit(byte *rgba, |
||
| 13 | byte * restrict src, byte cov, int len, byte * restrict dst) |
||
| 14 | { |
||
| 15 | /* COLOR * coverage + DST * (256-coverage) = (COLOR - DST)*coverage + DST*256 */ |
||
| 16 | unsigned int *dst32 = (unsigned int *)(void *)dst; |
||
| 17 | int alpha = rgba[3]; |
||
| 18 | unsigned int rb = rgba[0] | (rgba[2] << 16); |
||
| 19 | unsigned int ga = rgba[1] | 0xFF0000; |
||
| 20 | |||
| 21 | if (alpha == 0) |
||
| 22 | return; |
||
| 23 | |||
| 24 | if (alpha != 255) |
||
| 25 | { |
||
| 26 | alpha += alpha>>7; /* alpha is now in the 0...256 range */ |
||
| 27 | while (len--) |
||
| 28 | { |
||
| 29 | unsigned int ca, drb, dga, crb, cga; |
||
| 30 | cov += *src; *src++ = 0; |
||
| 31 | ca = cov + (cov>>7); /* ca is in 0...256 range */ |
||
| 32 | ca = (ca*alpha)>>8; /* ca is is in 0...256 range */ |
||
| 33 | drb = *dst32++; |
||
| 34 | if (ca != 0) |
||
| 35 | { |
||
| 36 | dga = drb & MASK; |
||
| 37 | drb = (drb<<8) & MASK; |
||
| 38 | cga = ga - (dga>>8); |
||
| 39 | crb = rb - (drb>>8); |
||
| 40 | dga += cga * ca; |
||
| 41 | drb += crb * ca; |
||
| 42 | dga &= MASK; |
||
| 43 | drb &= MASK; |
||
| 44 | drb = dga | (drb>>8); |
||
| 45 | dst32[-1] = drb; |
||
| 46 | } |
||
| 47 | } |
||
| 48 | } |
||
| 49 | else |
||
| 50 | { |
||
| 51 | while (len--) |
||
| 52 | { |
||
| 53 | unsigned int ca, drb, dga, crb, cga; |
||
| 54 | cov += *src; *src++ = 0; |
||
| 55 | ca = cov + (cov>>7); /* ca is in 0...256 range */ |
||
| 56 | drb = *dst32++; |
||
| 57 | if (ca == 0) |
||
| 58 | continue; |
||
| 59 | if (ca == 255) |
||
| 60 | { |
||
| 61 | drb = (ga<<8) | rb; |
||
| 62 | } |
||
| 63 | else |
||
| 64 | { |
||
| 65 | dga = drb & MASK; |
||
| 66 | drb = (drb<<8) & MASK; |
||
| 67 | cga = ga - (dga>>8); |
||
| 68 | crb = rb - (drb>>8); |
||
| 69 | dga += cga * ca; |
||
| 70 | drb += crb * ca; |
||
| 71 | dga &= MASK; |
||
| 72 | drb &= MASK; |
||
| 73 | drb = dga |(drb>>8); |
||
| 74 | } |
||
| 75 | dst32[-1] = drb; |
||
| 76 | } |
||
| 77 | } |
||
| 78 | } |
||
| 79 | |||
| 80 | static void |
||
| 81 | text_w4i1o4_32bit(byte *rgba, |
||
| 82 | byte * restrict src, int srcw, |
||
| 83 | byte * restrict dst, int dstw, int w0, int h) |
||
| 84 | { |
||
| 85 | unsigned int *dst32 = (unsigned int *)(void *)dst; |
||
| 86 | unsigned int alpha = rgba[3]; |
||
| 87 | unsigned int rb = rgba[0] | (rgba[2] << 16); |
||
| 88 | unsigned int ga = rgba[1] | 0xFF0000; |
||
| 89 | |||
| 90 | if (alpha == 0) |
||
| 91 | return; |
||
| 92 | |||
| 93 | srcw -= w0; |
||
| 94 | dstw = (dstw>>2)-w0; |
||
| 95 | |||
| 96 | if (alpha != 255) |
||
| 97 | { |
||
| 98 | alpha += alpha>>7; /* alpha is now in the 0...256 range */ |
||
| 99 | while (h--) |
||
| 100 | { |
||
| 101 | int w = w0; |
||
| 102 | while (w--) |
||
| 103 | { |
||
| 104 | unsigned int ca, drb, dga, crb, cga; |
||
| 105 | ca = *src++; |
||
| 106 | drb = *dst32++; |
||
| 107 | ca += ca>>7; |
||
| 108 | ca = (ca*alpha)>>8; |
||
| 109 | if (ca == 0) |
||
| 110 | continue; |
||
| 111 | dga = drb & MASK; |
||
| 112 | drb = (drb<<8) & MASK; |
||
| 113 | cga = ga - (dga>>8); |
||
| 114 | crb = rb - (drb>>8); |
||
| 115 | dga += cga * ca; |
||
| 116 | drb += crb * ca; |
||
| 117 | dga &= MASK; |
||
| 118 | drb &= MASK; |
||
| 119 | drb = dga | (drb>>8); |
||
| 120 | dst32[-1] = drb; |
||
| 121 | } |
||
| 122 | src += srcw; |
||
| 123 | dst32 += dstw; |
||
| 124 | } |
||
| 125 | } |
||
| 126 | else |
||
| 127 | { |
||
| 128 | while (h--) |
||
| 129 | { |
||
| 130 | int w = w0; |
||
| 131 | while (w--) |
||
| 132 | { |
||
| 133 | unsigned int ca, drb, dga, crb, cga; |
||
| 134 | ca = *src++; |
||
| 135 | drb = *dst32++; |
||
| 136 | ca += ca>>7; |
||
| 137 | if (ca == 0) |
||
| 138 | continue; |
||
| 139 | dga = drb & MASK; |
||
| 140 | drb = (drb<<8) & MASK; |
||
| 141 | cga = ga - (dga>>8); |
||
| 142 | crb = rb - (drb>>8); |
||
| 143 | dga += cga * ca; |
||
| 144 | drb += crb * ca; |
||
| 145 | dga &= MASK; |
||
| 146 | drb &= MASK; |
||
| 147 | drb = dga | (drb>>8); |
||
| 148 | dst32[-1] = drb; |
||
| 149 | } |
||
| 150 | src += srcw; |
||
| 151 | dst32 += dstw; |
||
| 152 | } |
||
| 153 | } |
||
| 154 | } |
||
| 155 | |||
| 156 | static void |
||
| 157 | img_4o4_32bit(byte * restrict src, byte cov, int len, byte * restrict dst, |
||
| 158 | fz_pixmap *image, int u, int v, int fa, int fb) |
||
| 159 | { |
||
| 160 | unsigned int *dst32 = (unsigned int *)(void *)dst; |
||
| 161 | unsigned int *samples = (unsigned int *)(void *)image->samples; |
||
| 162 | int w = image->w; |
||
| 163 | int h = image->h-1; |
||
| 164 | |||
| 165 | while (len--) |
||
| 166 | { |
||
| 167 | unsigned int a, a1, d, d1; |
||
| 168 | int sa; |
||
| 169 | cov += *src; *src = 0; src++; |
||
| 170 | /* (a,a1) = sampleargb(samples, w, h, u, v, argb); */ |
||
| 171 | { |
||
| 172 | int ui, ui1, vi, vi1, ud, vd; |
||
| 173 | unsigned int b, b1, c, c1; |
||
| 174 | ui1 = 1; |
||
| 175 | ui = u >> 16; |
||
| 176 | if (ui < 0) |
||
| 177 | { |
||
| 178 | ui = 0; |
||
| 179 | ui1 = 0; |
||
| 180 | } |
||
| 181 | else if (ui >= w-1) |
||
| 182 | { |
||
| 183 | ui = w-1; |
||
| 184 | ui1 = 0; |
||
| 185 | } |
||
| 186 | vi1 = w; |
||
| 187 | vi = v >> 16; |
||
| 188 | if (vi < 0) |
||
| 189 | { |
||
| 190 | vi = 0; |
||
| 191 | vi1 = 0; |
||
| 192 | } |
||
| 193 | else if (vi >= h) |
||
| 194 | { |
||
| 195 | vi = h; |
||
| 196 | vi1 = 0; |
||
| 197 | } |
||
| 198 | ui += vi*w; |
||
| 199 | a = samples[ui]; |
||
| 200 | b = samples[ui + ui1]; |
||
| 201 | c = samples[ui + vi1]; |
||
| 202 | d = samples[ui + ui1 + vi1]; |
||
| 203 | ud = (u>>8) & 0xFF; |
||
| 204 | vd = (v>>8) & 0xFF; |
||
| 205 | ud = FZ_EXPAND(ud); |
||
| 206 | vd = FZ_EXPAND(vd); |
||
| 207 | /* (a,a1) = blend(a,b,ud) */ |
||
| 208 | a1 = a & MASK; |
||
| 209 | a = (a<<8) & MASK; |
||
| 210 | b1 = (b>>8) & ~MASK; |
||
| 211 | b = b & ~MASK; |
||
| 212 | a = ((b -(a >>8)) * ud + a ) & MASK; |
||
| 213 | a1 = ((b1-(a1>>8)) * ud + a1) & MASK; |
||
| 214 | /* (c,c1) = blend(c,d,ud) */ |
||
| 215 | c1 = c & MASK; |
||
| 216 | c = (c<<8) & MASK; |
||
| 217 | d1 = (d>>8) & ~MASK; |
||
| 218 | d = d & ~MASK; |
||
| 219 | c = ((d -(c >>8)) * ud + c ) & MASK; |
||
| 220 | c1 = ((d1-(c1>>8)) * ud + c1) & MASK; |
||
| 221 | /* (a,a1) = blend((a,a1),(c,c1),vd) */ |
||
| 222 | a = (((c >>8)-(a >>8)) * vd + a ) & MASK; |
||
| 223 | a1 = (((c1>>8)-(a1>>8)) * vd + a1) & MASK; |
||
| 224 | } |
||
| 225 | sa = (a1>>24); |
||
| 226 | sa = FZ_COMBINE(FZ_EXPAND(sa), FZ_EXPAND(cov)); |
||
| 227 | a1 |= 0xFF000000; |
||
| 228 | d = *dst32++; |
||
| 229 | d1 = d & MASK; |
||
| 230 | d = (d<<8) & MASK; |
||
| 231 | a = (((a >>8)-(d >>8)) * sa + d ) & MASK; |
||
| 232 | a1 = (((a1>>8)-(d1>>8)) * sa + d1) & MASK; |
||
| 233 | dst32[-1] = (a>>8) | a1; |
||
| 234 | u += fa; |
||
| 235 | v += fb; |
||
| 236 | } |
||
| 237 | } |
||
| 238 | |||
| 239 | static void |
||
| 240 | img_w4i1o4_32bit(byte *rgba, byte * restrict src, byte cov, int len, |
||
| 241 | byte * restrict dst, fz_pixmap *image, int u, int v, int fa, int fb) |
||
| 242 | { |
||
| 243 | byte *samples = image->samples; |
||
| 244 | int w = image->w; |
||
| 245 | int h = image->h-1; |
||
| 246 | int alpha = FZ_EXPAND(rgba[3]); |
||
| 247 | unsigned int rb = rgba[0] | (rgba[2] << 16); |
||
| 248 | unsigned int ga = rgba[1] | 0xFF0000; |
||
| 249 | unsigned int *dst32 = (unsigned int *)(void *)dst; |
||
| 250 | |||
| 251 | if (alpha == 0) |
||
| 252 | return; |
||
| 253 | if (alpha != 256) |
||
| 254 | { |
||
| 255 | while (len--) |
||
| 256 | { |
||
| 257 | unsigned int ca, drb, dga, crb, cga; |
||
| 258 | unsigned int a, b; |
||
| 259 | cov += *src; *src = 0; src++; |
||
| 260 | drb = *dst32++; |
||
| 261 | ca = FZ_COMBINE(FZ_EXPAND(cov), alpha); |
||
| 262 | if (ca != 0) |
||
| 263 | { |
||
| 264 | int ui, ui1, vi, vi1, ud, vd; |
||
| 265 | /* a = samplemask(samples, w, h, u, v); */ |
||
| 266 | ui1 = 1; |
||
| 267 | ui = u >> 16; |
||
| 268 | if (ui < 0) |
||
| 269 | { |
||
| 270 | ui = 0; |
||
| 271 | ui1 = 0; |
||
| 272 | } |
||
| 273 | else if (ui >= w-1) |
||
| 274 | { |
||
| 275 | ui = w-1; |
||
| 276 | ui1 = 0; |
||
| 277 | } |
||
| 278 | vi1 = w; |
||
| 279 | vi = v >> 16; |
||
| 280 | if (vi < 0) |
||
| 281 | { |
||
| 282 | vi = 0; |
||
| 283 | vi1 = 0; |
||
| 284 | } |
||
| 285 | else if (vi >= h) |
||
| 286 | { |
||
| 287 | vi = h; |
||
| 288 | vi1 = 0; |
||
| 289 | } |
||
| 290 | ui += vi*w; |
||
| 291 | a = samples[ui]; |
||
| 292 | b = samples[ui + ui1]; |
||
| 293 | a |= samples[ui + vi1]<<16; |
||
| 294 | b |= samples[ui + ui1 + vi1]<<16; |
||
| 295 | ud = (u>>8) & 0xFF; |
||
| 296 | vd = (v>>8) & 0xFF; |
||
| 297 | ud = FZ_EXPAND(ud); |
||
| 298 | vd = FZ_EXPAND(vd); |
||
| 299 | /* a = blend(a,b,ud) */ |
||
| 300 | a = ((b-a) * ud + (a<<8)) & MASK; |
||
| 301 | /* a = blend(a,a>>16,vd) */ |
||
| 302 | a = (((a>>24)-(a>>8)) * vd + a); |
||
| 303 | a = (a>>8) & 0xFF; |
||
| 304 | ca = FZ_COMBINE(ca, FZ_EXPAND(a)); |
||
| 305 | } |
||
| 306 | if (ca != 0) |
||
| 307 | { |
||
| 308 | dga = drb & MASK; |
||
| 309 | drb = (drb<<8) & MASK; |
||
| 310 | cga = ga - (dga>>8); |
||
| 311 | crb = rb - (drb>>8); |
||
| 312 | dga += cga * ca; |
||
| 313 | drb += crb * ca; |
||
| 314 | dga &= MASK; |
||
| 315 | drb &= MASK; |
||
| 316 | drb = dga | (drb>>8); |
||
| 317 | dst32[-1] = drb; |
||
| 318 | } |
||
| 319 | u += fa; |
||
| 320 | v += fb; |
||
| 321 | } |
||
| 322 | } |
||
| 323 | else |
||
| 324 | { |
||
| 325 | while (len--) |
||
| 326 | { |
||
| 327 | unsigned int ca, drb, dga, crb, cga; |
||
| 328 | unsigned int a, b; |
||
| 329 | cov += *src; *src = 0; src++; |
||
| 330 | drb = *dst32++; |
||
| 331 | if (cov != 0) |
||
| 332 | { |
||
| 333 | int ui, ui1, vi, vi1, ud, vd; |
||
| 334 | /* a = samplemask(samples, w, h, u, v); */ |
||
| 335 | ui1 = 1; |
||
| 336 | ui = u >> 16; |
||
| 337 | if (ui < 0) |
||
| 338 | { |
||
| 339 | ui = 0; |
||
| 340 | ui1 = 0; |
||
| 341 | } |
||
| 342 | else if (ui >= w-1) |
||
| 343 | { |
||
| 344 | ui = w-1; |
||
| 345 | ui1 = 0; |
||
| 346 | } |
||
| 347 | vi1 = w; |
||
| 348 | vi = v >> 16; |
||
| 349 | if (vi < 0) |
||
| 350 | { |
||
| 351 | vi = 0; |
||
| 352 | vi1 = 0; |
||
| 353 | } |
||
| 354 | else if (vi >= h) |
||
| 355 | { |
||
| 356 | vi = h; |
||
| 357 | vi1 = 0; |
||
| 358 | } |
||
| 359 | ui += vi*w; |
||
| 360 | a = samples[ui]; |
||
| 361 | b = samples[ui + ui1]; |
||
| 362 | a |= samples[ui + vi1]<<16; |
||
| 363 | b |= samples[ui + ui1 + vi1]<<16; |
||
| 364 | ud = (u>>8) & 0xFF; |
||
| 365 | vd = (v>>8) & 0xFF; |
||
| 366 | ud = FZ_EXPAND(ud); |
||
| 367 | vd = FZ_EXPAND(vd); |
||
| 368 | /* a = blend(a,b,ud) */ |
||
| 369 | a = ((b-a) * ud + (a<<8)) & MASK; |
||
| 370 | /* a = blend(a,a>>16,vd) */ |
||
| 371 | a = (((a>>24)-(a>>8)) * vd + a); |
||
| 372 | a = (a>>8) & 0xFF; |
||
| 373 | ca = FZ_COMBINE(FZ_EXPAND(cov),FZ_EXPAND(a)); |
||
| 374 | if (ca != 0) |
||
| 375 | { |
||
| 376 | if (ca == 256) |
||
| 377 | { |
||
| 378 | drb = (ga<<8) | rb; |
||
| 379 | } |
||
| 380 | else |
||
| 381 | { |
||
| 382 | dga = drb & MASK; |
||
| 383 | drb = (drb<<8) & MASK; |
||
| 384 | cga = ga - (dga>>8); |
||
| 385 | crb = rb - (drb>>8); |
||
| 386 | dga += cga * ca; |
||
| 387 | drb += crb * ca; |
||
| 388 | dga &= MASK; |
||
| 389 | drb &= MASK; |
||
| 390 | drb = dga | (drb>>8); |
||
| 391 | } |
||
| 392 | dst32[-1] = drb; |
||
| 393 | } |
||
| 394 | } |
||
| 395 | u += fa; |
||
| 396 | v += fb; |
||
| 397 | } |
||
| 398 | } |
||
| 399 | } |
||
| 400 | |||
| 401 | static void |
||
| 402 | img_1o1_32bit(byte * restrict src, byte cov, int len, byte * restrict dst, |
||
| 403 | fz_pixmap *image, int u, int v, int fa, int fb) |
||
| 404 | { |
||
| 405 | byte *samples = image->samples; |
||
| 406 | int w = image->w; |
||
| 407 | int h = image->h-1; |
||
| 408 | |||
| 409 | while (len--) |
||
| 410 | { |
||
| 411 | unsigned int a, b; |
||
| 412 | cov += *src; *src = 0; src++; |
||
| 413 | if (cov != 0) |
||
| 414 | { |
||
| 415 | int ui, ui1, vi, vi1, ud, vd; |
||
| 416 | /* sa = samplemask(samples, w, h, u, v); */ |
||
| 417 | ui1 = 1; |
||
| 418 | ui = u >> 16; |
||
| 419 | if (ui < 0) |
||
| 420 | { |
||
| 421 | ui = 0; |
||
| 422 | ui1 = 0; |
||
| 423 | } |
||
| 424 | else if (ui >= w-1) |
||
| 425 | { |
||
| 426 | ui = w-1; |
||
| 427 | ui1 = 0; |
||
| 428 | } |
||
| 429 | vi1 = w; |
||
| 430 | vi = v >> 16; |
||
| 431 | if (vi < 0) |
||
| 432 | { |
||
| 433 | vi = 0; |
||
| 434 | vi1 = 0; |
||
| 435 | } |
||
| 436 | else if (vi >= h) |
||
| 437 | { |
||
| 438 | vi = h; |
||
| 439 | vi1 = 0; |
||
| 440 | } |
||
| 441 | ui += vi*w; |
||
| 442 | a = samples[ui]; |
||
| 443 | b = samples[ui + ui1]; |
||
| 444 | a |= samples[ui + vi1]<<16; |
||
| 445 | b |= samples[ui + ui1 + vi1]<<16; |
||
| 446 | ud = (u>>8) & 0xFF; |
||
| 447 | vd = (v>>8) & 0xFF; |
||
| 448 | ud = FZ_EXPAND(ud); |
||
| 449 | vd = FZ_EXPAND(vd); |
||
| 450 | /* a = blend(a,b,ud) */ |
||
| 451 | a = ((b-a) * ud + (a<<8)) & MASK; |
||
| 452 | /* a = blend(a,a>>16,vd) */ |
||
| 453 | a = (((a>>24)-(a>>8)) * vd + a); |
||
| 454 | a = (a>>8) & 0xFF; |
||
| 455 | a = FZ_COMBINE(FZ_EXPAND(a), FZ_EXPAND(cov)); |
||
| 456 | if (a != 0) |
||
| 457 | { |
||
| 458 | if (a == 256) |
||
| 459 | dst[0] = 255; |
||
| 460 | else |
||
| 461 | dst[0] = FZ_BLEND(255, dst[0], a); |
||
| 462 | } |
||
| 463 | } |
||
| 464 | dst++; |
||
| 465 | u += fa; |
||
| 466 | v += fb; |
||
| 467 | } |
||
| 468 | } |
||
| 469 | |||
| 470 | #endif |
||
| 471 | |||
| 472 | void fz_accelerate(void) |
||
| 473 | { |
||
| 474 | if (sizeof(int) == 4 && sizeof(unsigned int) == 4 && !fz_is_big_endian()) |
||
| 475 | { |
||
| 476 | // fz_path_w4i1o4 = path_w4i1o4_32bit; |
||
| 477 | // fz_text_w4i1o4 = text_w4i1o4_32bit; |
||
| 478 | // fz_img_4o4 = img_4o4_32bit; |
||
| 479 | // fz_img_w4i1o4 = img_w4i1o4_32bit; |
||
| 480 | // fz_img_1o1 = img_1o1_32bit; |
||
| 481 | } |
||
| 482 | |||
| 483 | #ifdef HAVE_CPUDEP |
||
| 484 | fz_accelerate_arch(); |
||
| 485 | #endif |
||
| 486 | } |