CanvasContext.cpp revision be3fba05e823f740f65b2679929347dc3dd282ad
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 "CanvasContext.h" 18 19#include "AnimationContext.h" 20#include "Caches.h" 21#include "DeferredLayerUpdater.h" 22#include "EglManager.h" 23#include "LayerRenderer.h" 24#include "OpenGLRenderer.h" 25#include "Properties.h" 26#include "RenderThread.h" 27#include "renderstate/RenderState.h" 28#include "renderstate/Stencil.h" 29 30#include <algorithm> 31#include <strings.h> 32#include <cutils/properties.h> 33#include <private/hwui/DrawGlInfo.h> 34 35#define TRIM_MEMORY_COMPLETE 80 36#define TRIM_MEMORY_UI_HIDDEN 20 37 38namespace android { 39namespace uirenderer { 40namespace renderthread { 41 42CanvasContext::CanvasContext(RenderThread& thread, bool translucent, 43 RenderNode* rootRenderNode, IContextFactory* contextFactory) 44 : mRenderThread(thread) 45 , mEglManager(thread.eglManager()) 46 , mOpaque(!translucent) 47 , mAnimationContext(contextFactory->createAnimationContext(mRenderThread.timeLord())) 48 , mRootRenderNode(rootRenderNode) 49 , mJankTracker(thread.timeLord().frameIntervalNanos()) 50 , mProfiler(mFrames) { 51 mRenderThread.renderState().registerCanvasContext(this); 52 mProfiler.setDensity(mRenderThread.mainDisplayInfo().density); 53} 54 55CanvasContext::~CanvasContext() { 56 destroy(); 57 mRenderThread.renderState().unregisterCanvasContext(this); 58} 59 60void CanvasContext::destroy() { 61 stopDrawing(); 62 setSurface(nullptr); 63 freePrefetechedLayers(); 64 destroyHardwareResources(); 65 mAnimationContext->destroy(); 66 if (mCanvas) { 67 delete mCanvas; 68 mCanvas = nullptr; 69 } 70} 71 72void CanvasContext::setSurface(ANativeWindow* window) { 73 ATRACE_CALL(); 74 75 mNativeWindow = window; 76 77 if (mEglSurface != EGL_NO_SURFACE) { 78 mEglManager.destroySurface(mEglSurface); 79 mEglSurface = EGL_NO_SURFACE; 80 } 81 82 if (window) { 83 mEglSurface = mEglManager.createSurface(window); 84 } 85 86 if (mEglSurface != EGL_NO_SURFACE) { 87 const bool preserveBuffer = (mSwapBehavior != kSwap_discardBuffer); 88 mBufferPreserved = mEglManager.setPreserveBuffer(mEglSurface, preserveBuffer); 89 mHaveNewSurface = true; 90 makeCurrent(); 91 } else { 92 mRenderThread.removeFrameCallback(this); 93 } 94} 95 96void CanvasContext::swapBuffers(const SkRect& dirty, EGLint width, EGLint height) { 97 if (CC_UNLIKELY(!mEglManager.swapBuffers(mEglSurface, dirty, width, height))) { 98 setSurface(nullptr); 99 } 100 mHaveNewSurface = false; 101} 102 103void CanvasContext::requireSurface() { 104 LOG_ALWAYS_FATAL_IF(mEglSurface == EGL_NO_SURFACE, 105 "requireSurface() called but no surface set!"); 106 makeCurrent(); 107} 108 109void CanvasContext::setSwapBehavior(SwapBehavior swapBehavior) { 110 mSwapBehavior = swapBehavior; 111} 112 113bool CanvasContext::initialize(ANativeWindow* window) { 114 setSurface(window); 115 if (mCanvas) return false; 116 mCanvas = new OpenGLRenderer(mRenderThread.renderState()); 117 mCanvas->initProperties(); 118 return true; 119} 120 121void CanvasContext::updateSurface(ANativeWindow* window) { 122 setSurface(window); 123} 124 125bool CanvasContext::pauseSurface(ANativeWindow* window) { 126 return mRenderThread.removeFrameCallback(this); 127} 128 129// TODO: don't pass viewport size, it's automatic via EGL 130void CanvasContext::setup(int width, int height, float lightRadius, 131 uint8_t ambientShadowAlpha, uint8_t spotShadowAlpha) { 132 if (!mCanvas) return; 133 mCanvas->initLight(lightRadius, ambientShadowAlpha, spotShadowAlpha); 134} 135 136void CanvasContext::setLightCenter(const Vector3& lightCenter) { 137 if (!mCanvas) return; 138 mCanvas->setLightCenter(lightCenter); 139} 140 141void CanvasContext::setOpaque(bool opaque) { 142 mOpaque = opaque; 143} 144 145void CanvasContext::makeCurrent() { 146 // TODO: Figure out why this workaround is needed, see b/13913604 147 // In the meantime this matches the behavior of GLRenderer, so it is not a regression 148 mHaveNewSurface |= mEglManager.makeCurrent(mEglSurface); 149} 150 151void CanvasContext::processLayerUpdate(DeferredLayerUpdater* layerUpdater) { 152 bool success = layerUpdater->apply(); 153 LOG_ALWAYS_FATAL_IF(!success, "Failed to update layer!"); 154 if (layerUpdater->backingLayer()->deferredUpdateScheduled) { 155 mCanvas->pushLayerUpdate(layerUpdater->backingLayer()); 156 } 157} 158 159static bool wasSkipped(FrameInfo* info) { 160 return info && ((*info)[FrameInfoIndex::Flags] & FrameInfoFlags::SkippedFrame); 161} 162 163void CanvasContext::prepareTree(TreeInfo& info, int64_t* uiFrameInfo, int64_t syncQueued) { 164 mRenderThread.removeFrameCallback(this); 165 166 // If the previous frame was dropped we don't need to hold onto it, so 167 // just keep using the previous frame's structure instead 168 if (!wasSkipped(mCurrentFrameInfo)) { 169 mCurrentFrameInfo = &mFrames.next(); 170 } 171 mCurrentFrameInfo->importUiThreadInfo(uiFrameInfo); 172 mCurrentFrameInfo->set(FrameInfoIndex::SyncQueued) = syncQueued; 173 mCurrentFrameInfo->markSyncStart(); 174 175 info.damageAccumulator = &mDamageAccumulator; 176 info.renderer = mCanvas; 177 if (mPrefetechedLayers.size() && info.mode == TreeInfo::MODE_FULL) { 178 info.canvasContext = this; 179 } 180 mAnimationContext->startFrame(info.mode); 181 mRootRenderNode->prepareTree(info); 182 mAnimationContext->runRemainingAnimations(info); 183 184 if (info.canvasContext) { 185 freePrefetechedLayers(); 186 } 187 188 if (CC_UNLIKELY(!mNativeWindow.get())) { 189 mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame); 190 info.out.canDrawThisFrame = false; 191 return; 192 } 193 194 int runningBehind = 0; 195 // TODO: This query is moderately expensive, investigate adding some sort 196 // of fast-path based off when we last called eglSwapBuffers() as well as 197 // last vsync time. Or something. 198 mNativeWindow->query(mNativeWindow.get(), 199 NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND, &runningBehind); 200 info.out.canDrawThisFrame = !runningBehind; 201 202 if (!info.out.canDrawThisFrame) { 203 mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame); 204 } 205 206 if (info.out.hasAnimations || !info.out.canDrawThisFrame) { 207 if (!info.out.requiresUiRedraw) { 208 // If animationsNeedsRedraw is set don't bother posting for an RT anim 209 // as we will just end up fighting the UI thread. 210 mRenderThread.postFrameCallback(this); 211 } 212 } 213} 214 215void CanvasContext::stopDrawing() { 216 mRenderThread.removeFrameCallback(this); 217} 218 219void CanvasContext::notifyFramePending() { 220 ATRACE_CALL(); 221 mRenderThread.pushBackFrameCallback(this); 222} 223 224void CanvasContext::draw() { 225 LOG_ALWAYS_FATAL_IF(!mCanvas || mEglSurface == EGL_NO_SURFACE, 226 "drawRenderNode called on a context with no canvas or surface!"); 227 228 SkRect dirty; 229 mDamageAccumulator.finish(&dirty); 230 231 if (dirty.isEmpty() && Properties::skipEmptyFrames) { 232 mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame); 233 return; 234 } 235 236 mCurrentFrameInfo->markIssueDrawCommandsStart(); 237 238 EGLint width, height; 239 mEglManager.beginFrame(mEglSurface, &width, &height); 240 if (width != mCanvas->getViewportWidth() || height != mCanvas->getViewportHeight()) { 241 mCanvas->setViewport(width, height); 242 dirty.setEmpty(); 243 } else if (!mBufferPreserved || mHaveNewSurface) { 244 dirty.setEmpty(); 245 } else { 246 if (!dirty.isEmpty() && !dirty.intersect(0, 0, width, height)) { 247 ALOGW("Dirty " RECT_STRING " doesn't intersect with 0 0 %d %d ?", 248 SK_RECT_ARGS(dirty), width, height); 249 dirty.setEmpty(); 250 } 251 profiler().unionDirty(&dirty); 252 } 253 254 if (!dirty.isEmpty()) { 255 mCanvas->prepareDirty(dirty.fLeft, dirty.fTop, 256 dirty.fRight, dirty.fBottom, mOpaque); 257 } else { 258 mCanvas->prepare(mOpaque); 259 } 260 261 Rect outBounds; 262 mCanvas->drawRenderNode(mRootRenderNode.get(), outBounds); 263 264 profiler().draw(mCanvas); 265 266 bool drew = mCanvas->finish(); 267 268 // Even if we decided to cancel the frame, from the perspective of jank 269 // metrics the frame was swapped at this point 270 mCurrentFrameInfo->markSwapBuffers(); 271 272 if (drew) { 273 swapBuffers(dirty, width, height); 274 } 275 276 // TODO: Use a fence for real completion? 277 mCurrentFrameInfo->markFrameCompleted(); 278 mJankTracker.addFrame(*mCurrentFrameInfo); 279 mRenderThread.jankTracker().addFrame(*mCurrentFrameInfo); 280} 281 282// Called by choreographer to do an RT-driven animation 283void CanvasContext::doFrame() { 284 if (CC_UNLIKELY(!mCanvas || mEglSurface == EGL_NO_SURFACE)) { 285 return; 286 } 287 288 ATRACE_CALL(); 289 290 int64_t frameInfo[UI_THREAD_FRAME_INFO_SIZE]; 291 UiFrameInfoBuilder(frameInfo) 292 .addFlag(FrameInfoFlags::RTAnimation) 293 .setVsync(mRenderThread.timeLord().computeFrameTimeNanos(), 294 mRenderThread.timeLord().latestVsync()); 295 296 TreeInfo info(TreeInfo::MODE_RT_ONLY, mRenderThread.renderState()); 297 prepareTree(info, frameInfo, systemTime(CLOCK_MONOTONIC)); 298 if (info.out.canDrawThisFrame) { 299 draw(); 300 } 301} 302 303void CanvasContext::invokeFunctor(RenderThread& thread, Functor* functor) { 304 ATRACE_CALL(); 305 DrawGlInfo::Mode mode = DrawGlInfo::kModeProcessNoContext; 306 if (thread.eglManager().hasEglContext()) { 307 mode = DrawGlInfo::kModeProcess; 308 } 309 310 thread.renderState().invokeFunctor(functor, mode, nullptr); 311} 312 313void CanvasContext::markLayerInUse(RenderNode* node) { 314 if (mPrefetechedLayers.erase(node)) { 315 node->decStrong(nullptr); 316 } 317} 318 319static void destroyPrefetechedNode(RenderNode* node) { 320 ALOGW("Incorrectly called buildLayer on View: %s, destroying layer...", node->getName()); 321 node->destroyHardwareResources(); 322 node->decStrong(nullptr); 323} 324 325void CanvasContext::freePrefetechedLayers() { 326 if (mPrefetechedLayers.size()) { 327 std::for_each(mPrefetechedLayers.begin(), mPrefetechedLayers.end(), destroyPrefetechedNode); 328 mPrefetechedLayers.clear(); 329 } 330} 331 332void CanvasContext::buildLayer(RenderNode* node) { 333 ATRACE_CALL(); 334 if (!mEglManager.hasEglContext() || !mCanvas) { 335 return; 336 } 337 // buildLayer() will leave the tree in an unknown state, so we must stop drawing 338 stopDrawing(); 339 340 TreeInfo info(TreeInfo::MODE_FULL, mRenderThread.renderState()); 341 info.damageAccumulator = &mDamageAccumulator; 342 info.renderer = mCanvas; 343 info.runAnimations = false; 344 node->prepareTree(info); 345 SkRect ignore; 346 mDamageAccumulator.finish(&ignore); 347 // Tickle the GENERIC property on node to mark it as dirty for damaging 348 // purposes when the frame is actually drawn 349 node->setPropertyFieldsDirty(RenderNode::GENERIC); 350 351 mCanvas->markLayersAsBuildLayers(); 352 mCanvas->flushLayerUpdates(); 353 354 node->incStrong(nullptr); 355 mPrefetechedLayers.insert(node); 356} 357 358bool CanvasContext::copyLayerInto(DeferredLayerUpdater* layer, SkBitmap* bitmap) { 359 layer->apply(); 360 return LayerRenderer::copyLayer(mRenderThread.renderState(), layer->backingLayer(), bitmap); 361} 362 363void CanvasContext::destroyHardwareResources() { 364 stopDrawing(); 365 if (mEglManager.hasEglContext()) { 366 freePrefetechedLayers(); 367 mRootRenderNode->destroyHardwareResources(); 368 Caches::getInstance().flush(Caches::kFlushMode_Layers); 369 } 370} 371 372void CanvasContext::trimMemory(RenderThread& thread, int level) { 373 // No context means nothing to free 374 if (!thread.eglManager().hasEglContext()) return; 375 376 ATRACE_CALL(); 377 if (level >= TRIM_MEMORY_COMPLETE) { 378 Caches::getInstance().flush(Caches::kFlushMode_Full); 379 thread.eglManager().destroy(); 380 } else if (level >= TRIM_MEMORY_UI_HIDDEN) { 381 Caches::getInstance().flush(Caches::kFlushMode_Moderate); 382 } 383} 384 385void CanvasContext::runWithGlContext(RenderTask* task) { 386 LOG_ALWAYS_FATAL_IF(!mEglManager.hasEglContext(), 387 "GL context not initialized!"); 388 task->run(); 389} 390 391Layer* CanvasContext::createTextureLayer() { 392 requireSurface(); 393 return LayerRenderer::createTextureLayer(mRenderThread.renderState()); 394} 395 396void CanvasContext::setTextureAtlas(RenderThread& thread, 397 const sp<GraphicBuffer>& buffer, int64_t* map, size_t mapSize) { 398 thread.eglManager().setTextureAtlas(buffer, map, mapSize); 399} 400 401void CanvasContext::dumpFrames(int fd) { 402 FILE* file = fdopen(fd, "a"); 403 fprintf(file, "\n\n---PROFILEDATA---\n"); 404 for (size_t i = 0; i < static_cast<size_t>(FrameInfoIndex::NumIndexes); i++) { 405 fprintf(file, "%s", FrameInfoNames[i].c_str()); 406 fprintf(file, ","); 407 } 408 for (size_t i = 0; i < mFrames.size(); i++) { 409 FrameInfo& frame = mFrames[i]; 410 if (frame[FrameInfoIndex::SyncStart] == 0) { 411 continue; 412 } 413 fprintf(file, "\n"); 414 for (int i = 0; i < static_cast<int>(FrameInfoIndex::NumIndexes); i++) { 415 fprintf(file, "%" PRId64 ",", frame[i]); 416 } 417 } 418 fprintf(file, "\n---PROFILEDATA---\n\n"); 419 fflush(file); 420} 421 422void CanvasContext::resetFrameStats() { 423 mFrames.clear(); 424 mRenderThread.jankTracker().reset(); 425} 426 427} /* namespace renderthread */ 428} /* namespace uirenderer */ 429} /* namespace android */ 430