DisplayListRenderer.cpp revision e3a9b24b5e3f9b2058486814a6d27729e51ad466
1/* 2 * Copyright (C) 2010 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 19#include <SkCamera.h> 20 21#include <private/hwui/DrawGlInfo.h> 22 23#include "DisplayListLogBuffer.h" 24#include "DisplayListRenderer.h" 25#include "Caches.h" 26 27namespace android { 28namespace uirenderer { 29 30/////////////////////////////////////////////////////////////////////////////// 31// Display list 32/////////////////////////////////////////////////////////////////////////////// 33 34const char* DisplayList::OP_NAMES[] = { 35 "Save", 36 "Restore", 37 "RestoreToCount", 38 "SaveLayer", 39 "SaveLayerAlpha", 40 "Translate", 41 "Rotate", 42 "Scale", 43 "Skew", 44 "SetMatrix", 45 "ConcatMatrix", 46 "ClipRect", 47 "DrawDisplayList", 48 "DrawLayer", 49 "DrawBitmap", 50 "DrawBitmapMatrix", 51 "DrawBitmapRect", 52 "DrawBitmapData", 53 "DrawBitmapMesh", 54 "DrawPatch", 55 "DrawColor", 56 "DrawRect", 57 "DrawRoundRect", 58 "DrawCircle", 59 "DrawOval", 60 "DrawArc", 61 "DrawPath", 62 "DrawLines", 63 "DrawPoints", 64 "DrawTextOnPath", 65 "DrawPosText", 66 "DrawText", 67 "DrawRects", 68 "ResetShader", 69 "SetupShader", 70 "ResetColorFilter", 71 "SetupColorFilter", 72 "ResetShadow", 73 "SetupShadow", 74 "ResetPaintFilter", 75 "SetupPaintFilter", 76 "DrawGLFunction" 77}; 78 79void DisplayList::outputLogBuffer(int fd) { 80 DisplayListLogBuffer& logBuffer = DisplayListLogBuffer::getInstance(); 81 if (logBuffer.isEmpty()) { 82 return; 83 } 84 85 FILE *file = fdopen(fd, "a"); 86 87 fprintf(file, "\nRecent DisplayList operations\n"); 88 logBuffer.outputCommands(file, OP_NAMES); 89 90 String8 cachesLog; 91 Caches::getInstance().dumpMemoryUsage(cachesLog); 92 fprintf(file, "\nCaches:\n%s", cachesLog.string()); 93 fprintf(file, "\n"); 94 95 fflush(file); 96} 97 98DisplayList::DisplayList(const DisplayListRenderer& recorder) : 99 mTransformMatrix(NULL), mTransformCamera(NULL), mTransformMatrix3D(NULL), 100 mStaticMatrix(NULL), mAnimationMatrix(NULL) { 101 102 initFromDisplayListRenderer(recorder); 103} 104 105DisplayList::~DisplayList() { 106 clearResources(); 107} 108 109void DisplayList::destroyDisplayListDeferred(DisplayList* displayList) { 110 if (displayList) { 111 DISPLAY_LIST_LOGD("Deferring display list destruction"); 112 Caches::getInstance().deleteDisplayListDeferred(displayList); 113 } 114} 115 116void DisplayList::clearResources() { 117 sk_free((void*) mReader.base()); 118 mReader.setMemory(NULL, 0); 119 120 delete mTransformMatrix; 121 delete mTransformCamera; 122 delete mTransformMatrix3D; 123 delete mStaticMatrix; 124 delete mAnimationMatrix; 125 126 mTransformMatrix = NULL; 127 mTransformCamera = NULL; 128 mTransformMatrix3D = NULL; 129 mStaticMatrix = NULL; 130 mAnimationMatrix = NULL; 131 132 Caches& caches = Caches::getInstance(); 133 caches.unregisterFunctors(mFunctorCount); 134 caches.resourceCache.lock(); 135 136 for (size_t i = 0; i < mBitmapResources.size(); i++) { 137 caches.resourceCache.decrementRefcountLocked(mBitmapResources.itemAt(i)); 138 } 139 140 for (size_t i = 0; i < mOwnedBitmapResources.size(); i++) { 141 SkBitmap* bitmap = mOwnedBitmapResources.itemAt(i); 142 caches.resourceCache.decrementRefcountLocked(bitmap); 143 caches.resourceCache.destructorLocked(bitmap); 144 } 145 146 for (size_t i = 0; i < mFilterResources.size(); i++) { 147 caches.resourceCache.decrementRefcountLocked(mFilterResources.itemAt(i)); 148 } 149 150 for (size_t i = 0; i < mShaders.size(); i++) { 151 caches.resourceCache.decrementRefcountLocked(mShaders.itemAt(i)); 152 caches.resourceCache.destructorLocked(mShaders.itemAt(i)); 153 } 154 155 for (size_t i = 0; i < mSourcePaths.size(); i++) { 156 caches.resourceCache.decrementRefcountLocked(mSourcePaths.itemAt(i)); 157 } 158 159 for (size_t i = 0; i < mLayers.size(); i++) { 160 caches.resourceCache.decrementRefcountLocked(mLayers.itemAt(i)); 161 } 162 163 caches.resourceCache.unlock(); 164 165 for (size_t i = 0; i < mPaints.size(); i++) { 166 delete mPaints.itemAt(i); 167 } 168 169 for (size_t i = 0; i < mPaths.size(); i++) { 170 SkPath* path = mPaths.itemAt(i); 171 caches.pathCache.remove(path); 172 delete path; 173 } 174 175 for (size_t i = 0; i < mMatrices.size(); i++) { 176 delete mMatrices.itemAt(i); 177 } 178 179 mBitmapResources.clear(); 180 mOwnedBitmapResources.clear(); 181 mFilterResources.clear(); 182 mShaders.clear(); 183 mSourcePaths.clear(); 184 mPaints.clear(); 185 mPaths.clear(); 186 mMatrices.clear(); 187 mLayers.clear(); 188} 189 190void DisplayList::reset() { 191 clearResources(); 192 init(); 193} 194 195void DisplayList::initFromDisplayListRenderer(const DisplayListRenderer& recorder, bool reusing) { 196 197 if (reusing) { 198 // re-using display list - clear out previous allocations 199 clearResources(); 200 } 201 202 init(); 203 204 const SkWriter32& writer = recorder.writeStream(); 205 if (writer.size() == 0) { 206 return; 207 } 208 209 mSize = writer.size(); 210 void* buffer = sk_malloc_throw(mSize); 211 writer.flatten(buffer); 212 mReader.setMemory(buffer, mSize); 213 214 mFunctorCount = recorder.getFunctorCount(); 215 216 Caches& caches = Caches::getInstance(); 217 caches.registerFunctors(mFunctorCount); 218 caches.resourceCache.lock(); 219 220 const Vector<SkBitmap*>& bitmapResources = recorder.getBitmapResources(); 221 for (size_t i = 0; i < bitmapResources.size(); i++) { 222 SkBitmap* resource = bitmapResources.itemAt(i); 223 mBitmapResources.add(resource); 224 caches.resourceCache.incrementRefcountLocked(resource); 225 } 226 227 const Vector<SkBitmap*> &ownedBitmapResources = recorder.getOwnedBitmapResources(); 228 for (size_t i = 0; i < ownedBitmapResources.size(); i++) { 229 SkBitmap* resource = ownedBitmapResources.itemAt(i); 230 mOwnedBitmapResources.add(resource); 231 caches.resourceCache.incrementRefcountLocked(resource); 232 } 233 234 const Vector<SkiaColorFilter*>& filterResources = recorder.getFilterResources(); 235 for (size_t i = 0; i < filterResources.size(); i++) { 236 SkiaColorFilter* resource = filterResources.itemAt(i); 237 mFilterResources.add(resource); 238 caches.resourceCache.incrementRefcountLocked(resource); 239 } 240 241 const Vector<SkiaShader*>& shaders = recorder.getShaders(); 242 for (size_t i = 0; i < shaders.size(); i++) { 243 SkiaShader* resource = shaders.itemAt(i); 244 mShaders.add(resource); 245 caches.resourceCache.incrementRefcountLocked(resource); 246 } 247 248 const SortedVector<SkPath*>& sourcePaths = recorder.getSourcePaths(); 249 for (size_t i = 0; i < sourcePaths.size(); i++) { 250 mSourcePaths.add(sourcePaths.itemAt(i)); 251 caches.resourceCache.incrementRefcountLocked(sourcePaths.itemAt(i)); 252 } 253 254 const Vector<Layer*>& layers = recorder.getLayers(); 255 for (size_t i = 0; i < layers.size(); i++) { 256 mLayers.add(layers.itemAt(i)); 257 caches.resourceCache.incrementRefcountLocked(layers.itemAt(i)); 258 } 259 260 caches.resourceCache.unlock(); 261 262 const Vector<SkPaint*>& paints = recorder.getPaints(); 263 for (size_t i = 0; i < paints.size(); i++) { 264 mPaints.add(paints.itemAt(i)); 265 } 266 267 const Vector<SkPath*>& paths = recorder.getPaths(); 268 for (size_t i = 0; i < paths.size(); i++) { 269 mPaths.add(paths.itemAt(i)); 270 } 271 272 const Vector<SkMatrix*>& matrices = recorder.getMatrices(); 273 for (size_t i = 0; i < matrices.size(); i++) { 274 mMatrices.add(matrices.itemAt(i)); 275 } 276} 277 278void DisplayList::init() { 279 mSize = 0; 280 mIsRenderable = true; 281 mFunctorCount = 0; 282 mLeft = 0; 283 mTop = 0; 284 mRight = 0; 285 mBottom = 0; 286 mClipChildren = true; 287 mAlpha = 1; 288 mMultipliedAlpha = 255; 289 mHasOverlappingRendering = true; 290 mTranslationX = 0; 291 mTranslationY = 0; 292 mRotation = 0; 293 mRotationX = 0; 294 mRotationY= 0; 295 mScaleX = 1; 296 mScaleY = 1; 297 mPivotX = 0; 298 mPivotY = 0; 299 mCameraDistance = 0; 300 mMatrixDirty = false; 301 mMatrixFlags = 0; 302 mPrevWidth = -1; 303 mPrevHeight = -1; 304 mWidth = 0; 305 mHeight = 0; 306 mPivotExplicitlySet = false; 307 mCaching = false; 308} 309 310size_t DisplayList::getSize() { 311 return mSize; 312} 313 314/** 315 * This function is a simplified version of replay(), where we simply retrieve and log the 316 * display list. This function should remain in sync with the replay() function. 317 */ 318void DisplayList::output(OpenGLRenderer& renderer, uint32_t level) { 319 TextContainer text; 320 321 uint32_t count = (level + 1) * 2; 322 char indent[count + 1]; 323 for (uint32_t i = 0; i < count; i++) { 324 indent[i] = ' '; 325 } 326 indent[count] = '\0'; 327 ALOGD("%sStart display list (%p, %s, render=%d)", (char*) indent + 2, this, 328 mName.string(), isRenderable()); 329 330 ALOGD("%s%s %d", indent, "Save", SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag); 331 int saveCount = renderer.getSaveCount() - 1; 332 333 outputViewProperties(renderer, (char*) indent); 334 mReader.rewind(); 335 336 while (!mReader.eof()) { 337 int op = mReader.readInt(); 338 if (op & OP_MAY_BE_SKIPPED_MASK) { 339 int skip = mReader.readInt(); 340 ALOGD("%sSkip %d", (char*) indent, skip); 341 op &= ~OP_MAY_BE_SKIPPED_MASK; 342 } 343 344 switch (op) { 345 case DrawGLFunction: { 346 Functor *functor = (Functor *) getInt(); 347 ALOGD("%s%s %p", (char*) indent, OP_NAMES[op], functor); 348 } 349 break; 350 case Save: { 351 int rendererNum = getInt(); 352 ALOGD("%s%s %d", (char*) indent, OP_NAMES[op], rendererNum); 353 } 354 break; 355 case Restore: { 356 ALOGD("%s%s", (char*) indent, OP_NAMES[op]); 357 } 358 break; 359 case RestoreToCount: { 360 int restoreCount = saveCount + getInt(); 361 ALOGD("%s%s %d", (char*) indent, OP_NAMES[op], restoreCount); 362 } 363 break; 364 case SaveLayer: { 365 float f1 = getFloat(); 366 float f2 = getFloat(); 367 float f3 = getFloat(); 368 float f4 = getFloat(); 369 SkPaint* paint = getPaint(renderer); 370 int flags = getInt(); 371 ALOGD("%s%s %.2f, %.2f, %.2f, %.2f, %p, 0x%x", (char*) indent, 372 OP_NAMES[op], f1, f2, f3, f4, paint, flags); 373 } 374 break; 375 case SaveLayerAlpha: { 376 float f1 = getFloat(); 377 float f2 = getFloat(); 378 float f3 = getFloat(); 379 float f4 = getFloat(); 380 int alpha = getInt(); 381 int flags = getInt(); 382 ALOGD("%s%s %.2f, %.2f, %.2f, %.2f, %d, 0x%x", (char*) indent, 383 OP_NAMES[op], f1, f2, f3, f4, alpha, flags); 384 } 385 break; 386 case Translate: { 387 float f1 = getFloat(); 388 float f2 = getFloat(); 389 ALOGD("%s%s %.2f, %.2f", (char*) indent, OP_NAMES[op], f1, f2); 390 } 391 break; 392 case Rotate: { 393 float rotation = getFloat(); 394 ALOGD("%s%s %.2f", (char*) indent, OP_NAMES[op], rotation); 395 } 396 break; 397 case Scale: { 398 float sx = getFloat(); 399 float sy = getFloat(); 400 ALOGD("%s%s %.2f, %.2f", (char*) indent, OP_NAMES[op], sx, sy); 401 } 402 break; 403 case Skew: { 404 float sx = getFloat(); 405 float sy = getFloat(); 406 ALOGD("%s%s %.2f, %.2f", (char*) indent, OP_NAMES[op], sx, sy); 407 } 408 break; 409 case SetMatrix: { 410 SkMatrix* matrix = getMatrix(); 411 ALOGD("%s%s %p", (char*) indent, OP_NAMES[op], matrix); 412 } 413 break; 414 case ConcatMatrix: { 415 SkMatrix* matrix = getMatrix(); 416 ALOGD("%s%s new concat %p: [%f, %f, %f] [%f, %f, %f] [%f, %f, %f]", 417 (char*) indent, OP_NAMES[op], matrix, matrix->get(0), matrix->get(1), 418 matrix->get(2), matrix->get(3), matrix->get(4), matrix->get(5), 419 matrix->get(6), matrix->get(7), matrix->get(8)); 420 } 421 break; 422 case ClipRect: { 423 float f1 = getFloat(); 424 float f2 = getFloat(); 425 float f3 = getFloat(); 426 float f4 = getFloat(); 427 int regionOp = getInt(); 428 ALOGD("%s%s %.2f, %.2f, %.2f, %.2f, %d", (char*) indent, OP_NAMES[op], 429 f1, f2, f3, f4, regionOp); 430 } 431 break; 432 case DrawDisplayList: { 433 DisplayList* displayList = getDisplayList(); 434 int32_t flags = getInt(); 435 ALOGD("%s%s %p, %dx%d, 0x%x %d", (char*) indent, OP_NAMES[op], 436 displayList, mWidth, mHeight, flags, level + 1); 437 renderer.outputDisplayList(displayList, level + 1); 438 } 439 break; 440 case DrawLayer: { 441 Layer* layer = (Layer*) getInt(); 442 float x = getFloat(); 443 float y = getFloat(); 444 SkPaint* paint = getPaint(renderer); 445 ALOGD("%s%s %p, %.2f, %.2f, %p", (char*) indent, OP_NAMES[op], 446 layer, x, y, paint); 447 } 448 break; 449 case DrawBitmap: { 450 SkBitmap* bitmap = getBitmap(); 451 float x = getFloat(); 452 float y = getFloat(); 453 SkPaint* paint = getPaint(renderer); 454 ALOGD("%s%s %p, %.2f, %.2f, %p", (char*) indent, OP_NAMES[op], 455 bitmap, x, y, paint); 456 } 457 break; 458 case DrawBitmapMatrix: { 459 SkBitmap* bitmap = getBitmap(); 460 SkMatrix* matrix = getMatrix(); 461 SkPaint* paint = getPaint(renderer); 462 ALOGD("%s%s %p, %p, %p", (char*) indent, OP_NAMES[op], 463 bitmap, matrix, paint); 464 } 465 break; 466 case DrawBitmapRect: { 467 SkBitmap* bitmap = getBitmap(); 468 float f1 = getFloat(); 469 float f2 = getFloat(); 470 float f3 = getFloat(); 471 float f4 = getFloat(); 472 float f5 = getFloat(); 473 float f6 = getFloat(); 474 float f7 = getFloat(); 475 float f8 = getFloat(); 476 SkPaint* paint = getPaint(renderer); 477 ALOGD("%s%s %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %p", 478 (char*) indent, OP_NAMES[op], bitmap, f1, f2, f3, f4, f5, f6, f7, f8, paint); 479 } 480 break; 481 case DrawBitmapData: { 482 SkBitmap* bitmap = getBitmapData(); 483 float x = getFloat(); 484 float y = getFloat(); 485 SkPaint* paint = getPaint(renderer); 486 ALOGD("%s%s %.2f, %.2f, %p", (char*) indent, OP_NAMES[op], x, y, paint); 487 } 488 break; 489 case DrawBitmapMesh: { 490 int verticesCount = 0; 491 uint32_t colorsCount = 0; 492 SkBitmap* bitmap = getBitmap(); 493 uint32_t meshWidth = getInt(); 494 uint32_t meshHeight = getInt(); 495 float* vertices = getFloats(verticesCount); 496 bool hasColors = getInt(); 497 int* colors = hasColors ? getInts(colorsCount) : NULL; 498 SkPaint* paint = getPaint(renderer); 499 ALOGD("%s%s", (char*) indent, OP_NAMES[op]); 500 } 501 break; 502 case DrawPatch: { 503 int32_t* xDivs = NULL; 504 int32_t* yDivs = NULL; 505 uint32_t* colors = NULL; 506 uint32_t xDivsCount = 0; 507 uint32_t yDivsCount = 0; 508 int8_t numColors = 0; 509 SkBitmap* bitmap = getBitmap(); 510 xDivs = getInts(xDivsCount); 511 yDivs = getInts(yDivsCount); 512 colors = getUInts(numColors); 513 float left = getFloat(); 514 float top = getFloat(); 515 float right = getFloat(); 516 float bottom = getFloat(); 517 int alpha = getInt(); 518 SkXfermode::Mode mode = (SkXfermode::Mode) getInt(); 519 ALOGD("%s%s %.2f, %.2f, %.2f, %.2f", (char*) indent, OP_NAMES[op], 520 left, top, right, bottom); 521 } 522 break; 523 case DrawColor: { 524 int color = getInt(); 525 int xferMode = getInt(); 526 ALOGD("%s%s 0x%x %d", (char*) indent, OP_NAMES[op], color, xferMode); 527 } 528 break; 529 case DrawRect: { 530 float f1 = getFloat(); 531 float f2 = getFloat(); 532 float f3 = getFloat(); 533 float f4 = getFloat(); 534 SkPaint* paint = getPaint(renderer); 535 ALOGD("%s%s %.2f, %.2f, %.2f, %.2f, %p", (char*) indent, OP_NAMES[op], 536 f1, f2, f3, f4, paint); 537 } 538 break; 539 case DrawRoundRect: { 540 float f1 = getFloat(); 541 float f2 = getFloat(); 542 float f3 = getFloat(); 543 float f4 = getFloat(); 544 float f5 = getFloat(); 545 float f6 = getFloat(); 546 SkPaint* paint = getPaint(renderer); 547 ALOGD("%s%s %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %p", 548 (char*) indent, OP_NAMES[op], f1, f2, f3, f4, f5, f6, paint); 549 } 550 break; 551 case DrawCircle: { 552 float f1 = getFloat(); 553 float f2 = getFloat(); 554 float f3 = getFloat(); 555 SkPaint* paint = getPaint(renderer); 556 ALOGD("%s%s %.2f, %.2f, %.2f, %p", 557 (char*) indent, OP_NAMES[op], f1, f2, f3, paint); 558 } 559 break; 560 case DrawOval: { 561 float f1 = getFloat(); 562 float f2 = getFloat(); 563 float f3 = getFloat(); 564 float f4 = getFloat(); 565 SkPaint* paint = getPaint(renderer); 566 ALOGD("%s%s %.2f, %.2f, %.2f, %.2f, %p", 567 (char*) indent, OP_NAMES[op], f1, f2, f3, f4, paint); 568 } 569 break; 570 case DrawArc: { 571 float f1 = getFloat(); 572 float f2 = getFloat(); 573 float f3 = getFloat(); 574 float f4 = getFloat(); 575 float f5 = getFloat(); 576 float f6 = getFloat(); 577 int i1 = getInt(); 578 SkPaint* paint = getPaint(renderer); 579 ALOGD("%s%s %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %d, %p", 580 (char*) indent, OP_NAMES[op], f1, f2, f3, f4, f5, f6, i1, paint); 581 } 582 break; 583 case DrawPath: { 584 SkPath* path = getPath(); 585 SkPaint* paint = getPaint(renderer); 586 ALOGD("%s%s %p, %p", (char*) indent, OP_NAMES[op], path, paint); 587 } 588 break; 589 case DrawLines: { 590 int count = 0; 591 float* points = getFloats(count); 592 SkPaint* paint = getPaint(renderer); 593 ALOGD("%s%s", (char*) indent, OP_NAMES[op]); 594 } 595 break; 596 case DrawPoints: { 597 int count = 0; 598 float* points = getFloats(count); 599 SkPaint* paint = getPaint(renderer); 600 ALOGD("%s%s", (char*) indent, OP_NAMES[op]); 601 } 602 break; 603 case DrawTextOnPath: { 604 getText(&text); 605 int32_t count = getInt(); 606 SkPath* path = getPath(); 607 float hOffset = getFloat(); 608 float vOffset = getFloat(); 609 SkPaint* paint = getPaint(renderer); 610 ALOGD("%s%s %s, %d, %d, %p", (char*) indent, OP_NAMES[op], 611 text.text(), text.length(), count, paint); 612 } 613 break; 614 case DrawPosText: { 615 getText(&text); 616 int count = getInt(); 617 int positionsCount = 0; 618 float* positions = getFloats(positionsCount); 619 SkPaint* paint = getPaint(renderer); 620 ALOGD("%s%s %s, %d, %d, %p", (char*) indent, OP_NAMES[op], 621 text.text(), text.length(), count, paint); 622 } 623 break; 624 case DrawText: { 625 getText(&text); 626 int32_t count = getInt(); 627 float x = getFloat(); 628 float y = getFloat(); 629 int32_t positionsCount = 0; 630 float* positions = getFloats(positionsCount); 631 SkPaint* paint = getPaint(renderer); 632 float length = getFloat(); 633 ALOGD("%s%s %s, %d, %d, %p", (char*) indent, OP_NAMES[op], 634 text.text(), text.length(), count, paint); 635 } 636 break; 637 case DrawRects: { 638 int32_t count = 0; 639 float* rects = getFloats(count); 640 SkPaint* paint = getPaint(renderer); 641 ALOGD("%s%s %d, %p", (char*) indent, OP_NAMES[op], count / 4, paint); 642 } 643 break; 644 case ResetShader: { 645 ALOGD("%s%s", (char*) indent, OP_NAMES[op]); 646 } 647 break; 648 case SetupShader: { 649 SkiaShader* shader = getShader(); 650 ALOGD("%s%s %p", (char*) indent, OP_NAMES[op], shader); 651 } 652 break; 653 case ResetColorFilter: { 654 ALOGD("%s%s", (char*) indent, OP_NAMES[op]); 655 } 656 break; 657 case SetupColorFilter: { 658 SkiaColorFilter *colorFilter = getColorFilter(); 659 ALOGD("%s%s %p", (char*) indent, OP_NAMES[op], colorFilter); 660 } 661 break; 662 case ResetShadow: { 663 ALOGD("%s%s", (char*) indent, OP_NAMES[op]); 664 } 665 break; 666 case SetupShadow: { 667 float radius = getFloat(); 668 float dx = getFloat(); 669 float dy = getFloat(); 670 int color = getInt(); 671 ALOGD("%s%s %.2f, %.2f, %.2f, 0x%x", (char*) indent, OP_NAMES[op], 672 radius, dx, dy, color); 673 } 674 break; 675 case ResetPaintFilter: { 676 ALOGD("%s%s", (char*) indent, OP_NAMES[op]); 677 } 678 break; 679 case SetupPaintFilter: { 680 int clearBits = getInt(); 681 int setBits = getInt(); 682 ALOGD("%s%s 0x%x, 0x%x", (char*) indent, OP_NAMES[op], clearBits, setBits); 683 } 684 break; 685 default: 686 ALOGD("Display List error: op not handled: %s%s", 687 (char*) indent, OP_NAMES[op]); 688 break; 689 } 690 } 691 ALOGD("%sDone (%p, %s)", (char*) indent + 2, this, mName.string()); 692} 693 694void DisplayList::updateMatrix() { 695 if (mMatrixDirty) { 696 if (!mTransformMatrix) { 697 mTransformMatrix = new SkMatrix(); 698 } 699 if (mMatrixFlags == 0 || mMatrixFlags == TRANSLATION) { 700 mTransformMatrix->reset(); 701 } else { 702 if (!mPivotExplicitlySet) { 703 if (mWidth != mPrevWidth || mHeight != mPrevHeight) { 704 mPrevWidth = mWidth; 705 mPrevHeight = mHeight; 706 mPivotX = mPrevWidth / 2; 707 mPivotY = mPrevHeight / 2; 708 } 709 } 710 if ((mMatrixFlags & ROTATION_3D) == 0) { 711 mTransformMatrix->setTranslate(mTranslationX, mTranslationY); 712 mTransformMatrix->preRotate(mRotation, mPivotX, mPivotY); 713 mTransformMatrix->preScale(mScaleX, mScaleY, mPivotX, mPivotY); 714 } else { 715 if (!mTransformCamera) { 716 mTransformCamera = new Sk3DView(); 717 mTransformMatrix3D = new SkMatrix(); 718 } 719 mTransformMatrix->reset(); 720 mTransformCamera->save(); 721 mTransformMatrix->preScale(mScaleX, mScaleY, mPivotX, mPivotY); 722 mTransformCamera->rotateX(mRotationX); 723 mTransformCamera->rotateY(mRotationY); 724 mTransformCamera->rotateZ(-mRotation); 725 mTransformCamera->getMatrix(mTransformMatrix3D); 726 mTransformMatrix3D->preTranslate(-mPivotX, -mPivotY); 727 mTransformMatrix3D->postTranslate(mPivotX + mTranslationX, 728 mPivotY + mTranslationY); 729 mTransformMatrix->postConcat(*mTransformMatrix3D); 730 mTransformCamera->restore(); 731 } 732 } 733 mMatrixDirty = false; 734 } 735} 736 737void DisplayList::outputViewProperties(OpenGLRenderer& renderer, char* indent) { 738 updateMatrix(); 739 if (mLeft != 0 || mTop != 0) { 740 ALOGD("%s%s %d, %d", indent, "Translate (left, top)", mLeft, mTop); 741 } 742 if (mStaticMatrix) { 743 ALOGD("%s%s %p: [%.2f, %.2f, %.2f] [%.2f, %.2f, %.2f] [%.2f, %.2f, %.2f]", 744 indent, "ConcatMatrix (static)", mStaticMatrix, 745 mStaticMatrix->get(0), mStaticMatrix->get(1), 746 mStaticMatrix->get(2), mStaticMatrix->get(3), 747 mStaticMatrix->get(4), mStaticMatrix->get(5), 748 mStaticMatrix->get(6), mStaticMatrix->get(7), 749 mStaticMatrix->get(8)); 750 } 751 if (mAnimationMatrix) { 752 ALOGD("%s%s %p: [%.2f, %.2f, %.2f] [%.2f, %.2f, %.2f] [%.2f, %.2f, %.2f]", 753 indent, "ConcatMatrix (animation)", mAnimationMatrix, 754 mAnimationMatrix->get(0), mAnimationMatrix->get(1), 755 mAnimationMatrix->get(2), mAnimationMatrix->get(3), 756 mAnimationMatrix->get(4), mAnimationMatrix->get(5), 757 mAnimationMatrix->get(6), mAnimationMatrix->get(7), 758 mAnimationMatrix->get(8)); 759 } 760 if (mMatrixFlags != 0) { 761 if (mMatrixFlags == TRANSLATION) { 762 ALOGD("%s%s %f, %f", indent, "Translate", mTranslationX, mTranslationY); 763 } else { 764 ALOGD("%s%s %p: [%.2f, %.2f, %.2f] [%.2f, %.2f, %.2f] [%.2f, %.2f, %.2f]", 765 indent, "ConcatMatrix", mTransformMatrix, 766 mTransformMatrix->get(0), mTransformMatrix->get(1), 767 mTransformMatrix->get(2), mTransformMatrix->get(3), 768 mTransformMatrix->get(4), mTransformMatrix->get(5), 769 mTransformMatrix->get(6), mTransformMatrix->get(7), 770 mTransformMatrix->get(8)); 771 } 772 } 773 if (mAlpha < 1 && !mCaching) { 774 if (!mHasOverlappingRendering) { 775 ALOGD("%s%s %.2f", indent, "SetAlpha", mAlpha); 776 } else { 777 int flags = SkCanvas::kHasAlphaLayer_SaveFlag; 778 if (mClipChildren) { 779 flags |= SkCanvas::kClipToLayer_SaveFlag; 780 } 781 ALOGD("%s%s %.2f, %.2f, %.2f, %.2f, %d, 0x%x", indent, "SaveLayerAlpha", 782 (float) 0, (float) 0, (float) mRight - mLeft, (float) mBottom - mTop, 783 mMultipliedAlpha, flags); 784 } 785 } 786 if (mClipChildren) { 787 ALOGD("%s%s %.2f, %.2f, %.2f, %.2f", indent, "ClipRect", 0.0f, 0.0f, 788 (float) mRight - mLeft, (float) mBottom - mTop); 789 } 790} 791 792void DisplayList::setViewProperties(OpenGLRenderer& renderer, uint32_t level) { 793#if DEBUG_DISPLAY_LIST 794 uint32_t count = (level + 1) * 2; 795 char indent[count + 1]; 796 for (uint32_t i = 0; i < count; i++) { 797 indent[i] = ' '; 798 } 799 indent[count] = '\0'; 800#endif 801 updateMatrix(); 802 if (mLeft != 0 || mTop != 0) { 803 DISPLAY_LIST_LOGD("%s%s %d, %d", indent, "Translate (left, top)", mLeft, mTop); 804 renderer.translate(mLeft, mTop); 805 } 806 if (mStaticMatrix) { 807 DISPLAY_LIST_LOGD( 808 "%s%s %p: [%.2f, %.2f, %.2f] [%.2f, %.2f, %.2f] [%.2f, %.2f, %.2f]", 809 indent, "ConcatMatrix (static)", mStaticMatrix, 810 mStaticMatrix->get(0), mStaticMatrix->get(1), 811 mStaticMatrix->get(2), mStaticMatrix->get(3), 812 mStaticMatrix->get(4), mStaticMatrix->get(5), 813 mStaticMatrix->get(6), mStaticMatrix->get(7), 814 mStaticMatrix->get(8)); 815 renderer.concatMatrix(mStaticMatrix); 816 } else if (mAnimationMatrix) { 817 DISPLAY_LIST_LOGD( 818 "%s%s %p: [%.2f, %.2f, %.2f] [%.2f, %.2f, %.2f] [%.2f, %.2f, %.2f]", 819 indent, "ConcatMatrix (animation)", mAnimationMatrix, 820 mAnimationMatrix->get(0), mAnimationMatrix->get(1), 821 mAnimationMatrix->get(2), mAnimationMatrix->get(3), 822 mAnimationMatrix->get(4), mAnimationMatrix->get(5), 823 mAnimationMatrix->get(6), mAnimationMatrix->get(7), 824 mAnimationMatrix->get(8)); 825 renderer.concatMatrix(mAnimationMatrix); 826 } 827 if (mMatrixFlags != 0) { 828 if (mMatrixFlags == TRANSLATION) { 829 DISPLAY_LIST_LOGD("%s%s %f, %f", indent, "Translate", mTranslationX, mTranslationY); 830 renderer.translate(mTranslationX, mTranslationY); 831 } else { 832 DISPLAY_LIST_LOGD( 833 "%s%s %p: [%.2f, %.2f, %.2f] [%.2f, %.2f, %.2f] [%.2f, %.2f, %.2f]", 834 indent, "ConcatMatrix", mTransformMatrix, 835 mTransformMatrix->get(0), mTransformMatrix->get(1), 836 mTransformMatrix->get(2), mTransformMatrix->get(3), 837 mTransformMatrix->get(4), mTransformMatrix->get(5), 838 mTransformMatrix->get(6), mTransformMatrix->get(7), 839 mTransformMatrix->get(8)); 840 renderer.concatMatrix(mTransformMatrix); 841 } 842 } 843 if (mAlpha < 1 && !mCaching) { 844 if (!mHasOverlappingRendering) { 845 DISPLAY_LIST_LOGD("%s%s %.2f", indent, "SetAlpha", mAlpha); 846 renderer.setAlpha(mAlpha); 847 } else { 848 // TODO: should be able to store the size of a DL at record time and not 849 // have to pass it into this call. In fact, this information might be in the 850 // location/size info that we store with the new native transform data. 851 int flags = SkCanvas::kHasAlphaLayer_SaveFlag; 852 if (mClipChildren) { 853 flags |= SkCanvas::kClipToLayer_SaveFlag; 854 } 855 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f, %d, 0x%x", indent, "SaveLayerAlpha", 856 (float) 0, (float) 0, (float) mRight - mLeft, (float) mBottom - mTop, 857 mMultipliedAlpha, flags); 858 renderer.saveLayerAlpha(0, 0, mRight - mLeft, mBottom - mTop, 859 mMultipliedAlpha, flags); 860 } 861 } 862 if (mClipChildren) { 863 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f", indent, "ClipRect", 0.0f, 0.0f, 864 (float) mRight - mLeft, (float) mBottom - mTop); 865 renderer.clipRect(0, 0, mRight - mLeft, mBottom - mTop, 866 SkRegion::kIntersect_Op); 867 } 868} 869 870/** 871 * Changes to replay(), specifically those involving opcode or parameter changes, should be mimicked 872 * in the output() function, since that function processes the same list of opcodes for the 873 * purposes of logging display list info for a given view. 874 */ 875status_t DisplayList::replay(OpenGLRenderer& renderer, Rect& dirty, int32_t flags, uint32_t level) { 876 status_t drawGlStatus = DrawGlInfo::kStatusDone; 877 TextContainer text; 878 mReader.rewind(); 879 880#if DEBUG_DISPLAY_LIST 881 uint32_t count = (level + 1) * 2; 882 char indent[count + 1]; 883 for (uint32_t i = 0; i < count; i++) { 884 indent[i] = ' '; 885 } 886 indent[count] = '\0'; 887 Rect* clipRect = renderer.getClipRect(); 888 DISPLAY_LIST_LOGD("%sStart display list (%p, %s), clipRect: %.0f, %.f, %.0f, %.0f", 889 (char*) indent + 2, this, mName.string(), clipRect->left, clipRect->top, 890 clipRect->right, clipRect->bottom); 891#endif 892 893 renderer.startMark(mName.string()); 894 895 int restoreTo = renderer.save(SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag); 896 DISPLAY_LIST_LOGD("%s%s %d %d", indent, "Save", 897 SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag, restoreTo); 898 setViewProperties(renderer, level); 899 900 if (renderer.quickRejectNoScissor(0, 0, mWidth, mHeight)) { 901 DISPLAY_LIST_LOGD("%s%s %d", (char*) indent, "RestoreToCount", restoreTo); 902 renderer.restoreToCount(restoreTo); 903 renderer.endMark(); 904 return drawGlStatus; 905 } 906 907 DisplayListLogBuffer& logBuffer = DisplayListLogBuffer::getInstance(); 908 int saveCount = renderer.getSaveCount() - 1; 909 910 while (!mReader.eof()) { 911 int op = mReader.readInt(); 912 if (op & OP_MAY_BE_SKIPPED_MASK) { 913 int32_t skip = mReader.readInt(); 914 if (CC_LIKELY(flags & kReplayFlag_ClipChildren)) { 915 mReader.skip(skip); 916 DISPLAY_LIST_LOGD("%s%s skipping %d bytes", (char*) indent, 917 OP_NAMES[op & ~OP_MAY_BE_SKIPPED_MASK], skip); 918 continue; 919 } else { 920 op &= ~OP_MAY_BE_SKIPPED_MASK; 921 } 922 } 923 logBuffer.writeCommand(level, op); 924 925#if DEBUG_DISPLAY_LIST_OPS_AS_EVENTS 926 Caches::getInstance().eventMark(strlen(OP_NAMES[op]), OP_NAMES[op]); 927#endif 928 929 switch (op) { 930 case DrawGLFunction: { 931 Functor *functor = (Functor *) getInt(); 932 DISPLAY_LIST_LOGD("%s%s %p", (char*) indent, OP_NAMES[op], functor); 933 renderer.startMark("GL functor"); 934 drawGlStatus |= renderer.callDrawGLFunction(functor, dirty); 935 renderer.endMark(); 936 } 937 break; 938 case Save: { 939 int32_t rendererNum = getInt(); 940 DISPLAY_LIST_LOGD("%s%s %d", (char*) indent, OP_NAMES[op], rendererNum); 941 renderer.save(rendererNum); 942 } 943 break; 944 case Restore: { 945 DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]); 946 renderer.restore(); 947 } 948 break; 949 case RestoreToCount: { 950 int32_t restoreCount = saveCount + getInt(); 951 DISPLAY_LIST_LOGD("%s%s %d", (char*) indent, OP_NAMES[op], restoreCount); 952 renderer.restoreToCount(restoreCount); 953 } 954 break; 955 case SaveLayer: { 956 float f1 = getFloat(); 957 float f2 = getFloat(); 958 float f3 = getFloat(); 959 float f4 = getFloat(); 960 SkPaint* paint = getPaint(renderer); 961 int32_t flags = getInt(); 962 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f, %p, 0x%x", (char*) indent, 963 OP_NAMES[op], f1, f2, f3, f4, paint, flags); 964 renderer.saveLayer(f1, f2, f3, f4, paint, flags); 965 } 966 break; 967 case SaveLayerAlpha: { 968 float f1 = getFloat(); 969 float f2 = getFloat(); 970 float f3 = getFloat(); 971 float f4 = getFloat(); 972 int32_t alpha = getInt(); 973 int32_t flags = getInt(); 974 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f, %d, 0x%x", (char*) indent, 975 OP_NAMES[op], f1, f2, f3, f4, alpha, flags); 976 renderer.saveLayerAlpha(f1, f2, f3, f4, alpha, flags); 977 } 978 break; 979 case Translate: { 980 float f1 = getFloat(); 981 float f2 = getFloat(); 982 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f", (char*) indent, OP_NAMES[op], f1, f2); 983 renderer.translate(f1, f2); 984 } 985 break; 986 case Rotate: { 987 float rotation = getFloat(); 988 DISPLAY_LIST_LOGD("%s%s %.2f", (char*) indent, OP_NAMES[op], rotation); 989 renderer.rotate(rotation); 990 } 991 break; 992 case Scale: { 993 float sx = getFloat(); 994 float sy = getFloat(); 995 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f", (char*) indent, OP_NAMES[op], sx, sy); 996 renderer.scale(sx, sy); 997 } 998 break; 999 case Skew: { 1000 float sx = getFloat(); 1001 float sy = getFloat(); 1002 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f", (char*) indent, OP_NAMES[op], sx, sy); 1003 renderer.skew(sx, sy); 1004 } 1005 break; 1006 case SetMatrix: { 1007 SkMatrix* matrix = getMatrix(); 1008 DISPLAY_LIST_LOGD("%s%s %p", (char*) indent, OP_NAMES[op], matrix); 1009 renderer.setMatrix(matrix); 1010 } 1011 break; 1012 case ConcatMatrix: { 1013 SkMatrix* matrix = getMatrix(); 1014 DISPLAY_LIST_LOGD( 1015 "%s%s %p: [%.2f, %.2f, %.2f] [%.2f, %.2f, %.2f] [%.2f, %.2f, %.2f]", 1016 (char*) indent, OP_NAMES[op], matrix, 1017 matrix->get(0), matrix->get(1), matrix->get(2), 1018 matrix->get(3), matrix->get(4), matrix->get(5), 1019 matrix->get(6), matrix->get(7), matrix->get(8)); 1020 renderer.concatMatrix(matrix); 1021 } 1022 break; 1023 case ClipRect: { 1024 float f1 = getFloat(); 1025 float f2 = getFloat(); 1026 float f3 = getFloat(); 1027 float f4 = getFloat(); 1028 int32_t regionOp = getInt(); 1029 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f, %d", (char*) indent, OP_NAMES[op], 1030 f1, f2, f3, f4, regionOp); 1031 renderer.clipRect(f1, f2, f3, f4, (SkRegion::Op) regionOp); 1032 } 1033 break; 1034 case DrawDisplayList: { 1035 DisplayList* displayList = getDisplayList(); 1036 int32_t flags = getInt(); 1037 DISPLAY_LIST_LOGD("%s%s %p, %dx%d, 0x%x %d", (char*) indent, OP_NAMES[op], 1038 displayList, mWidth, mHeight, flags, level + 1); 1039 drawGlStatus |= renderer.drawDisplayList(displayList, dirty, flags, level + 1); 1040 } 1041 break; 1042 case DrawLayer: { 1043 int oldAlpha = -1; 1044 Layer* layer = (Layer*) getInt(); 1045 float x = getFloat(); 1046 float y = getFloat(); 1047 SkPaint* paint = getPaint(renderer); 1048 if (mCaching && mMultipliedAlpha < 255) { 1049 oldAlpha = layer->getAlpha(); 1050 layer->setAlpha(mMultipliedAlpha); 1051 } 1052 DISPLAY_LIST_LOGD("%s%s %p, %.2f, %.2f, %p", (char*) indent, OP_NAMES[op], 1053 layer, x, y, paint); 1054 drawGlStatus |= renderer.drawLayer(layer, x, y, paint); 1055 if (oldAlpha >= 0) { 1056 layer->setAlpha(oldAlpha); 1057 } 1058 } 1059 break; 1060 case DrawBitmap: { 1061 int oldAlpha = -1; 1062 SkBitmap* bitmap = getBitmap(); 1063 float x = getFloat(); 1064 float y = getFloat(); 1065 SkPaint* paint = getPaint(renderer); 1066 if (mCaching && mMultipliedAlpha < 255) { 1067 oldAlpha = paint->getAlpha(); 1068 paint->setAlpha(mMultipliedAlpha); 1069 } 1070 DISPLAY_LIST_LOGD("%s%s %p, %.2f, %.2f, %p", (char*) indent, OP_NAMES[op], 1071 bitmap, x, y, paint); 1072 drawGlStatus |= renderer.drawBitmap(bitmap, x, y, paint); 1073 if (oldAlpha >= 0) { 1074 paint->setAlpha(oldAlpha); 1075 } 1076 } 1077 break; 1078 case DrawBitmapMatrix: { 1079 SkBitmap* bitmap = getBitmap(); 1080 SkMatrix* matrix = getMatrix(); 1081 SkPaint* paint = getPaint(renderer); 1082 DISPLAY_LIST_LOGD("%s%s %p, %p, %p", (char*) indent, OP_NAMES[op], 1083 bitmap, matrix, paint); 1084 drawGlStatus |= renderer.drawBitmap(bitmap, matrix, paint); 1085 } 1086 break; 1087 case DrawBitmapRect: { 1088 SkBitmap* bitmap = getBitmap(); 1089 float f1 = getFloat(); 1090 float f2 = getFloat(); 1091 float f3 = getFloat(); 1092 float f4 = getFloat(); 1093 float f5 = getFloat(); 1094 float f6 = getFloat(); 1095 float f7 = getFloat(); 1096 float f8 = getFloat(); 1097 SkPaint* paint = getPaint(renderer); 1098 DISPLAY_LIST_LOGD("%s%s %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %p", 1099 (char*) indent, OP_NAMES[op], bitmap, 1100 f1, f2, f3, f4, f5, f6, f7, f8,paint); 1101 drawGlStatus |= renderer.drawBitmap(bitmap, f1, f2, f3, f4, f5, f6, f7, f8, paint); 1102 } 1103 break; 1104 case DrawBitmapData: { 1105 SkBitmap* bitmap = getBitmapData(); 1106 float x = getFloat(); 1107 float y = getFloat(); 1108 SkPaint* paint = getPaint(renderer); 1109 DISPLAY_LIST_LOGD("%s%s %p, %.2f, %.2f, %p", (char*) indent, OP_NAMES[op], 1110 bitmap, x, y, paint); 1111 drawGlStatus |= renderer.drawBitmap(bitmap, x, y, paint); 1112 } 1113 break; 1114 case DrawBitmapMesh: { 1115 int32_t verticesCount = 0; 1116 uint32_t colorsCount = 0; 1117 1118 SkBitmap* bitmap = getBitmap(); 1119 uint32_t meshWidth = getInt(); 1120 uint32_t meshHeight = getInt(); 1121 float* vertices = getFloats(verticesCount); 1122 bool hasColors = getInt(); 1123 int32_t* colors = hasColors ? getInts(colorsCount) : NULL; 1124 SkPaint* paint = getPaint(renderer); 1125 1126 DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]); 1127 drawGlStatus |= renderer.drawBitmapMesh(bitmap, meshWidth, meshHeight, vertices, 1128 colors, paint); 1129 } 1130 break; 1131 case DrawPatch: { 1132 int32_t* xDivs = NULL; 1133 int32_t* yDivs = NULL; 1134 uint32_t* colors = NULL; 1135 uint32_t xDivsCount = 0; 1136 uint32_t yDivsCount = 0; 1137 int8_t numColors = 0; 1138 1139 SkBitmap* bitmap = getBitmap(); 1140 1141 xDivs = getInts(xDivsCount); 1142 yDivs = getInts(yDivsCount); 1143 colors = getUInts(numColors); 1144 1145 float left = getFloat(); 1146 float top = getFloat(); 1147 float right = getFloat(); 1148 float bottom = getFloat(); 1149 1150 int alpha = getInt(); 1151 SkXfermode::Mode mode = (SkXfermode::Mode) getInt(); 1152 1153 DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]); 1154 drawGlStatus |= renderer.drawPatch(bitmap, xDivs, yDivs, colors, 1155 xDivsCount, yDivsCount, numColors, left, top, right, bottom, 1156 alpha, mode); 1157 } 1158 break; 1159 case DrawColor: { 1160 int32_t color = getInt(); 1161 int32_t xferMode = getInt(); 1162 DISPLAY_LIST_LOGD("%s%s 0x%x %d", (char*) indent, OP_NAMES[op], color, xferMode); 1163 drawGlStatus |= renderer.drawColor(color, (SkXfermode::Mode) xferMode); 1164 } 1165 break; 1166 case DrawRect: { 1167 float f1 = getFloat(); 1168 float f2 = getFloat(); 1169 float f3 = getFloat(); 1170 float f4 = getFloat(); 1171 SkPaint* paint = getPaint(renderer); 1172 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f, %p", (char*) indent, OP_NAMES[op], 1173 f1, f2, f3, f4, paint); 1174 drawGlStatus |= renderer.drawRect(f1, f2, f3, f4, paint); 1175 } 1176 break; 1177 case DrawRoundRect: { 1178 float f1 = getFloat(); 1179 float f2 = getFloat(); 1180 float f3 = getFloat(); 1181 float f4 = getFloat(); 1182 float f5 = getFloat(); 1183 float f6 = getFloat(); 1184 SkPaint* paint = getPaint(renderer); 1185 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %p", 1186 (char*) indent, OP_NAMES[op], f1, f2, f3, f4, f5, f6, paint); 1187 drawGlStatus |= renderer.drawRoundRect(f1, f2, f3, f4, f5, f6, paint); 1188 } 1189 break; 1190 case DrawCircle: { 1191 float f1 = getFloat(); 1192 float f2 = getFloat(); 1193 float f3 = getFloat(); 1194 SkPaint* paint = getPaint(renderer); 1195 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %p", 1196 (char*) indent, OP_NAMES[op], f1, f2, f3, paint); 1197 drawGlStatus |= renderer.drawCircle(f1, f2, f3, paint); 1198 } 1199 break; 1200 case DrawOval: { 1201 float f1 = getFloat(); 1202 float f2 = getFloat(); 1203 float f3 = getFloat(); 1204 float f4 = getFloat(); 1205 SkPaint* paint = getPaint(renderer); 1206 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f, %p", 1207 (char*) indent, OP_NAMES[op], f1, f2, f3, f4, paint); 1208 drawGlStatus |= renderer.drawOval(f1, f2, f3, f4, paint); 1209 } 1210 break; 1211 case DrawArc: { 1212 float f1 = getFloat(); 1213 float f2 = getFloat(); 1214 float f3 = getFloat(); 1215 float f4 = getFloat(); 1216 float f5 = getFloat(); 1217 float f6 = getFloat(); 1218 int32_t i1 = getInt(); 1219 SkPaint* paint = getPaint(renderer); 1220 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %d, %p", 1221 (char*) indent, OP_NAMES[op], f1, f2, f3, f4, f5, f6, i1, paint); 1222 drawGlStatus |= renderer.drawArc(f1, f2, f3, f4, f5, f6, i1 == 1, paint); 1223 } 1224 break; 1225 case DrawPath: { 1226 SkPath* path = getPath(); 1227 SkPaint* paint = getPaint(renderer); 1228 DISPLAY_LIST_LOGD("%s%s %p, %p", (char*) indent, OP_NAMES[op], path, paint); 1229 drawGlStatus |= renderer.drawPath(path, paint); 1230 } 1231 break; 1232 case DrawLines: { 1233 int32_t count = 0; 1234 float* points = getFloats(count); 1235 SkPaint* paint = getPaint(renderer); 1236 DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]); 1237 drawGlStatus |= renderer.drawLines(points, count, paint); 1238 } 1239 break; 1240 case DrawPoints: { 1241 int32_t count = 0; 1242 float* points = getFloats(count); 1243 SkPaint* paint = getPaint(renderer); 1244 DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]); 1245 drawGlStatus |= renderer.drawPoints(points, count, paint); 1246 } 1247 break; 1248 case DrawTextOnPath: { 1249 getText(&text); 1250 int32_t count = getInt(); 1251 SkPath* path = getPath(); 1252 float hOffset = getFloat(); 1253 float vOffset = getFloat(); 1254 SkPaint* paint = getPaint(renderer); 1255 DISPLAY_LIST_LOGD("%s%s %s, %d, %d, %p", (char*) indent, OP_NAMES[op], 1256 text.text(), text.length(), count, paint); 1257 drawGlStatus |= renderer.drawTextOnPath(text.text(), text.length(), count, path, 1258 hOffset, vOffset, paint); 1259 } 1260 break; 1261 case DrawPosText: { 1262 getText(&text); 1263 int32_t count = getInt(); 1264 int32_t positionsCount = 0; 1265 float* positions = getFloats(positionsCount); 1266 SkPaint* paint = getPaint(renderer); 1267 DISPLAY_LIST_LOGD("%s%s %s, %d, %d, %p", (char*) indent, 1268 OP_NAMES[op], text.text(), text.length(), count, paint); 1269 drawGlStatus |= renderer.drawPosText(text.text(), text.length(), count, 1270 positions, paint); 1271 } 1272 break; 1273 case DrawText: { 1274 getText(&text); 1275 int32_t count = getInt(); 1276 float x = getFloat(); 1277 float y = getFloat(); 1278 int32_t positionsCount = 0; 1279 float* positions = getFloats(positionsCount); 1280 SkPaint* paint = getPaint(renderer); 1281 float length = getFloat(); 1282 DISPLAY_LIST_LOGD("%s%s %s, %d, %d, %.2f, %.2f, %p, %.2f", (char*) indent, 1283 OP_NAMES[op], text.text(), text.length(), count, x, y, paint, length); 1284 drawGlStatus |= renderer.drawText(text.text(), text.length(), count, 1285 x, y, positions, paint, length); 1286 } 1287 break; 1288 case DrawRects: { 1289 int32_t count = 0; 1290 float* rects = getFloats(count); 1291 SkPaint* paint = getPaint(renderer); 1292 DISPLAY_LIST_LOGD("%s%s %d, %p", (char*) indent, OP_NAMES[op], count, paint); 1293 drawGlStatus |= renderer.drawRects(rects, count / 4, paint); 1294 } 1295 break; 1296 case ResetShader: { 1297 DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]); 1298 renderer.resetShader(); 1299 } 1300 break; 1301 case SetupShader: { 1302 SkiaShader* shader = getShader(); 1303 DISPLAY_LIST_LOGD("%s%s %p", (char*) indent, OP_NAMES[op], shader); 1304 renderer.setupShader(shader); 1305 } 1306 break; 1307 case ResetColorFilter: { 1308 DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]); 1309 renderer.resetColorFilter(); 1310 } 1311 break; 1312 case SetupColorFilter: { 1313 SkiaColorFilter *colorFilter = getColorFilter(); 1314 DISPLAY_LIST_LOGD("%s%s %p", (char*) indent, OP_NAMES[op], colorFilter); 1315 renderer.setupColorFilter(colorFilter); 1316 } 1317 break; 1318 case ResetShadow: { 1319 DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]); 1320 renderer.resetShadow(); 1321 } 1322 break; 1323 case SetupShadow: { 1324 float radius = getFloat(); 1325 float dx = getFloat(); 1326 float dy = getFloat(); 1327 int32_t color = getInt(); 1328 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, 0x%x", (char*) indent, OP_NAMES[op], 1329 radius, dx, dy, color); 1330 renderer.setupShadow(radius, dx, dy, color); 1331 } 1332 break; 1333 case ResetPaintFilter: { 1334 DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]); 1335 renderer.resetPaintFilter(); 1336 } 1337 break; 1338 case SetupPaintFilter: { 1339 int32_t clearBits = getInt(); 1340 int32_t setBits = getInt(); 1341 DISPLAY_LIST_LOGD("%s%s 0x%x, 0x%x", (char*) indent, OP_NAMES[op], 1342 clearBits, setBits); 1343 renderer.setupPaintFilter(clearBits, setBits); 1344 } 1345 break; 1346 default: 1347 DISPLAY_LIST_LOGD("Display List error: op not handled: %s%s", 1348 (char*) indent, OP_NAMES[op]); 1349 break; 1350 } 1351 } 1352 1353 DISPLAY_LIST_LOGD("%s%s %d", (char*) indent, "RestoreToCount", restoreTo); 1354 renderer.restoreToCount(restoreTo); 1355 renderer.endMark(); 1356 1357 DISPLAY_LIST_LOGD("%sDone (%p, %s), returning %d", (char*) indent + 2, this, mName.string(), 1358 drawGlStatus); 1359 return drawGlStatus; 1360} 1361 1362/////////////////////////////////////////////////////////////////////////////// 1363// Base structure 1364/////////////////////////////////////////////////////////////////////////////// 1365 1366DisplayListRenderer::DisplayListRenderer(): 1367 mCaches(Caches::getInstance()), mWriter(MIN_WRITER_SIZE), 1368 mTranslateX(0.0f), mTranslateY(0.0f), mHasTranslate(false), 1369 mHasDrawOps(false), mFunctorCount(0) { 1370} 1371 1372DisplayListRenderer::~DisplayListRenderer() { 1373 reset(); 1374} 1375 1376void DisplayListRenderer::reset() { 1377 mWriter.reset(); 1378 1379 mCaches.resourceCache.lock(); 1380 1381 for (size_t i = 0; i < mBitmapResources.size(); i++) { 1382 mCaches.resourceCache.decrementRefcountLocked(mBitmapResources.itemAt(i)); 1383 } 1384 1385 for (size_t i = 0; i < mOwnedBitmapResources.size(); i++) { 1386 mCaches.resourceCache.decrementRefcountLocked(mOwnedBitmapResources.itemAt(i)); 1387 } 1388 1389 for (size_t i = 0; i < mFilterResources.size(); i++) { 1390 mCaches.resourceCache.decrementRefcountLocked(mFilterResources.itemAt(i)); 1391 } 1392 1393 for (size_t i = 0; i < mShaders.size(); i++) { 1394 mCaches.resourceCache.decrementRefcountLocked(mShaders.itemAt(i)); 1395 } 1396 1397 for (size_t i = 0; i < mSourcePaths.size(); i++) { 1398 mCaches.resourceCache.decrementRefcountLocked(mSourcePaths.itemAt(i)); 1399 } 1400 1401 for (size_t i = 0; i < mLayers.size(); i++) { 1402 mCaches.resourceCache.decrementRefcountLocked(mLayers.itemAt(i)); 1403 } 1404 1405 mCaches.resourceCache.unlock(); 1406 1407 mBitmapResources.clear(); 1408 mOwnedBitmapResources.clear(); 1409 mFilterResources.clear(); 1410 mSourcePaths.clear(); 1411 1412 mShaders.clear(); 1413 mShaderMap.clear(); 1414 1415 mPaints.clear(); 1416 mPaintMap.clear(); 1417 1418 mPaths.clear(); 1419 mPathMap.clear(); 1420 1421 mMatrices.clear(); 1422 1423 mLayers.clear(); 1424 1425 mHasDrawOps = false; 1426 mFunctorCount = 0; 1427} 1428 1429/////////////////////////////////////////////////////////////////////////////// 1430// Operations 1431/////////////////////////////////////////////////////////////////////////////// 1432 1433DisplayList* DisplayListRenderer::getDisplayList(DisplayList* displayList) { 1434 if (!displayList) { 1435 displayList = new DisplayList(*this); 1436 } else { 1437 displayList->initFromDisplayListRenderer(*this, true); 1438 } 1439 displayList->setRenderable(mHasDrawOps); 1440 return displayList; 1441} 1442 1443bool DisplayListRenderer::isDeferred() { 1444 return true; 1445} 1446 1447void DisplayListRenderer::setViewport(int width, int height) { 1448 mOrthoMatrix.loadOrtho(0, width, height, 0, -1, 1); 1449 1450 mWidth = width; 1451 mHeight = height; 1452} 1453 1454status_t DisplayListRenderer::prepareDirty(float left, float top, 1455 float right, float bottom, bool opaque) { 1456 mSnapshot = new Snapshot(mFirstSnapshot, 1457 SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag); 1458 mSaveCount = 1; 1459 1460 mSnapshot->setClip(0.0f, 0.0f, mWidth, mHeight); 1461 mDirtyClip = opaque; 1462 1463 mRestoreSaveCount = -1; 1464 1465 return DrawGlInfo::kStatusDone; // No invalidate needed at record-time 1466} 1467 1468void DisplayListRenderer::finish() { 1469 insertRestoreToCount(); 1470 insertTranlate(); 1471} 1472 1473void DisplayListRenderer::interrupt() { 1474} 1475 1476void DisplayListRenderer::resume() { 1477} 1478 1479status_t DisplayListRenderer::callDrawGLFunction(Functor *functor, Rect& dirty) { 1480 // Ignore dirty during recording, it matters only when we replay 1481 addOp(DisplayList::DrawGLFunction); 1482 addInt((int) functor); 1483 mFunctorCount++; 1484 return DrawGlInfo::kStatusDone; // No invalidate needed at record-time 1485} 1486 1487int DisplayListRenderer::save(int flags) { 1488 addOp(DisplayList::Save); 1489 addInt(flags); 1490 return OpenGLRenderer::save(flags); 1491} 1492 1493void DisplayListRenderer::restore() { 1494 if (mRestoreSaveCount < 0) { 1495 restoreToCount(getSaveCount() - 1); 1496 return; 1497 } 1498 1499 mRestoreSaveCount--; 1500 insertTranlate(); 1501 OpenGLRenderer::restore(); 1502} 1503 1504void DisplayListRenderer::restoreToCount(int saveCount) { 1505 mRestoreSaveCount = saveCount; 1506 insertTranlate(); 1507 OpenGLRenderer::restoreToCount(saveCount); 1508} 1509 1510int DisplayListRenderer::saveLayer(float left, float top, float right, float bottom, 1511 SkPaint* p, int flags) { 1512 addOp(DisplayList::SaveLayer); 1513 addBounds(left, top, right, bottom); 1514 addPaint(p); 1515 addInt(flags); 1516 return OpenGLRenderer::save(flags); 1517} 1518 1519int DisplayListRenderer::saveLayerAlpha(float left, float top, float right, float bottom, 1520 int alpha, int flags) { 1521 addOp(DisplayList::SaveLayerAlpha); 1522 addBounds(left, top, right, bottom); 1523 addInt(alpha); 1524 addInt(flags); 1525 return OpenGLRenderer::save(flags); 1526} 1527 1528void DisplayListRenderer::translate(float dx, float dy) { 1529 mHasTranslate = true; 1530 mTranslateX += dx; 1531 mTranslateY += dy; 1532 insertRestoreToCount(); 1533 OpenGLRenderer::translate(dx, dy); 1534} 1535 1536void DisplayListRenderer::rotate(float degrees) { 1537 addOp(DisplayList::Rotate); 1538 addFloat(degrees); 1539 OpenGLRenderer::rotate(degrees); 1540} 1541 1542void DisplayListRenderer::scale(float sx, float sy) { 1543 addOp(DisplayList::Scale); 1544 addPoint(sx, sy); 1545 OpenGLRenderer::scale(sx, sy); 1546} 1547 1548void DisplayListRenderer::skew(float sx, float sy) { 1549 addOp(DisplayList::Skew); 1550 addPoint(sx, sy); 1551 OpenGLRenderer::skew(sx, sy); 1552} 1553 1554void DisplayListRenderer::setMatrix(SkMatrix* matrix) { 1555 addOp(DisplayList::SetMatrix); 1556 addMatrix(matrix); 1557 OpenGLRenderer::setMatrix(matrix); 1558} 1559 1560void DisplayListRenderer::concatMatrix(SkMatrix* matrix) { 1561 addOp(DisplayList::ConcatMatrix); 1562 addMatrix(matrix); 1563 OpenGLRenderer::concatMatrix(matrix); 1564} 1565 1566bool DisplayListRenderer::clipRect(float left, float top, float right, float bottom, 1567 SkRegion::Op op) { 1568 addOp(DisplayList::ClipRect); 1569 addBounds(left, top, right, bottom); 1570 addInt(op); 1571 return OpenGLRenderer::clipRect(left, top, right, bottom, op); 1572} 1573 1574status_t DisplayListRenderer::drawDisplayList(DisplayList* displayList, 1575 Rect& dirty, int32_t flags, uint32_t level) { 1576 // dirty is an out parameter and should not be recorded, 1577 // it matters only when replaying the display list 1578 1579 addOp(DisplayList::DrawDisplayList); 1580 addDisplayList(displayList); 1581 addInt(flags); 1582 return DrawGlInfo::kStatusDone; 1583} 1584 1585status_t DisplayListRenderer::drawLayer(Layer* layer, float x, float y, SkPaint* paint) { 1586 addOp(DisplayList::DrawLayer); 1587 addLayer(layer); 1588 addPoint(x, y); 1589 addPaint(paint); 1590 return DrawGlInfo::kStatusDone; 1591} 1592 1593status_t DisplayListRenderer::drawBitmap(SkBitmap* bitmap, float left, float top, SkPaint* paint) { 1594 const bool reject = quickRejectNoScissor(left, top, 1595 left + bitmap->width(), top + bitmap->height()); 1596 uint32_t* location = addOp(DisplayList::DrawBitmap, reject); 1597 addBitmap(bitmap); 1598 addPoint(left, top); 1599 addPaint(paint); 1600 addSkip(location); 1601 return DrawGlInfo::kStatusDone; 1602} 1603 1604status_t DisplayListRenderer::drawBitmap(SkBitmap* bitmap, SkMatrix* matrix, SkPaint* paint) { 1605 Rect r(0.0f, 0.0f, bitmap->width(), bitmap->height()); 1606 const mat4 transform(*matrix); 1607 transform.mapRect(r); 1608 1609 const bool reject = quickRejectNoScissor(r.left, r.top, r.right, r.bottom); 1610 uint32_t* location = addOp(DisplayList::DrawBitmapMatrix, reject); 1611 addBitmap(bitmap); 1612 addMatrix(matrix); 1613 addPaint(paint); 1614 addSkip(location); 1615 return DrawGlInfo::kStatusDone; 1616} 1617 1618status_t DisplayListRenderer::drawBitmap(SkBitmap* bitmap, float srcLeft, float srcTop, 1619 float srcRight, float srcBottom, float dstLeft, float dstTop, 1620 float dstRight, float dstBottom, SkPaint* paint) { 1621 const bool reject = quickRejectNoScissor(dstLeft, dstTop, dstRight, dstBottom); 1622 uint32_t* location = addOp(DisplayList::DrawBitmapRect, reject); 1623 addBitmap(bitmap); 1624 addBounds(srcLeft, srcTop, srcRight, srcBottom); 1625 addBounds(dstLeft, dstTop, dstRight, dstBottom); 1626 addPaint(paint); 1627 addSkip(location); 1628 return DrawGlInfo::kStatusDone; 1629} 1630 1631status_t DisplayListRenderer::drawBitmapData(SkBitmap* bitmap, float left, float top, 1632 SkPaint* paint) { 1633 const bool reject = quickRejectNoScissor(left, top, 1634 left + bitmap->width(), top + bitmap->height()); 1635 uint32_t* location = addOp(DisplayList::DrawBitmapData, reject); 1636 addBitmapData(bitmap); 1637 addPoint(left, top); 1638 addPaint(paint); 1639 addSkip(location); 1640 return DrawGlInfo::kStatusDone; 1641} 1642 1643status_t DisplayListRenderer::drawBitmapMesh(SkBitmap* bitmap, int meshWidth, int meshHeight, 1644 float* vertices, int* colors, SkPaint* paint) { 1645 addOp(DisplayList::DrawBitmapMesh); 1646 addBitmap(bitmap); 1647 addInt(meshWidth); 1648 addInt(meshHeight); 1649 addFloats(vertices, (meshWidth + 1) * (meshHeight + 1) * 2); 1650 if (colors) { 1651 addInt(1); 1652 addInts(colors, (meshWidth + 1) * (meshHeight + 1)); 1653 } else { 1654 addInt(0); 1655 } 1656 addPaint(paint); 1657 return DrawGlInfo::kStatusDone; 1658} 1659 1660status_t DisplayListRenderer::drawPatch(SkBitmap* bitmap, const int32_t* xDivs, 1661 const int32_t* yDivs, const uint32_t* colors, uint32_t width, uint32_t height, 1662 int8_t numColors, float left, float top, float right, float bottom, SkPaint* paint) { 1663 int alpha; 1664 SkXfermode::Mode mode; 1665 OpenGLRenderer::getAlphaAndModeDirect(paint, &alpha, &mode); 1666 1667 const bool reject = quickRejectNoScissor(left, top, right, bottom); 1668 uint32_t* location = addOp(DisplayList::DrawPatch, reject); 1669 addBitmap(bitmap); 1670 addInts(xDivs, width); 1671 addInts(yDivs, height); 1672 addUInts(colors, numColors); 1673 addBounds(left, top, right, bottom); 1674 addInt(alpha); 1675 addInt(mode); 1676 addSkip(location); 1677 return DrawGlInfo::kStatusDone; 1678} 1679 1680status_t DisplayListRenderer::drawColor(int color, SkXfermode::Mode mode) { 1681 addOp(DisplayList::DrawColor); 1682 addInt(color); 1683 addInt(mode); 1684 return DrawGlInfo::kStatusDone; 1685} 1686 1687status_t DisplayListRenderer::drawRect(float left, float top, float right, float bottom, 1688 SkPaint* paint) { 1689 const bool reject = paint->getStyle() == SkPaint::kFill_Style && 1690 quickRejectNoScissor(left, top, right, bottom); 1691 uint32_t* location = addOp(DisplayList::DrawRect, reject); 1692 addBounds(left, top, right, bottom); 1693 addPaint(paint); 1694 addSkip(location); 1695 return DrawGlInfo::kStatusDone; 1696} 1697 1698status_t DisplayListRenderer::drawRoundRect(float left, float top, float right, float bottom, 1699 float rx, float ry, SkPaint* paint) { 1700 const bool reject = paint->getStyle() == SkPaint::kFill_Style && 1701 quickRejectNoScissor(left, top, right, bottom); 1702 uint32_t* location = addOp(DisplayList::DrawRoundRect, reject); 1703 addBounds(left, top, right, bottom); 1704 addPoint(rx, ry); 1705 addPaint(paint); 1706 addSkip(location); 1707 return DrawGlInfo::kStatusDone; 1708} 1709 1710status_t DisplayListRenderer::drawCircle(float x, float y, float radius, SkPaint* paint) { 1711 addOp(DisplayList::DrawCircle); 1712 addPoint(x, y); 1713 addFloat(radius); 1714 addPaint(paint); 1715 return DrawGlInfo::kStatusDone; 1716} 1717 1718status_t DisplayListRenderer::drawOval(float left, float top, float right, float bottom, 1719 SkPaint* paint) { 1720 addOp(DisplayList::DrawOval); 1721 addBounds(left, top, right, bottom); 1722 addPaint(paint); 1723 return DrawGlInfo::kStatusDone; 1724} 1725 1726status_t DisplayListRenderer::drawArc(float left, float top, float right, float bottom, 1727 float startAngle, float sweepAngle, bool useCenter, SkPaint* paint) { 1728 addOp(DisplayList::DrawArc); 1729 addBounds(left, top, right, bottom); 1730 addPoint(startAngle, sweepAngle); 1731 addInt(useCenter ? 1 : 0); 1732 addPaint(paint); 1733 return DrawGlInfo::kStatusDone; 1734} 1735 1736status_t DisplayListRenderer::drawPath(SkPath* path, SkPaint* paint) { 1737 float left, top, offset; 1738 uint32_t width, height; 1739 computePathBounds(path, paint, left, top, offset, width, height); 1740 1741 left -= offset; 1742 top -= offset; 1743 1744 const bool reject = quickRejectNoScissor(left, top, left + width, top + height); 1745 uint32_t* location = addOp(DisplayList::DrawPath, reject); 1746 addPath(path); 1747 addPaint(paint); 1748 addSkip(location); 1749 return DrawGlInfo::kStatusDone; 1750} 1751 1752status_t DisplayListRenderer::drawLines(float* points, int count, SkPaint* paint) { 1753 addOp(DisplayList::DrawLines); 1754 addFloats(points, count); 1755 addPaint(paint); 1756 return DrawGlInfo::kStatusDone; 1757} 1758 1759status_t DisplayListRenderer::drawPoints(float* points, int count, SkPaint* paint) { 1760 addOp(DisplayList::DrawPoints); 1761 addFloats(points, count); 1762 addPaint(paint); 1763 return DrawGlInfo::kStatusDone; 1764} 1765 1766status_t DisplayListRenderer::drawTextOnPath(const char* text, int bytesCount, int count, 1767 SkPath* path, float hOffset, float vOffset, SkPaint* paint) { 1768 if (!text || count <= 0) return DrawGlInfo::kStatusDone; 1769 addOp(DisplayList::DrawTextOnPath); 1770 addText(text, bytesCount); 1771 addInt(count); 1772 addPath(path); 1773 addFloat(hOffset); 1774 addFloat(vOffset); 1775 paint->setAntiAlias(true); 1776 SkPaint* addedPaint = addPaint(paint); 1777 FontRenderer& fontRenderer = mCaches.fontRenderer->getFontRenderer(addedPaint); 1778 fontRenderer.precache(addedPaint, text, count, *mSnapshot->transform); 1779 return DrawGlInfo::kStatusDone; 1780} 1781 1782status_t DisplayListRenderer::drawPosText(const char* text, int bytesCount, int count, 1783 const float* positions, SkPaint* paint) { 1784 if (!text || count <= 0) return DrawGlInfo::kStatusDone; 1785 addOp(DisplayList::DrawPosText); 1786 addText(text, bytesCount); 1787 addInt(count); 1788 addFloats(positions, count * 2); 1789 paint->setAntiAlias(true); 1790 SkPaint* addedPaint = addPaint(paint); 1791 FontRenderer& fontRenderer = mCaches.fontRenderer->getFontRenderer(addedPaint); 1792 fontRenderer.precache(addedPaint, text, count, *mSnapshot->transform); 1793 return DrawGlInfo::kStatusDone; 1794} 1795 1796status_t DisplayListRenderer::drawText(const char* text, int bytesCount, int count, 1797 float x, float y, const float* positions, SkPaint* paint, float length) { 1798 if (!text || count <= 0) return DrawGlInfo::kStatusDone; 1799 1800 // TODO: We should probably make a copy of the paint instead of modifying 1801 // it; modifying the paint will change its generationID the first 1802 // time, which might impact caches. More investigation needed to 1803 // see if it matters. 1804 // If we make a copy, then drawTextDecorations() should *not* make 1805 // its own copy as it does right now. 1806 // Beware: this needs Glyph encoding (already done on the Paint constructor) 1807 paint->setAntiAlias(true); 1808 if (length < 0.0f) length = paint->measureText(text, bytesCount); 1809 1810 bool reject = false; 1811 if (CC_LIKELY(paint->getTextAlign() == SkPaint::kLeft_Align)) { 1812 SkPaint::FontMetrics metrics; 1813 paint->getFontMetrics(&metrics, 0.0f); 1814 reject = quickRejectNoScissor(x, y + metrics.fTop, x + length, y + metrics.fBottom); 1815 } 1816 1817 uint32_t* location = addOp(DisplayList::DrawText, reject); 1818 addText(text, bytesCount); 1819 addInt(count); 1820 addFloat(x); 1821 addFloat(y); 1822 addFloats(positions, count * 2); 1823 SkPaint* addedPaint = addPaint(paint); 1824 if (!reject) { 1825 FontRenderer& fontRenderer = mCaches.fontRenderer->getFontRenderer(addedPaint); 1826 fontRenderer.precache(addedPaint, text, count, *mSnapshot->transform); 1827 } 1828 addFloat(length); 1829 addSkip(location); 1830 return DrawGlInfo::kStatusDone; 1831} 1832 1833status_t DisplayListRenderer::drawRects(const float* rects, int count, SkPaint* paint) { 1834 if (count <= 0) return DrawGlInfo::kStatusDone; 1835 1836 addOp(DisplayList::DrawRects); 1837 addFloats(rects, count * 4); 1838 addPaint(paint); 1839 return DrawGlInfo::kStatusDone; 1840} 1841 1842void DisplayListRenderer::resetShader() { 1843 addOp(DisplayList::ResetShader); 1844} 1845 1846void DisplayListRenderer::setupShader(SkiaShader* shader) { 1847 addOp(DisplayList::SetupShader); 1848 addShader(shader); 1849} 1850 1851void DisplayListRenderer::resetColorFilter() { 1852 addOp(DisplayList::ResetColorFilter); 1853} 1854 1855void DisplayListRenderer::setupColorFilter(SkiaColorFilter* filter) { 1856 addOp(DisplayList::SetupColorFilter); 1857 addColorFilter(filter); 1858} 1859 1860void DisplayListRenderer::resetShadow() { 1861 addOp(DisplayList::ResetShadow); 1862} 1863 1864void DisplayListRenderer::setupShadow(float radius, float dx, float dy, int color) { 1865 addOp(DisplayList::SetupShadow); 1866 addFloat(radius); 1867 addPoint(dx, dy); 1868 addInt(color); 1869} 1870 1871void DisplayListRenderer::resetPaintFilter() { 1872 addOp(DisplayList::ResetPaintFilter); 1873} 1874 1875void DisplayListRenderer::setupPaintFilter(int clearBits, int setBits) { 1876 addOp(DisplayList::SetupPaintFilter); 1877 addInt(clearBits); 1878 addInt(setBits); 1879} 1880 1881}; // namespace uirenderer 1882}; // namespace android 1883