1 /* 2 * Copyright 2006 The Android Open Source Project 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8 #include "SkCoreBlitters.h" 9 #include "SkColorPriv.h" 10 #include "SkShader.h" 11 #include "SkUtils.h" 12 #include "SkXfermode.h" 13 #include "SkBlitMask.h" 14 15 /////////////////////////////////////////////////////////////////////////////// 16 17 static void SkARGB32_Blit32(const SkBitmap& device, const SkMask& mask, 18 const SkIRect& clip, SkPMColor srcColor) { 19 U8CPU alpha = SkGetPackedA32(srcColor); 20 unsigned flags = SkBlitRow::kSrcPixelAlpha_Flag32; 21 if (alpha != 255) { 22 flags |= SkBlitRow::kGlobalAlpha_Flag32; 23 } 24 SkBlitRow::Proc32 proc = SkBlitRow::Factory32(flags); 25 26 int x = clip.fLeft; 27 int y = clip.fTop; 28 int width = clip.width(); 29 int height = clip.height(); 30 31 SkPMColor* dstRow = device.getAddr32(x, y); 32 const SkPMColor* srcRow = reinterpret_cast<const SkPMColor*>(mask.getAddr8(x, y)); 33 34 do { 35 proc(dstRow, srcRow, width, alpha); 36 dstRow = (SkPMColor*)((char*)dstRow + device.rowBytes()); 37 srcRow = (const SkPMColor*)((const char*)srcRow + mask.fRowBytes); 38 } while (--height != 0); 39 } 40 41 ////////////////////////////////////////////////////////////////////////////////////// 42 43 SkARGB32_Blitter::SkARGB32_Blitter(const SkBitmap& device, const SkPaint& paint) 44 : INHERITED(device) { 45 SkColor color = paint.getColor(); 46 fColor = color; 47 48 fSrcA = SkColorGetA(color); 49 unsigned scale = SkAlpha255To256(fSrcA); 50 fSrcR = SkAlphaMul(SkColorGetR(color), scale); 51 fSrcG = SkAlphaMul(SkColorGetG(color), scale); 52 fSrcB = SkAlphaMul(SkColorGetB(color), scale); 53 54 fPMColor = SkPackARGB32(fSrcA, fSrcR, fSrcG, fSrcB); 55 fColor32Proc = SkBlitRow::ColorProcFactory(); 56 fColorRect32Proc = SkBlitRow::ColorRectProcFactory(); 57 } 58 59 const SkBitmap* SkARGB32_Blitter::justAnOpaqueColor(uint32_t* value) { 60 if (255 == fSrcA) { 61 *value = fPMColor; 62 return &fDevice; 63 } 64 return NULL; 65 } 66 67 #if defined _WIN32 && _MSC_VER >= 1300 // disable warning : local variable used without having been initialized 68 #pragma warning ( push ) 69 #pragma warning ( disable : 4701 ) 70 #endif 71 72 void SkARGB32_Blitter::blitH(int x, int y, int width) { 73 SkASSERT(x >= 0 && y >= 0 && x + width <= fDevice.width()); 74 75 uint32_t* device = fDevice.getAddr32(x, y); 76 fColor32Proc(device, device, width, fPMColor); 77 } 78 79 void SkARGB32_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[], 80 const int16_t runs[]) { 81 if (fSrcA == 0) { 82 return; 83 } 84 85 uint32_t color = fPMColor; 86 uint32_t* device = fDevice.getAddr32(x, y); 87 unsigned opaqueMask = fSrcA; // if fSrcA is 0xFF, then we will catch the fast opaque case 88 89 for (;;) { 90 int count = runs[0]; 91 SkASSERT(count >= 0); 92 if (count <= 0) { 93 return; 94 } 95 unsigned aa = antialias[0]; 96 if (aa) { 97 if ((opaqueMask & aa) == 255) { 98 sk_memset32(device, color, count); 99 } else { 100 uint32_t sc = SkAlphaMulQ(color, SkAlpha255To256(aa)); 101 fColor32Proc(device, device, count, sc); 102 } 103 } 104 runs += count; 105 antialias += count; 106 device += count; 107 } 108 } 109 110 ////////////////////////////////////////////////////////////////////////////////////// 111 112 #define solid_8_pixels(mask, dst, color) \ 113 do { \ 114 if (mask & 0x80) dst[0] = color; \ 115 if (mask & 0x40) dst[1] = color; \ 116 if (mask & 0x20) dst[2] = color; \ 117 if (mask & 0x10) dst[3] = color; \ 118 if (mask & 0x08) dst[4] = color; \ 119 if (mask & 0x04) dst[5] = color; \ 120 if (mask & 0x02) dst[6] = color; \ 121 if (mask & 0x01) dst[7] = color; \ 122 } while (0) 123 124 #define SK_BLITBWMASK_NAME SkARGB32_BlitBW 125 #define SK_BLITBWMASK_ARGS , SkPMColor color 126 #define SK_BLITBWMASK_BLIT8(mask, dst) solid_8_pixels(mask, dst, color) 127 #define SK_BLITBWMASK_GETADDR getAddr32 128 #define SK_BLITBWMASK_DEVTYPE uint32_t 129 #include "SkBlitBWMaskTemplate.h" 130 131 #define blend_8_pixels(mask, dst, sc, dst_scale) \ 132 do { \ 133 if (mask & 0x80) { dst[0] = sc + SkAlphaMulQ(dst[0], dst_scale); } \ 134 if (mask & 0x40) { dst[1] = sc + SkAlphaMulQ(dst[1], dst_scale); } \ 135 if (mask & 0x20) { dst[2] = sc + SkAlphaMulQ(dst[2], dst_scale); } \ 136 if (mask & 0x10) { dst[3] = sc + SkAlphaMulQ(dst[3], dst_scale); } \ 137 if (mask & 0x08) { dst[4] = sc + SkAlphaMulQ(dst[4], dst_scale); } \ 138 if (mask & 0x04) { dst[5] = sc + SkAlphaMulQ(dst[5], dst_scale); } \ 139 if (mask & 0x02) { dst[6] = sc + SkAlphaMulQ(dst[6], dst_scale); } \ 140 if (mask & 0x01) { dst[7] = sc + SkAlphaMulQ(dst[7], dst_scale); } \ 141 } while (0) 142 143 #define SK_BLITBWMASK_NAME SkARGB32_BlendBW 144 #define SK_BLITBWMASK_ARGS , uint32_t sc, unsigned dst_scale 145 #define SK_BLITBWMASK_BLIT8(mask, dst) blend_8_pixels(mask, dst, sc, dst_scale) 146 #define SK_BLITBWMASK_GETADDR getAddr32 147 #define SK_BLITBWMASK_DEVTYPE uint32_t 148 #include "SkBlitBWMaskTemplate.h" 149 150 void SkARGB32_Blitter::blitMask(const SkMask& mask, const SkIRect& clip) { 151 SkASSERT(mask.fBounds.contains(clip)); 152 SkASSERT(fSrcA != 0xFF); 153 154 if (fSrcA == 0) { 155 return; 156 } 157 158 if (SkBlitMask::BlitColor(fDevice, mask, clip, fColor)) { 159 return; 160 } 161 162 if (mask.fFormat == SkMask::kBW_Format) { 163 SkARGB32_BlendBW(fDevice, mask, clip, fPMColor, SkAlpha255To256(255 - fSrcA)); 164 } else if (SkMask::kARGB32_Format == mask.fFormat) { 165 SkARGB32_Blit32(fDevice, mask, clip, fPMColor); 166 } 167 } 168 169 void SkARGB32_Opaque_Blitter::blitMask(const SkMask& mask, 170 const SkIRect& clip) { 171 SkASSERT(mask.fBounds.contains(clip)); 172 173 if (SkBlitMask::BlitColor(fDevice, mask, clip, fColor)) { 174 return; 175 } 176 177 if (mask.fFormat == SkMask::kBW_Format) { 178 SkARGB32_BlitBW(fDevice, mask, clip, fPMColor); 179 } else if (SkMask::kARGB32_Format == mask.fFormat) { 180 SkARGB32_Blit32(fDevice, mask, clip, fPMColor); 181 } 182 } 183 184 /////////////////////////////////////////////////////////////////////////////// 185 186 void SkARGB32_Blitter::blitV(int x, int y, int height, SkAlpha alpha) { 187 if (alpha == 0 || fSrcA == 0) { 188 return; 189 } 190 191 uint32_t* device = fDevice.getAddr32(x, y); 192 uint32_t color = fPMColor; 193 194 if (alpha != 255) { 195 color = SkAlphaMulQ(color, SkAlpha255To256(alpha)); 196 } 197 198 unsigned dst_scale = 255 - SkGetPackedA32(color); 199 uint32_t rowBytes = fDevice.rowBytes(); 200 while (--height >= 0) { 201 device[0] = color + SkAlphaMulQ(device[0], dst_scale); 202 device = (uint32_t*)((char*)device + rowBytes); 203 } 204 } 205 206 void SkARGB32_Blitter::blitRect(int x, int y, int width, int height) { 207 SkASSERT(x >= 0 && y >= 0 && x + width <= fDevice.width() && y + height <= fDevice.height()); 208 209 if (fSrcA == 0) { 210 return; 211 } 212 213 uint32_t* device = fDevice.getAddr32(x, y); 214 uint32_t color = fPMColor; 215 size_t rowBytes = fDevice.rowBytes(); 216 217 if (255 == SkGetPackedA32(color)) { 218 fColorRect32Proc(device, width, height, rowBytes, color); 219 } else { 220 while (--height >= 0) { 221 fColor32Proc(device, device, width, color); 222 device = (uint32_t*)((char*)device + rowBytes); 223 } 224 } 225 } 226 227 #if defined _WIN32 && _MSC_VER >= 1300 228 #pragma warning ( pop ) 229 #endif 230 231 /////////////////////////////////////////////////////////////////////// 232 233 void SkARGB32_Black_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[], 234 const int16_t runs[]) { 235 uint32_t* device = fDevice.getAddr32(x, y); 236 SkPMColor black = (SkPMColor)(SK_A32_MASK << SK_A32_SHIFT); 237 238 for (;;) { 239 int count = runs[0]; 240 SkASSERT(count >= 0); 241 if (count <= 0) { 242 return; 243 } 244 unsigned aa = antialias[0]; 245 if (aa) { 246 if (aa == 255) { 247 sk_memset32(device, black, count); 248 } else { 249 SkPMColor src = aa << SK_A32_SHIFT; 250 unsigned dst_scale = 256 - aa; 251 int n = count; 252 do { 253 --n; 254 device[n] = src + SkAlphaMulQ(device[n], dst_scale); 255 } while (n > 0); 256 } 257 } 258 runs += count; 259 antialias += count; 260 device += count; 261 } 262 } 263 264 /////////////////////////////////////////////////////////////////////////////// 265 266 // Special version of SkBlitRow::Factory32 that knows we're in kSrc_Mode, 267 // instead of kSrcOver_Mode 268 static void blend_srcmode(SkPMColor* SK_RESTRICT device, 269 const SkPMColor* SK_RESTRICT span, 270 int count, U8CPU aa) { 271 int aa256 = SkAlpha255To256(aa); 272 for (int i = 0; i < count; ++i) { 273 device[i] = SkFourByteInterp256(span[i], device[i], aa256); 274 } 275 } 276 277 SkARGB32_Shader_Blitter::SkARGB32_Shader_Blitter(const SkBitmap& device, 278 const SkPaint& paint) : INHERITED(device, paint) { 279 fBuffer = (SkPMColor*)sk_malloc_throw(device.width() * (sizeof(SkPMColor))); 280 281 fXfermode = paint.getXfermode(); 282 SkSafeRef(fXfermode); 283 284 int flags = 0; 285 if (!(fShader->getFlags() & SkShader::kOpaqueAlpha_Flag)) { 286 flags |= SkBlitRow::kSrcPixelAlpha_Flag32; 287 } 288 // we call this on the output from the shader 289 fProc32 = SkBlitRow::Factory32(flags); 290 // we call this on the output from the shader + alpha from the aa buffer 291 fProc32Blend = SkBlitRow::Factory32(flags | SkBlitRow::kGlobalAlpha_Flag32); 292 293 fShadeDirectlyIntoDevice = false; 294 if (fXfermode == NULL) { 295 if (fShader->getFlags() & SkShader::kOpaqueAlpha_Flag) { 296 fShadeDirectlyIntoDevice = true; 297 } 298 } else { 299 SkXfermode::Mode mode; 300 if (fXfermode->asMode(&mode)) { 301 if (SkXfermode::kSrc_Mode == mode) { 302 fShadeDirectlyIntoDevice = true; 303 fProc32Blend = blend_srcmode; 304 } 305 } 306 } 307 308 fConstInY = SkToBool(fShader->getFlags() & SkShader::kConstInY32_Flag); 309 } 310 311 SkARGB32_Shader_Blitter::~SkARGB32_Shader_Blitter() { 312 SkSafeUnref(fXfermode); 313 sk_free(fBuffer); 314 } 315 316 void SkARGB32_Shader_Blitter::blitH(int x, int y, int width) { 317 SkASSERT(x >= 0 && y >= 0 && x + width <= fDevice.width()); 318 319 uint32_t* device = fDevice.getAddr32(x, y); 320 321 if (fShadeDirectlyIntoDevice) { 322 fShader->shadeSpan(x, y, device, width); 323 } else { 324 SkPMColor* span = fBuffer; 325 fShader->shadeSpan(x, y, span, width); 326 if (fXfermode) { 327 fXfermode->xfer32(device, span, width, NULL); 328 } else { 329 fProc32(device, span, width, 255); 330 } 331 } 332 } 333 334 void SkARGB32_Shader_Blitter::blitRect(int x, int y, int width, int height) { 335 SkASSERT(x >= 0 && y >= 0 && 336 x + width <= fDevice.width() && y + height <= fDevice.height()); 337 338 uint32_t* device = fDevice.getAddr32(x, y); 339 size_t deviceRB = fDevice.rowBytes(); 340 SkShader* shader = fShader; 341 SkPMColor* span = fBuffer; 342 343 if (fConstInY) { 344 if (fShadeDirectlyIntoDevice) { 345 // shade the first row directly into the device 346 fShader->shadeSpan(x, y, device, width); 347 span = device; 348 while (--height > 0) { 349 device = (uint32_t*)((char*)device + deviceRB); 350 memcpy(device, span, width << 2); 351 } 352 } else { 353 fShader->shadeSpan(x, y, span, width); 354 SkXfermode* xfer = fXfermode; 355 if (xfer) { 356 do { 357 xfer->xfer32(device, span, width, NULL); 358 y += 1; 359 device = (uint32_t*)((char*)device + deviceRB); 360 } while (--height > 0); 361 } else { 362 SkBlitRow::Proc32 proc = fProc32; 363 do { 364 proc(device, span, width, 255); 365 y += 1; 366 device = (uint32_t*)((char*)device + deviceRB); 367 } while (--height > 0); 368 } 369 } 370 return; 371 } 372 373 if (fShadeDirectlyIntoDevice) { 374 void* ctx; 375 SkShader::ShadeProc shadeProc = fShader->asAShadeProc(&ctx); 376 if (shadeProc) { 377 do { 378 shadeProc(ctx, x, y, device, width); 379 y += 1; 380 device = (uint32_t*)((char*)device + deviceRB); 381 } while (--height > 0); 382 } else { 383 do { 384 shader->shadeSpan(x, y, device, width); 385 y += 1; 386 device = (uint32_t*)((char*)device + deviceRB); 387 } while (--height > 0); 388 } 389 } else { 390 SkXfermode* xfer = fXfermode; 391 if (xfer) { 392 do { 393 shader->shadeSpan(x, y, span, width); 394 xfer->xfer32(device, span, width, NULL); 395 y += 1; 396 device = (uint32_t*)((char*)device + deviceRB); 397 } while (--height > 0); 398 } else { 399 SkBlitRow::Proc32 proc = fProc32; 400 do { 401 shader->shadeSpan(x, y, span, width); 402 proc(device, span, width, 255); 403 y += 1; 404 device = (uint32_t*)((char*)device + deviceRB); 405 } while (--height > 0); 406 } 407 } 408 } 409 410 void SkARGB32_Shader_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[], 411 const int16_t runs[]) { 412 SkPMColor* span = fBuffer; 413 uint32_t* device = fDevice.getAddr32(x, y); 414 SkShader* shader = fShader; 415 416 if (fXfermode && !fShadeDirectlyIntoDevice) { 417 for (;;) { 418 SkXfermode* xfer = fXfermode; 419 420 int count = *runs; 421 if (count <= 0) 422 break; 423 int aa = *antialias; 424 if (aa) { 425 shader->shadeSpan(x, y, span, count); 426 if (aa == 255) { 427 xfer->xfer32(device, span, count, NULL); 428 } else { 429 // count is almost always 1 430 for (int i = count - 1; i >= 0; --i) { 431 xfer->xfer32(&device[i], &span[i], 1, antialias); 432 } 433 } 434 } 435 device += count; 436 runs += count; 437 antialias += count; 438 x += count; 439 } 440 } else if (fShadeDirectlyIntoDevice || 441 (fShader->getFlags() & SkShader::kOpaqueAlpha_Flag)) { 442 for (;;) { 443 int count = *runs; 444 if (count <= 0) { 445 break; 446 } 447 int aa = *antialias; 448 if (aa) { 449 if (aa == 255) { 450 // cool, have the shader draw right into the device 451 shader->shadeSpan(x, y, device, count); 452 } else { 453 shader->shadeSpan(x, y, span, count); 454 fProc32Blend(device, span, count, aa); 455 } 456 } 457 device += count; 458 runs += count; 459 antialias += count; 460 x += count; 461 } 462 } else { 463 for (;;) { 464 int count = *runs; 465 if (count <= 0) { 466 break; 467 } 468 int aa = *antialias; 469 if (aa) { 470 fShader->shadeSpan(x, y, span, count); 471 if (aa == 255) { 472 fProc32(device, span, count, 255); 473 } else { 474 fProc32Blend(device, span, count, aa); 475 } 476 } 477 device += count; 478 runs += count; 479 antialias += count; 480 x += count; 481 } 482 } 483 } 484 485 void SkARGB32_Shader_Blitter::blitMask(const SkMask& mask, const SkIRect& clip) { 486 // we only handle kA8 with an xfermode 487 if (fXfermode && (SkMask::kA8_Format != mask.fFormat)) { 488 this->INHERITED::blitMask(mask, clip); 489 return; 490 } 491 492 SkASSERT(mask.fBounds.contains(clip)); 493 494 SkBlitMask::RowProc proc = NULL; 495 if (!fXfermode) { 496 unsigned flags = 0; 497 if (fShader->getFlags() & SkShader::kOpaqueAlpha_Flag) { 498 flags |= SkBlitMask::kSrcIsOpaque_RowFlag; 499 } 500 proc = SkBlitMask::RowFactory(SkBitmap::kARGB_8888_Config, mask.fFormat, 501 (SkBlitMask::RowFlags)flags); 502 if (NULL == proc) { 503 this->INHERITED::blitMask(mask, clip); 504 return; 505 } 506 } 507 508 const int x = clip.fLeft; 509 const int width = clip.width(); 510 int y = clip.fTop; 511 int height = clip.height(); 512 513 char* dstRow = (char*)fDevice.getAddr32(x, y); 514 const size_t dstRB = fDevice.rowBytes(); 515 const uint8_t* maskRow = (const uint8_t*)mask.getAddr(x, y); 516 const size_t maskRB = mask.fRowBytes; 517 518 SkShader* shader = fShader; 519 SkPMColor* span = fBuffer; 520 521 if (fXfermode) { 522 SkASSERT(SkMask::kA8_Format == mask.fFormat); 523 SkXfermode* xfer = fXfermode; 524 do { 525 shader->shadeSpan(x, y, span, width); 526 xfer->xfer32((SkPMColor*)dstRow, span, width, maskRow); 527 dstRow += dstRB; 528 maskRow += maskRB; 529 y += 1; 530 } while (--height > 0); 531 } else { 532 do { 533 shader->shadeSpan(x, y, span, width); 534 proc(dstRow, maskRow, span, width); 535 dstRow += dstRB; 536 maskRow += maskRB; 537 y += 1; 538 } while (--height > 0); 539 } 540 } 541 542 void SkARGB32_Shader_Blitter::blitV(int x, int y, int height, SkAlpha alpha) { 543 SkASSERT(x >= 0 && y >= 0 && y + height <= fDevice.height()); 544 545 uint32_t* device = fDevice.getAddr32(x, y); 546 size_t deviceRB = fDevice.rowBytes(); 547 SkShader* shader = fShader; 548 549 if (fConstInY) { 550 SkPMColor c; 551 fShader->shadeSpan(x, y, &c, 1); 552 553 if (fShadeDirectlyIntoDevice) { 554 if (255 == alpha) { 555 do { 556 *device = c; 557 device = (uint32_t*)((char*)device + deviceRB); 558 } while (--height > 0); 559 } else { 560 do { 561 *device = SkFourByteInterp(c, *device, alpha); 562 device = (uint32_t*)((char*)device + deviceRB); 563 } while (--height > 0); 564 } 565 } else { 566 SkXfermode* xfer = fXfermode; 567 if (xfer) { 568 do { 569 xfer->xfer32(device, &c, 1, &alpha); 570 device = (uint32_t*)((char*)device + deviceRB); 571 } while (--height > 0); 572 } else { 573 SkBlitRow::Proc32 proc = (255 == alpha) ? fProc32 : fProc32Blend; 574 do { 575 proc(device, &c, 1, alpha); 576 device = (uint32_t*)((char*)device + deviceRB); 577 } while (--height > 0); 578 } 579 } 580 return; 581 } 582 583 if (fShadeDirectlyIntoDevice) { 584 void* ctx; 585 SkShader::ShadeProc shadeProc = fShader->asAShadeProc(&ctx); 586 if (255 == alpha) { 587 if (shadeProc) { 588 do { 589 shadeProc(ctx, x, y, device, 1); 590 y += 1; 591 device = (uint32_t*)((char*)device + deviceRB); 592 } while (--height > 0); 593 } else { 594 do { 595 shader->shadeSpan(x, y, device, 1); 596 y += 1; 597 device = (uint32_t*)((char*)device + deviceRB); 598 } while (--height > 0); 599 } 600 } else { // alpha < 255 601 SkPMColor c; 602 if (shadeProc) { 603 do { 604 shadeProc(ctx, x, y, &c, 1); 605 *device = SkFourByteInterp(c, *device, alpha); 606 y += 1; 607 device = (uint32_t*)((char*)device + deviceRB); 608 } while (--height > 0); 609 } else { 610 do { 611 shader->shadeSpan(x, y, &c, 1); 612 *device = SkFourByteInterp(c, *device, alpha); 613 y += 1; 614 device = (uint32_t*)((char*)device + deviceRB); 615 } while (--height > 0); 616 } 617 } 618 } else { 619 SkPMColor* span = fBuffer; 620 SkXfermode* xfer = fXfermode; 621 if (xfer) { 622 do { 623 shader->shadeSpan(x, y, span, 1); 624 xfer->xfer32(device, span, 1, &alpha); 625 y += 1; 626 device = (uint32_t*)((char*)device + deviceRB); 627 } while (--height > 0); 628 } else { 629 SkBlitRow::Proc32 proc = (255 == alpha) ? fProc32 : fProc32Blend; 630 do { 631 shader->shadeSpan(x, y, span, 1); 632 proc(device, span, 1, alpha); 633 y += 1; 634 device = (uint32_t*)((char*)device + deviceRB); 635 } while (--height > 0); 636 } 637 } 638 } 639
