PictureTest.cpp revision c54d8db4d169ea5f2af2a9a2349df007bd428475
1/* 2 * Copyright 2012 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 "SkBBoxHierarchy.h" 9#include "SkBlurImageFilter.h" 10#include "SkCanvas.h" 11#include "SkColorMatrixFilter.h" 12#include "SkColorPriv.h" 13#include "SkDashPathEffect.h" 14#include "SkData.h" 15#include "SkDecodingImageGenerator.h" 16#include "SkError.h" 17#include "SkImageEncoder.h" 18#include "SkImageGenerator.h" 19#include "SkLayerInfo.h" 20#include "SkPaint.h" 21#include "SkPicture.h" 22#include "SkPictureRecorder.h" 23#include "SkPictureUtils.h" 24#include "SkPixelRef.h" 25#include "SkRRect.h" 26#include "SkRandom.h" 27#include "SkRecord.h" 28#include "SkShader.h" 29#include "SkStream.h" 30 31#if SK_SUPPORT_GPU 32#include "SkSurface.h" 33#include "GrContextFactory.h" 34#endif 35#include "Test.h" 36 37#include "SkLumaColorFilter.h" 38#include "SkColorFilterImageFilter.h" 39 40static const int gColorScale = 30; 41static const int gColorOffset = 60; 42 43static void make_bm(SkBitmap* bm, int w, int h, SkColor color, bool immutable) { 44 bm->allocN32Pixels(w, h); 45 bm->eraseColor(color); 46 if (immutable) { 47 bm->setImmutable(); 48 } 49} 50 51static void make_checkerboard(SkBitmap* bm, int w, int h, bool immutable) { 52 SkASSERT(w % 2 == 0); 53 SkASSERT(h % 2 == 0); 54 bm->allocPixels(SkImageInfo::Make(w, h, kAlpha_8_SkColorType, 55 kPremul_SkAlphaType)); 56 SkAutoLockPixels lock(*bm); 57 for (int y = 0; y < h; y += 2) { 58 uint8_t* s = bm->getAddr8(0, y); 59 for (int x = 0; x < w; x += 2) { 60 *s++ = 0xFF; 61 *s++ = 0x00; 62 } 63 s = bm->getAddr8(0, y + 1); 64 for (int x = 0; x < w; x += 2) { 65 *s++ = 0x00; 66 *s++ = 0xFF; 67 } 68 } 69 if (immutable) { 70 bm->setImmutable(); 71 } 72} 73 74static void init_paint(SkPaint* paint, const SkBitmap &bm) { 75 SkShader* shader = SkShader::CreateBitmapShader(bm, 76 SkShader::kClamp_TileMode, 77 SkShader::kClamp_TileMode); 78 paint->setShader(shader)->unref(); 79} 80 81typedef void (*DrawBitmapProc)(SkCanvas*, const SkBitmap&, 82 const SkBitmap&, const SkPoint&, 83 SkTDArray<SkPixelRef*>* usedPixRefs); 84 85static void drawpaint_proc(SkCanvas* canvas, const SkBitmap& bm, 86 const SkBitmap& altBM, const SkPoint& pos, 87 SkTDArray<SkPixelRef*>* usedPixRefs) { 88 SkPaint paint; 89 init_paint(&paint, bm); 90 91 canvas->drawPaint(paint); 92 *usedPixRefs->append() = bm.pixelRef(); 93} 94 95static void drawpoints_proc(SkCanvas* canvas, const SkBitmap& bm, 96 const SkBitmap& altBM, const SkPoint& pos, 97 SkTDArray<SkPixelRef*>* usedPixRefs) { 98 SkPaint paint; 99 init_paint(&paint, bm); 100 101 // draw a rect 102 SkPoint points[5] = { 103 { pos.fX, pos.fY }, 104 { pos.fX + bm.width() - 1, pos.fY }, 105 { pos.fX + bm.width() - 1, pos.fY + bm.height() - 1 }, 106 { pos.fX, pos.fY + bm.height() - 1 }, 107 { pos.fX, pos.fY }, 108 }; 109 110 canvas->drawPoints(SkCanvas::kPolygon_PointMode, 5, points, paint); 111 *usedPixRefs->append() = bm.pixelRef(); 112} 113 114static void drawrect_proc(SkCanvas* canvas, const SkBitmap& bm, 115 const SkBitmap& altBM, const SkPoint& pos, 116 SkTDArray<SkPixelRef*>* usedPixRefs) { 117 SkPaint paint; 118 init_paint(&paint, bm); 119 120 SkRect r = { 0, 0, SkIntToScalar(bm.width()), SkIntToScalar(bm.height()) }; 121 r.offset(pos.fX, pos.fY); 122 123 canvas->drawRect(r, paint); 124 *usedPixRefs->append() = bm.pixelRef(); 125} 126 127static void drawoval_proc(SkCanvas* canvas, const SkBitmap& bm, 128 const SkBitmap& altBM, const SkPoint& pos, 129 SkTDArray<SkPixelRef*>* usedPixRefs) { 130 SkPaint paint; 131 init_paint(&paint, bm); 132 133 SkRect r = { 0, 0, SkIntToScalar(bm.width()), SkIntToScalar(bm.height()) }; 134 r.offset(pos.fX, pos.fY); 135 136 canvas->drawOval(r, paint); 137 *usedPixRefs->append() = bm.pixelRef(); 138} 139 140static void drawrrect_proc(SkCanvas* canvas, const SkBitmap& bm, 141 const SkBitmap& altBM, const SkPoint& pos, 142 SkTDArray<SkPixelRef*>* usedPixRefs) { 143 SkPaint paint; 144 init_paint(&paint, bm); 145 146 SkRect r = { 0, 0, SkIntToScalar(bm.width()), SkIntToScalar(bm.height()) }; 147 r.offset(pos.fX, pos.fY); 148 149 SkRRect rr; 150 rr.setRectXY(r, SkIntToScalar(bm.width())/4, SkIntToScalar(bm.height())/4); 151 canvas->drawRRect(rr, paint); 152 *usedPixRefs->append() = bm.pixelRef(); 153} 154 155static void drawpath_proc(SkCanvas* canvas, const SkBitmap& bm, 156 const SkBitmap& altBM, const SkPoint& pos, 157 SkTDArray<SkPixelRef*>* usedPixRefs) { 158 SkPaint paint; 159 init_paint(&paint, bm); 160 161 SkPath path; 162 path.lineTo(bm.width()/2.0f, SkIntToScalar(bm.height())); 163 path.lineTo(SkIntToScalar(bm.width()), 0); 164 path.close(); 165 path.offset(pos.fX, pos.fY); 166 167 canvas->drawPath(path, paint); 168 *usedPixRefs->append() = bm.pixelRef(); 169} 170 171static void drawbitmap_proc(SkCanvas* canvas, const SkBitmap& bm, 172 const SkBitmap& altBM, const SkPoint& pos, 173 SkTDArray<SkPixelRef*>* usedPixRefs) { 174 canvas->drawBitmap(bm, pos.fX, pos.fY, NULL); 175 *usedPixRefs->append() = bm.pixelRef(); 176} 177 178static void drawbitmap_withshader_proc(SkCanvas* canvas, const SkBitmap& bm, 179 const SkBitmap& altBM, const SkPoint& pos, 180 SkTDArray<SkPixelRef*>* usedPixRefs) { 181 SkPaint paint; 182 init_paint(&paint, bm); 183 184 // The bitmap in the paint is ignored unless we're drawing an A8 bitmap 185 canvas->drawBitmap(altBM, pos.fX, pos.fY, &paint); 186 *usedPixRefs->append() = bm.pixelRef(); 187 *usedPixRefs->append() = altBM.pixelRef(); 188} 189 190static void drawsprite_proc(SkCanvas* canvas, const SkBitmap& bm, 191 const SkBitmap& altBM, const SkPoint& pos, 192 SkTDArray<SkPixelRef*>* usedPixRefs) { 193 const SkMatrix& ctm = canvas->getTotalMatrix(); 194 195 SkPoint p(pos); 196 ctm.mapPoints(&p, 1); 197 198 canvas->drawSprite(bm, (int)p.fX, (int)p.fY, NULL); 199 *usedPixRefs->append() = bm.pixelRef(); 200} 201 202#if 0 203// Although specifiable, this case doesn't seem to make sense (i.e., the 204// bitmap in the shader is never used). 205static void drawsprite_withshader_proc(SkCanvas* canvas, const SkBitmap& bm, 206 const SkBitmap& altBM, const SkPoint& pos, 207 SkTDArray<SkPixelRef*>* usedPixRefs) { 208 SkPaint paint; 209 init_paint(&paint, bm); 210 211 const SkMatrix& ctm = canvas->getTotalMatrix(); 212 213 SkPoint p(pos); 214 ctm.mapPoints(&p, 1); 215 216 canvas->drawSprite(altBM, (int)p.fX, (int)p.fY, &paint); 217 *usedPixRefs->append() = bm.pixelRef(); 218 *usedPixRefs->append() = altBM.pixelRef(); 219} 220#endif 221 222static void drawbitmaprect_proc(SkCanvas* canvas, const SkBitmap& bm, 223 const SkBitmap& altBM, const SkPoint& pos, 224 SkTDArray<SkPixelRef*>* usedPixRefs) { 225 SkRect r = { 0, 0, SkIntToScalar(bm.width()), SkIntToScalar(bm.height()) }; 226 227 r.offset(pos.fX, pos.fY); 228 canvas->drawBitmapRectToRect(bm, NULL, r, NULL); 229 *usedPixRefs->append() = bm.pixelRef(); 230} 231 232static void drawbitmaprect_withshader_proc(SkCanvas* canvas, 233 const SkBitmap& bm, 234 const SkBitmap& altBM, 235 const SkPoint& pos, 236 SkTDArray<SkPixelRef*>* usedPixRefs) { 237 SkPaint paint; 238 init_paint(&paint, bm); 239 240 SkRect r = { 0, 0, SkIntToScalar(bm.width()), SkIntToScalar(bm.height()) }; 241 r.offset(pos.fX, pos.fY); 242 243 // The bitmap in the paint is ignored unless we're drawing an A8 bitmap 244 canvas->drawBitmapRectToRect(altBM, NULL, r, &paint); 245 *usedPixRefs->append() = bm.pixelRef(); 246 *usedPixRefs->append() = altBM.pixelRef(); 247} 248 249static void drawtext_proc(SkCanvas* canvas, const SkBitmap& bm, 250 const SkBitmap& altBM, const SkPoint& pos, 251 SkTDArray<SkPixelRef*>* usedPixRefs) { 252 SkPaint paint; 253 init_paint(&paint, bm); 254 paint.setTextSize(SkIntToScalar(1.5*bm.width())); 255 256 canvas->drawText("0", 1, pos.fX, pos.fY+bm.width(), paint); 257 *usedPixRefs->append() = bm.pixelRef(); 258} 259 260static void drawpostext_proc(SkCanvas* canvas, const SkBitmap& bm, 261 const SkBitmap& altBM, const SkPoint& pos, 262 SkTDArray<SkPixelRef*>* usedPixRefs) { 263 SkPaint paint; 264 init_paint(&paint, bm); 265 paint.setTextSize(SkIntToScalar(1.5*bm.width())); 266 267 SkPoint point = { pos.fX, pos.fY + bm.height() }; 268 canvas->drawPosText("O", 1, &point, paint); 269 *usedPixRefs->append() = bm.pixelRef(); 270} 271 272static void drawtextonpath_proc(SkCanvas* canvas, const SkBitmap& bm, 273 const SkBitmap& altBM, const SkPoint& pos, 274 SkTDArray<SkPixelRef*>* usedPixRefs) { 275 SkPaint paint; 276 277 init_paint(&paint, bm); 278 paint.setTextSize(SkIntToScalar(1.5*bm.width())); 279 280 SkPath path; 281 path.lineTo(SkIntToScalar(bm.width()), 0); 282 path.offset(pos.fX, pos.fY+bm.height()); 283 284 canvas->drawTextOnPath("O", 1, path, NULL, paint); 285 *usedPixRefs->append() = bm.pixelRef(); 286} 287 288static void drawverts_proc(SkCanvas* canvas, const SkBitmap& bm, 289 const SkBitmap& altBM, const SkPoint& pos, 290 SkTDArray<SkPixelRef*>* usedPixRefs) { 291 SkPaint paint; 292 init_paint(&paint, bm); 293 294 SkPoint verts[4] = { 295 { pos.fX, pos.fY }, 296 { pos.fX + bm.width(), pos.fY }, 297 { pos.fX + bm.width(), pos.fY + bm.height() }, 298 { pos.fX, pos.fY + bm.height() } 299 }; 300 SkPoint texs[4] = { { 0, 0 }, 301 { SkIntToScalar(bm.width()), 0 }, 302 { SkIntToScalar(bm.width()), SkIntToScalar(bm.height()) }, 303 { 0, SkIntToScalar(bm.height()) } }; 304 uint16_t indices[6] = { 0, 1, 2, 0, 2, 3 }; 305 306 canvas->drawVertices(SkCanvas::kTriangles_VertexMode, 4, verts, texs, NULL, NULL, 307 indices, 6, paint); 308 *usedPixRefs->append() = bm.pixelRef(); 309} 310 311// Return a picture with the bitmaps drawn at the specified positions. 312static SkPicture* record_bitmaps(const SkBitmap bm[], 313 const SkPoint pos[], 314 SkTDArray<SkPixelRef*> analytic[], 315 int count, 316 DrawBitmapProc proc) { 317 SkPictureRecorder recorder; 318 SkCanvas* canvas = recorder.beginRecording(1000, 1000); 319 for (int i = 0; i < count; ++i) { 320 analytic[i].rewind(); 321 canvas->save(); 322 SkRect clipRect = SkRect::MakeXYWH(pos[i].fX, pos[i].fY, 323 SkIntToScalar(bm[i].width()), 324 SkIntToScalar(bm[i].height())); 325 canvas->clipRect(clipRect, SkRegion::kIntersect_Op); 326 proc(canvas, bm[i], bm[count+i], pos[i], &analytic[i]); 327 canvas->restore(); 328 } 329 return recorder.endRecording(); 330} 331 332static void rand_rect(SkRect* rect, SkRandom& rand, SkScalar W, SkScalar H) { 333 rect->fLeft = rand.nextRangeScalar(-W, 2*W); 334 rect->fTop = rand.nextRangeScalar(-H, 2*H); 335 rect->fRight = rect->fLeft + rand.nextRangeScalar(0, W); 336 rect->fBottom = rect->fTop + rand.nextRangeScalar(0, H); 337 338 // we integralize rect to make our tests more predictable, since Gather is 339 // a little sloppy. 340 SkIRect ir; 341 rect->round(&ir); 342 rect->set(ir); 343} 344 345static void draw(SkPicture* pic, int width, int height, SkBitmap* result) { 346 make_bm(result, width, height, SK_ColorBLACK, false); 347 348 SkCanvas canvas(*result); 349 canvas.drawPicture(pic); 350} 351 352template <typename T> int find_index(const T* array, T elem, int count) { 353 for (int i = 0; i < count; ++i) { 354 if (array[i] == elem) { 355 return i; 356 } 357 } 358 return -1; 359} 360 361// Return true if 'ref' is found in array[] 362static bool find(SkPixelRef const * const * array, SkPixelRef const * ref, int count) { 363 return find_index<const SkPixelRef*>(array, ref, count) >= 0; 364} 365 366// Look at each pixel that is inside 'subset', and if its color appears in 367// colors[], find the corresponding value in refs[] and append that ref into 368// array, skipping duplicates of the same value. 369// Note that gathering pixelRefs from rendered colors suffers from the problem 370// that multiple simultaneous textures (e.g., A8 for alpha and 8888 for color) 371// isn't easy to reconstruct. 372static void gather_from_image(const SkBitmap& bm, SkPixelRef* const refs[], 373 int count, SkTDArray<SkPixelRef*>* array, 374 const SkRect& subset) { 375 SkIRect ir; 376 subset.roundOut(&ir); 377 378 if (!ir.intersect(0, 0, bm.width()-1, bm.height()-1)) { 379 return; 380 } 381 382 // Since we only want to return unique values in array, when we scan we just 383 // set a bit for each index'd color found. In practice we only have a few 384 // distinct colors, so we just use an int's bits as our array. Hence the 385 // assert that count <= number-of-bits-in-our-int. 386 SkASSERT((unsigned)count <= 32); 387 uint32_t bitarray = 0; 388 389 SkAutoLockPixels alp(bm); 390 391 for (int y = ir.fTop; y < ir.fBottom; ++y) { 392 for (int x = ir.fLeft; x < ir.fRight; ++x) { 393 SkPMColor pmc = *bm.getAddr32(x, y); 394 // the only good case where the color is not found would be if 395 // the color is transparent, meaning no bitmap was drawn in that 396 // pixel. 397 if (pmc) { 398 uint32_t index = SkGetPackedR32(pmc); 399 SkASSERT(SkGetPackedG32(pmc) == index); 400 SkASSERT(SkGetPackedB32(pmc) == index); 401 if (0 == index) { 402 continue; // background color 403 } 404 SkASSERT(0 == (index - gColorOffset) % gColorScale); 405 index = (index - gColorOffset) / gColorScale; 406 SkASSERT(static_cast<int>(index) < count); 407 bitarray |= 1 << index; 408 } 409 } 410 } 411 412 for (int i = 0; i < count; ++i) { 413 if (bitarray & (1 << i)) { 414 *array->append() = refs[i]; 415 } 416 } 417} 418 419static void gather_from_analytic(const SkPoint pos[], SkScalar w, SkScalar h, 420 const SkTDArray<SkPixelRef*> analytic[], 421 int count, 422 SkTDArray<SkPixelRef*>* result, 423 const SkRect& subset) { 424 for (int i = 0; i < count; ++i) { 425 SkRect rect = SkRect::MakeXYWH(pos[i].fX, pos[i].fY, w, h); 426 427 if (SkRect::Intersects(subset, rect)) { 428 result->append(analytic[i].count(), analytic[i].begin()); 429 } 430 } 431} 432 433 434static const struct { 435 const DrawBitmapProc proc; 436 const char* const desc; 437} gProcs[] = { 438 {drawpaint_proc, "drawpaint"}, 439 {drawpoints_proc, "drawpoints"}, 440 {drawrect_proc, "drawrect"}, 441 {drawoval_proc, "drawoval"}, 442 {drawrrect_proc, "drawrrect"}, 443 {drawpath_proc, "drawpath"}, 444 {drawbitmap_proc, "drawbitmap"}, 445 {drawbitmap_withshader_proc, "drawbitmap_withshader"}, 446 {drawsprite_proc, "drawsprite"}, 447#if 0 448 {drawsprite_withshader_proc, "drawsprite_withshader"}, 449#endif 450 {drawbitmaprect_proc, "drawbitmaprect"}, 451 {drawbitmaprect_withshader_proc, "drawbitmaprect_withshader"}, 452 {drawtext_proc, "drawtext"}, 453 {drawpostext_proc, "drawpostext"}, 454 {drawtextonpath_proc, "drawtextonpath"}, 455 {drawverts_proc, "drawverts"}, 456}; 457 458static void create_textures(SkBitmap* bm, SkPixelRef** refs, int num, int w, int h) { 459 // Our convention is that the color components contain an encoding of 460 // the index of their corresponding bitmap/pixelref. (0,0,0,0) is 461 // reserved for the background 462 for (int i = 0; i < num; ++i) { 463 make_bm(&bm[i], w, h, 464 SkColorSetARGB(0xFF, 465 gColorScale*i+gColorOffset, 466 gColorScale*i+gColorOffset, 467 gColorScale*i+gColorOffset), 468 true); 469 refs[i] = bm[i].pixelRef(); 470 } 471 472 // The A8 alternate bitmaps are all BW checkerboards 473 for (int i = 0; i < num; ++i) { 474 make_checkerboard(&bm[num+i], w, h, true); 475 refs[num+i] = bm[num+i].pixelRef(); 476 } 477} 478 479static void test_gatherpixelrefs(skiatest::Reporter* reporter) { 480 const int IW = 32; 481 const int IH = IW; 482 const SkScalar W = SkIntToScalar(IW); 483 const SkScalar H = W; 484 485 static const int N = 4; 486 SkBitmap bm[2*N]; 487 SkPixelRef* refs[2*N]; 488 SkTDArray<SkPixelRef*> analytic[N]; 489 490 const SkPoint pos[N] = { 491 { 0, 0 }, { W, 0 }, { 0, H }, { W, H } 492 }; 493 494 create_textures(bm, refs, N, IW, IH); 495 496 SkRandom rand; 497 for (size_t k = 0; k < SK_ARRAY_COUNT(gProcs); ++k) { 498 SkAutoTUnref<SkPicture> pic( 499 record_bitmaps(bm, pos, analytic, N, gProcs[k].proc)); 500 501 REPORTER_ASSERT(reporter, pic->willPlayBackBitmaps() || N == 0); 502 // quick check for a small piece of each quadrant, which should just 503 // contain 1 or 2 bitmaps. 504 for (size_t i = 0; i < SK_ARRAY_COUNT(pos); ++i) { 505 SkRect r; 506 r.set(2, 2, W - 2, H - 2); 507 r.offset(pos[i].fX, pos[i].fY); 508 SkAutoDataUnref data(SkPictureUtils::GatherPixelRefs(pic, r)); 509 if (!data) { 510 ERRORF(reporter, "SkPictureUtils::GatherPixelRefs returned " 511 "NULL for %s.", gProcs[k].desc); 512 continue; 513 } 514 SkPixelRef** gatheredRefs = (SkPixelRef**)data->data(); 515 int count = static_cast<int>(data->size() / sizeof(SkPixelRef*)); 516 REPORTER_ASSERT(reporter, 1 == count || 2 == count); 517 if (1 == count) { 518 REPORTER_ASSERT(reporter, gatheredRefs[0] == refs[i]); 519 } else if (2 == count) { 520 REPORTER_ASSERT(reporter, 521 (gatheredRefs[0] == refs[i] && gatheredRefs[1] == refs[i+N]) || 522 (gatheredRefs[1] == refs[i] && gatheredRefs[0] == refs[i+N])); 523 } 524 } 525 526 SkBitmap image; 527 draw(pic, 2*IW, 2*IH, &image); 528 529 // Test a bunch of random (mostly) rects, and compare the gather results 530 // with a deduced list of refs by looking at the colors drawn. 531 for (int j = 0; j < 100; ++j) { 532 SkRect r; 533 rand_rect(&r, rand, 2*W, 2*H); 534 535 SkTDArray<SkPixelRef*> fromImage; 536 gather_from_image(image, refs, N, &fromImage, r); 537 538 SkTDArray<SkPixelRef*> fromAnalytic; 539 gather_from_analytic(pos, W, H, analytic, N, &fromAnalytic, r); 540 541 SkData* data = SkPictureUtils::GatherPixelRefs(pic, r); 542 size_t dataSize = data ? data->size() : 0; 543 int gatherCount = static_cast<int>(dataSize / sizeof(SkPixelRef*)); 544 SkASSERT(gatherCount * sizeof(SkPixelRef*) == dataSize); 545 SkPixelRef** gatherRefs = data ? (SkPixelRef**)(data->data()) : NULL; 546 SkAutoDataUnref adu(data); 547 548 // Everything that we saw drawn should appear in the analytic list 549 // but the analytic list may contain some pixelRefs that were not 550 // seen in the image (e.g., A8 textures used as masks) 551 for (int i = 0; i < fromImage.count(); ++i) { 552 if (-1 == fromAnalytic.find(fromImage[i])) { 553 ERRORF(reporter, "PixelRef missing %d %s", 554 i, gProcs[k].desc); 555 } 556 } 557 558 /* 559 * GatherPixelRefs is conservative, so it can return more bitmaps 560 * than are strictly required. Thus our check here is only that 561 * Gather didn't miss any that we actually needed. Even that isn't 562 * a strict requirement on Gather, which is meant to be quick and 563 * only mostly-correct, but at the moment this test should work. 564 */ 565 for (int i = 0; i < fromAnalytic.count(); ++i) { 566 bool found = find(gatherRefs, fromAnalytic[i], gatherCount); 567 if (!found) { 568 ERRORF(reporter, "PixelRef missing %d %s", 569 i, gProcs[k].desc); 570 } 571#if 0 572 // enable this block of code to debug failures, as it will rerun 573 // the case that failed. 574 if (!found) { 575 SkData* data = SkPictureUtils::GatherPixelRefs(pic, r); 576 size_t dataSize = data ? data->size() : 0; 577 } 578#endif 579 } 580 } 581 } 582} 583 584/* Hit a few SkPicture::Analysis cases not handled elsewhere. */ 585static void test_analysis(skiatest::Reporter* reporter) { 586 SkPictureRecorder recorder; 587 588 SkCanvas* canvas = recorder.beginRecording(100, 100); 589 { 590 canvas->drawRect(SkRect::MakeWH(10, 10), SkPaint ()); 591 } 592 SkAutoTUnref<SkPicture> picture(recorder.endRecording()); 593 REPORTER_ASSERT(reporter, !picture->willPlayBackBitmaps()); 594 595 canvas = recorder.beginRecording(100, 100); 596 { 597 SkPaint paint; 598 // CreateBitmapShader is too smart for us; an empty (or 1x1) bitmap shader 599 // gets optimized into a non-bitmap form, so we create a 2x2 bitmap here. 600 SkBitmap bitmap; 601 bitmap.allocPixels(SkImageInfo::MakeN32Premul(2, 2)); 602 bitmap.eraseColor(SK_ColorBLUE); 603 *(bitmap.getAddr32(0, 0)) = SK_ColorGREEN; 604 SkShader* shader = SkShader::CreateBitmapShader(bitmap, SkShader::kClamp_TileMode, 605 SkShader::kClamp_TileMode); 606 paint.setShader(shader)->unref(); 607 REPORTER_ASSERT(reporter, 608 shader->asABitmap(NULL, NULL, NULL) == SkShader::kDefault_BitmapType); 609 610 canvas->drawRect(SkRect::MakeWH(10, 10), paint); 611 } 612 picture.reset(recorder.endRecording()); 613 REPORTER_ASSERT(reporter, picture->willPlayBackBitmaps()); 614} 615 616 617static void test_gatherpixelrefsandrects(skiatest::Reporter* reporter) { 618 const int IW = 32; 619 const int IH = IW; 620 const SkScalar W = SkIntToScalar(IW); 621 const SkScalar H = W; 622 623 static const int N = 4; 624 SkBitmap bm[2*N]; 625 SkPixelRef* refs[2*N]; 626 SkTDArray<SkPixelRef*> analytic[N]; 627 628 const SkPoint pos[N] = { 629 { 0, 0 }, { W, 0 }, { 0, H }, { W, H } 630 }; 631 632 create_textures(bm, refs, N, IW, IH); 633 634 SkRandom rand; 635 for (size_t k = 0; k < SK_ARRAY_COUNT(gProcs); ++k) { 636 SkAutoTUnref<SkPicture> pic( 637 record_bitmaps(bm, pos, analytic, N, gProcs[k].proc)); 638 639 REPORTER_ASSERT(reporter, pic->willPlayBackBitmaps() || N == 0); 640 641 SkAutoTUnref<SkPictureUtils::SkPixelRefContainer> prCont( 642 new SkPictureUtils::SkPixelRefsAndRectsList); 643 644 SkPictureUtils::GatherPixelRefsAndRects(pic, prCont); 645 646 // quick check for a small piece of each quadrant, which should just 647 // contain 1 or 2 bitmaps. 648 for (size_t i = 0; i < SK_ARRAY_COUNT(pos); ++i) { 649 SkRect r; 650 r.set(2, 2, W - 2, H - 2); 651 r.offset(pos[i].fX, pos[i].fY); 652 653 SkTDArray<SkPixelRef*> gatheredRefs; 654 prCont->query(r, &gatheredRefs); 655 656 int count = gatheredRefs.count(); 657 REPORTER_ASSERT(reporter, 1 == count || 2 == count); 658 if (1 == count) { 659 REPORTER_ASSERT(reporter, gatheredRefs[0] == refs[i]); 660 } else if (2 == count) { 661 REPORTER_ASSERT(reporter, 662 (gatheredRefs[0] == refs[i] && gatheredRefs[1] == refs[i+N]) || 663 (gatheredRefs[1] == refs[i] && gatheredRefs[0] == refs[i+N])); 664 } 665 } 666 667 SkBitmap image; 668 draw(pic, 2*IW, 2*IH, &image); 669 670 // Test a bunch of random (mostly) rects, and compare the gather results 671 // with the analytic results and the pixel refs seen in a rendering. 672 for (int j = 0; j < 100; ++j) { 673 SkRect r; 674 rand_rect(&r, rand, 2*W, 2*H); 675 676 SkTDArray<SkPixelRef*> fromImage; 677 gather_from_image(image, refs, N, &fromImage, r); 678 679 SkTDArray<SkPixelRef*> fromAnalytic; 680 gather_from_analytic(pos, W, H, analytic, N, &fromAnalytic, r); 681 682 SkTDArray<SkPixelRef*> gatheredRefs; 683 prCont->query(r, &gatheredRefs); 684 685 // Everything that we saw drawn should appear in the analytic list 686 // but the analytic list may contain some pixelRefs that were not 687 // seen in the image (e.g., A8 textures used as masks) 688 for (int i = 0; i < fromImage.count(); ++i) { 689 REPORTER_ASSERT(reporter, -1 != fromAnalytic.find(fromImage[i])); 690 } 691 692 // Everything in the analytic list should appear in the gathered 693 // list. 694 for (int i = 0; i < fromAnalytic.count(); ++i) { 695 REPORTER_ASSERT(reporter, -1 != gatheredRefs.find(fromAnalytic[i])); 696 } 697 } 698 } 699} 700 701#ifdef SK_DEBUG 702// Ensure that deleting an empty SkPicture does not assert. Asserts only fire 703// in debug mode, so only run in debug mode. 704static void test_deleting_empty_picture() { 705 SkPictureRecorder recorder; 706 // Creates an SkPictureRecord 707 recorder.beginRecording(0, 0); 708 // Turns that into an SkPicture 709 SkAutoTUnref<SkPicture> picture(recorder.endRecording()); 710 // Ceates a new SkPictureRecord 711 recorder.beginRecording(0, 0); 712} 713 714// Ensure that serializing an empty picture does not assert. Likewise only runs in debug mode. 715static void test_serializing_empty_picture() { 716 SkPictureRecorder recorder; 717 recorder.beginRecording(0, 0); 718 SkAutoTUnref<SkPicture> picture(recorder.endRecording()); 719 SkDynamicMemoryWStream stream; 720 picture->serialize(&stream); 721} 722#endif 723 724static void rand_op(SkCanvas* canvas, SkRandom& rand) { 725 SkPaint paint; 726 SkRect rect = SkRect::MakeWH(50, 50); 727 728 SkScalar unit = rand.nextUScalar1(); 729 if (unit <= 0.3) { 730// SkDebugf("save\n"); 731 canvas->save(); 732 } else if (unit <= 0.6) { 733// SkDebugf("restore\n"); 734 canvas->restore(); 735 } else if (unit <= 0.9) { 736// SkDebugf("clip\n"); 737 canvas->clipRect(rect); 738 } else { 739// SkDebugf("draw\n"); 740 canvas->drawPaint(paint); 741 } 742} 743 744#if SK_SUPPORT_GPU 745 746static void test_gpu_veto(skiatest::Reporter* reporter) { 747 SkPictureRecorder recorder; 748 749 SkCanvas* canvas = recorder.beginRecording(100, 100); 750 { 751 SkPath path; 752 path.moveTo(0, 0); 753 path.lineTo(50, 50); 754 755 SkScalar intervals[] = { 1.0f, 1.0f }; 756 SkAutoTUnref<SkDashPathEffect> dash(SkDashPathEffect::Create(intervals, 2, 0)); 757 758 SkPaint paint; 759 paint.setStyle(SkPaint::kStroke_Style); 760 paint.setPathEffect(dash); 761 762 canvas->drawPath(path, paint); 763 } 764 SkAutoTUnref<SkPicture> picture(recorder.endRecording()); 765 // path effects currently render an SkPicture undesireable for GPU rendering 766 767 const char *reason = NULL; 768 REPORTER_ASSERT(reporter, !picture->suitableForGpuRasterization(NULL, &reason)); 769 REPORTER_ASSERT(reporter, reason); 770 771 canvas = recorder.beginRecording(100, 100); 772 { 773 SkPath path; 774 775 path.moveTo(0, 0); 776 path.lineTo(0, 50); 777 path.lineTo(25, 25); 778 path.lineTo(50, 50); 779 path.lineTo(50, 0); 780 path.close(); 781 REPORTER_ASSERT(reporter, !path.isConvex()); 782 783 SkPaint paint; 784 paint.setAntiAlias(true); 785 for (int i = 0; i < 50; ++i) { 786 canvas->drawPath(path, paint); 787 } 788 } 789 picture.reset(recorder.endRecording()); 790 // A lot of small AA concave paths should be fine for GPU rendering 791 REPORTER_ASSERT(reporter, picture->suitableForGpuRasterization(NULL)); 792 793 canvas = recorder.beginRecording(100, 100); 794 { 795 SkPath path; 796 797 path.moveTo(0, 0); 798 path.lineTo(0, 100); 799 path.lineTo(50, 50); 800 path.lineTo(100, 100); 801 path.lineTo(100, 0); 802 path.close(); 803 REPORTER_ASSERT(reporter, !path.isConvex()); 804 805 SkPaint paint; 806 paint.setAntiAlias(true); 807 for (int i = 0; i < 50; ++i) { 808 canvas->drawPath(path, paint); 809 } 810 } 811 picture.reset(recorder.endRecording()); 812 // A lot of large AA concave paths currently render an SkPicture undesireable for GPU rendering 813 REPORTER_ASSERT(reporter, !picture->suitableForGpuRasterization(NULL)); 814 815 canvas = recorder.beginRecording(100, 100); 816 { 817 SkPath path; 818 819 path.moveTo(0, 0); 820 path.lineTo(0, 50); 821 path.lineTo(25, 25); 822 path.lineTo(50, 50); 823 path.lineTo(50, 0); 824 path.close(); 825 REPORTER_ASSERT(reporter, !path.isConvex()); 826 827 SkPaint paint; 828 paint.setAntiAlias(true); 829 paint.setStyle(SkPaint::kStroke_Style); 830 paint.setStrokeWidth(0); 831 for (int i = 0; i < 50; ++i) { 832 canvas->drawPath(path, paint); 833 } 834 } 835 picture.reset(recorder.endRecording()); 836 // hairline stroked AA concave paths are fine for GPU rendering 837 REPORTER_ASSERT(reporter, picture->suitableForGpuRasterization(NULL)); 838 839 canvas = recorder.beginRecording(100, 100); 840 { 841 SkPaint paint; 842 SkScalar intervals [] = { 10, 20 }; 843 SkPathEffect* pe = SkDashPathEffect::Create(intervals, 2, 25); 844 paint.setPathEffect(pe)->unref(); 845 846 SkPoint points [2] = { { 0, 0 }, { 100, 0 } }; 847 canvas->drawPoints(SkCanvas::kLines_PointMode, 2, points, paint); 848 } 849 picture.reset(recorder.endRecording()); 850 // fast-path dashed effects are fine for GPU rendering ... 851 REPORTER_ASSERT(reporter, picture->suitableForGpuRasterization(NULL)); 852 853 canvas = recorder.beginRecording(100, 100); 854 { 855 SkPaint paint; 856 SkScalar intervals [] = { 10, 20 }; 857 SkPathEffect* pe = SkDashPathEffect::Create(intervals, 2, 25); 858 paint.setPathEffect(pe)->unref(); 859 860 canvas->drawRect(SkRect::MakeWH(10, 10), paint); 861 } 862 picture.reset(recorder.endRecording()); 863 // ... but only when applied to drawPoint() calls 864 REPORTER_ASSERT(reporter, !picture->suitableForGpuRasterization(NULL)); 865 866 // Nest the previous picture inside a new one. 867 canvas = recorder.beginRecording(100, 100); 868 { 869 canvas->drawPicture(picture.get()); 870 } 871 picture.reset(recorder.endRecording()); 872 REPORTER_ASSERT(reporter, !picture->suitableForGpuRasterization(NULL)); 873} 874 875#endif 876 877static void test_savelayer_extraction(skiatest::Reporter* reporter) { 878 static const int kWidth = 100; 879 static const int kHeight = 100; 880 881 // Create complex paint that the bounding box computation code can't 882 // optimize away 883 SkScalar blueToRedMatrix[20] = { 0 }; 884 blueToRedMatrix[2] = blueToRedMatrix[18] = SK_Scalar1; 885 SkAutoTUnref<SkColorFilter> blueToRed(SkColorMatrixFilter::Create(blueToRedMatrix)); 886 SkAutoTUnref<SkImageFilter> filter(SkColorFilterImageFilter::Create(blueToRed.get())); 887 888 SkPaint complexPaint; 889 complexPaint.setImageFilter(filter); 890 891 SkAutoTUnref<SkPicture> pict, child; 892 SkRTreeFactory bbhFactory; 893 894 { 895 SkPictureRecorder recorder; 896 897 SkCanvas* c = recorder.beginRecording(SkIntToScalar(kWidth), SkIntToScalar(kHeight), 898 &bbhFactory, 899 SkPictureRecorder::kComputeSaveLayerInfo_RecordFlag); 900 901 c->saveLayer(NULL, &complexPaint); 902 c->restore(); 903 904 child.reset(recorder.endRecording()); 905 } 906 907 // create a picture with the structure: 908 // 1) 909 // SaveLayer 910 // Restore 911 // 2) 912 // SaveLayer 913 // Translate 914 // SaveLayer w/ bound 915 // Restore 916 // Restore 917 // 3) 918 // SaveLayer w/ copyable paint 919 // Restore 920 // 4) 921 // SaveLayer 922 // DrawPicture (which has a SaveLayer/Restore pair) 923 // Restore 924 // 5) 925 // SaveLayer 926 // DrawPicture with Matrix & Paint (with SaveLayer/Restore pair) 927 // Restore 928 { 929 SkPictureRecorder recorder; 930 931 SkCanvas* c = recorder.beginRecording(SkIntToScalar(kWidth), 932 SkIntToScalar(kHeight), 933 &bbhFactory, 934 SkPictureRecorder::kComputeSaveLayerInfo_RecordFlag); 935 // 1) 936 c->saveLayer(NULL, &complexPaint); // layer #0 937 c->restore(); 938 939 // 2) 940 c->saveLayer(NULL, NULL); // layer #1 941 c->translate(kWidth / 2.0f, kHeight / 2.0f); 942 SkRect r = SkRect::MakeXYWH(0, 0, kWidth/2, kHeight/2); 943 c->saveLayer(&r, &complexPaint); // layer #2 944 c->restore(); 945 c->restore(); 946 947 // 3) 948 { 949 c->saveLayer(NULL, &complexPaint); // layer #3 950 c->restore(); 951 } 952 953 SkPaint layerPaint; 954 layerPaint.setColor(SK_ColorRED); // Non-alpha only to avoid SaveLayerDrawRestoreNooper 955 // 4) 956 { 957 c->saveLayer(NULL, &layerPaint); // layer #4 958 c->drawPicture(child); // layer #5 inside picture 959 c->restore(); 960 } 961 // 5 962 { 963 SkPaint picturePaint; 964 SkMatrix trans; 965 trans.setTranslate(10, 10); 966 967 c->saveLayer(NULL, &layerPaint); // layer #6 968 c->drawPicture(child, &trans, &picturePaint); // layer #7 inside picture 969 c->restore(); 970 } 971 972 pict.reset(recorder.endRecording()); 973 } 974 975 // Now test out the SaveLayer extraction 976 { 977 SkPicture::AccelData::Key key = SkLayerInfo::ComputeKey(); 978 979 const SkPicture::AccelData* data = pict->EXPERIMENTAL_getAccelData(key); 980 REPORTER_ASSERT(reporter, data); 981 982 const SkLayerInfo *gpuData = static_cast<const SkLayerInfo*>(data); 983 REPORTER_ASSERT(reporter, 8 == gpuData->numBlocks()); 984 985 const SkLayerInfo::BlockInfo& info0 = gpuData->block(0); 986 // The parent/child layers appear in reverse order 987 const SkLayerInfo::BlockInfo& info1 = gpuData->block(2); 988 const SkLayerInfo::BlockInfo& info2 = gpuData->block(1); 989 990 const SkLayerInfo::BlockInfo& info3 = gpuData->block(3); 991 992 // The parent/child layers appear in reverse order 993 const SkLayerInfo::BlockInfo& info4 = gpuData->block(5); 994 const SkLayerInfo::BlockInfo& info5 = gpuData->block(4); 995 996 // The parent/child layers appear in reverse order 997 const SkLayerInfo::BlockInfo& info6 = gpuData->block(7); 998 const SkLayerInfo::BlockInfo& info7 = gpuData->block(6); 999 1000 REPORTER_ASSERT(reporter, NULL == info0.fPicture); 1001 REPORTER_ASSERT(reporter, kWidth == info0.fBounds.width() && 1002 kHeight == info0.fBounds.height()); 1003 REPORTER_ASSERT(reporter, info0.fLocalMat.isIdentity()); 1004 REPORTER_ASSERT(reporter, info0.fPreMat.isIdentity()); 1005 REPORTER_ASSERT(reporter, 0 == info0.fBounds.fLeft && 0 == info0.fBounds.fTop); 1006 REPORTER_ASSERT(reporter, NULL != info0.fPaint); 1007 REPORTER_ASSERT(reporter, !info0.fIsNested && !info0.fHasNestedLayers); 1008 1009 REPORTER_ASSERT(reporter, NULL == info1.fPicture); 1010 REPORTER_ASSERT(reporter, kWidth/2.0 == info1.fBounds.width() && 1011 kHeight/2.0 == info1.fBounds.height()); 1012 REPORTER_ASSERT(reporter, info1.fLocalMat.isIdentity()); 1013 REPORTER_ASSERT(reporter, info1.fPreMat.isIdentity()); 1014 REPORTER_ASSERT(reporter, kWidth/2.0 == info1.fBounds.fLeft && 1015 kHeight/2.0 == info1.fBounds.fTop); 1016 REPORTER_ASSERT(reporter, NULL == info1.fPaint); 1017 REPORTER_ASSERT(reporter, !info1.fIsNested && 1018 info1.fHasNestedLayers); // has a nested SL 1019 1020 REPORTER_ASSERT(reporter, NULL == info2.fPicture); 1021 REPORTER_ASSERT(reporter, kWidth / 2 == info2.fBounds.width() && 1022 kHeight / 2 == info2.fBounds.height()); // bound reduces size 1023 REPORTER_ASSERT(reporter, !info2.fLocalMat.isIdentity()); 1024 REPORTER_ASSERT(reporter, info2.fPreMat.isIdentity()); 1025 REPORTER_ASSERT(reporter, kWidth / 2 == info2.fBounds.fLeft && // translated 1026 kHeight / 2 == info2.fBounds.fTop); 1027 REPORTER_ASSERT(reporter, NULL != info2.fPaint); 1028 REPORTER_ASSERT(reporter, info2.fIsNested && !info2.fHasNestedLayers); // is nested 1029 1030 REPORTER_ASSERT(reporter, NULL == info3.fPicture); 1031 REPORTER_ASSERT(reporter, kWidth == info3.fBounds.width() && 1032 kHeight == info3.fBounds.height()); 1033 REPORTER_ASSERT(reporter, info3.fLocalMat.isIdentity()); 1034 REPORTER_ASSERT(reporter, info3.fPreMat.isIdentity()); 1035 REPORTER_ASSERT(reporter, 0 == info3.fBounds.fLeft && 0 == info3.fBounds.fTop); 1036 REPORTER_ASSERT(reporter, info3.fPaint); 1037 REPORTER_ASSERT(reporter, !info3.fIsNested && !info3.fHasNestedLayers); 1038 1039 REPORTER_ASSERT(reporter, NULL == info4.fPicture); 1040 REPORTER_ASSERT(reporter, kWidth == info4.fBounds.width() && 1041 kHeight == info4.fBounds.height()); 1042 REPORTER_ASSERT(reporter, 0 == info4.fBounds.fLeft && 0 == info4.fBounds.fTop); 1043 REPORTER_ASSERT(reporter, info4.fLocalMat.isIdentity()); 1044 REPORTER_ASSERT(reporter, info4.fPreMat.isIdentity()); 1045 REPORTER_ASSERT(reporter, info4.fPaint); 1046 REPORTER_ASSERT(reporter, !info4.fIsNested && 1047 info4.fHasNestedLayers); // has a nested SL 1048 1049 REPORTER_ASSERT(reporter, child == info5.fPicture); // in a child picture 1050 REPORTER_ASSERT(reporter, kWidth == info5.fBounds.width() && 1051 kHeight == info5.fBounds.height()); 1052 REPORTER_ASSERT(reporter, 0 == info5.fBounds.fLeft && 0 == info5.fBounds.fTop); 1053 REPORTER_ASSERT(reporter, info5.fLocalMat.isIdentity()); 1054 REPORTER_ASSERT(reporter, info5.fPreMat.isIdentity()); 1055 REPORTER_ASSERT(reporter, NULL != info5.fPaint); 1056 REPORTER_ASSERT(reporter, info5.fIsNested && !info5.fHasNestedLayers); // is nested 1057 1058 REPORTER_ASSERT(reporter, NULL == info6.fPicture); 1059 REPORTER_ASSERT(reporter, kWidth-10 == info6.fBounds.width() && 1060 kHeight-10 == info6.fBounds.height()); 1061 REPORTER_ASSERT(reporter, 10 == info6.fBounds.fLeft && 10 == info6.fBounds.fTop); 1062 REPORTER_ASSERT(reporter, info6.fLocalMat.isIdentity()); 1063 REPORTER_ASSERT(reporter, info6.fPreMat.isIdentity()); 1064 REPORTER_ASSERT(reporter, info6.fPaint); 1065 REPORTER_ASSERT(reporter, !info6.fIsNested && 1066 info6.fHasNestedLayers); // has a nested SL 1067 1068 REPORTER_ASSERT(reporter, child == info7.fPicture); // in a child picture 1069 REPORTER_ASSERT(reporter, kWidth == info7.fBounds.width() && 1070 kHeight == info7.fBounds.height()); 1071 REPORTER_ASSERT(reporter, 0 == info7.fBounds.fLeft && 0 == info7.fBounds.fTop); 1072 REPORTER_ASSERT(reporter, info7.fLocalMat.isIdentity()); 1073 REPORTER_ASSERT(reporter, info7.fPreMat.isIdentity()); 1074 REPORTER_ASSERT(reporter, NULL != info7.fPaint); 1075 REPORTER_ASSERT(reporter, info7.fIsNested && !info7.fHasNestedLayers); // is nested 1076 } 1077} 1078 1079static void test_has_text(skiatest::Reporter* reporter) { 1080 SkPictureRecorder recorder; 1081 1082 SkCanvas* canvas = recorder.beginRecording(100,100); 1083 { 1084 canvas->drawRect(SkRect::MakeWH(20, 20), SkPaint()); 1085 } 1086 SkAutoTUnref<SkPicture> picture(recorder.endRecording()); 1087 REPORTER_ASSERT(reporter, !picture->hasText()); 1088 1089 SkPoint point = SkPoint::Make(10, 10); 1090 canvas = recorder.beginRecording(100,100); 1091 { 1092 canvas->drawText("Q", 1, point.fX, point.fY, SkPaint()); 1093 } 1094 picture.reset(recorder.endRecording()); 1095 REPORTER_ASSERT(reporter, picture->hasText()); 1096 1097 canvas = recorder.beginRecording(100,100); 1098 { 1099 canvas->drawPosText("Q", 1, &point, SkPaint()); 1100 } 1101 picture.reset(recorder.endRecording()); 1102 REPORTER_ASSERT(reporter, picture->hasText()); 1103 1104 canvas = recorder.beginRecording(100,100); 1105 { 1106 canvas->drawPosTextH("Q", 1, &point.fX, point.fY, SkPaint()); 1107 } 1108 picture.reset(recorder.endRecording()); 1109 REPORTER_ASSERT(reporter, picture->hasText()); 1110 1111 canvas = recorder.beginRecording(100,100); 1112 { 1113 SkPath path; 1114 path.moveTo(0, 0); 1115 path.lineTo(50, 50); 1116 1117 canvas->drawTextOnPathHV("Q", 1, path, point.fX, point.fY, SkPaint()); 1118 } 1119 picture.reset(recorder.endRecording()); 1120 REPORTER_ASSERT(reporter, picture->hasText()); 1121 1122 canvas = recorder.beginRecording(100,100); 1123 { 1124 SkPath path; 1125 path.moveTo(0, 0); 1126 path.lineTo(50, 50); 1127 1128 canvas->drawTextOnPath("Q", 1, path, NULL, SkPaint()); 1129 } 1130 picture.reset(recorder.endRecording()); 1131 REPORTER_ASSERT(reporter, picture->hasText()); 1132 1133 // Nest the previous picture inside a new one. 1134 canvas = recorder.beginRecording(100,100); 1135 { 1136 canvas->drawPicture(picture.get()); 1137 } 1138 picture.reset(recorder.endRecording()); 1139 REPORTER_ASSERT(reporter, picture->hasText()); 1140} 1141 1142static void set_canvas_to_save_count_4(SkCanvas* canvas) { 1143 canvas->restoreToCount(1); 1144 canvas->save(); 1145 canvas->save(); 1146 canvas->save(); 1147} 1148 1149/** 1150 * A canvas that records the number of saves, saveLayers and restores. 1151 */ 1152class SaveCountingCanvas : public SkCanvas { 1153public: 1154 SaveCountingCanvas(int width, int height) 1155 : INHERITED(width, height) 1156 , fSaveCount(0) 1157 , fSaveLayerCount(0) 1158 , fRestoreCount(0){ 1159 } 1160 1161 virtual SaveLayerStrategy willSaveLayer(const SkRect* bounds, const SkPaint* paint, 1162 SaveFlags flags) SK_OVERRIDE { 1163 ++fSaveLayerCount; 1164 return this->INHERITED::willSaveLayer(bounds, paint, flags); 1165 } 1166 1167 virtual void willSave() SK_OVERRIDE { 1168 ++fSaveCount; 1169 this->INHERITED::willSave(); 1170 } 1171 1172 virtual void willRestore() SK_OVERRIDE { 1173 ++fRestoreCount; 1174 this->INHERITED::willRestore(); 1175 } 1176 1177 unsigned int getSaveCount() const { return fSaveCount; } 1178 unsigned int getSaveLayerCount() const { return fSaveLayerCount; } 1179 unsigned int getRestoreCount() const { return fRestoreCount; } 1180 1181private: 1182 unsigned int fSaveCount; 1183 unsigned int fSaveLayerCount; 1184 unsigned int fRestoreCount; 1185 1186 typedef SkCanvas INHERITED; 1187}; 1188 1189void check_save_state(skiatest::Reporter* reporter, SkPicture* picture, 1190 unsigned int numSaves, unsigned int numSaveLayers, 1191 unsigned int numRestores) { 1192 SaveCountingCanvas canvas(SkScalarCeilToInt(picture->cullRect().width()), 1193 SkScalarCeilToInt(picture->cullRect().height())); 1194 1195 picture->playback(&canvas); 1196 1197 // Optimizations may have removed these, 1198 // so expect to have seen no more than num{Saves,SaveLayers,Restores}. 1199 REPORTER_ASSERT(reporter, numSaves >= canvas.getSaveCount()); 1200 REPORTER_ASSERT(reporter, numSaveLayers >= canvas.getSaveLayerCount()); 1201 REPORTER_ASSERT(reporter, numRestores >= canvas.getRestoreCount()); 1202} 1203 1204// This class exists so SkPicture can friend it and give it access to 1205// the 'partialReplay' method. 1206class SkPictureRecorderReplayTester { 1207public: 1208 static SkPicture* Copy(SkPictureRecorder* recorder) { 1209 SkPictureRecorder recorder2; 1210 1211 SkCanvas* canvas = recorder2.beginRecording(10, 10); 1212 1213 recorder->partialReplay(canvas); 1214 1215 return recorder2.endRecording(); 1216 } 1217}; 1218 1219static void create_imbalance(SkCanvas* canvas) { 1220 SkRect clipRect = SkRect::MakeWH(2, 2); 1221 SkRect drawRect = SkRect::MakeWH(10, 10); 1222 canvas->save(); 1223 canvas->clipRect(clipRect, SkRegion::kReplace_Op); 1224 canvas->translate(1.0f, 1.0f); 1225 SkPaint p; 1226 p.setColor(SK_ColorGREEN); 1227 canvas->drawRect(drawRect, p); 1228 // no restore 1229} 1230 1231// This tests that replaying a potentially unbalanced picture into a canvas 1232// doesn't affect the canvas' save count or matrix/clip state. 1233static void check_balance(skiatest::Reporter* reporter, SkPicture* picture) { 1234 SkBitmap bm; 1235 bm.allocN32Pixels(4, 3); 1236 SkCanvas canvas(bm); 1237 1238 int beforeSaveCount = canvas.getSaveCount(); 1239 1240 SkMatrix beforeMatrix = canvas.getTotalMatrix(); 1241 1242 SkRect beforeClip; 1243 1244 canvas.getClipBounds(&beforeClip); 1245 1246 canvas.drawPicture(picture); 1247 1248 REPORTER_ASSERT(reporter, beforeSaveCount == canvas.getSaveCount()); 1249 REPORTER_ASSERT(reporter, beforeMatrix == canvas.getTotalMatrix()); 1250 1251 SkRect afterClip; 1252 1253 canvas.getClipBounds(&afterClip); 1254 1255 REPORTER_ASSERT(reporter, afterClip == beforeClip); 1256} 1257 1258// Test out SkPictureRecorder::partialReplay 1259DEF_TEST(PictureRecorder_replay, reporter) { 1260 // check save/saveLayer state 1261 { 1262 SkPictureRecorder recorder; 1263 1264 SkCanvas* canvas = recorder.beginRecording(10, 10); 1265 1266 canvas->saveLayer(NULL, NULL); 1267 1268 SkAutoTUnref<SkPicture> copy(SkPictureRecorderReplayTester::Copy(&recorder)); 1269 1270 // The extra save and restore comes from the Copy process. 1271 check_save_state(reporter, copy, 2, 1, 3); 1272 1273 canvas->saveLayer(NULL, NULL); 1274 1275 SkAutoTUnref<SkPicture> final(recorder.endRecording()); 1276 1277 check_save_state(reporter, final, 1, 2, 3); 1278 1279 // The copy shouldn't pick up any operations added after it was made 1280 check_save_state(reporter, copy, 2, 1, 3); 1281 } 1282 1283 // (partially) check leakage of draw ops 1284 { 1285 SkPictureRecorder recorder; 1286 1287 SkCanvas* canvas = recorder.beginRecording(10, 10); 1288 1289 SkRect r = SkRect::MakeWH(5, 5); 1290 SkPaint p; 1291 1292 canvas->drawRect(r, p); 1293 1294 SkAutoTUnref<SkPicture> copy(SkPictureRecorderReplayTester::Copy(&recorder)); 1295 1296 REPORTER_ASSERT(reporter, !copy->willPlayBackBitmaps()); 1297 1298 SkBitmap bm; 1299 make_bm(&bm, 10, 10, SK_ColorRED, true); 1300 1301 r.offset(5.0f, 5.0f); 1302 canvas->drawBitmapRectToRect(bm, NULL, r); 1303 1304 SkAutoTUnref<SkPicture> final(recorder.endRecording()); 1305 REPORTER_ASSERT(reporter, final->willPlayBackBitmaps()); 1306 1307 REPORTER_ASSERT(reporter, copy->uniqueID() != final->uniqueID()); 1308 1309 // The snapshot shouldn't pick up any operations added after it was made 1310 REPORTER_ASSERT(reporter, !copy->willPlayBackBitmaps()); 1311 } 1312 1313 // Recreate the Android partialReplay test case 1314 { 1315 SkPictureRecorder recorder; 1316 1317 SkCanvas* canvas = recorder.beginRecording(4, 3, NULL, 0); 1318 create_imbalance(canvas); 1319 1320 int expectedSaveCount = canvas->getSaveCount(); 1321 1322 SkAutoTUnref<SkPicture> copy(SkPictureRecorderReplayTester::Copy(&recorder)); 1323 check_balance(reporter, copy); 1324 1325 REPORTER_ASSERT(reporter, expectedSaveCount = canvas->getSaveCount()); 1326 1327 // End the recording of source to test the picture finalization 1328 // process isn't complicated by the partialReplay step 1329 SkAutoTUnref<SkPicture> final(recorder.endRecording()); 1330 } 1331} 1332 1333static void test_unbalanced_save_restores(skiatest::Reporter* reporter) { 1334 SkCanvas testCanvas(100, 100); 1335 set_canvas_to_save_count_4(&testCanvas); 1336 1337 REPORTER_ASSERT(reporter, 4 == testCanvas.getSaveCount()); 1338 1339 SkPaint paint; 1340 SkRect rect = SkRect::MakeLTRB(-10000000, -10000000, 10000000, 10000000); 1341 1342 SkPictureRecorder recorder; 1343 1344 { 1345 // Create picture with 2 unbalanced saves 1346 SkCanvas* canvas = recorder.beginRecording(100, 100); 1347 canvas->save(); 1348 canvas->translate(10, 10); 1349 canvas->drawRect(rect, paint); 1350 canvas->save(); 1351 canvas->translate(10, 10); 1352 canvas->drawRect(rect, paint); 1353 SkAutoTUnref<SkPicture> extraSavePicture(recorder.endRecording()); 1354 1355 testCanvas.drawPicture(extraSavePicture); 1356 REPORTER_ASSERT(reporter, 4 == testCanvas.getSaveCount()); 1357 } 1358 1359 set_canvas_to_save_count_4(&testCanvas); 1360 1361 { 1362 // Create picture with 2 unbalanced restores 1363 SkCanvas* canvas = recorder.beginRecording(100, 100); 1364 canvas->save(); 1365 canvas->translate(10, 10); 1366 canvas->drawRect(rect, paint); 1367 canvas->save(); 1368 canvas->translate(10, 10); 1369 canvas->drawRect(rect, paint); 1370 canvas->restore(); 1371 canvas->restore(); 1372 canvas->restore(); 1373 canvas->restore(); 1374 SkAutoTUnref<SkPicture> extraRestorePicture(recorder.endRecording()); 1375 1376 testCanvas.drawPicture(extraRestorePicture); 1377 REPORTER_ASSERT(reporter, 4 == testCanvas.getSaveCount()); 1378 } 1379 1380 set_canvas_to_save_count_4(&testCanvas); 1381 1382 { 1383 SkCanvas* canvas = recorder.beginRecording(100, 100); 1384 canvas->translate(10, 10); 1385 canvas->drawRect(rect, paint); 1386 SkAutoTUnref<SkPicture> noSavePicture(recorder.endRecording()); 1387 1388 testCanvas.drawPicture(noSavePicture); 1389 REPORTER_ASSERT(reporter, 4 == testCanvas.getSaveCount()); 1390 REPORTER_ASSERT(reporter, testCanvas.getTotalMatrix().isIdentity()); 1391 } 1392} 1393 1394static void test_peephole() { 1395 SkRandom rand; 1396 1397 SkPictureRecorder recorder; 1398 1399 for (int j = 0; j < 100; j++) { 1400 SkRandom rand2(rand); // remember the seed 1401 1402 SkCanvas* canvas = recorder.beginRecording(100, 100); 1403 1404 for (int i = 0; i < 1000; ++i) { 1405 rand_op(canvas, rand); 1406 } 1407 SkAutoTUnref<SkPicture> picture(recorder.endRecording()); 1408 1409 rand = rand2; 1410 } 1411 1412 { 1413 SkCanvas* canvas = recorder.beginRecording(100, 100); 1414 SkRect rect = SkRect::MakeWH(50, 50); 1415 1416 for (int i = 0; i < 100; ++i) { 1417 canvas->save(); 1418 } 1419 while (canvas->getSaveCount() > 1) { 1420 canvas->clipRect(rect); 1421 canvas->restore(); 1422 } 1423 SkAutoTUnref<SkPicture> picture(recorder.endRecording()); 1424 } 1425} 1426 1427#ifndef SK_DEBUG 1428// Only test this is in release mode. We deliberately crash in debug mode, since a valid caller 1429// should never do this. 1430static void test_bad_bitmap() { 1431 // This bitmap has a width and height but no pixels. As a result, attempting to record it will 1432 // fail. 1433 SkBitmap bm; 1434 bm.setInfo(SkImageInfo::MakeN32Premul(100, 100)); 1435 SkPictureRecorder recorder; 1436 SkCanvas* recordingCanvas = recorder.beginRecording(100, 100); 1437 recordingCanvas->drawBitmap(bm, 0, 0); 1438 SkAutoTUnref<SkPicture> picture(recorder.endRecording()); 1439 1440 SkCanvas canvas; 1441 canvas.drawPicture(picture); 1442} 1443#endif 1444 1445static SkData* encode_bitmap_to_data(size_t*, const SkBitmap& bm) { 1446 return SkImageEncoder::EncodeData(bm, SkImageEncoder::kPNG_Type, 100); 1447} 1448 1449static SkData* serialized_picture_from_bitmap(const SkBitmap& bitmap) { 1450 SkPictureRecorder recorder; 1451 SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(bitmap.width()), 1452 SkIntToScalar(bitmap.height())); 1453 canvas->drawBitmap(bitmap, 0, 0); 1454 SkAutoTUnref<SkPicture> picture(recorder.endRecording()); 1455 1456 SkDynamicMemoryWStream wStream; 1457 picture->serialize(&wStream, &encode_bitmap_to_data); 1458 return wStream.copyToData(); 1459} 1460 1461struct ErrorContext { 1462 int fErrors; 1463 skiatest::Reporter* fReporter; 1464}; 1465 1466static void assert_one_parse_error_cb(SkError error, void* context) { 1467 ErrorContext* errorContext = static_cast<ErrorContext*>(context); 1468 errorContext->fErrors++; 1469 // This test only expects one error, and that is a kParseError. If there are others, 1470 // there is some unknown problem. 1471 REPORTER_ASSERT_MESSAGE(errorContext->fReporter, 1 == errorContext->fErrors, 1472 "This threw more errors than expected."); 1473 REPORTER_ASSERT_MESSAGE(errorContext->fReporter, kParseError_SkError == error, 1474 SkGetLastErrorString()); 1475} 1476 1477static void test_bitmap_with_encoded_data(skiatest::Reporter* reporter) { 1478 // Create a bitmap that will be encoded. 1479 SkBitmap original; 1480 make_bm(&original, 100, 100, SK_ColorBLUE, true); 1481 SkDynamicMemoryWStream wStream; 1482 if (!SkImageEncoder::EncodeStream(&wStream, original, SkImageEncoder::kPNG_Type, 100)) { 1483 return; 1484 } 1485 SkAutoDataUnref data(wStream.copyToData()); 1486 1487 SkBitmap bm; 1488 bool installSuccess = SkInstallDiscardablePixelRef( 1489 SkDecodingImageGenerator::Create(data, SkDecodingImageGenerator::Options()), &bm); 1490 REPORTER_ASSERT(reporter, installSuccess); 1491 1492 // Write both bitmaps to pictures, and ensure that the resulting data streams are the same. 1493 // Flattening original will follow the old path of performing an encode, while flattening bm 1494 // will use the already encoded data. 1495 SkAutoDataUnref picture1(serialized_picture_from_bitmap(original)); 1496 SkAutoDataUnref picture2(serialized_picture_from_bitmap(bm)); 1497 REPORTER_ASSERT(reporter, picture1->equals(picture2)); 1498 // Now test that a parse error was generated when trying to create a new SkPicture without 1499 // providing a function to decode the bitmap. 1500 ErrorContext context; 1501 context.fErrors = 0; 1502 context.fReporter = reporter; 1503 SkSetErrorCallback(assert_one_parse_error_cb, &context); 1504 SkMemoryStream pictureStream(picture1); 1505 SkClearLastError(); 1506 SkAutoTUnref<SkPicture> pictureFromStream(SkPicture::CreateFromStream(&pictureStream, NULL)); 1507 REPORTER_ASSERT(reporter, pictureFromStream.get() != NULL); 1508 SkClearLastError(); 1509 SkSetErrorCallback(NULL, NULL); 1510} 1511 1512static void test_clip_bound_opt(skiatest::Reporter* reporter) { 1513 // Test for crbug.com/229011 1514 SkRect rect1 = SkRect::MakeXYWH(SkIntToScalar(4), SkIntToScalar(4), 1515 SkIntToScalar(2), SkIntToScalar(2)); 1516 SkRect rect2 = SkRect::MakeXYWH(SkIntToScalar(7), SkIntToScalar(7), 1517 SkIntToScalar(1), SkIntToScalar(1)); 1518 SkRect rect3 = SkRect::MakeXYWH(SkIntToScalar(6), SkIntToScalar(6), 1519 SkIntToScalar(1), SkIntToScalar(1)); 1520 1521 SkPath invPath; 1522 invPath.addOval(rect1); 1523 invPath.setFillType(SkPath::kInverseEvenOdd_FillType); 1524 SkPath path; 1525 path.addOval(rect2); 1526 SkPath path2; 1527 path2.addOval(rect3); 1528 SkIRect clipBounds; 1529 SkPictureRecorder recorder; 1530 1531 // Testing conservative-raster-clip that is enabled by PictureRecord 1532 { 1533 SkCanvas* canvas = recorder.beginRecording(10, 10); 1534 canvas->clipPath(invPath, SkRegion::kIntersect_Op); 1535 bool nonEmpty = canvas->getClipDeviceBounds(&clipBounds); 1536 REPORTER_ASSERT(reporter, true == nonEmpty); 1537 REPORTER_ASSERT(reporter, 0 == clipBounds.fLeft); 1538 REPORTER_ASSERT(reporter, 0 == clipBounds.fTop); 1539 REPORTER_ASSERT(reporter, 10 == clipBounds.fBottom); 1540 REPORTER_ASSERT(reporter, 10 == clipBounds.fRight); 1541 } 1542 { 1543 SkCanvas* canvas = recorder.beginRecording(10, 10); 1544 canvas->clipPath(path, SkRegion::kIntersect_Op); 1545 canvas->clipPath(invPath, SkRegion::kIntersect_Op); 1546 bool nonEmpty = canvas->getClipDeviceBounds(&clipBounds); 1547 REPORTER_ASSERT(reporter, true == nonEmpty); 1548 REPORTER_ASSERT(reporter, 7 == clipBounds.fLeft); 1549 REPORTER_ASSERT(reporter, 7 == clipBounds.fTop); 1550 REPORTER_ASSERT(reporter, 8 == clipBounds.fBottom); 1551 REPORTER_ASSERT(reporter, 8 == clipBounds.fRight); 1552 } 1553 { 1554 SkCanvas* canvas = recorder.beginRecording(10, 10); 1555 canvas->clipPath(path, SkRegion::kIntersect_Op); 1556 canvas->clipPath(invPath, SkRegion::kUnion_Op); 1557 bool nonEmpty = canvas->getClipDeviceBounds(&clipBounds); 1558 REPORTER_ASSERT(reporter, true == nonEmpty); 1559 REPORTER_ASSERT(reporter, 0 == clipBounds.fLeft); 1560 REPORTER_ASSERT(reporter, 0 == clipBounds.fTop); 1561 REPORTER_ASSERT(reporter, 10 == clipBounds.fBottom); 1562 REPORTER_ASSERT(reporter, 10 == clipBounds.fRight); 1563 } 1564 { 1565 SkCanvas* canvas = recorder.beginRecording(10, 10); 1566 canvas->clipPath(path, SkRegion::kDifference_Op); 1567 bool nonEmpty = canvas->getClipDeviceBounds(&clipBounds); 1568 REPORTER_ASSERT(reporter, true == nonEmpty); 1569 REPORTER_ASSERT(reporter, 0 == clipBounds.fLeft); 1570 REPORTER_ASSERT(reporter, 0 == clipBounds.fTop); 1571 REPORTER_ASSERT(reporter, 10 == clipBounds.fBottom); 1572 REPORTER_ASSERT(reporter, 10 == clipBounds.fRight); 1573 } 1574 { 1575 SkCanvas* canvas = recorder.beginRecording(10, 10); 1576 canvas->clipPath(path, SkRegion::kReverseDifference_Op); 1577 bool nonEmpty = canvas->getClipDeviceBounds(&clipBounds); 1578 // True clip is actually empty in this case, but the best 1579 // determination we can make using only bounds as input is that the 1580 // clip is included in the bounds of 'path'. 1581 REPORTER_ASSERT(reporter, true == nonEmpty); 1582 REPORTER_ASSERT(reporter, 7 == clipBounds.fLeft); 1583 REPORTER_ASSERT(reporter, 7 == clipBounds.fTop); 1584 REPORTER_ASSERT(reporter, 8 == clipBounds.fBottom); 1585 REPORTER_ASSERT(reporter, 8 == clipBounds.fRight); 1586 } 1587 { 1588 SkCanvas* canvas = recorder.beginRecording(10, 10); 1589 canvas->clipPath(path, SkRegion::kIntersect_Op); 1590 canvas->clipPath(path2, SkRegion::kXOR_Op); 1591 bool nonEmpty = canvas->getClipDeviceBounds(&clipBounds); 1592 REPORTER_ASSERT(reporter, true == nonEmpty); 1593 REPORTER_ASSERT(reporter, 6 == clipBounds.fLeft); 1594 REPORTER_ASSERT(reporter, 6 == clipBounds.fTop); 1595 REPORTER_ASSERT(reporter, 8 == clipBounds.fBottom); 1596 REPORTER_ASSERT(reporter, 8 == clipBounds.fRight); 1597 } 1598} 1599 1600/** 1601 * A canvas that records the number of clip commands. 1602 */ 1603class ClipCountingCanvas : public SkCanvas { 1604public: 1605 ClipCountingCanvas(int width, int height) 1606 : INHERITED(width, height) 1607 , fClipCount(0){ 1608 } 1609 1610 virtual void onClipRect(const SkRect& r, 1611 SkRegion::Op op, 1612 ClipEdgeStyle edgeStyle) SK_OVERRIDE { 1613 fClipCount += 1; 1614 this->INHERITED::onClipRect(r, op, edgeStyle); 1615 } 1616 1617 virtual void onClipRRect(const SkRRect& rrect, 1618 SkRegion::Op op, 1619 ClipEdgeStyle edgeStyle)SK_OVERRIDE { 1620 fClipCount += 1; 1621 this->INHERITED::onClipRRect(rrect, op, edgeStyle); 1622 } 1623 1624 virtual void onClipPath(const SkPath& path, 1625 SkRegion::Op op, 1626 ClipEdgeStyle edgeStyle) SK_OVERRIDE { 1627 fClipCount += 1; 1628 this->INHERITED::onClipPath(path, op, edgeStyle); 1629 } 1630 1631 virtual void onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op) SK_OVERRIDE { 1632 fClipCount += 1; 1633 this->INHERITED::onClipRegion(deviceRgn, op); 1634 } 1635 1636 unsigned getClipCount() const { return fClipCount; } 1637 1638private: 1639 unsigned fClipCount; 1640 1641 typedef SkCanvas INHERITED; 1642}; 1643 1644static void test_clip_expansion(skiatest::Reporter* reporter) { 1645 SkPictureRecorder recorder; 1646 SkCanvas* canvas = recorder.beginRecording(10, 10); 1647 1648 canvas->clipRect(SkRect::MakeEmpty(), SkRegion::kReplace_Op); 1649 // The following expanding clip should not be skipped. 1650 canvas->clipRect(SkRect::MakeXYWH(4, 4, 3, 3), SkRegion::kUnion_Op); 1651 // Draw something so the optimizer doesn't just fold the world. 1652 SkPaint p; 1653 p.setColor(SK_ColorBLUE); 1654 canvas->drawPaint(p); 1655 SkAutoTUnref<SkPicture> picture(recorder.endRecording()); 1656 1657 ClipCountingCanvas testCanvas(10, 10); 1658 picture->playback(&testCanvas); 1659 1660 // Both clips should be present on playback. 1661 REPORTER_ASSERT(reporter, testCanvas.getClipCount() == 2); 1662} 1663 1664static void test_hierarchical(skiatest::Reporter* reporter) { 1665 SkBitmap bm; 1666 make_bm(&bm, 10, 10, SK_ColorRED, true); 1667 1668 SkPictureRecorder recorder; 1669 1670 recorder.beginRecording(10, 10); 1671 SkAutoTUnref<SkPicture> childPlain(recorder.endRecording()); 1672 REPORTER_ASSERT(reporter, !childPlain->willPlayBackBitmaps()); // 0 1673 1674 recorder.beginRecording(10, 10)->drawBitmap(bm, 0, 0); 1675 SkAutoTUnref<SkPicture> childWithBitmap(recorder.endRecording()); 1676 REPORTER_ASSERT(reporter, childWithBitmap->willPlayBackBitmaps()); // 1 1677 1678 { 1679 SkCanvas* canvas = recorder.beginRecording(10, 10); 1680 canvas->drawPicture(childPlain); 1681 SkAutoTUnref<SkPicture> parentPP(recorder.endRecording()); 1682 REPORTER_ASSERT(reporter, !parentPP->willPlayBackBitmaps()); // 0 1683 } 1684 { 1685 SkCanvas* canvas = recorder.beginRecording(10, 10); 1686 canvas->drawPicture(childWithBitmap); 1687 SkAutoTUnref<SkPicture> parentPWB(recorder.endRecording()); 1688 REPORTER_ASSERT(reporter, parentPWB->willPlayBackBitmaps()); // 1 1689 } 1690 { 1691 SkCanvas* canvas = recorder.beginRecording(10, 10); 1692 canvas->drawBitmap(bm, 0, 0); 1693 canvas->drawPicture(childPlain); 1694 SkAutoTUnref<SkPicture> parentWBP(recorder.endRecording()); 1695 REPORTER_ASSERT(reporter, parentWBP->willPlayBackBitmaps()); // 1 1696 } 1697 { 1698 SkCanvas* canvas = recorder.beginRecording(10, 10); 1699 canvas->drawBitmap(bm, 0, 0); 1700 canvas->drawPicture(childWithBitmap); 1701 SkAutoTUnref<SkPicture> parentWBWB(recorder.endRecording()); 1702 REPORTER_ASSERT(reporter, parentWBWB->willPlayBackBitmaps()); // 2 1703 } 1704} 1705 1706static void test_gen_id(skiatest::Reporter* reporter) { 1707 1708 SkPictureRecorder recorder; 1709 recorder.beginRecording(0, 0); 1710 SkAutoTUnref<SkPicture> empty(recorder.endRecording()); 1711 1712 // Empty pictures should still have a valid ID 1713 REPORTER_ASSERT(reporter, empty->uniqueID() != SK_InvalidGenID); 1714 1715 SkCanvas* canvas = recorder.beginRecording(1, 1); 1716 canvas->drawARGB(255, 255, 255, 255); 1717 SkAutoTUnref<SkPicture> hasData(recorder.endRecording()); 1718 // picture should have a non-zero id after recording 1719 REPORTER_ASSERT(reporter, hasData->uniqueID() != SK_InvalidGenID); 1720 1721 // both pictures should have different ids 1722 REPORTER_ASSERT(reporter, hasData->uniqueID() != empty->uniqueID()); 1723} 1724 1725static void test_bytes_used(skiatest::Reporter* reporter) { 1726 SkPictureRecorder recorder; 1727 1728 recorder.beginRecording(0, 0); 1729 SkAutoTUnref<SkPicture> empty(recorder.endRecording()); 1730 1731 // Sanity check to make sure we aren't under-measuring. 1732 REPORTER_ASSERT(reporter, SkPictureUtils::ApproximateBytesUsed(empty.get()) >= 1733 sizeof(SkPicture) + sizeof(SkRecord)); 1734 1735 // Protect against any unintentional bloat. 1736 size_t approxUsed = SkPictureUtils::ApproximateBytesUsed(empty.get()); 1737 REPORTER_ASSERT(reporter, approxUsed <= 136); 1738 1739 // Sanity check of nested SkPictures. 1740 SkPictureRecorder r2; 1741 r2.beginRecording(0, 0); 1742 r2.getRecordingCanvas()->drawPicture(empty.get()); 1743 SkAutoTUnref<SkPicture> nested(r2.endRecording()); 1744 1745 REPORTER_ASSERT(reporter, SkPictureUtils::ApproximateBytesUsed(nested.get()) > 1746 SkPictureUtils::ApproximateBytesUsed(empty.get())); 1747} 1748 1749DEF_TEST(Picture, reporter) { 1750#ifdef SK_DEBUG 1751 test_deleting_empty_picture(); 1752 test_serializing_empty_picture(); 1753#else 1754 test_bad_bitmap(); 1755#endif 1756 test_unbalanced_save_restores(reporter); 1757 test_peephole(); 1758#if SK_SUPPORT_GPU 1759 test_gpu_veto(reporter); 1760#endif 1761 test_has_text(reporter); 1762 test_analysis(reporter); 1763 test_gatherpixelrefs(reporter); 1764 test_gatherpixelrefsandrects(reporter); 1765 test_bitmap_with_encoded_data(reporter); 1766 test_clip_bound_opt(reporter); 1767 test_clip_expansion(reporter); 1768 test_hierarchical(reporter); 1769 test_gen_id(reporter); 1770 test_savelayer_extraction(reporter); 1771 test_bytes_used(reporter); 1772} 1773 1774static void draw_bitmaps(const SkBitmap bitmap, SkCanvas* canvas) { 1775 const SkPaint paint; 1776 const SkRect rect = { 5.0f, 5.0f, 8.0f, 8.0f }; 1777 const SkIRect irect = { 2, 2, 3, 3 }; 1778 1779 // Don't care what these record, as long as they're legal. 1780 canvas->drawBitmap(bitmap, 0.0f, 0.0f, &paint); 1781 canvas->drawBitmapRectToRect(bitmap, &rect, rect, &paint, SkCanvas::kNone_DrawBitmapRectFlag); 1782 canvas->drawBitmapNine(bitmap, irect, rect, &paint); 1783 canvas->drawSprite(bitmap, 1, 1); 1784} 1785 1786static void test_draw_bitmaps(SkCanvas* canvas) { 1787 SkBitmap empty; 1788 draw_bitmaps(empty, canvas); 1789 empty.setInfo(SkImageInfo::MakeN32Premul(10, 10)); 1790 draw_bitmaps(empty, canvas); 1791} 1792 1793DEF_TEST(Picture_EmptyBitmap, r) { 1794 SkPictureRecorder recorder; 1795 test_draw_bitmaps(recorder.beginRecording(10, 10)); 1796 SkAutoTUnref<SkPicture> picture(recorder.endRecording()); 1797} 1798 1799DEF_TEST(Canvas_EmptyBitmap, r) { 1800 SkBitmap dst; 1801 dst.allocN32Pixels(10, 10); 1802 SkCanvas canvas(dst); 1803 1804 test_draw_bitmaps(&canvas); 1805} 1806 1807DEF_TEST(DontOptimizeSaveLayerDrawDrawRestore, reporter) { 1808 // This test is from crbug.com/344987. 1809 // The commands are: 1810 // saveLayer with paint that modifies alpha 1811 // drawBitmapRectToRect 1812 // drawBitmapRectToRect 1813 // restore 1814 // The bug was that this structure was modified so that: 1815 // - The saveLayer and restore were eliminated 1816 // - The alpha was only applied to the first drawBitmapRectToRect 1817 1818 // This test draws blue and red squares inside a 50% transparent 1819 // layer. Both colours should show up muted. 1820 // When the bug is present, the red square (the second bitmap) 1821 // shows upwith full opacity. 1822 1823 SkBitmap blueBM; 1824 make_bm(&blueBM, 100, 100, SkColorSetARGB(255, 0, 0, 255), true); 1825 SkBitmap redBM; 1826 make_bm(&redBM, 100, 100, SkColorSetARGB(255, 255, 0, 0), true); 1827 SkPaint semiTransparent; 1828 semiTransparent.setAlpha(0x80); 1829 1830 SkPictureRecorder recorder; 1831 SkCanvas* canvas = recorder.beginRecording(100, 100); 1832 canvas->drawARGB(0, 0, 0, 0); 1833 1834 canvas->saveLayer(0, &semiTransparent); 1835 canvas->drawBitmap(blueBM, 25, 25); 1836 canvas->drawBitmap(redBM, 50, 50); 1837 canvas->restore(); 1838 1839 SkAutoTUnref<SkPicture> picture(recorder.endRecording()); 1840 1841 // Now replay the picture back on another canvas 1842 // and check a couple of its pixels. 1843 SkBitmap replayBM; 1844 make_bm(&replayBM, 100, 100, SK_ColorBLACK, false); 1845 SkCanvas replayCanvas(replayBM); 1846 picture->playback(&replayCanvas); 1847 replayCanvas.flush(); 1848 1849 // With the bug present, at (55, 55) we would get a fully opaque red 1850 // intead of a dark red. 1851 REPORTER_ASSERT(reporter, replayBM.getColor(30, 30) == 0xff000080); 1852 REPORTER_ASSERT(reporter, replayBM.getColor(55, 55) == 0xff800000); 1853} 1854 1855struct CountingBBH : public SkBBoxHierarchy { 1856 mutable int searchCalls; 1857 1858 CountingBBH() : searchCalls(0) {} 1859 1860 virtual void search(const SkRect& query, SkTDArray<unsigned>* results) const SK_OVERRIDE { 1861 this->searchCalls++; 1862 } 1863 1864 virtual void insert(SkAutoTMalloc<SkRect>*, int) SK_OVERRIDE {} 1865 virtual size_t bytesUsed() const { return 0; } 1866}; 1867 1868class SpoonFedBBHFactory : public SkBBHFactory { 1869public: 1870 explicit SpoonFedBBHFactory(SkBBoxHierarchy* bbh) : fBBH(bbh) {} 1871 SkBBoxHierarchy* operator()(const SkRect&) const SK_OVERRIDE { 1872 return SkRef(fBBH); 1873 } 1874private: 1875 SkBBoxHierarchy* fBBH; 1876}; 1877 1878// When the canvas clip covers the full picture, we don't need to call the BBH. 1879DEF_TEST(Picture_SkipBBH, r) { 1880 CountingBBH bbh; 1881 SpoonFedBBHFactory factory(&bbh); 1882 1883 SkPictureRecorder recorder; 1884 recorder.beginRecording(320, 240, &factory); 1885 SkAutoTUnref<const SkPicture> picture(recorder.endRecording()); 1886 1887 SkCanvas big(640, 480), small(300, 200); 1888 1889 picture->playback(&big); 1890 REPORTER_ASSERT(r, bbh.searchCalls == 0); 1891 1892 picture->playback(&small); 1893 REPORTER_ASSERT(r, bbh.searchCalls == 1); 1894} 1895 1896DEF_TEST(Picture_BitmapLeak, r) { 1897 SkBitmap mut, immut; 1898 mut.allocN32Pixels(300, 200); 1899 immut.allocN32Pixels(300, 200); 1900 immut.setImmutable(); 1901 SkASSERT(!mut.isImmutable()); 1902 SkASSERT(immut.isImmutable()); 1903 1904 // No one can hold a ref on our pixels yet. 1905 REPORTER_ASSERT(r, mut.pixelRef()->unique()); 1906 REPORTER_ASSERT(r, immut.pixelRef()->unique()); 1907 1908 SkAutoTUnref<const SkPicture> pic; 1909 { 1910 // we want the recorder to go out of scope before our subsequent checks, so we 1911 // place it inside local braces. 1912 SkPictureRecorder rec; 1913 SkCanvas* canvas = rec.beginRecording(1920, 1200); 1914 canvas->drawBitmap(mut, 0, 0); 1915 canvas->drawBitmap(immut, 800, 600); 1916 pic.reset(rec.endRecording()); 1917 } 1918 1919 // The picture shares the immutable pixels but copies the mutable ones. 1920 REPORTER_ASSERT(r, mut.pixelRef()->unique()); 1921 REPORTER_ASSERT(r, !immut.pixelRef()->unique()); 1922 1923 // When the picture goes away, it's just our bitmaps holding the refs. 1924 pic.reset(NULL); 1925 REPORTER_ASSERT(r, mut.pixelRef()->unique()); 1926 REPORTER_ASSERT(r, immut.pixelRef()->unique()); 1927} 1928