PathCache.cpp revision 36fad8f6fcfbc2087b910600ed5a6f9741177d00
1/* 2 * Copyright (C) 2013 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#define LOG_TAG "OpenGLRenderer" 18#define ATRACE_TAG ATRACE_TAG_VIEW 19 20#include <SkBitmap.h> 21#include <SkCanvas.h> 22#include <SkPaint.h> 23#include <SkPath.h> 24#include <SkRect.h> 25 26#include <utils/JenkinsHash.h> 27#include <utils/Trace.h> 28 29#include "Caches.h" 30#include "PathCache.h" 31 32#include "thread/Signal.h" 33#include "thread/Task.h" 34#include "thread/TaskProcessor.h" 35 36namespace android { 37namespace uirenderer { 38 39/////////////////////////////////////////////////////////////////////////////// 40// Cache entries 41/////////////////////////////////////////////////////////////////////////////// 42 43PathDescription::PathDescription(): 44 type(kShapeNone), 45 join(SkPaint::kDefault_Join), 46 cap(SkPaint::kDefault_Cap), 47 style(SkPaint::kFill_Style), 48 miter(4.0f), 49 strokeWidth(1.0f), 50 pathEffect(NULL) { 51 memset(&shape, 0, sizeof(Shape)); 52} 53 54PathDescription::PathDescription(ShapeType type, SkPaint* paint): 55 type(type), 56 join(paint->getStrokeJoin()), 57 cap(paint->getStrokeCap()), 58 style(paint->getStyle()), 59 miter(paint->getStrokeMiter()), 60 strokeWidth(paint->getStrokeWidth()), 61 pathEffect(paint->getPathEffect()) { 62 memset(&shape, 0, sizeof(Shape)); 63} 64 65hash_t PathDescription::hash() const { 66 uint32_t hash = JenkinsHashMix(0, type); 67 hash = JenkinsHashMix(hash, join); 68 hash = JenkinsHashMix(hash, cap); 69 hash = JenkinsHashMix(hash, style); 70 hash = JenkinsHashMix(hash, android::hash_type(miter)); 71 hash = JenkinsHashMix(hash, android::hash_type(strokeWidth)); 72 hash = JenkinsHashMix(hash, android::hash_type(pathEffect)); 73 hash = JenkinsHashMixBytes(hash, (uint8_t*) &shape, sizeof(Shape)); 74 return JenkinsHashWhiten(hash); 75} 76 77int PathDescription::compare(const PathDescription& rhs) const { 78 return memcmp(this, &rhs, sizeof(PathDescription)); 79} 80 81/////////////////////////////////////////////////////////////////////////////// 82// Utilities 83/////////////////////////////////////////////////////////////////////////////// 84 85bool PathCache::canDrawAsConvexPath(SkPath* path, SkPaint* paint) { 86 // NOTE: This should only be used after PathTessellator handles joins properly 87 return paint->getPathEffect() == NULL && path->getConvexity() == SkPath::kConvex_Convexity; 88} 89 90void PathCache::computePathBounds(const SkPath* path, const SkPaint* paint, 91 float& left, float& top, float& offset, uint32_t& width, uint32_t& height) { 92 const SkRect& bounds = path->getBounds(); 93 PathCache::computeBounds(bounds, paint, left, top, offset, width, height); 94} 95 96void PathCache::computeBounds(const SkRect& bounds, const SkPaint* paint, 97 float& left, float& top, float& offset, uint32_t& width, uint32_t& height) { 98 const float pathWidth = fmax(bounds.width(), 1.0f); 99 const float pathHeight = fmax(bounds.height(), 1.0f); 100 101 left = bounds.fLeft; 102 top = bounds.fTop; 103 104 offset = (int) floorf(fmax(paint->getStrokeWidth(), 1.0f) * 1.5f + 0.5f); 105 106 width = uint32_t(pathWidth + offset * 2.0 + 0.5); 107 height = uint32_t(pathHeight + offset * 2.0 + 0.5); 108} 109 110static void initBitmap(SkBitmap& bitmap, uint32_t width, uint32_t height) { 111 bitmap.setConfig(SkBitmap::kA8_Config, width, height); 112 bitmap.allocPixels(); 113 bitmap.eraseColor(0); 114} 115 116static void initPaint(SkPaint& paint) { 117 // Make sure the paint is opaque, color, alpha, filter, etc. 118 // will be applied later when compositing the alpha8 texture 119 paint.setColor(0xff000000); 120 paint.setAlpha(255); 121 paint.setColorFilter(NULL); 122 paint.setMaskFilter(NULL); 123 paint.setShader(NULL); 124 SkXfermode* mode = SkXfermode::Create(SkXfermode::kSrc_Mode); 125 SkSafeUnref(paint.setXfermode(mode)); 126} 127 128static void drawPath(const SkPath *path, const SkPaint* paint, SkBitmap& bitmap, 129 float left, float top, float offset, uint32_t width, uint32_t height) { 130 initBitmap(bitmap, width, height); 131 132 SkPaint pathPaint(*paint); 133 initPaint(pathPaint); 134 135 SkCanvas canvas(bitmap); 136 canvas.translate(-left + offset, -top + offset); 137 canvas.drawPath(*path, pathPaint); 138} 139 140static PathTexture* createTexture(float left, float top, float offset, 141 uint32_t width, uint32_t height, uint32_t id) { 142 PathTexture* texture = new PathTexture(Caches::getInstance()); 143 texture->left = left; 144 texture->top = top; 145 texture->offset = offset; 146 texture->width = width; 147 texture->height = height; 148 texture->generation = id; 149 return texture; 150} 151 152/////////////////////////////////////////////////////////////////////////////// 153// Cache constructor/destructor 154/////////////////////////////////////////////////////////////////////////////// 155 156PathCache::PathCache(): 157 mCache(LruCache<PathDescription, PathTexture*>::kUnlimitedCapacity), 158 mSize(0), mMaxSize(MB(DEFAULT_PATH_CACHE_SIZE)) { 159 char property[PROPERTY_VALUE_MAX]; 160 if (property_get(PROPERTY_PATH_CACHE_SIZE, property, NULL) > 0) { 161 INIT_LOGD(" Setting %s cache size to %sMB", name, property); 162 setMaxSize(MB(atof(property))); 163 } else { 164 INIT_LOGD(" Using default %s cache size of %.2fMB", name, DEFAULT_PATH_CACHE_SIZE); 165 } 166 init(); 167} 168 169PathCache::~PathCache() { 170 mCache.clear(); 171} 172 173void PathCache::init() { 174 mCache.setOnEntryRemovedListener(this); 175 176 GLint maxTextureSize; 177 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize); 178 mMaxTextureSize = maxTextureSize; 179 180 mDebugEnabled = readDebugLevel() & kDebugCaches; 181} 182 183/////////////////////////////////////////////////////////////////////////////// 184// Size management 185/////////////////////////////////////////////////////////////////////////////// 186 187uint32_t PathCache::getSize() { 188 return mSize; 189} 190 191uint32_t PathCache::getMaxSize() { 192 return mMaxSize; 193} 194 195void PathCache::setMaxSize(uint32_t maxSize) { 196 mMaxSize = maxSize; 197 while (mSize > mMaxSize) { 198 mCache.removeOldest(); 199 } 200} 201 202/////////////////////////////////////////////////////////////////////////////// 203// Callbacks 204/////////////////////////////////////////////////////////////////////////////// 205 206void PathCache::operator()(PathDescription& entry, PathTexture*& texture) { 207 removeTexture(texture); 208} 209 210/////////////////////////////////////////////////////////////////////////////// 211// Caching 212/////////////////////////////////////////////////////////////////////////////// 213 214void PathCache::removeTexture(PathTexture* texture) { 215 if (texture) { 216 const uint32_t size = texture->width * texture->height; 217 218 // If there is a pending task we must wait for it to return 219 // before attempting our cleanup 220 const sp<Task<SkBitmap*> >& task = texture->task(); 221 if (task != NULL) { 222 SkBitmap* bitmap = task->getResult(); 223 texture->clearTask(); 224 } else { 225 // If there is a pending task, the path was not added 226 // to the cache and the size wasn't increased 227 if (size > mSize) { 228 ALOGE("Removing path texture of size %d will leave " 229 "the cache in an inconsistent state", size); 230 } 231 mSize -= size; 232 } 233 234 PATH_LOGD("PathCache::delete name, size, mSize = %d, %d, %d", 235 texture->id, size, mSize); 236 if (mDebugEnabled) { 237 ALOGD("Shape deleted, size = %d", size); 238 } 239 240 if (texture->id) { 241 Caches::getInstance().deleteTexture(texture->id); 242 } 243 delete texture; 244 } 245} 246 247void PathCache::purgeCache(uint32_t width, uint32_t height) { 248 const uint32_t size = width * height; 249 // Don't even try to cache a bitmap that's bigger than the cache 250 if (size < mMaxSize) { 251 while (mSize + size > mMaxSize) { 252 mCache.removeOldest(); 253 } 254 } 255} 256 257void PathCache::trim() { 258 while (mSize > mMaxSize) { 259 mCache.removeOldest(); 260 } 261} 262 263PathTexture* PathCache::addTexture(const PathDescription& entry, const SkPath *path, 264 const SkPaint* paint) { 265 ATRACE_CALL(); 266 267 float left, top, offset; 268 uint32_t width, height; 269 computePathBounds(path, paint, left, top, offset, width, height); 270 271 if (!checkTextureSize(width, height)) return NULL; 272 273 purgeCache(width, height); 274 275 SkBitmap bitmap; 276 drawPath(path, paint, bitmap, left, top, offset, width, height); 277 278 PathTexture* texture = createTexture(left, top, offset, width, height, 279 path->getGenerationID()); 280 generateTexture(entry, &bitmap, texture); 281 282 return texture; 283} 284 285void PathCache::generateTexture(const PathDescription& entry, SkBitmap* bitmap, 286 PathTexture* texture, bool addToCache) { 287 generateTexture(*bitmap, texture); 288 289 uint32_t size = texture->width * texture->height; 290 if (size < mMaxSize) { 291 mSize += size; 292 PATH_LOGD("PathCache::get/create: name, size, mSize = %d, %d, %d", 293 texture->id, size, mSize); 294 if (mDebugEnabled) { 295 ALOGD("Shape created, size = %d", size); 296 } 297 if (addToCache) { 298 mCache.put(entry, texture); 299 } 300 } else { 301 // It's okay to add a texture that's bigger than the cache since 302 // we'll trim the cache later when addToCache is set to false 303 if (!addToCache) { 304 mSize += size; 305 } 306 texture->cleanup = true; 307 } 308} 309 310void PathCache::clear() { 311 mCache.clear(); 312} 313 314void PathCache::generateTexture(SkBitmap& bitmap, Texture* texture) { 315 SkAutoLockPixels alp(bitmap); 316 if (!bitmap.readyToDraw()) { 317 ALOGE("Cannot generate texture from bitmap"); 318 return; 319 } 320 321 glGenTextures(1, &texture->id); 322 323 Caches::getInstance().bindTexture(texture->id); 324 // Textures are Alpha8 325 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 326 327 texture->blend = true; 328 glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, texture->width, texture->height, 0, 329 GL_ALPHA, GL_UNSIGNED_BYTE, bitmap.getPixels()); 330 331 texture->setFilter(GL_LINEAR); 332 texture->setWrap(GL_CLAMP_TO_EDGE); 333} 334 335/////////////////////////////////////////////////////////////////////////////// 336// Path precaching 337/////////////////////////////////////////////////////////////////////////////// 338 339PathCache::PathProcessor::PathProcessor(Caches& caches): 340 TaskProcessor<SkBitmap*>(&caches.tasks), mMaxTextureSize(caches.maxTextureSize) { 341} 342 343void PathCache::PathProcessor::onProcess(const sp<Task<SkBitmap*> >& task) { 344 sp<PathTask> t = static_cast<PathTask* >(task.get()); 345 ATRACE_NAME("pathPrecache"); 346 347 float left, top, offset; 348 uint32_t width, height; 349 PathCache::computePathBounds(t->path, t->paint, left, top, offset, width, height); 350 351 PathTexture* texture = t->texture; 352 texture->left = left; 353 texture->top = top; 354 texture->offset = offset; 355 texture->width = width; 356 texture->height = height; 357 358 if (width <= mMaxTextureSize && height <= mMaxTextureSize) { 359 SkBitmap* bitmap = new SkBitmap(); 360 drawPath(t->path, t->paint, *bitmap, left, top, offset, width, height); 361 t->setResult(bitmap); 362 } else { 363 texture->width = 0; 364 texture->height = 0; 365 t->setResult(NULL); 366 } 367} 368 369/////////////////////////////////////////////////////////////////////////////// 370// Paths 371/////////////////////////////////////////////////////////////////////////////// 372 373void PathCache::remove(Vector<PathDescription>& pathsToRemove, const path_pair_t& pair) { 374 LruCache<PathDescription, PathTexture*>::Iterator i(mCache); 375 376 while (i.next()) { 377 const PathDescription& key = i.key(); 378 if (key.type == kShapePath && 379 (key.shape.path.mPath == pair.getFirst() || 380 key.shape.path.mPath == pair.getSecond())) { 381 pathsToRemove.push(key); 382 } 383 } 384} 385 386void PathCache::removeDeferred(SkPath* path) { 387 Mutex::Autolock l(mLock); 388 mGarbage.push(path_pair_t(path, const_cast<SkPath*>(path->getSourcePath()))); 389} 390 391void PathCache::clearGarbage() { 392 Vector<PathDescription> pathsToRemove; 393 394 { // scope for the mutex 395 Mutex::Autolock l(mLock); 396 size_t count = mGarbage.size(); 397 for (size_t i = 0; i < count; i++) { 398 const path_pair_t& pair = mGarbage.itemAt(i); 399 remove(pathsToRemove, pair); 400 delete pair.getFirst(); 401 } 402 mGarbage.clear(); 403 } 404 405 for (size_t i = 0; i < pathsToRemove.size(); i++) { 406 mCache.remove(pathsToRemove.itemAt(i)); 407 } 408} 409 410/** 411 * To properly handle path mutations at draw time we always make a copy 412 * of paths objects when recording display lists. The source path points 413 * to the path we originally copied the path from. This ensures we use 414 * the original path as a cache key the first time a path is inserted 415 * in the cache. The source path is also used to reclaim garbage when a 416 * Dalvik Path object is collected. 417 */ 418static SkPath* getSourcePath(SkPath* path) { 419 const SkPath* sourcePath = path->getSourcePath(); 420 if (sourcePath && sourcePath->getGenerationID() == path->getGenerationID()) { 421 return const_cast<SkPath*>(sourcePath); 422 } 423 return path; 424} 425 426PathTexture* PathCache::get(SkPath* path, SkPaint* paint) { 427 path = getSourcePath(path); 428 429 PathDescription entry(kShapePath, paint); 430 entry.shape.path.mPath = path; 431 432 PathTexture* texture = mCache.get(entry); 433 434 if (!texture) { 435 texture = addTexture(entry, path, paint); 436 } else { 437 // A bitmap is attached to the texture, this means we need to 438 // upload it as a GL texture 439 const sp<Task<SkBitmap*> >& task = texture->task(); 440 if (task != NULL) { 441 // But we must first wait for the worker thread to be done 442 // producing the bitmap, so let's wait 443 SkBitmap* bitmap = task->getResult(); 444 if (bitmap) { 445 generateTexture(entry, bitmap, texture, false); 446 texture->clearTask(); 447 } else { 448 ALOGW("Path too large to be rendered into a texture"); 449 texture->clearTask(); 450 texture = NULL; 451 mCache.remove(entry); 452 } 453 } else if (path->getGenerationID() != texture->generation) { 454 // The size of the path might have changed so we first 455 // remove the entry from the cache 456 mCache.remove(entry); 457 texture = addTexture(entry, path, paint); 458 } 459 } 460 461 return texture; 462} 463 464void PathCache::precache(SkPath* path, SkPaint* paint) { 465 if (!Caches::getInstance().tasks.canRunTasks()) { 466 return; 467 } 468 469 path = getSourcePath(path); 470 471 PathDescription entry(kShapePath, paint); 472 entry.shape.path.mPath = path; 473 474 PathTexture* texture = mCache.get(entry); 475 476 bool generate = false; 477 if (!texture) { 478 generate = true; 479 } else if (path->getGenerationID() != texture->generation) { 480 mCache.remove(entry); 481 generate = true; 482 } 483 484 if (generate) { 485 // It is important to specify the generation ID so we do not 486 // attempt to precache the same path several times 487 texture = createTexture(0.0f, 0.0f, 0.0f, 0, 0, path->getGenerationID()); 488 sp<PathTask> task = new PathTask(path, paint, texture); 489 texture->setTask(task); 490 491 // During the precaching phase we insert path texture objects into 492 // the cache that do not point to any GL texture. They are instead 493 // treated as a task for the precaching worker thread. This is why 494 // we do not check the cache limit when inserting these objects. 495 // The conversion into GL texture will happen in get(), when a client 496 // asks for a path texture. This is also when the cache limit will 497 // be enforced. 498 mCache.put(entry, texture); 499 500 if (mProcessor == NULL) { 501 mProcessor = new PathProcessor(Caches::getInstance()); 502 } 503 mProcessor->add(task); 504 } 505} 506 507/////////////////////////////////////////////////////////////////////////////// 508// Rounded rects 509/////////////////////////////////////////////////////////////////////////////// 510 511PathTexture* PathCache::getRoundRect(float width, float height, 512 float rx, float ry, SkPaint* paint) { 513 PathDescription entry(kShapeRoundRect, paint); 514 entry.shape.roundRect.mWidth = width; 515 entry.shape.roundRect.mHeight = height; 516 entry.shape.roundRect.mRx = rx; 517 entry.shape.roundRect.mRy = ry; 518 519 PathTexture* texture = get(entry); 520 521 if (!texture) { 522 SkPath path; 523 SkRect r; 524 r.set(0.0f, 0.0f, width, height); 525 path.addRoundRect(r, rx, ry, SkPath::kCW_Direction); 526 527 texture = addTexture(entry, &path, paint); 528 } 529 530 return texture; 531} 532 533/////////////////////////////////////////////////////////////////////////////// 534// Circles 535/////////////////////////////////////////////////////////////////////////////// 536 537PathTexture* PathCache::getCircle(float radius, SkPaint* paint) { 538 PathDescription entry(kShapeCircle, paint); 539 entry.shape.circle.mRadius = radius; 540 541 PathTexture* texture = get(entry); 542 543 if (!texture) { 544 SkPath path; 545 path.addCircle(radius, radius, radius, SkPath::kCW_Direction); 546 547 texture = addTexture(entry, &path, paint); 548 } 549 550 return texture; 551} 552 553/////////////////////////////////////////////////////////////////////////////// 554// Ovals 555/////////////////////////////////////////////////////////////////////////////// 556 557PathTexture* PathCache::getOval(float width, float height, SkPaint* paint) { 558 PathDescription entry(kShapeOval, paint); 559 entry.shape.oval.mWidth = width; 560 entry.shape.oval.mHeight = height; 561 562 PathTexture* texture = get(entry); 563 564 if (!texture) { 565 SkPath path; 566 SkRect r; 567 r.set(0.0f, 0.0f, width, height); 568 path.addOval(r, SkPath::kCW_Direction); 569 570 texture = addTexture(entry, &path, paint); 571 } 572 573 return texture; 574} 575 576/////////////////////////////////////////////////////////////////////////////// 577// Rects 578/////////////////////////////////////////////////////////////////////////////// 579 580PathTexture* PathCache::getRect(float width, float height, SkPaint* paint) { 581 PathDescription entry(kShapeRect, paint); 582 entry.shape.rect.mWidth = width; 583 entry.shape.rect.mHeight = height; 584 585 PathTexture* texture = get(entry); 586 587 if (!texture) { 588 SkPath path; 589 SkRect r; 590 r.set(0.0f, 0.0f, width, height); 591 path.addRect(r, SkPath::kCW_Direction); 592 593 texture = addTexture(entry, &path, paint); 594 } 595 596 return texture; 597} 598 599/////////////////////////////////////////////////////////////////////////////// 600// Arcs 601/////////////////////////////////////////////////////////////////////////////// 602 603PathTexture* PathCache::getArc(float width, float height, 604 float startAngle, float sweepAngle, bool useCenter, SkPaint* paint) { 605 PathDescription entry(kShapeArc, paint); 606 entry.shape.arc.mWidth = width; 607 entry.shape.arc.mHeight = height; 608 entry.shape.arc.mStartAngle = startAngle; 609 entry.shape.arc.mSweepAngle = sweepAngle; 610 entry.shape.arc.mUseCenter = useCenter; 611 612 PathTexture* texture = get(entry); 613 614 if (!texture) { 615 SkPath path; 616 SkRect r; 617 r.set(0.0f, 0.0f, width, height); 618 if (useCenter) { 619 path.moveTo(r.centerX(), r.centerY()); 620 } 621 path.arcTo(r, startAngle, sweepAngle, !useCenter); 622 if (useCenter) { 623 path.close(); 624 } 625 626 texture = addTexture(entry, &path, paint); 627 } 628 629 return texture; 630} 631 632}; // namespace uirenderer 633}; // namespace android 634