1/* 2 * Copyright 2014 Google Inc. 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 "sk_tool_utils.h" 9 10#include "Resources.h" 11#include "SkBitmap.h" 12#include "SkCanvas.h" 13#include "SkImage.h" 14#include "SkPixelRef.h" 15#include "SkPM4f.h" 16#include "SkPoint3.h" 17#include "SkShader.h" 18#include "SkSurface.h" 19#include "SkTestScalerContext.h" 20#include "SkTextBlob.h" 21 22namespace sk_tool_utils { 23 24const char* alphatype_name(SkAlphaType at) { 25 switch (at) { 26 case kUnknown_SkAlphaType: return "Unknown"; 27 case kOpaque_SkAlphaType: return "Opaque"; 28 case kPremul_SkAlphaType: return "Premul"; 29 case kUnpremul_SkAlphaType: return "Unpremul"; 30 } 31 SkASSERT(false); 32 return "unexpected alphatype"; 33} 34 35const char* colortype_name(SkColorType ct) { 36 switch (ct) { 37 case kUnknown_SkColorType: return "Unknown"; 38 case kAlpha_8_SkColorType: return "Alpha_8"; 39 case kRGB_565_SkColorType: return "RGB_565"; 40 case kARGB_4444_SkColorType: return "ARGB_4444"; 41 case kRGBA_8888_SkColorType: return "RGBA_8888"; 42 case kRGB_888x_SkColorType: return "RGB_888x"; 43 case kBGRA_8888_SkColorType: return "BGRA_8888"; 44 case kRGBA_1010102_SkColorType: return "RGBA_1010102"; 45 case kRGB_101010x_SkColorType: return "RGB_101010x"; 46 case kGray_8_SkColorType: return "Gray_8"; 47 case kRGBA_F16_SkColorType: return "RGBA_F16"; 48 } 49 SkASSERT(false); 50 return "unexpected colortype"; 51} 52 53SkColor color_to_565(SkColor color) { 54 SkPMColor pmColor = SkPreMultiplyColor(color); 55 U16CPU color16 = SkPixel32ToPixel16(pmColor); 56 return SkPixel16ToColor(color16); 57} 58 59void write_pixels(SkCanvas* canvas, const SkBitmap& bitmap, int x, int y, 60 SkColorType colorType, SkAlphaType alphaType) { 61 SkBitmap tmp(bitmap); 62 const SkImageInfo info = SkImageInfo::Make(tmp.width(), tmp.height(), colorType, alphaType); 63 64 canvas->writePixels(info, tmp.getPixels(), tmp.rowBytes(), x, y); 65} 66 67void write_pixels(SkSurface* surface, const SkBitmap& src, int x, int y, 68 SkColorType colorType, SkAlphaType alphaType) { 69 const SkImageInfo info = SkImageInfo::Make(src.width(), src.height(), colorType, alphaType); 70 surface->writePixels({info, src.getPixels(), src.rowBytes()}, x, y); 71} 72 73sk_sp<SkShader> create_checkerboard_shader(SkColor c1, SkColor c2, int size) { 74 SkBitmap bm; 75 bm.allocPixels(SkImageInfo::MakeS32(2 * size, 2 * size, kPremul_SkAlphaType)); 76 bm.eraseColor(c1); 77 bm.eraseArea(SkIRect::MakeLTRB(0, 0, size, size), c2); 78 bm.eraseArea(SkIRect::MakeLTRB(size, size, 2 * size, 2 * size), c2); 79 return SkShader::MakeBitmapShader( 80 bm, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode); 81} 82 83SkBitmap create_checkerboard_bitmap(int w, int h, SkColor c1, SkColor c2, int checkSize) { 84 SkBitmap bitmap; 85 bitmap.allocPixels(SkImageInfo::MakeS32(w, h, kPremul_SkAlphaType)); 86 SkCanvas canvas(bitmap); 87 88 sk_tool_utils::draw_checkerboard(&canvas, c1, c2, checkSize); 89 return bitmap; 90} 91 92void draw_checkerboard(SkCanvas* canvas, SkColor c1, SkColor c2, int size) { 93 SkPaint paint; 94 paint.setShader(create_checkerboard_shader(c1, c2, size)); 95 paint.setBlendMode(SkBlendMode::kSrc); 96 canvas->drawPaint(paint); 97} 98 99SkBitmap create_string_bitmap(int w, int h, SkColor c, int x, int y, 100 int textSize, const char* str) { 101 SkBitmap bitmap; 102 bitmap.allocN32Pixels(w, h); 103 SkCanvas canvas(bitmap); 104 105 SkPaint paint; 106 paint.setAntiAlias(true); 107 sk_tool_utils::set_portable_typeface(&paint); 108 paint.setColor(c); 109 paint.setTextSize(SkIntToScalar(textSize)); 110 111 canvas.clear(0x00000000); 112 canvas.drawString(str, SkIntToScalar(x), SkIntToScalar(y), paint); 113 114 // Tag data as sRGB (without doing any color space conversion). Color-space aware configs 115 // will process this correctly but legacy configs will render as if this returned N32. 116 SkBitmap result; 117 result.setInfo(SkImageInfo::MakeS32(w, h, kPremul_SkAlphaType)); 118 result.setPixelRef(sk_ref_sp(bitmap.pixelRef()), 0, 0); 119 return result; 120} 121 122void add_to_text_blob_w_len(SkTextBlobBuilder* builder, const char* text, size_t len, 123 const SkPaint& origPaint, SkScalar x, SkScalar y) { 124 SkPaint paint(origPaint); 125 SkTDArray<uint16_t> glyphs; 126 127 glyphs.append(paint.textToGlyphs(text, len, nullptr)); 128 paint.textToGlyphs(text, len, glyphs.begin()); 129 130 paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding); 131 const SkTextBlobBuilder::RunBuffer& run = builder->allocRun(paint, glyphs.count(), x, y, 132 nullptr); 133 memcpy(run.glyphs, glyphs.begin(), glyphs.count() * sizeof(uint16_t)); 134} 135 136void add_to_text_blob(SkTextBlobBuilder* builder, const char* text, 137 const SkPaint& origPaint, SkScalar x, SkScalar y) { 138 add_to_text_blob_w_len(builder, text, strlen(text), origPaint, x, y); 139} 140 141SkPath make_star(const SkRect& bounds, int numPts, int step) { 142 SkPath path; 143 path.setFillType(SkPath::kEvenOdd_FillType); 144 path.moveTo(0,-1); 145 for (int i = 1; i < numPts; ++i) { 146 int idx = i*step; 147 SkScalar theta = idx * 2*SK_ScalarPI/numPts + SK_ScalarPI/2; 148 SkScalar x = SkScalarCos(theta); 149 SkScalar y = -SkScalarSin(theta); 150 path.lineTo(x, y); 151 } 152 path.transform(SkMatrix::MakeRectToRect(path.getBounds(), bounds, SkMatrix::kFill_ScaleToFit)); 153 return path; 154} 155 156#if !defined(__clang__) && defined(_MSC_VER) 157 // MSVC takes ~2 minutes to compile this function with optimization. 158 // We don't really care to wait that long for this function. 159 #pragma optimize("", off) 160#endif 161void make_big_path(SkPath& path) { 162 #include "BigPathBench.inc" 163} 164 165static float gaussian2d_value(int x, int y, float sigma) { 166 // don't bother with the scale term since we're just going to normalize the 167 // kernel anyways 168 float temp = expf(-(x*x + y*y)/(2*sigma*sigma)); 169 return temp; 170} 171 172static float* create_2d_kernel(float sigma, int* filterSize) { 173 // We will actually take 2*halfFilterSize+1 samples (i.e., our filter kernel 174 // sizes are always odd) 175 int halfFilterSize = SkScalarCeilToInt(6*sigma)/2; 176 int wh = *filterSize = 2*halfFilterSize + 1; 177 178 float* temp = new float[wh*wh]; 179 180 float filterTot = 0.0f; 181 for (int yOff = 0; yOff < wh; ++yOff) { 182 for (int xOff = 0; xOff < wh; ++xOff) { 183 temp[yOff*wh+xOff] = gaussian2d_value(xOff-halfFilterSize, yOff-halfFilterSize, sigma); 184 185 filterTot += temp[yOff*wh+xOff]; 186 } 187 } 188 189 // normalize the kernel 190 for (int yOff = 0; yOff < wh; ++yOff) { 191 for (int xOff = 0; xOff < wh; ++xOff) { 192 temp[yOff*wh+xOff] /= filterTot; 193 } 194 } 195 196 return temp; 197} 198 199static SkPMColor blur_pixel(const SkBitmap& bm, int x, int y, float* kernel, int wh) { 200 SkASSERT(wh & 0x1); 201 202 int halfFilterSize = (wh-1)/2; 203 204 float r = 0.0f, g = 0.0f, b = 0.0f; 205 for (int yOff = 0; yOff < wh; ++yOff) { 206 int ySamp = y + yOff - halfFilterSize; 207 208 if (ySamp < 0) { 209 ySamp = 0; 210 } else if (ySamp > bm.height()-1) { 211 ySamp = bm.height()-1; 212 } 213 214 for (int xOff = 0; xOff < wh; ++xOff) { 215 int xSamp = x + xOff - halfFilterSize; 216 217 if (xSamp < 0) { 218 xSamp = 0; 219 } else if (xSamp > bm.width()-1) { 220 xSamp = bm.width()-1; 221 } 222 223 float filter = kernel[yOff*wh + xOff]; 224 225 SkPMColor c = *bm.getAddr32(xSamp, ySamp); 226 227 r += SkGetPackedR32(c) * filter; 228 g += SkGetPackedG32(c) * filter; 229 b += SkGetPackedB32(c) * filter; 230 } 231 } 232 233 U8CPU r8, g8, b8; 234 235 r8 = (U8CPU) (r+0.5f); 236 g8 = (U8CPU) (g+0.5f); 237 b8 = (U8CPU) (b+0.5f); 238 239 return SkPackARGB32(255, r8, g8, b8); 240} 241 242SkBitmap slow_blur(const SkBitmap& src, float sigma) { 243 SkBitmap dst; 244 245 dst.allocN32Pixels(src.width(), src.height(), true); 246 247 int wh; 248 std::unique_ptr<float[]> kernel(create_2d_kernel(sigma, &wh)); 249 250 for (int y = 0; y < src.height(); ++y) { 251 for (int x = 0; x < src.width(); ++x) { 252 *dst.getAddr32(x, y) = blur_pixel(src, x, y, kernel.get(), wh); 253 } 254 } 255 256 return dst; 257} 258 259// compute the intersection point between the diagonal and the ellipse in the 260// lower right corner 261static SkPoint intersection(SkScalar w, SkScalar h) { 262 SkASSERT(w > 0.0f || h > 0.0f); 263 264 return SkPoint::Make(w / SK_ScalarSqrt2, h / SK_ScalarSqrt2); 265} 266 267// Use the intersection of the corners' diagonals with their ellipses to shrink 268// the bounding rect 269SkRect compute_central_occluder(const SkRRect& rr) { 270 const SkRect r = rr.getBounds(); 271 272 SkScalar newL = r.fLeft, newT = r.fTop, newR = r.fRight, newB = r.fBottom; 273 274 SkVector radii = rr.radii(SkRRect::kUpperLeft_Corner); 275 if (!radii.isZero()) { 276 SkPoint p = intersection(radii.fX, radii.fY); 277 278 newL = SkTMax(newL, r.fLeft + radii.fX - p.fX); 279 newT = SkTMax(newT, r.fTop + radii.fY - p.fY); 280 } 281 282 radii = rr.radii(SkRRect::kUpperRight_Corner); 283 if (!radii.isZero()) { 284 SkPoint p = intersection(radii.fX, radii.fY); 285 286 newR = SkTMin(newR, r.fRight + p.fX - radii.fX); 287 newT = SkTMax(newT, r.fTop + radii.fY - p.fY); 288 } 289 290 radii = rr.radii(SkRRect::kLowerRight_Corner); 291 if (!radii.isZero()) { 292 SkPoint p = intersection(radii.fX, radii.fY); 293 294 newR = SkTMin(newR, r.fRight + p.fX - radii.fX); 295 newB = SkTMin(newB, r.fBottom - radii.fY + p.fY); 296 } 297 298 radii = rr.radii(SkRRect::kLowerLeft_Corner); 299 if (!radii.isZero()) { 300 SkPoint p = intersection(radii.fX, radii.fY); 301 302 newL = SkTMax(newL, r.fLeft + radii.fX - p.fX); 303 newB = SkTMin(newB, r.fBottom - radii.fY + p.fY); 304 } 305 306 return SkRect::MakeLTRB(newL, newT, newR, newB); 307} 308 309// The widest inset rect 310SkRect compute_widest_occluder(const SkRRect& rr) { 311 const SkRect& r = rr.getBounds(); 312 313 const SkVector& ul = rr.radii(SkRRect::kUpperLeft_Corner); 314 const SkVector& ur = rr.radii(SkRRect::kUpperRight_Corner); 315 const SkVector& lr = rr.radii(SkRRect::kLowerRight_Corner); 316 const SkVector& ll = rr.radii(SkRRect::kLowerLeft_Corner); 317 318 SkScalar maxT = SkTMax(ul.fY, ur.fY); 319 SkScalar maxB = SkTMax(ll.fY, lr.fY); 320 321 return SkRect::MakeLTRB(r.fLeft, r.fTop + maxT, r.fRight, r.fBottom - maxB); 322 323} 324 325// The tallest inset rect 326SkRect compute_tallest_occluder(const SkRRect& rr) { 327 const SkRect& r = rr.getBounds(); 328 329 const SkVector& ul = rr.radii(SkRRect::kUpperLeft_Corner); 330 const SkVector& ur = rr.radii(SkRRect::kUpperRight_Corner); 331 const SkVector& lr = rr.radii(SkRRect::kLowerRight_Corner); 332 const SkVector& ll = rr.radii(SkRRect::kLowerLeft_Corner); 333 334 SkScalar maxL = SkTMax(ul.fX, ll.fX); 335 SkScalar maxR = SkTMax(ur.fX, lr.fX); 336 337 return SkRect::MakeLTRB(r.fLeft + maxL, r.fTop, r.fRight - maxR, r.fBottom); 338} 339 340bool copy_to(SkBitmap* dst, SkColorType dstColorType, const SkBitmap& src) { 341 SkPixmap srcPM; 342 if (!src.peekPixels(&srcPM)) { 343 return false; 344 } 345 346 SkBitmap tmpDst; 347 SkImageInfo dstInfo = srcPM.info().makeColorType(dstColorType); 348 if (!tmpDst.setInfo(dstInfo)) { 349 return false; 350 } 351 352 if (!tmpDst.tryAllocPixels()) { 353 return false; 354 } 355 356 SkPixmap dstPM; 357 if (!tmpDst.peekPixels(&dstPM)) { 358 return false; 359 } 360 361 if (!srcPM.readPixels(dstPM)) { 362 return false; 363 } 364 365 dst->swap(tmpDst); 366 return true; 367} 368 369void copy_to_g8(SkBitmap* dst, const SkBitmap& src) { 370 SkASSERT(kBGRA_8888_SkColorType == src.colorType() || 371 kRGBA_8888_SkColorType == src.colorType()); 372 373 SkImageInfo grayInfo = src.info().makeColorType(kGray_8_SkColorType); 374 dst->allocPixels(grayInfo); 375 uint8_t* dst8 = (uint8_t*)dst->getPixels(); 376 const uint32_t* src32 = (const uint32_t*)src.getPixels(); 377 378 const int w = src.width(); 379 const int h = src.height(); 380 const bool isBGRA = (kBGRA_8888_SkColorType == src.colorType()); 381 for (int y = 0; y < h; ++y) { 382 if (isBGRA) { 383 // BGRA 384 for (int x = 0; x < w; ++x) { 385 uint32_t s = src32[x]; 386 dst8[x] = SkComputeLuminance((s >> 16) & 0xFF, (s >> 8) & 0xFF, s & 0xFF); 387 } 388 } else { 389 // RGBA 390 for (int x = 0; x < w; ++x) { 391 uint32_t s = src32[x]; 392 dst8[x] = SkComputeLuminance(s & 0xFF, (s >> 8) & 0xFF, (s >> 16) & 0xFF); 393 } 394 } 395 src32 = (const uint32_t*)((const char*)src32 + src.rowBytes()); 396 dst8 += dst->rowBytes(); 397 } 398} 399 400 ////////////////////////////////////////////////////////////////////////////////////////////// 401 402 static int scale255(float x) { 403 return sk_float_round2int(x * 255); 404 } 405 406 static unsigned diff(const SkColorType ct, const void* a, const void* b) { 407 int dr = 0, 408 dg = 0, 409 db = 0, 410 da = 0; 411 switch (ct) { 412 case kRGBA_8888_SkColorType: 413 case kBGRA_8888_SkColorType: { 414 SkPMColor c0 = *(const SkPMColor*)a; 415 SkPMColor c1 = *(const SkPMColor*)b; 416 dr = SkGetPackedR32(c0) - SkGetPackedR32(c1); 417 dg = SkGetPackedG32(c0) - SkGetPackedG32(c1); 418 db = SkGetPackedB32(c0) - SkGetPackedB32(c1); 419 da = SkGetPackedA32(c0) - SkGetPackedA32(c1); 420 } break; 421 case kRGB_565_SkColorType: { 422 uint16_t c0 = *(const uint16_t*)a; 423 uint16_t c1 = *(const uint16_t*)b; 424 dr = SkGetPackedR16(c0) - SkGetPackedR16(c1); 425 dg = SkGetPackedG16(c0) - SkGetPackedG16(c1); 426 db = SkGetPackedB16(c0) - SkGetPackedB16(c1); 427 } break; 428 case kARGB_4444_SkColorType: { 429 uint16_t c0 = *(const uint16_t*)a; 430 uint16_t c1 = *(const uint16_t*)b; 431 dr = SkGetPackedR4444(c0) - SkGetPackedR4444(c1); 432 dg = SkGetPackedG4444(c0) - SkGetPackedG4444(c1); 433 db = SkGetPackedB4444(c0) - SkGetPackedB4444(c1); 434 da = SkGetPackedA4444(c0) - SkGetPackedA4444(c1); 435 } break; 436 case kAlpha_8_SkColorType: 437 case kGray_8_SkColorType: 438 da = (const uint8_t*)a - (const uint8_t*)b; 439 break; 440 case kRGBA_F16_SkColorType: { 441 const SkPM4f* c0 = (const SkPM4f*)a; 442 const SkPM4f* c1 = (const SkPM4f*)b; 443 dr = scale255(c0->r() - c1->r()); 444 dg = scale255(c0->g() - c1->g()); 445 db = scale255(c0->b() - c1->b()); 446 da = scale255(c0->a() - c1->a()); 447 } break; 448 default: 449 return 0; 450 } 451 dr = SkAbs32(dr); 452 dg = SkAbs32(dg); 453 db = SkAbs32(db); 454 da = SkAbs32(da); 455 return SkMax32(dr, SkMax32(dg, SkMax32(db, da))); 456 } 457 458 bool equal_pixels(const SkPixmap& a, const SkPixmap& b, unsigned maxDiff, 459 bool respectColorSpace) { 460 if (a.width() != b.width() || 461 a.height() != b.height() || 462 a.colorType() != b.colorType() || 463 (respectColorSpace && (a.colorSpace() != b.colorSpace()))) 464 { 465 return false; 466 } 467 468 for (int y = 0; y < a.height(); ++y) { 469 const char* aptr = (const char*)a.addr(0, y); 470 const char* bptr = (const char*)b.addr(0, y); 471 if (memcmp(aptr, bptr, a.width() * a.info().bytesPerPixel())) { 472 for (int x = 0; x < a.width(); ++x) { 473 if (diff(a.colorType(), a.addr(x, y), b.addr(x, y)) > maxDiff) { 474 return false; 475 } 476 } 477 } 478 aptr += a.rowBytes(); 479 bptr += b.rowBytes(); 480 } 481 return true; 482 } 483 484 bool equal_pixels(const SkBitmap& bm0, const SkBitmap& bm1, unsigned maxDiff, 485 bool respectColorSpaces) { 486 SkPixmap pm0, pm1; 487 return bm0.peekPixels(&pm0) && bm1.peekPixels(&pm1) && 488 equal_pixels(pm0, pm1, maxDiff, respectColorSpaces); 489 } 490 491 bool equal_pixels(const SkImage* a, const SkImage* b, unsigned maxDiff, 492 bool respectColorSpaces) { 493 // ensure that peekPixels will succeed 494 auto imga = a->makeRasterImage(); 495 auto imgb = b->makeRasterImage(); 496 a = imga.get(); 497 b = imgb.get(); 498 499 SkPixmap pm0, pm1; 500 return a->peekPixels(&pm0) && b->peekPixels(&pm1) && 501 equal_pixels(pm0, pm1, maxDiff, respectColorSpaces); 502 } 503 504 sk_sp<SkSurface> makeSurface(SkCanvas* canvas, const SkImageInfo& info, 505 const SkSurfaceProps* props) { 506 auto surf = canvas->makeSurface(info, props); 507 if (!surf) { 508 surf = SkSurface::MakeRaster(info, props); 509 } 510 return surf; 511 } 512} // namespace sk_tool_utils 513