1 /* 2 * Copyright (C) 2013 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #define LOG_TAG "OpenGLRenderer" 18 #define ATRACE_TAG ATRACE_TAG_VIEW 19 20 #include <SkCanvas.h> 21 22 #include <utils/Trace.h> 23 #include <ui/Rect.h> 24 #include <ui/Region.h> 25 26 #include "Caches.h" 27 #include "Debug.h" 28 #include "DeferredDisplayList.h" 29 #include "DisplayListOp.h" 30 #include "OpenGLRenderer.h" 31 #include "Properties.h" 32 #include "utils/MathUtils.h" 33 34 #if DEBUG_DEFER 35 #define DEFER_LOGD(...) ALOGD(__VA_ARGS__) 36 #else 37 #define DEFER_LOGD(...) 38 #endif 39 40 namespace android { 41 namespace uirenderer { 42 43 // Depth of the save stack at the beginning of batch playback at flush time 44 #define FLUSH_SAVE_STACK_DEPTH 2 45 46 #define DEBUG_COLOR_BARRIER 0x1f000000 47 #define DEBUG_COLOR_MERGEDBATCH 0x5f7f7fff 48 #define DEBUG_COLOR_MERGEDBATCH_SOLO 0x5f7fff7f 49 50 ///////////////////////////////////////////////////////////////////////////////// 51 // Operation Batches 52 ///////////////////////////////////////////////////////////////////////////////// 53 54 class Batch { 55 public: 56 virtual void replay(OpenGLRenderer& renderer, Rect& dirty, int index) = 0; 57 virtual ~Batch() {} 58 virtual bool purelyDrawBatch() { return false; } 59 virtual bool coversBounds(const Rect& bounds) { return false; } 60 }; 61 62 class DrawBatch : public Batch { 63 public: 64 DrawBatch(const DeferInfo& deferInfo) : mAllOpsOpaque(true), 65 mBatchId(deferInfo.batchId), mMergeId(deferInfo.mergeId) { 66 mOps.clear(); 67 } 68 69 virtual ~DrawBatch() { mOps.clear(); } 70 71 virtual void add(DrawOp* op, const DeferredDisplayState* state, bool opaqueOverBounds) { 72 // NOTE: ignore empty bounds special case, since we don't merge across those ops 73 mBounds.unionWith(state->mBounds); 74 mAllOpsOpaque &= opaqueOverBounds; 75 mOps.add(OpStatePair(op, state)); 76 } 77 78 bool intersects(const Rect& rect) { 79 if (!rect.intersects(mBounds)) return false; 80 81 for (unsigned int i = 0; i < mOps.size(); i++) { 82 if (rect.intersects(mOps[i].state->mBounds)) { 83 #if DEBUG_DEFER 84 DEFER_LOGD("op intersects with op %p with bounds %f %f %f %f:", mOps[i].op, 85 mOps[i].state->mBounds.left, mOps[i].state->mBounds.top, 86 mOps[i].state->mBounds.right, mOps[i].state->mBounds.bottom); 87 mOps[i].op->output(2); 88 #endif 89 return true; 90 } 91 } 92 return false; 93 } 94 95 virtual void replay(OpenGLRenderer& renderer, Rect& dirty, int index) override { 96 DEFER_LOGD("%d replaying DrawBatch %p, with %d ops (batch id %x, merge id %p)", 97 index, this, mOps.size(), getBatchId(), getMergeId()); 98 99 for (unsigned int i = 0; i < mOps.size(); i++) { 100 DrawOp* op = mOps[i].op; 101 const DeferredDisplayState* state = mOps[i].state; 102 renderer.restoreDisplayState(*state); 103 104 #if DEBUG_DISPLAY_LIST_OPS_AS_EVENTS 105 renderer.eventMark(op->name()); 106 #endif 107 op->applyDraw(renderer, dirty); 108 109 #if DEBUG_MERGE_BEHAVIOR 110 const Rect& bounds = state->mBounds; 111 int batchColor = 0x1f000000; 112 if (getBatchId() & 0x1) batchColor |= 0x0000ff; 113 if (getBatchId() & 0x2) batchColor |= 0x00ff00; 114 if (getBatchId() & 0x4) batchColor |= 0xff0000; 115 renderer.drawScreenSpaceColorRect(bounds.left, bounds.top, bounds.right, bounds.bottom, 116 batchColor); 117 #endif 118 } 119 } 120 121 virtual bool purelyDrawBatch() override { return true; } 122 123 virtual bool coversBounds(const Rect& bounds) override { 124 if (CC_LIKELY(!mAllOpsOpaque || !mBounds.contains(bounds) || count() == 1)) return false; 125 126 Region uncovered(android::Rect(bounds.left, bounds.top, bounds.right, bounds.bottom)); 127 for (unsigned int i = 0; i < mOps.size(); i++) { 128 const Rect &r = mOps[i].state->mBounds; 129 uncovered.subtractSelf(android::Rect(r.left, r.top, r.right, r.bottom)); 130 } 131 return uncovered.isEmpty(); 132 } 133 134 inline int getBatchId() const { return mBatchId; } 135 inline mergeid_t getMergeId() const { return mMergeId; } 136 inline int count() const { return mOps.size(); } 137 138 protected: 139 Vector<OpStatePair> mOps; 140 Rect mBounds; // union of bounds of contained ops 141 private: 142 bool mAllOpsOpaque; 143 int mBatchId; 144 mergeid_t mMergeId; 145 }; 146 147 class MergingDrawBatch : public DrawBatch { 148 public: 149 MergingDrawBatch(DeferInfo& deferInfo, int width, int height) : 150 DrawBatch(deferInfo), mClipRect(width, height), 151 mClipSideFlags(kClipSide_None) {} 152 153 /* 154 * Helper for determining if a new op can merge with a MergingDrawBatch based on their bounds 155 * and clip side flags. Positive bounds delta means new bounds fit in old. 156 */ 157 static inline bool checkSide(const int currentFlags, const int newFlags, const int side, 158 float boundsDelta) { 159 bool currentClipExists = currentFlags & side; 160 bool newClipExists = newFlags & side; 161 162 // if current is clipped, we must be able to fit new bounds in current 163 if (boundsDelta > 0 && currentClipExists) return false; 164 165 // if new is clipped, we must be able to fit current bounds in new 166 if (boundsDelta < 0 && newClipExists) return false; 167 168 return true; 169 } 170 171 /* 172 * Checks if a (mergeable) op can be merged into this batch 173 * 174 * If true, the op's multiDraw must be guaranteed to handle both ops simultaneously, so it is 175 * important to consider all paint attributes used in the draw calls in deciding both a) if an 176 * op tries to merge at all, and b) if the op can merge with another set of ops 177 * 178 * False positives can lead to information from the paints of subsequent merged operations being 179 * dropped, so we make simplifying qualifications on the ops that can merge, per op type. 180 */ 181 bool canMergeWith(const DrawOp* op, const DeferredDisplayState* state) { 182 bool isTextBatch = getBatchId() == DeferredDisplayList::kOpBatch_Text || 183 getBatchId() == DeferredDisplayList::kOpBatch_ColorText; 184 185 // Overlapping other operations is only allowed for text without shadow. For other ops, 186 // multiDraw isn't guaranteed to overdraw correctly 187 if (!isTextBatch || op->hasTextShadow()) { 188 if (intersects(state->mBounds)) return false; 189 } 190 const DeferredDisplayState* lhs = state; 191 const DeferredDisplayState* rhs = mOps[0].state; 192 193 if (!MathUtils::areEqual(lhs->mAlpha, rhs->mAlpha)) return false; 194 195 // Identical round rect clip state means both ops will clip in the same way, or not at all. 196 // As the state objects are const, we can compare their pointers to determine mergeability 197 if (lhs->mRoundRectClipState != rhs->mRoundRectClipState) return false; 198 if (lhs->mProjectionPathMask != rhs->mProjectionPathMask) return false; 199 200 /* Clipping compatibility check 201 * 202 * Exploits the fact that if a op or batch is clipped on a side, its bounds will equal its 203 * clip for that side. 204 */ 205 const int currentFlags = mClipSideFlags; 206 const int newFlags = state->mClipSideFlags; 207 if (currentFlags != kClipSide_None || newFlags != kClipSide_None) { 208 const Rect& opBounds = state->mBounds; 209 float boundsDelta = mBounds.left - opBounds.left; 210 if (!checkSide(currentFlags, newFlags, kClipSide_Left, boundsDelta)) return false; 211 boundsDelta = mBounds.top - opBounds.top; 212 if (!checkSide(currentFlags, newFlags, kClipSide_Top, boundsDelta)) return false; 213 214 // right and bottom delta calculation reversed to account for direction 215 boundsDelta = opBounds.right - mBounds.right; 216 if (!checkSide(currentFlags, newFlags, kClipSide_Right, boundsDelta)) return false; 217 boundsDelta = opBounds.bottom - mBounds.bottom; 218 if (!checkSide(currentFlags, newFlags, kClipSide_Bottom, boundsDelta)) return false; 219 } 220 221 // if paints are equal, then modifiers + paint attribs don't need to be compared 222 if (op->mPaint == mOps[0].op->mPaint) return true; 223 224 if (op->getPaintAlpha() != mOps[0].op->getPaintAlpha()) return false; 225 226 if (op->mPaint && mOps[0].op->mPaint && 227 op->mPaint->getColorFilter() != mOps[0].op->mPaint->getColorFilter()) { 228 return false; 229 } 230 231 if (op->mPaint && mOps[0].op->mPaint && 232 op->mPaint->getShader() != mOps[0].op->mPaint->getShader()) { 233 return false; 234 } 235 236 return true; 237 } 238 239 virtual void add(DrawOp* op, const DeferredDisplayState* state, 240 bool opaqueOverBounds) override { 241 DrawBatch::add(op, state, opaqueOverBounds); 242 243 const int newClipSideFlags = state->mClipSideFlags; 244 mClipSideFlags |= newClipSideFlags; 245 if (newClipSideFlags & kClipSide_Left) mClipRect.left = state->mClip.left; 246 if (newClipSideFlags & kClipSide_Top) mClipRect.top = state->mClip.top; 247 if (newClipSideFlags & kClipSide_Right) mClipRect.right = state->mClip.right; 248 if (newClipSideFlags & kClipSide_Bottom) mClipRect.bottom = state->mClip.bottom; 249 } 250 251 virtual void replay(OpenGLRenderer& renderer, Rect& dirty, int index) override { 252 DEFER_LOGD("%d replaying MergingDrawBatch %p, with %d ops," 253 " clip flags %x (batch id %x, merge id %p)", 254 index, this, mOps.size(), mClipSideFlags, getBatchId(), getMergeId()); 255 if (mOps.size() == 1) { 256 DrawBatch::replay(renderer, dirty, -1); 257 return; 258 } 259 260 // clipping in the merged case is done ahead of time since all ops share the clip (if any) 261 renderer.setupMergedMultiDraw(mClipSideFlags ? &mClipRect : nullptr); 262 263 DrawOp* op = mOps[0].op; 264 #if DEBUG_DISPLAY_LIST_OPS_AS_EVENTS 265 renderer.eventMark("multiDraw"); 266 renderer.eventMark(op->name()); 267 #endif 268 op->multiDraw(renderer, dirty, mOps, mBounds); 269 270 #if DEBUG_MERGE_BEHAVIOR 271 renderer.drawScreenSpaceColorRect(mBounds.left, mBounds.top, mBounds.right, mBounds.bottom, 272 DEBUG_COLOR_MERGEDBATCH); 273 #endif 274 } 275 276 private: 277 /* 278 * Contains the effective clip rect shared by all merged ops. Initialized to the layer viewport, 279 * it will shrink if an op must be clipped on a certain side. The clipped sides are reflected in 280 * mClipSideFlags. 281 */ 282 Rect mClipRect; 283 int mClipSideFlags; 284 }; 285 286 class StateOpBatch : public Batch { 287 public: 288 // creates a single operation batch 289 StateOpBatch(const StateOp* op, const DeferredDisplayState* state) : mOp(op), mState(state) {} 290 291 virtual void replay(OpenGLRenderer& renderer, Rect& dirty, int index) override { 292 DEFER_LOGD("replaying state op batch %p", this); 293 renderer.restoreDisplayState(*mState); 294 295 // use invalid save count because it won't be used at flush time - RestoreToCountOp is the 296 // only one to use it, and we don't use that class at flush time, instead calling 297 // renderer.restoreToCount directly 298 int saveCount = -1; 299 mOp->applyState(renderer, saveCount); 300 } 301 302 private: 303 const StateOp* mOp; 304 const DeferredDisplayState* mState; 305 }; 306 307 class RestoreToCountBatch : public Batch { 308 public: 309 RestoreToCountBatch(const StateOp* op, const DeferredDisplayState* state, int restoreCount) : 310 mState(state), mRestoreCount(restoreCount) {} 311 312 virtual void replay(OpenGLRenderer& renderer, Rect& dirty, int index) override { 313 DEFER_LOGD("batch %p restoring to count %d", this, mRestoreCount); 314 315 renderer.restoreDisplayState(*mState); 316 renderer.restoreToCount(mRestoreCount); 317 } 318 319 private: 320 // we use the state storage for the RestoreToCountOp, but don't replay the op itself 321 const DeferredDisplayState* mState; 322 323 /* 324 * The count used here represents the flush() time saveCount. This is as opposed to the 325 * DisplayList record time, or defer() time values (which are RestoreToCountOp's mCount, and 326 * (saveCount + mCount) respectively). Since the count is different from the original 327 * RestoreToCountOp, we don't store a pointer to the op, as elsewhere. 328 */ 329 const int mRestoreCount; 330 }; 331 332 #if DEBUG_MERGE_BEHAVIOR 333 class BarrierDebugBatch : public Batch { 334 virtual void replay(OpenGLRenderer& renderer, Rect& dirty, int index) { 335 renderer.drawScreenSpaceColorRect(0, 0, 10000, 10000, DEBUG_COLOR_BARRIER); 336 } 337 }; 338 #endif 339 340 ///////////////////////////////////////////////////////////////////////////////// 341 // DeferredDisplayList 342 ///////////////////////////////////////////////////////////////////////////////// 343 344 void DeferredDisplayList::resetBatchingState() { 345 for (int i = 0; i < kOpBatch_Count; i++) { 346 mBatchLookup[i] = nullptr; 347 mMergingBatches[i].clear(); 348 } 349 #if DEBUG_MERGE_BEHAVIOR 350 if (mBatches.size() != 0) { 351 mBatches.add(new BarrierDebugBatch()); 352 } 353 #endif 354 mEarliestBatchIndex = mBatches.size(); 355 } 356 357 void DeferredDisplayList::clear() { 358 resetBatchingState(); 359 mComplexClipStackStart = -1; 360 361 for (unsigned int i = 0; i < mBatches.size(); i++) { 362 delete mBatches[i]; 363 } 364 mBatches.clear(); 365 mSaveStack.clear(); 366 mEarliestBatchIndex = 0; 367 mEarliestUnclearedIndex = 0; 368 } 369 370 ///////////////////////////////////////////////////////////////////////////////// 371 // Operation adding 372 ///////////////////////////////////////////////////////////////////////////////// 373 374 int DeferredDisplayList::getStateOpDeferFlags() const { 375 // For both clipOp and save(Layer)Op, we don't want to save drawing info, and only want to save 376 // the clip if we aren't recording a complex clip (and can thus trust it to be a rect) 377 return recordingComplexClip() ? 0 : kStateDeferFlag_Clip; 378 } 379 380 int DeferredDisplayList::getDrawOpDeferFlags() const { 381 return kStateDeferFlag_Draw | getStateOpDeferFlags(); 382 } 383 384 /** 385 * When an clipping operation occurs that could cause a complex clip, record the operation and all 386 * subsequent clipOps, save/restores (if the clip flag is set). During a flush, instead of loading 387 * the clip from deferred state, we play back all of the relevant state operations that generated 388 * the complex clip. 389 * 390 * Note that we don't need to record the associated restore operation, since operations at defer 391 * time record whether they should store the renderer's current clip 392 */ 393 void DeferredDisplayList::addClip(OpenGLRenderer& renderer, ClipOp* op) { 394 if (recordingComplexClip() || op->canCauseComplexClip() || !renderer.hasRectToRectTransform()) { 395 DEFER_LOGD("%p Received complex clip operation %p", this, op); 396 397 // NOTE: defer clip op before setting mComplexClipStackStart so previous clip is recorded 398 storeStateOpBarrier(renderer, op); 399 400 if (!recordingComplexClip()) { 401 mComplexClipStackStart = renderer.getSaveCount() - 1; 402 DEFER_LOGD(" Starting complex clip region, start is %d", mComplexClipStackStart); 403 } 404 } 405 } 406 407 /** 408 * For now, we record save layer operations as barriers in the batch list, preventing drawing 409 * operations from reordering around the saveLayer and it's associated restore() 410 * 411 * In the future, we should send saveLayer commands (if they can be played out of order) and their 412 * contained drawing operations to a seperate list of batches, so that they may draw at the 413 * beginning of the frame. This would avoid targetting and removing an FBO in the middle of a frame. 414 * 415 * saveLayer operations should be pulled to the beginning of the frame if the canvas doesn't have a 416 * complex clip, and if the flags (kClip_SaveFlag & kClipToLayer_SaveFlag) are set. 417 */ 418 void DeferredDisplayList::addSaveLayer(OpenGLRenderer& renderer, 419 SaveLayerOp* op, int newSaveCount) { 420 DEFER_LOGD("%p adding saveLayerOp %p, flags %x, new count %d", 421 this, op, op->getFlags(), newSaveCount); 422 423 storeStateOpBarrier(renderer, op); 424 mSaveStack.push(newSaveCount); 425 } 426 427 /** 428 * Takes save op and it's return value - the new save count - and stores it into the stream as a 429 * barrier if it's needed to properly modify a complex clip 430 */ 431 void DeferredDisplayList::addSave(OpenGLRenderer& renderer, SaveOp* op, int newSaveCount) { 432 int saveFlags = op->getFlags(); 433 DEFER_LOGD("%p adding saveOp %p, flags %x, new count %d", this, op, saveFlags, newSaveCount); 434 435 if (recordingComplexClip() && (saveFlags & SkCanvas::kClip_SaveFlag)) { 436 // store and replay the save operation, as it may be needed to correctly playback the clip 437 DEFER_LOGD(" adding save barrier with new save count %d", newSaveCount); 438 storeStateOpBarrier(renderer, op); 439 mSaveStack.push(newSaveCount); 440 } 441 } 442 443 /** 444 * saveLayer() commands must be associated with a restoreToCount batch that will clean up and draw 445 * the layer in the deferred list 446 * 447 * other save() commands which occur as children of a snapshot with complex clip will be deferred, 448 * and must be restored 449 * 450 * Either will act as a barrier to draw operation reordering, as we want to play back layer 451 * save/restore and complex canvas modifications (including save/restore) in order. 452 */ 453 void DeferredDisplayList::addRestoreToCount(OpenGLRenderer& renderer, StateOp* op, 454 int newSaveCount) { 455 DEFER_LOGD("%p addRestoreToCount %d", this, newSaveCount); 456 457 if (recordingComplexClip() && newSaveCount <= mComplexClipStackStart) { 458 mComplexClipStackStart = -1; 459 resetBatchingState(); 460 } 461 462 if (mSaveStack.isEmpty() || newSaveCount > mSaveStack.top()) { 463 return; 464 } 465 466 while (!mSaveStack.isEmpty() && mSaveStack.top() >= newSaveCount) mSaveStack.pop(); 467 468 storeRestoreToCountBarrier(renderer, op, mSaveStack.size() + FLUSH_SAVE_STACK_DEPTH); 469 } 470 471 void DeferredDisplayList::addDrawOp(OpenGLRenderer& renderer, DrawOp* op) { 472 /* 1: op calculates local bounds */ 473 DeferredDisplayState* const state = createState(); 474 if (op->getLocalBounds(state->mBounds)) { 475 if (state->mBounds.isEmpty()) { 476 // valid empty bounds, don't bother deferring 477 tryRecycleState(state); 478 return; 479 } 480 } else { 481 state->mBounds.setEmpty(); 482 } 483 484 /* 2: renderer calculates global bounds + stores state */ 485 if (renderer.storeDisplayState(*state, getDrawOpDeferFlags())) { 486 tryRecycleState(state); 487 return; // quick rejected 488 } 489 490 /* 3: ask op for defer info, given renderer state */ 491 DeferInfo deferInfo; 492 op->onDefer(renderer, deferInfo, *state); 493 494 // complex clip has a complex set of expectations on the renderer state - for now, avoid taking 495 // the merge path in those cases 496 deferInfo.mergeable &= !recordingComplexClip(); 497 deferInfo.opaqueOverBounds &= !recordingComplexClip() 498 && mSaveStack.isEmpty() 499 && !state->mRoundRectClipState; 500 501 if (CC_LIKELY(mAvoidOverdraw) && mBatches.size() && 502 state->mClipSideFlags != kClipSide_ConservativeFull && 503 deferInfo.opaqueOverBounds && state->mBounds.contains(mBounds)) { 504 // avoid overdraw by resetting drawing state + discarding drawing ops 505 discardDrawingBatches(mBatches.size() - 1); 506 resetBatchingState(); 507 } 508 509 if (CC_UNLIKELY(Properties::drawReorderDisabled)) { 510 // TODO: elegant way to reuse batches? 511 DrawBatch* b = new DrawBatch(deferInfo); 512 b->add(op, state, deferInfo.opaqueOverBounds); 513 mBatches.add(b); 514 return; 515 } 516 517 // find the latest batch of the new op's type, and try to merge the new op into it 518 DrawBatch* targetBatch = nullptr; 519 520 // insertion point of a new batch, will hopefully be immediately after similar batch 521 // (eventually, should be similar shader) 522 int insertBatchIndex = mBatches.size(); 523 if (!mBatches.isEmpty()) { 524 if (state->mBounds.isEmpty()) { 525 // don't know the bounds for op, so add to last batch and start from scratch on next op 526 DrawBatch* b = new DrawBatch(deferInfo); 527 b->add(op, state, deferInfo.opaqueOverBounds); 528 mBatches.add(b); 529 resetBatchingState(); 530 #if DEBUG_DEFER 531 DEFER_LOGD("Warning: Encountered op with empty bounds, resetting batches"); 532 op->output(2); 533 #endif 534 return; 535 } 536 537 if (deferInfo.mergeable) { 538 // Try to merge with any existing batch with same mergeId. 539 if (mMergingBatches[deferInfo.batchId].get(deferInfo.mergeId, targetBatch)) { 540 if (!((MergingDrawBatch*) targetBatch)->canMergeWith(op, state)) { 541 targetBatch = nullptr; 542 } 543 } 544 } else { 545 // join with similar, non-merging batch 546 targetBatch = (DrawBatch*)mBatchLookup[deferInfo.batchId]; 547 } 548 549 if (targetBatch || deferInfo.mergeable) { 550 // iterate back toward target to see if anything drawn since should overlap the new op 551 // if no target, merging ops still interate to find similar batch to insert after 552 for (int i = mBatches.size() - 1; i >= mEarliestBatchIndex; i--) { 553 DrawBatch* overBatch = (DrawBatch*)mBatches[i]; 554 555 if (overBatch == targetBatch) break; 556 557 // TODO: also consider shader shared between batch types 558 if (deferInfo.batchId == overBatch->getBatchId()) { 559 insertBatchIndex = i + 1; 560 if (!targetBatch) break; // found insert position, quit 561 } 562 563 if (overBatch->intersects(state->mBounds)) { 564 // NOTE: it may be possible to optimize for special cases where two operations 565 // of the same batch/paint could swap order, such as with a non-mergeable 566 // (clipped) and a mergeable text operation 567 targetBatch = nullptr; 568 #if DEBUG_DEFER 569 DEFER_LOGD("op couldn't join batch %p, was intersected by batch %d", 570 targetBatch, i); 571 op->output(2); 572 #endif 573 break; 574 } 575 } 576 } 577 } 578 579 if (!targetBatch) { 580 if (deferInfo.mergeable) { 581 targetBatch = new MergingDrawBatch(deferInfo, 582 renderer.getViewportWidth(), renderer.getViewportHeight()); 583 mMergingBatches[deferInfo.batchId].put(deferInfo.mergeId, targetBatch); 584 } else { 585 targetBatch = new DrawBatch(deferInfo); 586 mBatchLookup[deferInfo.batchId] = targetBatch; 587 } 588 589 DEFER_LOGD("creating %singBatch %p, bid %x, at %d", 590 deferInfo.mergeable ? "Merg" : "Draw", 591 targetBatch, deferInfo.batchId, insertBatchIndex); 592 mBatches.insertAt(targetBatch, insertBatchIndex); 593 } 594 595 targetBatch->add(op, state, deferInfo.opaqueOverBounds); 596 } 597 598 void DeferredDisplayList::storeStateOpBarrier(OpenGLRenderer& renderer, StateOp* op) { 599 DEFER_LOGD("%p adding state op barrier at pos %d", this, mBatches.size()); 600 601 DeferredDisplayState* state = createState(); 602 renderer.storeDisplayState(*state, getStateOpDeferFlags()); 603 mBatches.add(new StateOpBatch(op, state)); 604 resetBatchingState(); 605 } 606 607 void DeferredDisplayList::storeRestoreToCountBarrier(OpenGLRenderer& renderer, StateOp* op, 608 int newSaveCount) { 609 DEFER_LOGD("%p adding restore to count %d barrier, pos %d", 610 this, newSaveCount, mBatches.size()); 611 612 // store displayState for the restore operation, as it may be associated with a saveLayer that 613 // doesn't have kClip_SaveFlag set 614 DeferredDisplayState* state = createState(); 615 renderer.storeDisplayState(*state, getStateOpDeferFlags()); 616 mBatches.add(new RestoreToCountBatch(op, state, newSaveCount)); 617 resetBatchingState(); 618 } 619 620 ///////////////////////////////////////////////////////////////////////////////// 621 // Replay / flush 622 ///////////////////////////////////////////////////////////////////////////////// 623 624 static void replayBatchList(const Vector<Batch*>& batchList, 625 OpenGLRenderer& renderer, Rect& dirty) { 626 627 for (unsigned int i = 0; i < batchList.size(); i++) { 628 if (batchList[i]) { 629 batchList[i]->replay(renderer, dirty, i); 630 } 631 } 632 DEFER_LOGD("--flushed, drew %d batches", batchList.size()); 633 } 634 635 void DeferredDisplayList::flush(OpenGLRenderer& renderer, Rect& dirty) { 636 ATRACE_NAME("flush drawing commands"); 637 Caches::getInstance().fontRenderer->endPrecaching(); 638 639 if (isEmpty()) return; // nothing to flush 640 renderer.restoreToCount(1); 641 642 DEFER_LOGD("--flushing"); 643 renderer.eventMark("Flush"); 644 645 // save and restore so that reordering doesn't affect final state 646 renderer.save(SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag); 647 648 if (CC_LIKELY(mAvoidOverdraw)) { 649 for (unsigned int i = 1; i < mBatches.size(); i++) { 650 if (mBatches[i] && mBatches[i]->coversBounds(mBounds)) { 651 discardDrawingBatches(i - 1); 652 } 653 } 654 } 655 // NOTE: depth of the save stack at this point, before playback, should be reflected in 656 // FLUSH_SAVE_STACK_DEPTH, so that save/restores match up correctly 657 replayBatchList(mBatches, renderer, dirty); 658 659 renderer.restoreToCount(1); 660 661 DEFER_LOGD("--flush complete, returning %x", status); 662 clear(); 663 } 664 665 void DeferredDisplayList::discardDrawingBatches(const unsigned int maxIndex) { 666 for (unsigned int i = mEarliestUnclearedIndex; i <= maxIndex; i++) { 667 // leave deferred state ops alone for simplicity (empty save restore pairs may now exist) 668 if (mBatches[i] && mBatches[i]->purelyDrawBatch()) { 669 delete mBatches[i]; 670 mBatches.replaceAt(nullptr, i); 671 } 672 } 673 mEarliestUnclearedIndex = maxIndex + 1; 674 } 675 676 }; // namespace uirenderer 677 }; // namespace android 678