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