1 /* 2 * Copyright 2013 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 "SkCanvas.h" 9 #include "SkData.h" 10 #include "SkDecodingImageGenerator.h" 11 #include "SkImageEncoder.h" 12 #include "SkRRect.h" 13 #include "SkSurface.h" 14 #include "SkUtils.h" 15 #include "Test.h" 16 17 #if SK_SUPPORT_GPU 18 #include "GrContextFactory.h" 19 #else 20 class GrContextFactory; 21 class GrContext; 22 #endif 23 24 enum SurfaceType { 25 kRaster_SurfaceType, 26 kRasterDirect_SurfaceType, 27 kGpu_SurfaceType, 28 kGpuScratch_SurfaceType, 29 }; 30 31 static void release_storage(void* pixels, void* context) { 32 SkASSERT(pixels == context); 33 sk_free(pixels); 34 } 35 36 static SkSurface* createSurface(SurfaceType surfaceType, GrContext* context, 37 SkImageInfo* requestedInfo = NULL) { 38 static const SkImageInfo info = SkImageInfo::MakeN32Premul(10, 10); 39 40 if (requestedInfo) { 41 *requestedInfo = info; 42 } 43 44 switch (surfaceType) { 45 case kRaster_SurfaceType: 46 return SkSurface::NewRaster(info); 47 case kRasterDirect_SurfaceType: { 48 const size_t rowBytes = info.minRowBytes(); 49 void* storage = sk_malloc_throw(info.getSafeSize(rowBytes)); 50 return SkSurface::NewRasterDirectReleaseProc(info, storage, rowBytes, 51 release_storage, storage); 52 } 53 case kGpu_SurfaceType: 54 #if SK_SUPPORT_GPU 55 return context ? SkSurface::NewRenderTarget(context, info, 0, NULL) : NULL; 56 #endif 57 break; 58 case kGpuScratch_SurfaceType: 59 #if SK_SUPPORT_GPU 60 return context ? SkSurface::NewScratchRenderTarget(context, info) : NULL; 61 #endif 62 break; 63 } 64 return NULL; 65 } 66 67 enum ImageType { 68 kRasterCopy_ImageType, 69 kRasterData_ImageType, 70 kGpu_ImageType, 71 kCodec_ImageType, 72 }; 73 74 static void test_image(skiatest::Reporter* reporter) { 75 SkImageInfo info = SkImageInfo::MakeN32Premul(1, 1); 76 size_t rowBytes = info.minRowBytes(); 77 size_t size = info.getSafeSize(rowBytes); 78 SkData* data = SkData::NewUninitialized(size); 79 80 REPORTER_ASSERT(reporter, 1 == data->getRefCnt()); 81 SkImage* image = SkImage::NewRasterData(info, data, rowBytes); 82 REPORTER_ASSERT(reporter, 2 == data->getRefCnt()); 83 image->unref(); 84 REPORTER_ASSERT(reporter, 1 == data->getRefCnt()); 85 data->unref(); 86 } 87 88 static SkImage* createImage(ImageType imageType, GrContext* context, 89 SkColor color) { 90 const SkPMColor pmcolor = SkPreMultiplyColor(color); 91 const SkImageInfo info = SkImageInfo::MakeN32Premul(10, 10); 92 const size_t rowBytes = info.minRowBytes(); 93 const size_t size = rowBytes * info.height(); 94 95 SkAutoTUnref<SkData> data(SkData::NewUninitialized(size)); 96 void* addr = data->writable_data(); 97 sk_memset32((SkPMColor*)addr, pmcolor, SkToInt(size >> 2)); 98 99 switch (imageType) { 100 case kRasterCopy_ImageType: 101 return SkImage::NewRasterCopy(info, addr, rowBytes); 102 case kRasterData_ImageType: 103 return SkImage::NewRasterData(info, data, rowBytes); 104 case kGpu_ImageType: 105 return NULL; // TODO 106 case kCodec_ImageType: { 107 SkBitmap bitmap; 108 bitmap.installPixels(info, addr, rowBytes); 109 SkAutoTUnref<SkData> src( 110 SkImageEncoder::EncodeData(bitmap, SkImageEncoder::kPNG_Type, 111 100)); 112 return SkImage::NewFromGenerator( 113 SkDecodingImageGenerator::Create(data, SkDecodingImageGenerator::Options())); 114 } 115 } 116 SkASSERT(false); 117 return NULL; 118 } 119 120 static void test_imagepeek(skiatest::Reporter* reporter) { 121 static const struct { 122 ImageType fType; 123 bool fPeekShouldSucceed; 124 } gRec[] = { 125 { kRasterCopy_ImageType, true }, 126 { kRasterData_ImageType, true }, 127 { kGpu_ImageType, false }, 128 { kCodec_ImageType, false }, 129 }; 130 131 const SkColor color = SK_ColorRED; 132 const SkPMColor pmcolor = SkPreMultiplyColor(color); 133 134 for (size_t i = 0; i < SK_ARRAY_COUNT(gRec); ++i) { 135 SkImageInfo info; 136 size_t rowBytes; 137 138 SkAutoTUnref<SkImage> image(createImage(gRec[i].fType, NULL, color)); 139 if (!image.get()) { 140 continue; // gpu may not be enabled 141 } 142 const void* addr = image->peekPixels(&info, &rowBytes); 143 bool success = SkToBool(addr); 144 REPORTER_ASSERT(reporter, gRec[i].fPeekShouldSucceed == success); 145 if (success) { 146 REPORTER_ASSERT(reporter, 10 == info.width()); 147 REPORTER_ASSERT(reporter, 10 == info.height()); 148 REPORTER_ASSERT(reporter, kN32_SkColorType == info.colorType()); 149 REPORTER_ASSERT(reporter, kPremul_SkAlphaType == info.alphaType() || 150 kOpaque_SkAlphaType == info.alphaType()); 151 REPORTER_ASSERT(reporter, info.minRowBytes() <= rowBytes); 152 REPORTER_ASSERT(reporter, pmcolor == *(const SkPMColor*)addr); 153 } 154 } 155 } 156 157 static void test_canvaspeek(skiatest::Reporter* reporter, 158 GrContextFactory* factory) { 159 static const struct { 160 SurfaceType fType; 161 bool fPeekShouldSucceed; 162 } gRec[] = { 163 { kRaster_SurfaceType, true }, 164 { kRasterDirect_SurfaceType, true }, 165 #if SK_SUPPORT_GPU 166 { kGpu_SurfaceType, false }, 167 { kGpuScratch_SurfaceType, false }, 168 #endif 169 }; 170 171 const SkColor color = SK_ColorRED; 172 const SkPMColor pmcolor = SkPreMultiplyColor(color); 173 174 int cnt; 175 #if SK_SUPPORT_GPU 176 cnt = GrContextFactory::kGLContextTypeCnt; 177 #else 178 cnt = 1; 179 #endif 180 181 for (int i= 0; i < cnt; ++i) { 182 GrContext* context = NULL; 183 #if SK_SUPPORT_GPU 184 GrContextFactory::GLContextType glCtxType = (GrContextFactory::GLContextType) i; 185 if (!GrContextFactory::IsRenderingGLContext(glCtxType)) { 186 continue; 187 } 188 context = factory->get(glCtxType); 189 190 if (NULL == context) { 191 continue; 192 } 193 #endif 194 for (size_t i = 0; i < SK_ARRAY_COUNT(gRec); ++i) { 195 SkImageInfo info, requestInfo; 196 size_t rowBytes; 197 198 SkAutoTUnref<SkSurface> surface(createSurface(gRec[i].fType, context, 199 &requestInfo)); 200 surface->getCanvas()->clear(color); 201 202 const void* addr = surface->getCanvas()->peekPixels(&info, &rowBytes); 203 bool success = SkToBool(addr); 204 REPORTER_ASSERT(reporter, gRec[i].fPeekShouldSucceed == success); 205 206 SkImageInfo info2; 207 size_t rb2; 208 const void* addr2 = surface->peekPixels(&info2, &rb2); 209 210 if (success) { 211 REPORTER_ASSERT(reporter, requestInfo == info); 212 REPORTER_ASSERT(reporter, requestInfo.minRowBytes() <= rowBytes); 213 REPORTER_ASSERT(reporter, pmcolor == *(const SkPMColor*)addr); 214 215 REPORTER_ASSERT(reporter, addr2 == addr); 216 REPORTER_ASSERT(reporter, info2 == info); 217 REPORTER_ASSERT(reporter, rb2 == rowBytes); 218 } else { 219 REPORTER_ASSERT(reporter, NULL == addr2); 220 } 221 } 222 } 223 } 224 225 static void TestSurfaceCopyOnWrite(skiatest::Reporter* reporter, SurfaceType surfaceType, 226 GrContext* context) { 227 // Verify that the right canvas commands trigger a copy on write 228 SkSurface* surface = createSurface(surfaceType, context); 229 SkAutoTUnref<SkSurface> aur_surface(surface); 230 SkCanvas* canvas = surface->getCanvas(); 231 232 const SkRect testRect = 233 SkRect::MakeXYWH(SkIntToScalar(0), SkIntToScalar(0), 234 SkIntToScalar(4), SkIntToScalar(5)); 235 SkMatrix testMatrix; 236 testMatrix.reset(); 237 testMatrix.setScale(SkIntToScalar(2), SkIntToScalar(3)); 238 239 SkPath testPath; 240 testPath.addRect(SkRect::MakeXYWH(SkIntToScalar(0), SkIntToScalar(0), 241 SkIntToScalar(2), SkIntToScalar(1))); 242 243 const SkIRect testIRect = SkIRect::MakeXYWH(0, 0, 2, 1); 244 245 SkRegion testRegion; 246 testRegion.setRect(testIRect); 247 248 249 const SkColor testColor = 0x01020304; 250 const SkPaint testPaint; 251 const SkPoint testPoints[3] = { 252 {SkIntToScalar(0), SkIntToScalar(0)}, 253 {SkIntToScalar(2), SkIntToScalar(1)}, 254 {SkIntToScalar(0), SkIntToScalar(2)} 255 }; 256 const size_t testPointCount = 3; 257 258 SkBitmap testBitmap; 259 testBitmap.allocN32Pixels(10, 10); 260 testBitmap.eraseColor(0); 261 262 SkRRect testRRect; 263 testRRect.setRectXY(testRect, SK_Scalar1, SK_Scalar1); 264 265 SkString testText("Hello World"); 266 const SkPoint testPoints2[] = { 267 { SkIntToScalar(0), SkIntToScalar(1) }, 268 { SkIntToScalar(1), SkIntToScalar(1) }, 269 { SkIntToScalar(2), SkIntToScalar(1) }, 270 { SkIntToScalar(3), SkIntToScalar(1) }, 271 { SkIntToScalar(4), SkIntToScalar(1) }, 272 { SkIntToScalar(5), SkIntToScalar(1) }, 273 { SkIntToScalar(6), SkIntToScalar(1) }, 274 { SkIntToScalar(7), SkIntToScalar(1) }, 275 { SkIntToScalar(8), SkIntToScalar(1) }, 276 { SkIntToScalar(9), SkIntToScalar(1) }, 277 { SkIntToScalar(10), SkIntToScalar(1) }, 278 }; 279 280 #define EXPECT_COPY_ON_WRITE(command) \ 281 { \ 282 SkImage* imageBefore = surface->newImageSnapshot(); \ 283 SkAutoTUnref<SkImage> aur_before(imageBefore); \ 284 canvas-> command ; \ 285 SkImage* imageAfter = surface->newImageSnapshot(); \ 286 SkAutoTUnref<SkImage> aur_after(imageAfter); \ 287 REPORTER_ASSERT(reporter, imageBefore != imageAfter); \ 288 } 289 290 EXPECT_COPY_ON_WRITE(clear(testColor)) 291 EXPECT_COPY_ON_WRITE(drawPaint(testPaint)) 292 EXPECT_COPY_ON_WRITE(drawPoints(SkCanvas::kPoints_PointMode, testPointCount, testPoints, \ 293 testPaint)) 294 EXPECT_COPY_ON_WRITE(drawOval(testRect, testPaint)) 295 EXPECT_COPY_ON_WRITE(drawRect(testRect, testPaint)) 296 EXPECT_COPY_ON_WRITE(drawRRect(testRRect, testPaint)) 297 EXPECT_COPY_ON_WRITE(drawPath(testPath, testPaint)) 298 EXPECT_COPY_ON_WRITE(drawBitmap(testBitmap, 0, 0)) 299 EXPECT_COPY_ON_WRITE(drawBitmapRect(testBitmap, NULL, testRect)) 300 EXPECT_COPY_ON_WRITE(drawBitmapMatrix(testBitmap, testMatrix, NULL)) 301 EXPECT_COPY_ON_WRITE(drawBitmapNine(testBitmap, testIRect, testRect, NULL)) 302 EXPECT_COPY_ON_WRITE(drawSprite(testBitmap, 0, 0, NULL)) 303 EXPECT_COPY_ON_WRITE(drawText(testText.c_str(), testText.size(), 0, 1, testPaint)) 304 EXPECT_COPY_ON_WRITE(drawPosText(testText.c_str(), testText.size(), testPoints2, \ 305 testPaint)) 306 EXPECT_COPY_ON_WRITE(drawTextOnPath(testText.c_str(), testText.size(), testPath, NULL, \ 307 testPaint)) 308 } 309 310 static void TestSurfaceWritableAfterSnapshotRelease(skiatest::Reporter* reporter, 311 SurfaceType surfaceType, 312 GrContext* context) { 313 // This test succeeds by not triggering an assertion. 314 // The test verifies that the surface remains writable (usable) after 315 // acquiring and releasing a snapshot without triggering a copy on write. 316 SkAutoTUnref<SkSurface> surface(createSurface(surfaceType, context)); 317 SkCanvas* canvas = surface->getCanvas(); 318 canvas->clear(1); 319 surface->newImageSnapshot()->unref(); // Create and destroy SkImage 320 canvas->clear(2); // Must not assert internally 321 } 322 323 #if SK_SUPPORT_GPU 324 static void TestSurfaceInCache(skiatest::Reporter* reporter, 325 SurfaceType surfaceType, 326 GrContext* context) { 327 context->freeGpuResources(); 328 int resourceCount; 329 330 context->getResourceCacheUsage(&resourceCount, NULL); 331 REPORTER_ASSERT(reporter, 0 == resourceCount); 332 SkAutoTUnref<SkSurface> surface(createSurface(surfaceType, context)); 333 // Note: the stencil buffer is always cached, so kGpu_SurfaceType uses 334 // one cached resource, and kGpuScratch_SurfaceType uses two. 335 int expectedCachedResources = surfaceType == kGpuScratch_SurfaceType ? 2 : 1; 336 context->getResourceCacheUsage(&resourceCount, NULL); 337 REPORTER_ASSERT(reporter, expectedCachedResources == resourceCount); 338 339 // Verify that all the cached resources are locked in cache. 340 context->freeGpuResources(); 341 context->getResourceCacheUsage(&resourceCount, NULL); 342 REPORTER_ASSERT(reporter, expectedCachedResources == resourceCount); 343 344 // Verify that all the cached resources are unlocked upon surface release 345 surface.reset(0); 346 context->freeGpuResources(); 347 context->getResourceCacheUsage(&resourceCount, NULL); 348 REPORTER_ASSERT(reporter, 0 == resourceCount); 349 } 350 351 static void Test_crbug263329(skiatest::Reporter* reporter, 352 SurfaceType surfaceType, 353 GrContext* context) { 354 // This is a regression test for crbug.com/263329 355 // Bug was caused by onCopyOnWrite releasing the old surface texture 356 // back to the scratch texture pool even though the texture is used 357 // by and active SkImage_Gpu. 358 SkAutoTUnref<SkSurface> surface1(createSurface(surfaceType, context)); 359 SkAutoTUnref<SkSurface> surface2(createSurface(surfaceType, context)); 360 SkCanvas* canvas1 = surface1->getCanvas(); 361 SkCanvas* canvas2 = surface2->getCanvas(); 362 canvas1->clear(1); 363 SkAutoTUnref<SkImage> image1(surface1->newImageSnapshot()); 364 // Trigger copy on write, new backing is a scratch texture 365 canvas1->clear(2); 366 SkAutoTUnref<SkImage> image2(surface1->newImageSnapshot()); 367 // Trigger copy on write, old backing should not be returned to scratch 368 // pool because it is held by image2 369 canvas1->clear(3); 370 371 canvas2->clear(4); 372 SkAutoTUnref<SkImage> image3(surface2->newImageSnapshot()); 373 // Trigger copy on write on surface2. The new backing store should not 374 // be recycling a texture that is held by an existing image. 375 canvas2->clear(5); 376 SkAutoTUnref<SkImage> image4(surface2->newImageSnapshot()); 377 REPORTER_ASSERT(reporter, image4->getTexture() != image3->getTexture()); 378 // The following assertion checks crbug.com/263329 379 REPORTER_ASSERT(reporter, image4->getTexture() != image2->getTexture()); 380 REPORTER_ASSERT(reporter, image4->getTexture() != image1->getTexture()); 381 REPORTER_ASSERT(reporter, image3->getTexture() != image2->getTexture()); 382 REPORTER_ASSERT(reporter, image3->getTexture() != image1->getTexture()); 383 REPORTER_ASSERT(reporter, image2->getTexture() != image1->getTexture()); 384 } 385 386 static void TestGetTexture(skiatest::Reporter* reporter, 387 SurfaceType surfaceType, 388 GrContext* context) { 389 SkAutoTUnref<SkSurface> surface(createSurface(surfaceType, context)); 390 SkAutoTUnref<SkImage> image(surface->newImageSnapshot()); 391 GrTexture* texture = image->getTexture(); 392 if (surfaceType == kGpu_SurfaceType || surfaceType == kGpuScratch_SurfaceType) { 393 REPORTER_ASSERT(reporter, texture); 394 REPORTER_ASSERT(reporter, 0 != texture->getTextureHandle()); 395 } else { 396 REPORTER_ASSERT(reporter, NULL == texture); 397 } 398 surface->notifyContentWillChange(SkSurface::kDiscard_ContentChangeMode); 399 REPORTER_ASSERT(reporter, image->getTexture() == texture); 400 } 401 #endif 402 403 static void TestSurfaceNoCanvas(skiatest::Reporter* reporter, 404 SurfaceType surfaceType, 405 GrContext* context, 406 SkSurface::ContentChangeMode mode) { 407 // Verifies the robustness of SkSurface for handling use cases where calls 408 // are made before a canvas is created. 409 { 410 // Test passes by not asserting 411 SkSurface* surface = createSurface(surfaceType, context); 412 SkAutoTUnref<SkSurface> aur_surface(surface); 413 surface->notifyContentWillChange(mode); 414 SkDEBUGCODE(surface->validate();) 415 } 416 { 417 SkSurface* surface = createSurface(surfaceType, context); 418 SkAutoTUnref<SkSurface> aur_surface(surface); 419 SkImage* image1 = surface->newImageSnapshot(); 420 SkAutoTUnref<SkImage> aur_image1(image1); 421 SkDEBUGCODE(image1->validate();) 422 SkDEBUGCODE(surface->validate();) 423 surface->notifyContentWillChange(mode); 424 SkDEBUGCODE(image1->validate();) 425 SkDEBUGCODE(surface->validate();) 426 SkImage* image2 = surface->newImageSnapshot(); 427 SkAutoTUnref<SkImage> aur_image2(image2); 428 SkDEBUGCODE(image2->validate();) 429 SkDEBUGCODE(surface->validate();) 430 REPORTER_ASSERT(reporter, image1 != image2); 431 } 432 433 } 434 435 DEF_GPUTEST(Surface, reporter, factory) { 436 test_image(reporter); 437 438 TestSurfaceCopyOnWrite(reporter, kRaster_SurfaceType, NULL); 439 TestSurfaceWritableAfterSnapshotRelease(reporter, kRaster_SurfaceType, NULL); 440 TestSurfaceNoCanvas(reporter, kRaster_SurfaceType, NULL, SkSurface::kDiscard_ContentChangeMode); 441 TestSurfaceNoCanvas(reporter, kRaster_SurfaceType, NULL, SkSurface::kRetain_ContentChangeMode); 442 443 test_imagepeek(reporter); 444 test_canvaspeek(reporter, factory); 445 446 #if SK_SUPPORT_GPU 447 TestGetTexture(reporter, kRaster_SurfaceType, NULL); 448 if (factory) { 449 for (int i= 0; i < GrContextFactory::kGLContextTypeCnt; ++i) { 450 GrContextFactory::GLContextType glCtxType = (GrContextFactory::GLContextType) i; 451 if (!GrContextFactory::IsRenderingGLContext(glCtxType)) { 452 continue; 453 } 454 GrContext* context = factory->get(glCtxType); 455 if (context) { 456 TestSurfaceInCache(reporter, kGpu_SurfaceType, context); 457 TestSurfaceInCache(reporter, kGpuScratch_SurfaceType, context); 458 Test_crbug263329(reporter, kGpu_SurfaceType, context); 459 Test_crbug263329(reporter, kGpuScratch_SurfaceType, context); 460 TestSurfaceCopyOnWrite(reporter, kGpu_SurfaceType, context); 461 TestSurfaceCopyOnWrite(reporter, kGpuScratch_SurfaceType, context); 462 TestSurfaceWritableAfterSnapshotRelease(reporter, kGpu_SurfaceType, context); 463 TestSurfaceWritableAfterSnapshotRelease(reporter, kGpuScratch_SurfaceType, context); 464 TestSurfaceNoCanvas(reporter, kGpu_SurfaceType, context, SkSurface::kDiscard_ContentChangeMode); 465 TestSurfaceNoCanvas(reporter, kGpuScratch_SurfaceType, context, SkSurface::kDiscard_ContentChangeMode); 466 TestSurfaceNoCanvas(reporter, kGpu_SurfaceType, context, SkSurface::kRetain_ContentChangeMode); 467 TestSurfaceNoCanvas(reporter, kGpuScratch_SurfaceType, context, SkSurface::kRetain_ContentChangeMode); 468 TestGetTexture(reporter, kGpu_SurfaceType, context); 469 TestGetTexture(reporter, kGpuScratch_SurfaceType, context); 470 } 471 } 472 } 473 #endif 474 } 475
