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