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