CanvasContext.cpp revision 764045da2ce980f1eee78171de5b4f09dfb601a7
1/* 2 * Copyright (C) 2014 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 <GpuMemoryTracker.h> 18#include "CanvasContext.h" 19 20#include "AnimationContext.h" 21#include "Caches.h" 22#include "DeferredLayerUpdater.h" 23#include "EglManager.h" 24#include "LayerUpdateQueue.h" 25#include "LayerRenderer.h" 26#include "OpenGLRenderer.h" 27#include "Properties.h" 28#include "Readback.h" 29#include "RenderThread.h" 30#include "hwui/Canvas.h" 31#include "renderstate/RenderState.h" 32#include "renderstate/Stencil.h" 33#include "protos/hwui.pb.h" 34#include "utils/GLUtils.h" 35#include "utils/TimeUtils.h" 36 37#include <cutils/properties.h> 38#include <google/protobuf/io/zero_copy_stream_impl.h> 39#include <private/hwui/DrawGlInfo.h> 40#include <strings.h> 41 42#include <algorithm> 43#include <fcntl.h> 44#include <sys/stat.h> 45 46#include <cstdlib> 47 48#define TRIM_MEMORY_COMPLETE 80 49#define TRIM_MEMORY_UI_HIDDEN 20 50 51#define ENABLE_RENDERNODE_SERIALIZATION false 52 53#define LOG_FRAMETIME_MMA 0 54 55#if LOG_FRAMETIME_MMA 56static float sBenchMma = 0; 57static int sFrameCount = 0; 58static const float NANOS_PER_MILLIS_F = 1000000.0f; 59#endif 60 61namespace android { 62namespace uirenderer { 63namespace renderthread { 64 65CanvasContext::CanvasContext(RenderThread& thread, bool translucent, 66 RenderNode* rootRenderNode, IContextFactory* contextFactory) 67 : mRenderThread(thread) 68 , mEglManager(thread.eglManager()) 69 , mOpaque(!translucent) 70 , mAnimationContext(contextFactory->createAnimationContext(mRenderThread.timeLord())) 71 , mJankTracker(thread.timeLord().frameIntervalNanos()) 72 , mProfiler(mFrames) 73 , mContentDrawBounds(0, 0, 0, 0) { 74 mRenderNodes.emplace_back(rootRenderNode); 75 mRenderThread.renderState().registerCanvasContext(this); 76 mProfiler.setDensity(mRenderThread.mainDisplayInfo().density); 77} 78 79CanvasContext::~CanvasContext() { 80 destroy(nullptr); 81 mRenderThread.renderState().unregisterCanvasContext(this); 82} 83 84void CanvasContext::destroy(TreeObserver* observer) { 85 stopDrawing(); 86 setSurface(nullptr); 87 freePrefetchedLayers(observer); 88 destroyHardwareResources(observer); 89 mAnimationContext->destroy(); 90#if !HWUI_NEW_OPS 91 if (mCanvas) { 92 delete mCanvas; 93 mCanvas = nullptr; 94 } 95#endif 96} 97 98void CanvasContext::setSurface(Surface* surface) { 99 ATRACE_CALL(); 100 101 mNativeSurface = surface; 102 103 if (mEglSurface != EGL_NO_SURFACE) { 104 mEglManager.destroySurface(mEglSurface); 105 mEglSurface = EGL_NO_SURFACE; 106 } 107 108 if (surface) { 109 mEglSurface = mEglManager.createSurface(surface); 110 } 111 112 mFrameNumber = -1; 113 114 if (mEglSurface != EGL_NO_SURFACE) { 115 const bool preserveBuffer = (mSwapBehavior != kSwap_discardBuffer); 116 mBufferPreserved = mEglManager.setPreserveBuffer(mEglSurface, preserveBuffer); 117 mHaveNewSurface = true; 118 mSwapHistory.clear(); 119 } else { 120 mRenderThread.removeFrameCallback(this); 121 } 122} 123 124void CanvasContext::setSwapBehavior(SwapBehavior swapBehavior) { 125 mSwapBehavior = swapBehavior; 126} 127 128void CanvasContext::initialize(Surface* surface) { 129 setSurface(surface); 130#if !HWUI_NEW_OPS 131 if (mCanvas) return; 132 mCanvas = new OpenGLRenderer(mRenderThread.renderState()); 133 mCanvas->initProperties(); 134#endif 135} 136 137void CanvasContext::updateSurface(Surface* surface) { 138 setSurface(surface); 139} 140 141bool CanvasContext::pauseSurface(Surface* surface) { 142 return mRenderThread.removeFrameCallback(this); 143} 144 145void CanvasContext::setStopped(bool stopped) { 146 if (mStopped != stopped) { 147 mStopped = stopped; 148 if (mStopped) { 149 mRenderThread.removeFrameCallback(this); 150 if (mEglManager.isCurrent(mEglSurface)) { 151 mEglManager.makeCurrent(EGL_NO_SURFACE); 152 } 153 } else if (mIsDirty && hasSurface()) { 154 mRenderThread.postFrameCallback(this); 155 } 156 } 157} 158 159void CanvasContext::setup(float lightRadius, 160 uint8_t ambientShadowAlpha, uint8_t spotShadowAlpha) { 161#if HWUI_NEW_OPS 162 mLightGeometry.radius = lightRadius; 163 mLightInfo.ambientShadowAlpha = ambientShadowAlpha; 164 mLightInfo.spotShadowAlpha = spotShadowAlpha; 165#else 166 if (!mCanvas) return; 167 mCanvas->initLight(lightRadius, ambientShadowAlpha, spotShadowAlpha); 168#endif 169} 170 171void CanvasContext::setLightCenter(const Vector3& lightCenter) { 172#if HWUI_NEW_OPS 173 mLightGeometry.center = lightCenter; 174#else 175 if (!mCanvas) return; 176 mCanvas->setLightCenter(lightCenter); 177#endif 178} 179 180void CanvasContext::setOpaque(bool opaque) { 181 mOpaque = opaque; 182} 183 184bool CanvasContext::makeCurrent() { 185 if (mStopped) return false; 186 187 // TODO: Figure out why this workaround is needed, see b/13913604 188 // In the meantime this matches the behavior of GLRenderer, so it is not a regression 189 EGLint error = 0; 190 mHaveNewSurface |= mEglManager.makeCurrent(mEglSurface, &error); 191 if (error) { 192 setSurface(nullptr); 193 } 194 return !error; 195} 196 197static bool wasSkipped(FrameInfo* info) { 198 return info && ((*info)[FrameInfoIndex::Flags] & FrameInfoFlags::SkippedFrame); 199} 200 201void CanvasContext::prepareTree(TreeInfo& info, int64_t* uiFrameInfo, 202 int64_t syncQueued, RenderNode* target) { 203 mRenderThread.removeFrameCallback(this); 204 205 // If the previous frame was dropped we don't need to hold onto it, so 206 // just keep using the previous frame's structure instead 207 if (!wasSkipped(mCurrentFrameInfo)) { 208 mCurrentFrameInfo = &mFrames.next(); 209 } 210 mCurrentFrameInfo->importUiThreadInfo(uiFrameInfo); 211 mCurrentFrameInfo->set(FrameInfoIndex::SyncQueued) = syncQueued; 212 mCurrentFrameInfo->markSyncStart(); 213 214 info.damageAccumulator = &mDamageAccumulator; 215#if HWUI_NEW_OPS 216 info.layerUpdateQueue = &mLayerUpdateQueue; 217#else 218 info.renderer = mCanvas; 219#endif 220 221 mAnimationContext->startFrame(info.mode); 222 for (const sp<RenderNode>& node : mRenderNodes) { 223 // Only the primary target node will be drawn full - all other nodes would get drawn in 224 // real time mode. In case of a window, the primary node is the window content and the other 225 // node(s) are non client / filler nodes. 226 info.mode = (node.get() == target ? TreeInfo::MODE_FULL : TreeInfo::MODE_RT_ONLY); 227 node->prepareTree(info); 228 GL_CHECKPOINT(MODERATE); 229 } 230 mAnimationContext->runRemainingAnimations(info); 231 GL_CHECKPOINT(MODERATE); 232 233 freePrefetchedLayers(info.observer); 234 GL_CHECKPOINT(MODERATE); 235 236 mIsDirty = true; 237 238 if (CC_UNLIKELY(!mNativeSurface.get())) { 239 mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame); 240 info.out.canDrawThisFrame = false; 241 return; 242 } 243 244 if (CC_LIKELY(mSwapHistory.size() && !Properties::forceDrawFrame)) { 245 nsecs_t latestVsync = mRenderThread.timeLord().latestVsync(); 246 const SwapHistory& lastSwap = mSwapHistory.back(); 247 nsecs_t vsyncDelta = std::abs(lastSwap.vsyncTime - latestVsync); 248 // The slight fudge-factor is to deal with cases where 249 // the vsync was estimated due to being slow handling the signal. 250 // See the logic in TimeLord#computeFrameTimeNanos or in 251 // Choreographer.java for details on when this happens 252 if (vsyncDelta < 2_ms) { 253 // Already drew for this vsync pulse, UI draw request missed 254 // the deadline for RT animations 255 info.out.canDrawThisFrame = false; 256 } else if (lastSwap.swapTime < latestVsync) { 257 info.out.canDrawThisFrame = true; 258 } else { 259 // We're maybe behind? Find out for sure 260 int runningBehind = 0; 261 // TODO: Have this method be on Surface, too, not just ANativeWindow... 262 ANativeWindow* window = mNativeSurface.get(); 263 window->query(window, NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND, &runningBehind); 264 info.out.canDrawThisFrame = !runningBehind; 265 } 266 } else { 267 info.out.canDrawThisFrame = true; 268 } 269 270 if (!info.out.canDrawThisFrame) { 271 mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame); 272 } 273 274 if (info.out.hasAnimations || !info.out.canDrawThisFrame) { 275 if (!info.out.requiresUiRedraw) { 276 // If animationsNeedsRedraw is set don't bother posting for an RT anim 277 // as we will just end up fighting the UI thread. 278 mRenderThread.postFrameCallback(this); 279 } 280 } 281} 282 283void CanvasContext::stopDrawing() { 284 mRenderThread.removeFrameCallback(this); 285 mAnimationContext->detachAnimators(); 286} 287 288void CanvasContext::notifyFramePending() { 289 ATRACE_CALL(); 290 mRenderThread.pushBackFrameCallback(this); 291} 292 293void CanvasContext::draw() { 294#if !HWUI_NEW_OPS 295 LOG_ALWAYS_FATAL_IF(!mCanvas || mEglSurface == EGL_NO_SURFACE, 296 "drawRenderNode called on a context with no canvas or surface!"); 297#endif 298 299 SkRect dirty; 300 mDamageAccumulator.finish(&dirty); 301 302 // TODO: Re-enable after figuring out cause of b/22592975 303// if (dirty.isEmpty() && Properties::skipEmptyFrames) { 304// mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame); 305// return; 306// } 307 308 mCurrentFrameInfo->markIssueDrawCommandsStart(); 309 310 Frame frame = mEglManager.beginFrame(mEglSurface); 311 312 if (frame.width() != mLastFrameWidth || frame.height() != mLastFrameHeight) { 313 // can't rely on prior content of window if viewport size changes 314 dirty.setEmpty(); 315 mLastFrameWidth = frame.width(); 316 mLastFrameHeight = frame.height(); 317 } else if (mHaveNewSurface || frame.bufferAge() == 0) { 318 // New surface needs a full draw 319 dirty.setEmpty(); 320 } else { 321 if (!dirty.isEmpty() && !dirty.intersect(0, 0, frame.width(), frame.height())) { 322 ALOGW("Dirty " RECT_STRING " doesn't intersect with 0 0 %d %d ?", 323 SK_RECT_ARGS(dirty), frame.width(), frame.height()); 324 dirty.setEmpty(); 325 } 326 profiler().unionDirty(&dirty); 327 } 328 329 if (dirty.isEmpty()) { 330 dirty.set(0, 0, frame.width(), frame.height()); 331 } 332 333 // At this point dirty is the area of the screen to update. However, 334 // the area of the frame we need to repaint is potentially different, so 335 // stash the screen area for later 336 SkRect screenDirty(dirty); 337 338 // If the buffer age is 0 we do a full-screen repaint (handled above) 339 // If the buffer age is 1 the buffer contents are the same as they were 340 // last frame so there's nothing to union() against 341 // Therefore we only care about the > 1 case. 342 if (frame.bufferAge() > 1) { 343 if (frame.bufferAge() > (int) mSwapHistory.size()) { 344 // We don't have enough history to handle this old of a buffer 345 // Just do a full-draw 346 dirty.set(0, 0, frame.width(), frame.height()); 347 } else { 348 // At this point we haven't yet added the latest frame 349 // to the damage history (happens below) 350 // So we need to damage 351 for (int i = mSwapHistory.size() - 1; 352 i > ((int) mSwapHistory.size()) - frame.bufferAge(); i--) { 353 dirty.join(mSwapHistory[i].damage); 354 } 355 } 356 } 357 358 mEglManager.damageFrame(frame, dirty); 359 360#if HWUI_NEW_OPS 361 auto& caches = Caches::getInstance(); 362 FrameBuilder frameBuilder(dirty, frame.width(), frame.height(), mLightGeometry, caches); 363 364 frameBuilder.deferLayers(mLayerUpdateQueue); 365 mLayerUpdateQueue.clear(); 366 367 frameBuilder.deferRenderNodeScene(mRenderNodes, mContentDrawBounds); 368 369 BakedOpRenderer renderer(caches, mRenderThread.renderState(), 370 mOpaque, mLightInfo); 371 frameBuilder.replayBakedOps<BakedOpDispatcher>(renderer); 372 profiler().draw(&renderer); 373 bool drew = renderer.didDraw(); 374 375 // post frame cleanup 376 caches.clearGarbage(); 377 caches.pathCache.trim(); 378 caches.tessellationCache.trim(); 379 380#if DEBUG_MEMORY_USAGE 381 mCaches.dumpMemoryUsage(); 382#else 383 if (CC_UNLIKELY(Properties::debugLevel & kDebugMemory)) { 384 caches.dumpMemoryUsage(); 385 } 386#endif 387 388#else 389 mCanvas->prepareDirty(frame.width(), frame.height(), 390 dirty.fLeft, dirty.fTop, dirty.fRight, dirty.fBottom, mOpaque); 391 392 Rect outBounds; 393 // It there are multiple render nodes, they are laid out as follows: 394 // #0 - backdrop (content + caption) 395 // #1 - content (positioned at (0,0) and clipped to - its bounds mContentDrawBounds) 396 // #2 - additional overlay nodes 397 // Usually the backdrop cannot be seen since it will be entirely covered by the content. While 398 // resizing however it might become partially visible. The following render loop will crop the 399 // backdrop against the content and draw the remaining part of it. It will then draw the content 400 // cropped to the backdrop (since that indicates a shrinking of the window). 401 // 402 // Additional nodes will be drawn on top with no particular clipping semantics. 403 404 // The bounds of the backdrop against which the content should be clipped. 405 Rect backdropBounds = mContentDrawBounds; 406 // Usually the contents bounds should be mContentDrawBounds - however - we will 407 // move it towards the fixed edge to give it a more stable appearance (for the moment). 408 Rect contentBounds; 409 // If there is no content bounds we ignore the layering as stated above and start with 2. 410 int layer = (mContentDrawBounds.isEmpty() || mRenderNodes.size() == 1) ? 2 : 0; 411 // Draw all render nodes. Note that 412 for (const sp<RenderNode>& node : mRenderNodes) { 413 if (layer == 0) { // Backdrop. 414 // Draw the backdrop clipped to the inverse content bounds, but assume that the content 415 // was moved to the upper left corner. 416 const RenderProperties& properties = node->properties(); 417 Rect targetBounds(properties.getLeft(), properties.getTop(), 418 properties.getRight(), properties.getBottom()); 419 // Move the content bounds towards the fixed corner of the backdrop. 420 const int x = targetBounds.left; 421 const int y = targetBounds.top; 422 contentBounds.set(x, y, x + mContentDrawBounds.getWidth(), 423 y + mContentDrawBounds.getHeight()); 424 // Remember the intersection of the target bounds and the intersection bounds against 425 // which we have to crop the content. 426 backdropBounds.set(x, y, x + backdropBounds.getWidth(), y + backdropBounds.getHeight()); 427 backdropBounds.doIntersect(targetBounds); 428 // Check if we have to draw something on the left side ... 429 if (targetBounds.left < contentBounds.left) { 430 mCanvas->save(SaveFlags::Clip); 431 if (mCanvas->clipRect(targetBounds.left, targetBounds.top, 432 contentBounds.left, targetBounds.bottom, 433 SkRegion::kIntersect_Op)) { 434 mCanvas->drawRenderNode(node.get(), outBounds); 435 } 436 // Reduce the target area by the area we have just painted. 437 targetBounds.left = std::min(contentBounds.left, targetBounds.right); 438 mCanvas->restore(); 439 } 440 // ... or on the right side ... 441 if (targetBounds.right > contentBounds.right && 442 !targetBounds.isEmpty()) { 443 mCanvas->save(SaveFlags::Clip); 444 if (mCanvas->clipRect(contentBounds.right, targetBounds.top, 445 targetBounds.right, targetBounds.bottom, 446 SkRegion::kIntersect_Op)) { 447 mCanvas->drawRenderNode(node.get(), outBounds); 448 } 449 // Reduce the target area by the area we have just painted. 450 targetBounds.right = std::max(targetBounds.left, contentBounds.right); 451 mCanvas->restore(); 452 } 453 // ... or at the top ... 454 if (targetBounds.top < contentBounds.top && 455 !targetBounds.isEmpty()) { 456 mCanvas->save(SaveFlags::Clip); 457 if (mCanvas->clipRect(targetBounds.left, targetBounds.top, targetBounds.right, 458 contentBounds.top, 459 SkRegion::kIntersect_Op)) { 460 mCanvas->drawRenderNode(node.get(), outBounds); 461 } 462 // Reduce the target area by the area we have just painted. 463 targetBounds.top = std::min(contentBounds.top, targetBounds.bottom); 464 mCanvas->restore(); 465 } 466 // ... or at the bottom. 467 if (targetBounds.bottom > contentBounds.bottom && 468 !targetBounds.isEmpty()) { 469 mCanvas->save(SaveFlags::Clip); 470 if (mCanvas->clipRect(targetBounds.left, contentBounds.bottom, targetBounds.right, 471 targetBounds.bottom, SkRegion::kIntersect_Op)) { 472 mCanvas->drawRenderNode(node.get(), outBounds); 473 } 474 mCanvas->restore(); 475 } 476 } else if (layer == 1) { // Content 477 // It gets cropped against the bounds of the backdrop to stay inside. 478 mCanvas->save(SaveFlags::MatrixClip); 479 480 // We shift and clip the content to match its final location in the window. 481 const float left = mContentDrawBounds.left; 482 const float top = mContentDrawBounds.top; 483 const float dx = backdropBounds.left - left; 484 const float dy = backdropBounds.top - top; 485 const float width = backdropBounds.getWidth(); 486 const float height = backdropBounds.getHeight(); 487 488 mCanvas->translate(dx, dy); 489 if (mCanvas->clipRect(left, top, left + width, top + height, SkRegion::kIntersect_Op)) { 490 mCanvas->drawRenderNode(node.get(), outBounds); 491 } 492 mCanvas->restore(); 493 } else { // draw the rest on top at will! 494 mCanvas->drawRenderNode(node.get(), outBounds); 495 } 496 layer++; 497 } 498 499 profiler().draw(mCanvas); 500 501 bool drew = mCanvas->finish(); 502#endif 503 504 waitOnFences(); 505 506 GL_CHECKPOINT(LOW); 507 508 // Even if we decided to cancel the frame, from the perspective of jank 509 // metrics the frame was swapped at this point 510 mCurrentFrameInfo->markSwapBuffers(); 511 mIsDirty = false; 512 513 if (drew || mEglManager.damageRequiresSwap()) { 514 if (CC_UNLIKELY(!mEglManager.swapBuffers(frame, screenDirty))) { 515 setSurface(nullptr); 516 } 517 SwapHistory& swap = mSwapHistory.next(); 518 swap.damage = screenDirty; 519 swap.swapTime = systemTime(CLOCK_MONOTONIC); 520 swap.vsyncTime = mRenderThread.timeLord().latestVsync(); 521 mHaveNewSurface = false; 522 mFrameNumber = -1; 523 } 524 525 // TODO: Use a fence for real completion? 526 mCurrentFrameInfo->markFrameCompleted(); 527 528#if LOG_FRAMETIME_MMA 529 float thisFrame = mCurrentFrameInfo->duration( 530 FrameInfoIndex::IssueDrawCommandsStart, 531 FrameInfoIndex::FrameCompleted) / NANOS_PER_MILLIS_F; 532 if (sFrameCount) { 533 sBenchMma = ((9 * sBenchMma) + thisFrame) / 10; 534 } else { 535 sBenchMma = thisFrame; 536 } 537 if (++sFrameCount == 10) { 538 sFrameCount = 1; 539 ALOGD("Average frame time: %.4f", sBenchMma); 540 } 541#endif 542 543 mJankTracker.addFrame(*mCurrentFrameInfo); 544 mRenderThread.jankTracker().addFrame(*mCurrentFrameInfo); 545 if (CC_UNLIKELY(mFrameMetricsReporter.get() != nullptr)) { 546 mFrameMetricsReporter->reportFrameMetrics(mCurrentFrameInfo->data()); 547 } 548 549 GpuMemoryTracker::onFrameCompleted(); 550} 551 552// Called by choreographer to do an RT-driven animation 553void CanvasContext::doFrame() { 554#if HWUI_NEW_OPS 555 if (CC_UNLIKELY(mEglSurface == EGL_NO_SURFACE)) return; 556#else 557 if (CC_UNLIKELY(!mCanvas || mEglSurface == EGL_NO_SURFACE)) return; 558#endif 559 prepareAndDraw(nullptr); 560} 561 562void CanvasContext::prepareAndDraw(RenderNode* node) { 563 ATRACE_CALL(); 564 565 nsecs_t vsync = mRenderThread.timeLord().computeFrameTimeNanos(); 566 int64_t frameInfo[UI_THREAD_FRAME_INFO_SIZE]; 567 UiFrameInfoBuilder(frameInfo) 568 .addFlag(FrameInfoFlags::RTAnimation) 569 .setVsync(vsync, vsync); 570 571 TreeInfo info(TreeInfo::MODE_RT_ONLY, *this); 572 prepareTree(info, frameInfo, systemTime(CLOCK_MONOTONIC), node); 573 if (info.out.canDrawThisFrame) { 574 draw(); 575 } 576} 577 578void CanvasContext::invokeFunctor(RenderThread& thread, Functor* functor) { 579 ATRACE_CALL(); 580 DrawGlInfo::Mode mode = DrawGlInfo::kModeProcessNoContext; 581 if (thread.eglManager().hasEglContext()) { 582 mode = DrawGlInfo::kModeProcess; 583 } 584 585 thread.renderState().invokeFunctor(functor, mode, nullptr); 586} 587 588void CanvasContext::markLayerInUse(RenderNode* node) { 589 if (mPrefetchedLayers.erase(node)) { 590 node->decStrong(nullptr); 591 } 592} 593 594void CanvasContext::freePrefetchedLayers(TreeObserver* observer) { 595 if (mPrefetchedLayers.size()) { 596 for (auto& node : mPrefetchedLayers) { 597 ALOGW("Incorrectly called buildLayer on View: %s, destroying layer...", 598 node->getName()); 599 node->destroyHardwareResources(observer); 600 node->decStrong(observer); 601 } 602 mPrefetchedLayers.clear(); 603 } 604} 605 606void CanvasContext::buildLayer(RenderNode* node, TreeObserver* observer) { 607 ATRACE_CALL(); 608 if (!mEglManager.hasEglContext()) return; 609#if !HWUI_NEW_OPS 610 if (!mCanvas) return; 611#endif 612 613 // buildLayer() will leave the tree in an unknown state, so we must stop drawing 614 stopDrawing(); 615 616 TreeInfo info(TreeInfo::MODE_FULL, *this); 617 info.damageAccumulator = &mDamageAccumulator; 618 info.observer = observer; 619#if HWUI_NEW_OPS 620 info.layerUpdateQueue = &mLayerUpdateQueue; 621#else 622 info.renderer = mCanvas; 623#endif 624 info.runAnimations = false; 625 node->prepareTree(info); 626 SkRect ignore; 627 mDamageAccumulator.finish(&ignore); 628 // Tickle the GENERIC property on node to mark it as dirty for damaging 629 // purposes when the frame is actually drawn 630 node->setPropertyFieldsDirty(RenderNode::GENERIC); 631 632#if HWUI_NEW_OPS 633 static const std::vector< sp<RenderNode> > emptyNodeList; 634 auto& caches = Caches::getInstance(); 635 FrameBuilder frameBuilder(mLayerUpdateQueue, mLightGeometry, caches); 636 mLayerUpdateQueue.clear(); 637 BakedOpRenderer renderer(caches, mRenderThread.renderState(), 638 mOpaque, mLightInfo); 639 LOG_ALWAYS_FATAL_IF(renderer.didDraw(), "shouldn't draw in buildlayer case"); 640 frameBuilder.replayBakedOps<BakedOpDispatcher>(renderer); 641#else 642 mCanvas->markLayersAsBuildLayers(); 643 mCanvas->flushLayerUpdates(); 644#endif 645 646 node->incStrong(nullptr); 647 mPrefetchedLayers.insert(node); 648} 649 650bool CanvasContext::copyLayerInto(DeferredLayerUpdater* layer, SkBitmap* bitmap) { 651 layer->apply(); 652 return Readback::copyTextureLayerInto(mRenderThread, *(layer->backingLayer()), bitmap) 653 == CopyResult::Success; 654} 655 656void CanvasContext::destroyHardwareResources(TreeObserver* observer) { 657 stopDrawing(); 658 if (mEglManager.hasEglContext()) { 659 freePrefetchedLayers(observer); 660 for (const sp<RenderNode>& node : mRenderNodes) { 661 node->destroyHardwareResources(observer); 662 } 663 Caches& caches = Caches::getInstance(); 664 // Make sure to release all the textures we were owning as there won't 665 // be another draw 666 caches.textureCache.resetMarkInUse(this); 667 mRenderThread.renderState().flush(Caches::FlushMode::Layers); 668 } 669} 670 671void CanvasContext::trimMemory(RenderThread& thread, int level) { 672 // No context means nothing to free 673 if (!thread.eglManager().hasEglContext()) return; 674 675 ATRACE_CALL(); 676 if (level >= TRIM_MEMORY_COMPLETE) { 677 thread.renderState().flush(Caches::FlushMode::Full); 678 thread.eglManager().destroy(); 679 } else if (level >= TRIM_MEMORY_UI_HIDDEN) { 680 thread.renderState().flush(Caches::FlushMode::Moderate); 681 } 682} 683 684Layer* CanvasContext::createTextureLayer() { 685 mEglManager.initialize(); 686 return LayerRenderer::createTextureLayer(mRenderThread.renderState()); 687} 688 689void CanvasContext::setTextureAtlas(RenderThread& thread, 690 const sp<GraphicBuffer>& buffer, int64_t* map, size_t mapSize) { 691 thread.eglManager().setTextureAtlas(buffer, map, mapSize); 692} 693 694void CanvasContext::dumpFrames(int fd) { 695 FILE* file = fdopen(fd, "a"); 696 fprintf(file, "\n\n---PROFILEDATA---\n"); 697 for (size_t i = 0; i < static_cast<size_t>(FrameInfoIndex::NumIndexes); i++) { 698 fprintf(file, "%s", FrameInfoNames[i].c_str()); 699 fprintf(file, ","); 700 } 701 for (size_t i = 0; i < mFrames.size(); i++) { 702 FrameInfo& frame = mFrames[i]; 703 if (frame[FrameInfoIndex::SyncStart] == 0) { 704 continue; 705 } 706 fprintf(file, "\n"); 707 for (int i = 0; i < static_cast<int>(FrameInfoIndex::NumIndexes); i++) { 708 fprintf(file, "%" PRId64 ",", frame[i]); 709 } 710 } 711 fprintf(file, "\n---PROFILEDATA---\n\n"); 712 fflush(file); 713} 714 715void CanvasContext::resetFrameStats() { 716 mFrames.clear(); 717 mRenderThread.jankTracker().reset(); 718} 719 720void CanvasContext::serializeDisplayListTree() { 721#if ENABLE_RENDERNODE_SERIALIZATION 722 using namespace google::protobuf::io; 723 char package[128]; 724 // Check whether tracing is enabled for this process. 725 FILE * file = fopen("/proc/self/cmdline", "r"); 726 if (file) { 727 if (!fgets(package, 128, file)) { 728 ALOGE("Error reading cmdline: %s (%d)", strerror(errno), errno); 729 fclose(file); 730 return; 731 } 732 fclose(file); 733 } else { 734 ALOGE("Error opening /proc/self/cmdline: %s (%d)", strerror(errno), 735 errno); 736 return; 737 } 738 char path[1024]; 739 snprintf(path, 1024, "/data/data/%s/cache/rendertree_dump", package); 740 int fd = open(path, O_CREAT | O_WRONLY, S_IRWXU | S_IRGRP | S_IROTH); 741 if (fd == -1) { 742 ALOGD("Failed to open '%s'", path); 743 return; 744 } 745 proto::RenderNode tree; 746 // TODO: Streaming writes? 747 mRootRenderNode->copyTo(&tree); 748 std::string data = tree.SerializeAsString(); 749 write(fd, data.c_str(), data.length()); 750 close(fd); 751#endif 752} 753 754void CanvasContext::waitOnFences() { 755 if (mFrameFences.size()) { 756 ATRACE_CALL(); 757 for (auto& fence : mFrameFences) { 758 fence->getResult(); 759 } 760 mFrameFences.clear(); 761 } 762} 763 764class CanvasContext::FuncTaskProcessor : public TaskProcessor<bool> { 765public: 766 explicit FuncTaskProcessor(Caches& caches) 767 : TaskProcessor<bool>(&caches.tasks) {} 768 769 virtual void onProcess(const sp<Task<bool> >& task) override { 770 FuncTask* t = static_cast<FuncTask*>(task.get()); 771 t->func(); 772 task->setResult(true); 773 } 774}; 775 776void CanvasContext::enqueueFrameWork(std::function<void()>&& func) { 777 if (!mFrameWorkProcessor.get()) { 778 mFrameWorkProcessor = new FuncTaskProcessor(Caches::getInstance()); 779 } 780 sp<FuncTask> task(new FuncTask()); 781 task->func = func; 782 mFrameFences.push_back(task); 783 mFrameWorkProcessor->add(task); 784} 785 786int64_t CanvasContext::getFrameNumber() { 787 // mFrameNumber is reset to -1 when the surface changes or we swap buffers 788 if (mFrameNumber == -1 && mNativeSurface.get()) { 789 mFrameNumber = static_cast<int64_t>(mNativeSurface->getNextFrameNumber()); 790 } 791 return mFrameNumber; 792} 793 794} /* namespace renderthread */ 795} /* namespace uirenderer */ 796} /* namespace android */ 797