DisplayListRenderer.cpp revision 5baa3a62a97544669fba6d65a11c07f252e654dd
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 20#include "DisplayListLogBuffer.h" 21#include "DisplayListRenderer.h" 22#include <utils/String8.h> 23#include "Caches.h" 24 25namespace android { 26namespace uirenderer { 27 28 29/////////////////////////////////////////////////////////////////////////////// 30// Display list 31/////////////////////////////////////////////////////////////////////////////// 32 33const char* DisplayList::OP_NAMES[] = { 34 "Save", 35 "Restore", 36 "RestoreToCount", 37 "SaveLayer", 38 "SaveLayerAlpha", 39 "Translate", 40 "Rotate", 41 "Scale", 42 "Skew", 43 "SetMatrix", 44 "ConcatMatrix", 45 "ClipRect", 46 "DrawDisplayList", 47 "DrawLayer", 48 "DrawBitmap", 49 "DrawBitmapMatrix", 50 "DrawBitmapRect", 51 "DrawBitmapMesh", 52 "DrawPatch", 53 "DrawColor", 54 "DrawRect", 55 "DrawRoundRect", 56 "DrawCircle", 57 "DrawOval", 58 "DrawArc", 59 "DrawPath", 60 "DrawLines", 61 "DrawPoints", 62 "DrawText", 63 "ResetShader", 64 "SetupShader", 65 "ResetColorFilter", 66 "SetupColorFilter", 67 "ResetShadow", 68 "SetupShadow", 69 "DrawGLFunction" 70}; 71 72void DisplayList::outputLogBuffer(int fd) { 73 DisplayListLogBuffer& logBuffer = DisplayListLogBuffer::getInstance(); 74 if (logBuffer.isEmpty()) { 75 return; 76 } 77 78 FILE *file = fdopen(fd, "a"); 79 80 fprintf(file, "\nRecent DisplayList operations\n"); 81 logBuffer.outputCommands(file, OP_NAMES); 82 83 String8 cachesLog; 84 Caches::getInstance().dumpMemoryUsage(cachesLog); 85 fprintf(file, "\nCaches:\n%s", cachesLog.string()); 86 fprintf(file, "\n"); 87 88 fflush(file); 89} 90 91DisplayList::DisplayList(const DisplayListRenderer& recorder) { 92 initFromDisplayListRenderer(recorder); 93} 94 95DisplayList::~DisplayList() { 96 clearResources(); 97} 98 99void DisplayList::clearResources() { 100 sk_free((void*) mReader.base()); 101 102 Caches& caches = Caches::getInstance(); 103 104 for (size_t i = 0; i < mBitmapResources.size(); i++) { 105 caches.resourceCache.decrementRefcount(mBitmapResources.itemAt(i)); 106 } 107 mBitmapResources.clear(); 108 109 for (size_t i = 0; i < mFilterResources.size(); i++) { 110 caches.resourceCache.decrementRefcount(mFilterResources.itemAt(i)); 111 } 112 mFilterResources.clear(); 113 114 for (size_t i = 0; i < mShaders.size(); i++) { 115 caches.resourceCache.decrementRefcount(mShaders.itemAt(i)); 116 caches.resourceCache.destructor(mShaders.itemAt(i)); 117 } 118 mShaders.clear(); 119 120 for (size_t i = 0; i < mPaints.size(); i++) { 121 delete mPaints.itemAt(i); 122 } 123 mPaints.clear(); 124 125 for (size_t i = 0; i < mPaths.size(); i++) { 126 SkPath* path = mPaths.itemAt(i); 127 caches.pathCache.remove(path); 128 delete path; 129 } 130 mPaths.clear(); 131 132 for (size_t i = 0; i < mMatrices.size(); i++) { 133 delete mMatrices.itemAt(i); 134 } 135 mMatrices.clear(); 136} 137 138void DisplayList::initFromDisplayListRenderer(const DisplayListRenderer& recorder, bool reusing) { 139 const SkWriter32& writer = recorder.writeStream(); 140 init(); 141 142 if (writer.size() == 0) { 143 return; 144 } 145 146 if (reusing) { 147 // re-using display list - clear out previous allocations 148 clearResources(); 149 } 150 151 mSize = writer.size(); 152 void* buffer = sk_malloc_throw(mSize); 153 writer.flatten(buffer); 154 mReader.setMemory(buffer, mSize); 155 156 Caches& caches = Caches::getInstance(); 157 158 const Vector<SkBitmap*> &bitmapResources = recorder.getBitmapResources(); 159 for (size_t i = 0; i < bitmapResources.size(); i++) { 160 SkBitmap* resource = bitmapResources.itemAt(i); 161 mBitmapResources.add(resource); 162 caches.resourceCache.incrementRefcount(resource); 163 } 164 165 const Vector<SkiaColorFilter*> &filterResources = recorder.getFilterResources(); 166 for (size_t i = 0; i < filterResources.size(); i++) { 167 SkiaColorFilter* resource = filterResources.itemAt(i); 168 mFilterResources.add(resource); 169 caches.resourceCache.incrementRefcount(resource); 170 } 171 172 const Vector<SkiaShader*> &shaders = recorder.getShaders(); 173 for (size_t i = 0; i < shaders.size(); i++) { 174 SkiaShader* resource = shaders.itemAt(i); 175 mShaders.add(resource); 176 caches.resourceCache.incrementRefcount(resource); 177 } 178 179 const Vector<SkPaint*> &paints = recorder.getPaints(); 180 for (size_t i = 0; i < paints.size(); i++) { 181 mPaints.add(paints.itemAt(i)); 182 } 183 184 const Vector<SkPath*> &paths = recorder.getPaths(); 185 for (size_t i = 0; i < paths.size(); i++) { 186 mPaths.add(paths.itemAt(i)); 187 } 188 189 const Vector<SkMatrix*> &matrices = recorder.getMatrices(); 190 for (size_t i = 0; i < matrices.size(); i++) { 191 mMatrices.add(matrices.itemAt(i)); 192 } 193} 194 195void DisplayList::init() { 196 mSize = 0; 197 mIsRenderable = true; 198} 199 200size_t DisplayList::getSize() { 201 return mSize; 202} 203 204/** 205 * This function is a simplified version of replay(), where we simply retrieve and log the 206 * display list. This function should remain in sync with the replay() function. 207 */ 208void DisplayList::output(OpenGLRenderer& renderer, uint32_t level) { 209 TextContainer text; 210 211 uint32_t count = (level + 1) * 2; 212 char indent[count + 1]; 213 for (uint32_t i = 0; i < count; i++) { 214 indent[i] = ' '; 215 } 216 indent[count] = '\0'; 217 ALOGD("%sStart display list (%p)", (char*) indent + 2, this); 218 219 int saveCount = renderer.getSaveCount() - 1; 220 221 mReader.rewind(); 222 223 while (!mReader.eof()) { 224 int op = mReader.readInt(); 225 226 switch (op) { 227 case DrawGLFunction: { 228 Functor *functor = (Functor *) getInt(); 229 ALOGD("%s%s %p", (char*) indent, OP_NAMES[op], functor); 230 } 231 break; 232 case Save: { 233 int rendererNum = getInt(); 234 ALOGD("%s%s %d", (char*) indent, OP_NAMES[op], rendererNum); 235 } 236 break; 237 case Restore: { 238 ALOGD("%s%s", (char*) indent, OP_NAMES[op]); 239 } 240 break; 241 case RestoreToCount: { 242 int restoreCount = saveCount + getInt(); 243 ALOGD("%s%s %d", (char*) indent, OP_NAMES[op], restoreCount); 244 } 245 break; 246 case SaveLayer: { 247 float f1 = getFloat(); 248 float f2 = getFloat(); 249 float f3 = getFloat(); 250 float f4 = getFloat(); 251 SkPaint* paint = getPaint(); 252 int flags = getInt(); 253 ALOGD("%s%s %.2f, %.2f, %.2f, %.2f, %p, 0x%x", (char*) indent, 254 OP_NAMES[op], f1, f2, f3, f4, paint, flags); 255 } 256 break; 257 case SaveLayerAlpha: { 258 float f1 = getFloat(); 259 float f2 = getFloat(); 260 float f3 = getFloat(); 261 float f4 = getFloat(); 262 int alpha = getInt(); 263 int flags = getInt(); 264 ALOGD("%s%s %.2f, %.2f, %.2f, %.2f, %d, 0x%x", (char*) indent, 265 OP_NAMES[op], f1, f2, f3, f4, alpha, flags); 266 } 267 break; 268 case Translate: { 269 float f1 = getFloat(); 270 float f2 = getFloat(); 271 ALOGD("%s%s %.2f, %.2f", (char*) indent, OP_NAMES[op], f1, f2); 272 } 273 break; 274 case Rotate: { 275 float rotation = getFloat(); 276 ALOGD("%s%s %.2f", (char*) indent, OP_NAMES[op], rotation); 277 } 278 break; 279 case Scale: { 280 float sx = getFloat(); 281 float sy = getFloat(); 282 ALOGD("%s%s %.2f, %.2f", (char*) indent, OP_NAMES[op], sx, sy); 283 } 284 break; 285 case Skew: { 286 float sx = getFloat(); 287 float sy = getFloat(); 288 ALOGD("%s%s %.2f, %.2f", (char*) indent, OP_NAMES[op], sx, sy); 289 } 290 break; 291 case SetMatrix: { 292 SkMatrix* matrix = getMatrix(); 293 ALOGD("%s%s %p", (char*) indent, OP_NAMES[op], matrix); 294 } 295 break; 296 case ConcatMatrix: { 297 SkMatrix* matrix = getMatrix(); 298 ALOGD("%s%s %p", (char*) indent, OP_NAMES[op], matrix); 299 } 300 break; 301 case ClipRect: { 302 float f1 = getFloat(); 303 float f2 = getFloat(); 304 float f3 = getFloat(); 305 float f4 = getFloat(); 306 int regionOp = getInt(); 307 ALOGD("%s%s %.2f, %.2f, %.2f, %.2f, %d", (char*) indent, OP_NAMES[op], 308 f1, f2, f3, f4, regionOp); 309 } 310 break; 311 case DrawDisplayList: { 312 DisplayList* displayList = getDisplayList(); 313 uint32_t width = getUInt(); 314 uint32_t height = getUInt(); 315 ALOGD("%s%s %p, %dx%d, %d", (char*) indent, OP_NAMES[op], 316 displayList, width, height, level + 1); 317 renderer.outputDisplayList(displayList, level + 1); 318 } 319 break; 320 case DrawLayer: { 321 Layer* layer = (Layer*) getInt(); 322 float x = getFloat(); 323 float y = getFloat(); 324 SkPaint* paint = getPaint(); 325 ALOGD("%s%s %p, %.2f, %.2f, %p", (char*) indent, OP_NAMES[op], 326 layer, x, y, paint); 327 } 328 break; 329 case DrawBitmap: { 330 SkBitmap* bitmap = getBitmap(); 331 float x = getFloat(); 332 float y = getFloat(); 333 SkPaint* paint = getPaint(); 334 ALOGD("%s%s %p, %.2f, %.2f, %p", (char*) indent, OP_NAMES[op], 335 bitmap, x, y, paint); 336 } 337 break; 338 case DrawBitmapMatrix: { 339 SkBitmap* bitmap = getBitmap(); 340 SkMatrix* matrix = getMatrix(); 341 SkPaint* paint = getPaint(); 342 ALOGD("%s%s %p, %p, %p", (char*) indent, OP_NAMES[op], 343 bitmap, matrix, paint); 344 } 345 break; 346 case DrawBitmapRect: { 347 SkBitmap* bitmap = getBitmap(); 348 float f1 = getFloat(); 349 float f2 = getFloat(); 350 float f3 = getFloat(); 351 float f4 = getFloat(); 352 float f5 = getFloat(); 353 float f6 = getFloat(); 354 float f7 = getFloat(); 355 float f8 = getFloat(); 356 SkPaint* paint = getPaint(); 357 ALOGD("%s%s %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %p", 358 (char*) indent, OP_NAMES[op], bitmap, f1, f2, f3, f4, f5, f6, f7, f8, paint); 359 } 360 break; 361 case DrawBitmapMesh: { 362 int verticesCount = 0; 363 uint32_t colorsCount = 0; 364 SkBitmap* bitmap = getBitmap(); 365 uint32_t meshWidth = getInt(); 366 uint32_t meshHeight = getInt(); 367 float* vertices = getFloats(verticesCount); 368 bool hasColors = getInt(); 369 int* colors = hasColors ? getInts(colorsCount) : NULL; 370 SkPaint* paint = getPaint(); 371 ALOGD("%s%s", (char*) indent, OP_NAMES[op]); 372 } 373 break; 374 case DrawPatch: { 375 int32_t* xDivs = NULL; 376 int32_t* yDivs = NULL; 377 uint32_t* colors = NULL; 378 uint32_t xDivsCount = 0; 379 uint32_t yDivsCount = 0; 380 int8_t numColors = 0; 381 SkBitmap* bitmap = getBitmap(); 382 xDivs = getInts(xDivsCount); 383 yDivs = getInts(yDivsCount); 384 colors = getUInts(numColors); 385 float left = getFloat(); 386 float top = getFloat(); 387 float right = getFloat(); 388 float bottom = getFloat(); 389 SkPaint* paint = getPaint(); 390 ALOGD("%s%s %.2f, %.2f, %.2f, %.2f", (char*) indent, OP_NAMES[op], 391 left, top, right, bottom); 392 } 393 break; 394 case DrawColor: { 395 int color = getInt(); 396 int xferMode = getInt(); 397 ALOGD("%s%s 0x%x %d", (char*) indent, OP_NAMES[op], color, xferMode); 398 } 399 break; 400 case DrawRect: { 401 float f1 = getFloat(); 402 float f2 = getFloat(); 403 float f3 = getFloat(); 404 float f4 = getFloat(); 405 SkPaint* paint = getPaint(); 406 ALOGD("%s%s %.2f, %.2f, %.2f, %.2f, %p", (char*) indent, OP_NAMES[op], 407 f1, f2, f3, f4, paint); 408 } 409 break; 410 case DrawRoundRect: { 411 float f1 = getFloat(); 412 float f2 = getFloat(); 413 float f3 = getFloat(); 414 float f4 = getFloat(); 415 float f5 = getFloat(); 416 float f6 = getFloat(); 417 SkPaint* paint = getPaint(); 418 ALOGD("%s%s %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %p", 419 (char*) indent, OP_NAMES[op], f1, f2, f3, f4, f5, f6, paint); 420 } 421 break; 422 case DrawCircle: { 423 float f1 = getFloat(); 424 float f2 = getFloat(); 425 float f3 = getFloat(); 426 SkPaint* paint = getPaint(); 427 ALOGD("%s%s %.2f, %.2f, %.2f, %p", 428 (char*) indent, OP_NAMES[op], f1, f2, f3, paint); 429 } 430 break; 431 case DrawOval: { 432 float f1 = getFloat(); 433 float f2 = getFloat(); 434 float f3 = getFloat(); 435 float f4 = getFloat(); 436 SkPaint* paint = getPaint(); 437 ALOGD("%s%s %.2f, %.2f, %.2f, %.2f, %p", 438 (char*) indent, OP_NAMES[op], f1, f2, f3, f4, paint); 439 } 440 break; 441 case DrawArc: { 442 float f1 = getFloat(); 443 float f2 = getFloat(); 444 float f3 = getFloat(); 445 float f4 = getFloat(); 446 float f5 = getFloat(); 447 float f6 = getFloat(); 448 int i1 = getInt(); 449 SkPaint* paint = getPaint(); 450 ALOGD("%s%s %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %d, %p", 451 (char*) indent, OP_NAMES[op], f1, f2, f3, f4, f5, f6, i1, paint); 452 } 453 break; 454 case DrawPath: { 455 SkPath* path = getPath(); 456 SkPaint* paint = getPaint(); 457 ALOGD("%s%s %p, %p", (char*) indent, OP_NAMES[op], path, paint); 458 } 459 break; 460 case DrawLines: { 461 int count = 0; 462 float* points = getFloats(count); 463 SkPaint* paint = getPaint(); 464 ALOGD("%s%s", (char*) indent, OP_NAMES[op]); 465 } 466 break; 467 case DrawPoints: { 468 int count = 0; 469 float* points = getFloats(count); 470 SkPaint* paint = getPaint(); 471 ALOGD("%s%s", (char*) indent, OP_NAMES[op]); 472 } 473 break; 474 case DrawText: { 475 getText(&text); 476 int count = getInt(); 477 float x = getFloat(); 478 float y = getFloat(); 479 SkPaint* paint = getPaint(); 480 float length = getFloat(); 481 ALOGD("%s%s %s, %d, %d, %.2f, %.2f, %p, %.2f", (char*) indent, OP_NAMES[op], 482 text.text(), text.length(), count, x, y, paint, length); 483 } 484 break; 485 case ResetShader: { 486 ALOGD("%s%s", (char*) indent, OP_NAMES[op]); 487 } 488 break; 489 case SetupShader: { 490 SkiaShader* shader = getShader(); 491 ALOGD("%s%s %p", (char*) indent, OP_NAMES[op], shader); 492 } 493 break; 494 case ResetColorFilter: { 495 ALOGD("%s%s", (char*) indent, OP_NAMES[op]); 496 } 497 break; 498 case SetupColorFilter: { 499 SkiaColorFilter *colorFilter = getColorFilter(); 500 ALOGD("%s%s %p", (char*) indent, OP_NAMES[op], colorFilter); 501 } 502 break; 503 case ResetShadow: { 504 ALOGD("%s%s", (char*) indent, OP_NAMES[op]); 505 } 506 break; 507 case SetupShadow: { 508 float radius = getFloat(); 509 float dx = getFloat(); 510 float dy = getFloat(); 511 int color = getInt(); 512 ALOGD("%s%s %.2f, %.2f, %.2f, 0x%x", (char*) indent, OP_NAMES[op], 513 radius, dx, dy, color); 514 } 515 break; 516 default: 517 ALOGD("Display List error: op not handled: %s%s", 518 (char*) indent, OP_NAMES[op]); 519 break; 520 } 521 } 522 523 ALOGD("%sDone", (char*) indent + 2); 524} 525 526/** 527 * Changes to replay(), specifically those involving opcode or parameter changes, should be mimicked 528 * in the output() function, since that function processes the same list of opcodes for the 529 * purposes of logging display list info for a given view. 530 */ 531bool DisplayList::replay(OpenGLRenderer& renderer, Rect& dirty, uint32_t level) { 532 bool needsInvalidate = false; 533 TextContainer text; 534 mReader.rewind(); 535 536#if DEBUG_DISPLAY_LIST 537 uint32_t count = (level + 1) * 2; 538 char indent[count + 1]; 539 for (uint32_t i = 0; i < count; i++) { 540 indent[i] = ' '; 541 } 542 indent[count] = '\0'; 543 DISPLAY_LIST_LOGD("%sStart display list (%p)", (char*) indent + 2, this); 544#endif 545 546 DisplayListLogBuffer& logBuffer = DisplayListLogBuffer::getInstance(); 547 int saveCount = renderer.getSaveCount() - 1; 548 while (!mReader.eof()) { 549 int op = mReader.readInt(); 550 logBuffer.writeCommand(level, op); 551 552 switch (op) { 553 case DrawGLFunction: { 554 Functor *functor = (Functor *) getInt(); 555 DISPLAY_LIST_LOGD("%s%s %p", (char*) indent, OP_NAMES[op], functor); 556 needsInvalidate |= renderer.callDrawGLFunction(functor, dirty); 557 } 558 break; 559 case Save: { 560 int rendererNum = getInt(); 561 DISPLAY_LIST_LOGD("%s%s %d", (char*) indent, OP_NAMES[op], rendererNum); 562 renderer.save(rendererNum); 563 } 564 break; 565 case Restore: { 566 DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]); 567 renderer.restore(); 568 } 569 break; 570 case RestoreToCount: { 571 int restoreCount = saveCount + getInt(); 572 DISPLAY_LIST_LOGD("%s%s %d", (char*) indent, OP_NAMES[op], restoreCount); 573 renderer.restoreToCount(restoreCount); 574 } 575 break; 576 case SaveLayer: { 577 float f1 = getFloat(); 578 float f2 = getFloat(); 579 float f3 = getFloat(); 580 float f4 = getFloat(); 581 SkPaint* paint = getPaint(); 582 int flags = getInt(); 583 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f, %p, 0x%x", (char*) indent, 584 OP_NAMES[op], f1, f2, f3, f4, paint, flags); 585 renderer.saveLayer(f1, f2, f3, f4, paint, flags); 586 } 587 break; 588 case SaveLayerAlpha: { 589 float f1 = getFloat(); 590 float f2 = getFloat(); 591 float f3 = getFloat(); 592 float f4 = getFloat(); 593 int alpha = getInt(); 594 int flags = getInt(); 595 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f, %d, 0x%x", (char*) indent, 596 OP_NAMES[op], f1, f2, f3, f4, alpha, flags); 597 renderer.saveLayerAlpha(f1, f2, f3, f4, alpha, flags); 598 } 599 break; 600 case Translate: { 601 float f1 = getFloat(); 602 float f2 = getFloat(); 603 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f", (char*) indent, OP_NAMES[op], f1, f2); 604 renderer.translate(f1, f2); 605 } 606 break; 607 case Rotate: { 608 float rotation = getFloat(); 609 DISPLAY_LIST_LOGD("%s%s %.2f", (char*) indent, OP_NAMES[op], rotation); 610 renderer.rotate(rotation); 611 } 612 break; 613 case Scale: { 614 float sx = getFloat(); 615 float sy = getFloat(); 616 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f", (char*) indent, OP_NAMES[op], sx, sy); 617 renderer.scale(sx, sy); 618 } 619 break; 620 case Skew: { 621 float sx = getFloat(); 622 float sy = getFloat(); 623 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f", (char*) indent, OP_NAMES[op], sx, sy); 624 renderer.skew(sx, sy); 625 } 626 break; 627 case SetMatrix: { 628 SkMatrix* matrix = getMatrix(); 629 DISPLAY_LIST_LOGD("%s%s %p", (char*) indent, OP_NAMES[op], matrix); 630 renderer.setMatrix(matrix); 631 } 632 break; 633 case ConcatMatrix: { 634 SkMatrix* matrix = getMatrix(); 635 DISPLAY_LIST_LOGD("%s%s %p", (char*) indent, OP_NAMES[op], matrix); 636 renderer.concatMatrix(matrix); 637 } 638 break; 639 case ClipRect: { 640 float f1 = getFloat(); 641 float f2 = getFloat(); 642 float f3 = getFloat(); 643 float f4 = getFloat(); 644 int regionOp = getInt(); 645 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f, %d", (char*) indent, OP_NAMES[op], 646 f1, f2, f3, f4, regionOp); 647 renderer.clipRect(f1, f2, f3, f4, (SkRegion::Op) regionOp); 648 } 649 break; 650 case DrawDisplayList: { 651 DisplayList* displayList = getDisplayList(); 652 uint32_t width = getUInt(); 653 uint32_t height = getUInt(); 654 DISPLAY_LIST_LOGD("%s%s %p, %dx%d, %d", (char*) indent, OP_NAMES[op], 655 displayList, width, height, level + 1); 656 needsInvalidate |= renderer.drawDisplayList(displayList, width, height, 657 dirty, level + 1); 658 } 659 break; 660 case DrawLayer: { 661 Layer* layer = (Layer*) getInt(); 662 float x = getFloat(); 663 float y = getFloat(); 664 SkPaint* paint = getPaint(); 665 DISPLAY_LIST_LOGD("%s%s %p, %.2f, %.2f, %p", (char*) indent, OP_NAMES[op], 666 layer, x, y, paint); 667 renderer.drawLayer(layer, x, y, paint); 668 } 669 break; 670 case DrawBitmap: { 671 SkBitmap* bitmap = getBitmap(); 672 float x = getFloat(); 673 float y = getFloat(); 674 SkPaint* paint = getPaint(); 675 DISPLAY_LIST_LOGD("%s%s %p, %.2f, %.2f, %p", (char*) indent, OP_NAMES[op], 676 bitmap, x, y, paint); 677 renderer.drawBitmap(bitmap, x, y, paint); 678 } 679 break; 680 case DrawBitmapMatrix: { 681 SkBitmap* bitmap = getBitmap(); 682 SkMatrix* matrix = getMatrix(); 683 SkPaint* paint = getPaint(); 684 DISPLAY_LIST_LOGD("%s%s %p, %p, %p", (char*) indent, OP_NAMES[op], 685 bitmap, matrix, paint); 686 renderer.drawBitmap(bitmap, matrix, paint); 687 } 688 break; 689 case DrawBitmapRect: { 690 SkBitmap* bitmap = getBitmap(); 691 float f1 = getFloat(); 692 float f2 = getFloat(); 693 float f3 = getFloat(); 694 float f4 = getFloat(); 695 float f5 = getFloat(); 696 float f6 = getFloat(); 697 float f7 = getFloat(); 698 float f8 = getFloat(); 699 SkPaint* paint = getPaint(); 700 DISPLAY_LIST_LOGD("%s%s %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %p", 701 (char*) indent, OP_NAMES[op], bitmap, f1, f2, f3, f4, f5, f6, f7, f8, paint); 702 renderer.drawBitmap(bitmap, f1, f2, f3, f4, f5, f6, f7, f8, paint); 703 } 704 break; 705 case DrawBitmapMesh: { 706 int verticesCount = 0; 707 uint32_t colorsCount = 0; 708 709 SkBitmap* bitmap = getBitmap(); 710 uint32_t meshWidth = getInt(); 711 uint32_t meshHeight = getInt(); 712 float* vertices = getFloats(verticesCount); 713 bool hasColors = getInt(); 714 int* colors = hasColors ? getInts(colorsCount) : NULL; 715 SkPaint* paint = getPaint(); 716 717 DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]); 718 renderer.drawBitmapMesh(bitmap, meshWidth, meshHeight, vertices, colors, paint); 719 } 720 break; 721 case DrawPatch: { 722 int32_t* xDivs = NULL; 723 int32_t* yDivs = NULL; 724 uint32_t* colors = NULL; 725 uint32_t xDivsCount = 0; 726 uint32_t yDivsCount = 0; 727 int8_t numColors = 0; 728 729 SkBitmap* bitmap = getBitmap(); 730 731 xDivs = getInts(xDivsCount); 732 yDivs = getInts(yDivsCount); 733 colors = getUInts(numColors); 734 735 float left = getFloat(); 736 float top = getFloat(); 737 float right = getFloat(); 738 float bottom = getFloat(); 739 SkPaint* paint = getPaint(); 740 741 DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]); 742 renderer.drawPatch(bitmap, xDivs, yDivs, colors, xDivsCount, yDivsCount, 743 numColors, left, top, right, bottom, paint); 744 } 745 break; 746 case DrawColor: { 747 int color = getInt(); 748 int xferMode = getInt(); 749 DISPLAY_LIST_LOGD("%s%s 0x%x %d", (char*) indent, OP_NAMES[op], color, xferMode); 750 renderer.drawColor(color, (SkXfermode::Mode) xferMode); 751 } 752 break; 753 case DrawRect: { 754 float f1 = getFloat(); 755 float f2 = getFloat(); 756 float f3 = getFloat(); 757 float f4 = getFloat(); 758 SkPaint* paint = getPaint(); 759 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f, %p", (char*) indent, OP_NAMES[op], 760 f1, f2, f3, f4, paint); 761 renderer.drawRect(f1, f2, f3, f4, paint); 762 } 763 break; 764 case DrawRoundRect: { 765 float f1 = getFloat(); 766 float f2 = getFloat(); 767 float f3 = getFloat(); 768 float f4 = getFloat(); 769 float f5 = getFloat(); 770 float f6 = getFloat(); 771 SkPaint* paint = getPaint(); 772 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %p", 773 (char*) indent, OP_NAMES[op], f1, f2, f3, f4, f5, f6, paint); 774 renderer.drawRoundRect(f1, f2, f3, f4, f5, f6, paint); 775 } 776 break; 777 case DrawCircle: { 778 float f1 = getFloat(); 779 float f2 = getFloat(); 780 float f3 = getFloat(); 781 SkPaint* paint = getPaint(); 782 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %p", 783 (char*) indent, OP_NAMES[op], f1, f2, f3, paint); 784 renderer.drawCircle(f1, f2, f3, paint); 785 } 786 break; 787 case DrawOval: { 788 float f1 = getFloat(); 789 float f2 = getFloat(); 790 float f3 = getFloat(); 791 float f4 = getFloat(); 792 SkPaint* paint = getPaint(); 793 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f, %p", 794 (char*) indent, OP_NAMES[op], f1, f2, f3, f4, paint); 795 renderer.drawOval(f1, f2, f3, f4, paint); 796 } 797 break; 798 case DrawArc: { 799 float f1 = getFloat(); 800 float f2 = getFloat(); 801 float f3 = getFloat(); 802 float f4 = getFloat(); 803 float f5 = getFloat(); 804 float f6 = getFloat(); 805 int i1 = getInt(); 806 SkPaint* paint = getPaint(); 807 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %d, %p", 808 (char*) indent, OP_NAMES[op], f1, f2, f3, f4, f5, f6, i1, paint); 809 renderer.drawArc(f1, f2, f3, f4, f5, f6, i1 == 1, paint); 810 } 811 break; 812 case DrawPath: { 813 SkPath* path = getPath(); 814 SkPaint* paint = getPaint(); 815 DISPLAY_LIST_LOGD("%s%s %p, %p", (char*) indent, OP_NAMES[op], path, paint); 816 renderer.drawPath(path, paint); 817 } 818 break; 819 case DrawLines: { 820 int count = 0; 821 float* points = getFloats(count); 822 SkPaint* paint = getPaint(); 823 DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]); 824 renderer.drawLines(points, count, paint); 825 } 826 break; 827 case DrawPoints: { 828 int count = 0; 829 float* points = getFloats(count); 830 SkPaint* paint = getPaint(); 831 DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]); 832 renderer.drawPoints(points, count, paint); 833 } 834 break; 835 case DrawText: { 836 getText(&text); 837 int count = getInt(); 838 float x = getFloat(); 839 float y = getFloat(); 840 SkPaint* paint = getPaint(); 841 float length = getFloat(); 842 DISPLAY_LIST_LOGD("%s%s %s, %d, %d, %.2f, %.2f, %p, %.2f", (char*) indent, 843 OP_NAMES[op], text.text(), text.length(), count, x, y, paint, length); 844 renderer.drawText(text.text(), text.length(), count, x, y, paint, length); 845 } 846 break; 847 case ResetShader: { 848 DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]); 849 renderer.resetShader(); 850 } 851 break; 852 case SetupShader: { 853 SkiaShader* shader = getShader(); 854 DISPLAY_LIST_LOGD("%s%s %p", (char*) indent, OP_NAMES[op], shader); 855 renderer.setupShader(shader); 856 } 857 break; 858 case ResetColorFilter: { 859 DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]); 860 renderer.resetColorFilter(); 861 } 862 break; 863 case SetupColorFilter: { 864 SkiaColorFilter *colorFilter = getColorFilter(); 865 DISPLAY_LIST_LOGD("%s%s %p", (char*) indent, OP_NAMES[op], colorFilter); 866 renderer.setupColorFilter(colorFilter); 867 } 868 break; 869 case ResetShadow: { 870 DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]); 871 renderer.resetShadow(); 872 } 873 break; 874 case SetupShadow: { 875 float radius = getFloat(); 876 float dx = getFloat(); 877 float dy = getFloat(); 878 int color = getInt(); 879 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, 0x%x", (char*) indent, OP_NAMES[op], 880 radius, dx, dy, color); 881 renderer.setupShadow(radius, dx, dy, color); 882 } 883 break; 884 default: 885 DISPLAY_LIST_LOGD("Display List error: op not handled: %s%s", 886 (char*) indent, OP_NAMES[op]); 887 break; 888 } 889 } 890 891 DISPLAY_LIST_LOGD("%sDone, returning %d", (char*) indent + 2, needsInvalidate); 892 return needsInvalidate; 893} 894 895/////////////////////////////////////////////////////////////////////////////// 896// Base structure 897/////////////////////////////////////////////////////////////////////////////// 898 899DisplayListRenderer::DisplayListRenderer(): mWriter(MIN_WRITER_SIZE), mHasDrawOps(false) { 900} 901 902DisplayListRenderer::~DisplayListRenderer() { 903 reset(); 904} 905 906void DisplayListRenderer::reset() { 907 mWriter.reset(); 908 909 Caches& caches = Caches::getInstance(); 910 for (size_t i = 0; i < mBitmapResources.size(); i++) { 911 caches.resourceCache.decrementRefcount(mBitmapResources.itemAt(i)); 912 } 913 mBitmapResources.clear(); 914 915 for (size_t i = 0; i < mFilterResources.size(); i++) { 916 caches.resourceCache.decrementRefcount(mFilterResources.itemAt(i)); 917 } 918 mFilterResources.clear(); 919 920 for (size_t i = 0; i < mShaders.size(); i++) { 921 caches.resourceCache.decrementRefcount(mShaders.itemAt(i)); 922 } 923 mShaders.clear(); 924 mShaderMap.clear(); 925 926 mPaints.clear(); 927 mPaintMap.clear(); 928 929 mPaths.clear(); 930 mPathMap.clear(); 931 932 mMatrices.clear(); 933 934 mHasDrawOps = false; 935} 936 937/////////////////////////////////////////////////////////////////////////////// 938// Operations 939/////////////////////////////////////////////////////////////////////////////// 940 941DisplayList* DisplayListRenderer::getDisplayList(DisplayList* displayList) { 942 if (!displayList) { 943 displayList = new DisplayList(*this); 944 } else { 945 displayList->initFromDisplayListRenderer(*this, true); 946 } 947 displayList->setRenderable(mHasDrawOps); 948 return displayList; 949} 950 951void DisplayListRenderer::setViewport(int width, int height) { 952 mOrthoMatrix.loadOrtho(0, width, height, 0, -1, 1); 953 954 mWidth = width; 955 mHeight = height; 956} 957 958void DisplayListRenderer::prepareDirty(float left, float top, 959 float right, float bottom, bool opaque) { 960 mSnapshot = new Snapshot(mFirstSnapshot, 961 SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag); 962 mSaveCount = 1; 963 mSnapshot->setClip(0.0f, 0.0f, mWidth, mHeight); 964 mRestoreSaveCount = -1; 965} 966 967void DisplayListRenderer::finish() { 968 insertRestoreToCount(); 969 OpenGLRenderer::finish(); 970} 971 972void DisplayListRenderer::interrupt() { 973} 974 975void DisplayListRenderer::resume() { 976} 977 978bool DisplayListRenderer::callDrawGLFunction(Functor *functor, Rect& dirty) { 979 // Ignore dirty during recording, it matters only when we replay 980 addOp(DisplayList::DrawGLFunction); 981 addInt((int) functor); 982 return false; // No invalidate needed at record-time 983} 984 985int DisplayListRenderer::save(int flags) { 986 addOp(DisplayList::Save); 987 addInt(flags); 988 return OpenGLRenderer::save(flags); 989} 990 991void DisplayListRenderer::restore() { 992 if (mRestoreSaveCount < 0) { 993 addOp(DisplayList::Restore); 994 } else { 995 mRestoreSaveCount--; 996 } 997 OpenGLRenderer::restore(); 998} 999 1000void DisplayListRenderer::restoreToCount(int saveCount) { 1001 mRestoreSaveCount = saveCount; 1002 OpenGLRenderer::restoreToCount(saveCount); 1003} 1004 1005int DisplayListRenderer::saveLayer(float left, float top, float right, float bottom, 1006 SkPaint* p, int flags) { 1007 addOp(DisplayList::SaveLayer); 1008 addBounds(left, top, right, bottom); 1009 addPaint(p); 1010 addInt(flags); 1011 return OpenGLRenderer::save(flags); 1012} 1013 1014int DisplayListRenderer::saveLayerAlpha(float left, float top, float right, float bottom, 1015 int alpha, int flags) { 1016 addOp(DisplayList::SaveLayerAlpha); 1017 addBounds(left, top, right, bottom); 1018 addInt(alpha); 1019 addInt(flags); 1020 return OpenGLRenderer::save(flags); 1021} 1022 1023void DisplayListRenderer::translate(float dx, float dy) { 1024 addOp(DisplayList::Translate); 1025 addPoint(dx, dy); 1026 OpenGLRenderer::translate(dx, dy); 1027} 1028 1029void DisplayListRenderer::rotate(float degrees) { 1030 addOp(DisplayList::Rotate); 1031 addFloat(degrees); 1032 OpenGLRenderer::rotate(degrees); 1033} 1034 1035void DisplayListRenderer::scale(float sx, float sy) { 1036 addOp(DisplayList::Scale); 1037 addPoint(sx, sy); 1038 OpenGLRenderer::scale(sx, sy); 1039} 1040 1041void DisplayListRenderer::skew(float sx, float sy) { 1042 addOp(DisplayList::Skew); 1043 addPoint(sx, sy); 1044 OpenGLRenderer::skew(sx, sy); 1045} 1046 1047void DisplayListRenderer::setMatrix(SkMatrix* matrix) { 1048 addOp(DisplayList::SetMatrix); 1049 addMatrix(matrix); 1050 OpenGLRenderer::setMatrix(matrix); 1051} 1052 1053void DisplayListRenderer::concatMatrix(SkMatrix* matrix) { 1054 addOp(DisplayList::ConcatMatrix); 1055 addMatrix(matrix); 1056 OpenGLRenderer::concatMatrix(matrix); 1057} 1058 1059bool DisplayListRenderer::clipRect(float left, float top, float right, float bottom, 1060 SkRegion::Op op) { 1061 addOp(DisplayList::ClipRect); 1062 addBounds(left, top, right, bottom); 1063 addInt(op); 1064 return OpenGLRenderer::clipRect(left, top, right, bottom, op); 1065} 1066 1067bool DisplayListRenderer::drawDisplayList(DisplayList* displayList, 1068 uint32_t width, uint32_t height, Rect& dirty, uint32_t level) { 1069 // dirty is an out parameter and should not be recorded, 1070 // it matters only when replaying the display list 1071 addOp(DisplayList::DrawDisplayList); 1072 addDisplayList(displayList); 1073 addSize(width, height); 1074 return false; 1075} 1076 1077void DisplayListRenderer::drawLayer(Layer* layer, float x, float y, SkPaint* paint) { 1078 addOp(DisplayList::DrawLayer); 1079 addInt((int) layer); 1080 addPoint(x, y); 1081 addPaint(paint); 1082} 1083 1084void DisplayListRenderer::drawBitmap(SkBitmap* bitmap, float left, float top, 1085 SkPaint* paint) { 1086 addOp(DisplayList::DrawBitmap); 1087 addBitmap(bitmap); 1088 addPoint(left, top); 1089 addPaint(paint); 1090} 1091 1092void DisplayListRenderer::drawBitmap(SkBitmap* bitmap, SkMatrix* matrix, 1093 SkPaint* paint) { 1094 addOp(DisplayList::DrawBitmapMatrix); 1095 addBitmap(bitmap); 1096 addMatrix(matrix); 1097 addPaint(paint); 1098} 1099 1100void DisplayListRenderer::drawBitmap(SkBitmap* bitmap, float srcLeft, float srcTop, 1101 float srcRight, float srcBottom, float dstLeft, float dstTop, 1102 float dstRight, float dstBottom, SkPaint* paint) { 1103 addOp(DisplayList::DrawBitmapRect); 1104 addBitmap(bitmap); 1105 addBounds(srcLeft, srcTop, srcRight, srcBottom); 1106 addBounds(dstLeft, dstTop, dstRight, dstBottom); 1107 addPaint(paint); 1108} 1109 1110void DisplayListRenderer::drawBitmapMesh(SkBitmap* bitmap, int meshWidth, int meshHeight, 1111 float* vertices, int* colors, SkPaint* paint) { 1112 addOp(DisplayList::DrawBitmapMesh); 1113 addBitmap(bitmap); 1114 addInt(meshWidth); 1115 addInt(meshHeight); 1116 addFloats(vertices, (meshWidth + 1) * (meshHeight + 1) * 2); 1117 if (colors) { 1118 addInt(1); 1119 addInts(colors, (meshWidth + 1) * (meshHeight + 1)); 1120 } else { 1121 addInt(0); 1122 } 1123 addPaint(paint); 1124} 1125 1126void DisplayListRenderer::drawPatch(SkBitmap* bitmap, const int32_t* xDivs, const int32_t* yDivs, 1127 const uint32_t* colors, uint32_t width, uint32_t height, int8_t numColors, 1128 float left, float top, float right, float bottom, SkPaint* paint) { 1129 addOp(DisplayList::DrawPatch); 1130 addBitmap(bitmap); 1131 addInts(xDivs, width); 1132 addInts(yDivs, height); 1133 addUInts(colors, numColors); 1134 addBounds(left, top, right, bottom); 1135 addPaint(paint); 1136} 1137 1138void DisplayListRenderer::drawColor(int color, SkXfermode::Mode mode) { 1139 addOp(DisplayList::DrawColor); 1140 addInt(color); 1141 addInt(mode); 1142} 1143 1144void DisplayListRenderer::drawRect(float left, float top, float right, float bottom, 1145 SkPaint* paint) { 1146 addOp(DisplayList::DrawRect); 1147 addBounds(left, top, right, bottom); 1148 addPaint(paint); 1149} 1150 1151void DisplayListRenderer::drawRoundRect(float left, float top, float right, float bottom, 1152 float rx, float ry, SkPaint* paint) { 1153 addOp(DisplayList::DrawRoundRect); 1154 addBounds(left, top, right, bottom); 1155 addPoint(rx, ry); 1156 addPaint(paint); 1157} 1158 1159void DisplayListRenderer::drawCircle(float x, float y, float radius, SkPaint* paint) { 1160 addOp(DisplayList::DrawCircle); 1161 addPoint(x, y); 1162 addFloat(radius); 1163 addPaint(paint); 1164} 1165 1166void DisplayListRenderer::drawOval(float left, float top, float right, float bottom, 1167 SkPaint* paint) { 1168 addOp(DisplayList::DrawOval); 1169 addBounds(left, top, right, bottom); 1170 addPaint(paint); 1171} 1172 1173void DisplayListRenderer::drawArc(float left, float top, float right, float bottom, 1174 float startAngle, float sweepAngle, bool useCenter, SkPaint* paint) { 1175 addOp(DisplayList::DrawArc); 1176 addBounds(left, top, right, bottom); 1177 addPoint(startAngle, sweepAngle); 1178 addInt(useCenter ? 1 : 0); 1179 addPaint(paint); 1180} 1181 1182void DisplayListRenderer::drawPath(SkPath* path, SkPaint* paint) { 1183 addOp(DisplayList::DrawPath); 1184 addPath(path); 1185 addPaint(paint); 1186} 1187 1188void DisplayListRenderer::drawLines(float* points, int count, SkPaint* paint) { 1189 addOp(DisplayList::DrawLines); 1190 addFloats(points, count); 1191 addPaint(paint); 1192} 1193 1194void DisplayListRenderer::drawPoints(float* points, int count, SkPaint* paint) { 1195 addOp(DisplayList::DrawPoints); 1196 addFloats(points, count); 1197 addPaint(paint); 1198} 1199 1200void DisplayListRenderer::drawText(const char* text, int bytesCount, int count, 1201 float x, float y, SkPaint* paint, float length) { 1202 if (count <= 0) return; 1203 addOp(DisplayList::DrawText); 1204 addText(text, bytesCount); 1205 addInt(count); 1206 addPoint(x, y); 1207 // TODO: We should probably make a copy of the paint instead of modifying 1208 // it; modifying the paint will change its generationID the first 1209 // time, which might impact caches. More investigation needed to 1210 // see if it matters. 1211 // If we make a copy, then drawTextDecorations() should *not* make 1212 // its own copy as it does right now. 1213 paint->setAntiAlias(true); 1214#if RENDER_TEXT_AS_GLYPHS 1215 paint->setTextEncoding(SkPaint::kGlyphID_TextEncoding); 1216#endif 1217 addPaint(paint); 1218 addFloat(length < 0.0f ? paint->measureText(text, bytesCount) : length); 1219} 1220 1221void DisplayListRenderer::resetShader() { 1222 addOp(DisplayList::ResetShader); 1223} 1224 1225void DisplayListRenderer::setupShader(SkiaShader* shader) { 1226 addOp(DisplayList::SetupShader); 1227 addShader(shader); 1228} 1229 1230void DisplayListRenderer::resetColorFilter() { 1231 addOp(DisplayList::ResetColorFilter); 1232} 1233 1234void DisplayListRenderer::setupColorFilter(SkiaColorFilter* filter) { 1235 addOp(DisplayList::SetupColorFilter); 1236 addColorFilter(filter); 1237} 1238 1239void DisplayListRenderer::resetShadow() { 1240 addOp(DisplayList::ResetShadow); 1241} 1242 1243void DisplayListRenderer::setupShadow(float radius, float dx, float dy, int color) { 1244 addOp(DisplayList::SetupShadow); 1245 addFloat(radius); 1246 addPoint(dx, dy); 1247 addInt(color); 1248} 1249 1250}; // namespace uirenderer 1251}; // namespace android 1252