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